From 58c3fe089d4cdc595f6f175a8a9bf35b9c53a89e Mon Sep 17 00:00:00 2001 From: Martin Ruckert Date: Fri, 12 Nov 2021 11:09:17 +0000 Subject: eliminating htex.w and giving all file names the hi... prefix git-svn-id: svn://tug.org/texlive/trunk@61033 c570f23f-e606-0410-a88d-b1316a301751 --- Build/source/texk/web2c/hitexdir/am/hitex.am | 46 +- Build/source/texk/web2c/hitexdir/format.w | 186 +- Build/source/texk/web2c/hitexdir/hilexer.c | 3230 ++ Build/source/texk/web2c/hitexdir/hilexer.l | 353 + Build/source/texk/web2c/hitexdir/hiparser.c | 4132 +++ Build/source/texk/web2c/hitexdir/hiparser.h | 173 + Build/source/texk/web2c/hitexdir/hiparser.y | 1111 + Build/source/texk/web2c/hitexdir/hishrink-lexer.c | 3206 -- Build/source/texk/web2c/hitexdir/hishrink-parser.c | 3896 --- Build/source/texk/web2c/hitexdir/hishrink-parser.h | 258 - Build/source/texk/web2c/hitexdir/hitex.w | 32922 ++++++++++++++++++- Build/source/texk/web2c/hitexdir/htex.w | 29213 ---------------- 12 files changed, 40642 insertions(+), 38084 deletions(-) create mode 100644 Build/source/texk/web2c/hitexdir/hilexer.c create mode 100644 Build/source/texk/web2c/hitexdir/hilexer.l create mode 100644 Build/source/texk/web2c/hitexdir/hiparser.c create mode 100644 Build/source/texk/web2c/hitexdir/hiparser.h create mode 100644 Build/source/texk/web2c/hitexdir/hiparser.y delete mode 100644 Build/source/texk/web2c/hitexdir/hishrink-lexer.c delete mode 100644 Build/source/texk/web2c/hitexdir/hishrink-parser.c delete mode 100644 Build/source/texk/web2c/hitexdir/hishrink-parser.h delete mode 100644 Build/source/texk/web2c/hitexdir/htex.w (limited to 'Build') diff --git a/Build/source/texk/web2c/hitexdir/am/hitex.am b/Build/source/texk/web2c/hitexdir/am/hitex.am index 109cb4e0e42..2419d82d3bc 100644 --- a/Build/source/texk/web2c/hitexdir/am/hitex.am +++ b/Build/source/texk/web2c/hitexdir/am/hitex.am @@ -16,9 +16,9 @@ hiall: hitex hishrink histretch ## Except we eschew all lex/yacc steps in the Makefile here; see below. ## AM_YFLAGS = -d -v -Wno-yacc -hitex_CPPFLAGS = $(AM_CPPFLAGS) $(ZLIB_INCLUDES) +hitex_CPPFLAGS = $(AM_CPPFLAGS) $(ZLIB_INCLUDES) hitex_CPPFLAGS += -I$(srcdir)/libmd5 -hitex_LDADD = $(KPATHSEA_LIBS) $(ZLIB_LIBS) +hitex_LDADD = $(KPATHSEA_LIBS) $(ZLIB_LIBS) libmd5.a hitex_LDADD += libmd5.a hitex_DEPENDENCIES = $(KPATHSEA_DEPEND) $(ZLIB_DEPEND) libmd5.a # @@ -32,20 +32,19 @@ hishrink_LDADD = $(ZLIB_LIBS) hishrink_DEPENDENCIES = $(ZLIB_DEPEND) # HiTeX CWEB sources -hitex_web = hitexdir/format.w hitexdir/htex.w hitexdir/hitex.w +hitex_web = hitexdir/format.w hitexdir/hitex.w # Creating several files: need stamp file and two rules with identical recipes hi_ctangle_sh = CWEBINPUTS=$(srcdir)/hitexdir AM_V_P=$(AM_V_P) $(SHELL) ./tangle-sh $@ $(CTANGLE) # HiTeX C/yacc/lex sources generated using ctangle. # For each cweb (.w) source file, list the files generated. -format_c_h_l_y = basetypes.h error.h hformat.h \ - mkhformat.c \ - hput.c hput.h \ - hget.c hget.h \ - shrink.l shrink.y \ +format_c_h_l_y = hibasetypes.h hierror.h hiformat.h \ + himktables.c \ + hiput.c hiput.h \ + higet.c higet.h \ + hilexer.l hiparser.y \ hishrink.c histretch.c -htex_c_h = htex.c htex.h hitex_c_h = hitex.c hitex.h $(format_c_h_l_y): format-tangle @@ -60,36 +59,31 @@ $(hitex_c_h): hitex-tangle hitex-tangle: ctangle$(EXEEXT) hitexdir/hitex.w tangle-sh $(hi_ctangle_sh) hitex -# htex.c needs hitex.h, so depend on the hitex tangle. -$(htex_c_h): htex-tangle hitex-tangle - $(hi_ctangle_sh) htex -# -htex-tangle: ctangle$(EXEEXT) hitexdir/htex.w tangle-sh hitex-tangle - $(hi_ctangle_sh) htex - -# Generating hformat.c using mkhformat. -hformat.c: mkhformat - ./mkhformat >hformat.c || { rm -f hformat.c; exit 1; } +# Generating hitables.c using himktables. +hitables.c: himktables + ./himktables > $@ || { rm -f hitables.c; exit 1; } # hitex -nodist_hitex_SOURCES = hformat.c hput.c $(htex_c_h) $(hitex_c_h) +nodist_hitex_SOURCES = hitables.c hiput.c $(hitex_c_h) # histretch -nodist_histretch_SOURCES = hformat.c histretch.c +nodist_histretch_SOURCES = hitables.c histretch.c # The actual sources for the lexer and parser are in format.w. # However, to simplify life with Automake (a little), we include the # generated [.ch] files as if they were the sources here, and don't try # to have Automake support the derivation from .w. # -nodist_hishrink_SOURCES = hformat.c hishrink.c \ - hitexdir/hishrink-lexer.c \ - hitexdir/hishrink-parser.c hitexdir/hishrink-parser.h +# The $(srcdir) is not necessary if everything is up to date, +# but can help with the remake if the [.ch] or [.ly] are not present. +nodist_hishrink_SOURCES = hitables.c \ + hitexdir/hilexer.c \ + hitexdir/hiparser.c hitexdir/hiparser.h # This is our attempt to ensure that bison got run before anything else, # when needed. # -$(hishrink_OBJECTS): $(srcdir)/hitexdir/hishrink-parser.h +$(hishrink_OBJECTS): $(srcdir)/hitexdir/hiparser.h # # By the way, the $(BUILT_SOURCES) suggestion in the Automake manual for # this does not work for us, because we want to be able to invoke @@ -100,7 +94,7 @@ EXTRA_DIST += hitexdir/ChangeLog $(hitex_web) DISTCLEANFILES += $(nodist_hitex_SOURCES) DISTCLEANFILES += $(nodist_hishrink_SOURCES) $(nodist_histretch_SOURCES) -DISTCLEANFILES += format-tangle htex-tangle hitex-tangle +DISTCLEANFILES += format-tangle hitex-tangle ## HiTeX tests # still missing diff --git a/Build/source/texk/web2c/hitexdir/format.w b/Build/source/texk/web2c/hitexdir/format.w index 1a9f6f54a25..5b1fd22a2d8 100644 --- a/Build/source/texk/web2c/hitexdir/format.w +++ b/Build/source/texk/web2c/hitexdir/format.w @@ -47,9 +47,9 @@ \def\setrevision$#1: #2 ${\gdef\lastrevision{#2}} -\setrevision$Revision: 2515 $ +\setrevision$Revision: 2541 $ \def\setdate$#1(#2) ${\gdef\lastdate{#2}} -\setdate$Date: 2021-09-23 17:59:58 +0200 (Thu, 23 Sep 2021) $ +\setdate$Date: 2021-10-26 09:03:28 +0200 (Tue, 26 Oct 2021) $ \null @@ -719,7 +719,7 @@ HGETTAG(a);@/@t{}@> @= HGETTAG(z);@+ if (a!=z) - QUIT(@["Tag mismatch [%s,%d]!=[%s,%d] at 0x%x to 0x%tx\n"@],@| + QUIT(@["Tag mismatch [%s,%d]!=[%s,%d] at 0x%x to " SIZE_F "\n"@],@| NAME(a),INFO(a),NAME(z),INFO(z),@|node_pos, hpos-hstart-1); @ @@ -938,7 +938,7 @@ Last not least, we add rules for signed\index{signed integer} integers. @ @= -integer: SIGNED @+| UNSIGNED { RNG("number",$1,0,INT32_MAX);}; +integer: SIGNED @+| UNSIGNED { RNG("number",$1,0,0x7FFFFFFF);}; @ To preserve the ``signedness'' of an integer also for positive signed integers @@ -1227,7 +1227,7 @@ void hwrite_charcode(uint32_t c) \getcode @= #define @[HGET_UTF8C(X)@] (X)=HGET8;@+ if ((X&0xC0)!=0x80) \ - QUIT(@["UTF8 continuation byte expected at 0x%tx got 0x%02X\n"@],hpos-hstart-1,X)@; + QUIT(@["UTF8 continuation byte expected at " SIZE_F " got 0x%02X\n"@],hpos-hstart-1,X)@; uint32_t hget_utf8(void) { uint8_t a; @@ -2824,7 +2824,7 @@ void hget_size_boundary(info_t info) { uint32_t n; if (info<2) return; n=HGET8; - if (n-1!=0x100-info) QUIT(@["Size boundary byte 0x%x with info value %d at 0x%tx"@], + if (n-1!=0x100-info) QUIT(@["Size boundary byte 0x%x with info value %d at " SIZE_F@], n, info,hpos-hstart-1); } @@ -2861,7 +2861,7 @@ void hget_list(list_t *l) hpos=hpos+(L).s; hget_size_boundary(I);\ { uint32_t s=hget_list_size(I); \ if (s!=(L).s) \ - QUIT(@["List sizes at 0x%x and 0x%tx do not match 0x%x != 0x%x"@],node_pos+1,hpos-hstart-I-1,(L).s,s);} + QUIT(@["List sizes at 0x%x and " SIZE_F " do not match 0x%x != 0x%x"@],node_pos+1,hpos-hstart-I-1,(L).s,s);} @ \putcode @@ -5788,7 +5788,7 @@ content_node: stream_def_node @+ | stream_ins_node; { xdimen_t x; uint16_t f,r; uint8_t n; - DBG(DBGDEF,"Defining normal stream %d at 0x%tx\n",*(hpos-1),hpos-hstart-2); + DBG(DBGDEF,"Defining normal stream %d at " SIZE_F "\n",*(hpos-1),hpos-hstart-2); hget_xdimen_node(&x); @+hwrite_xdimen_node(&x); HGET16(f); @+RNG("magnification factor",f,0,1000);@+ hwritef(" %d",f); n=HGET8; if (n==255) hwritef(" *"); else { REF_RNG(stream_kind,n);@+hwrite_ref(n);@+} @@ -5804,7 +5804,7 @@ static bool hget_stream_def(void) else { ref_t df; @@; - DBG(DBGDEF,"Defining stream %d at 0x%tx\n",*hpos,hpos-hstart-1); + DBG(DBGDEF,"Defining stream %d at " SIZE_F "\n",*hpos,hpos-hstart-1); DEF(df,stream_kind,HGET8); hwrite_start();@+hwritef("stream");@+@+hwrite_ref(df.n); if (df.n>0) @@ -6165,12 +6165,12 @@ void hput_range(uint8_t pg, bool on) { if (((next_range-1)/2)>max_ref[range_kind]) QUIT("Page range %d > %d",(next_range-1)/2,max_ref[range_kind]); if (on && page_on[pg]!=0) - QUIT(@["Template %d is switched on at 0x%x and 0x%tx"@],@| + QUIT(@["Template %d is switched on at 0x%x and " SIZE_F@],@| pg, range_pos[page_on[pg]].pos, hpos-hstart); else if (!on && page_on[pg]==0) - QUIT(@["Template %d is switched off at 0x%tx but was not on"@],@| + QUIT(@["Template %d is switched off at " SIZE_F " but was not on"@],@| pg, hpos-hstart); - DBG(DBGRANGE,@["Range *%d %s at 0x%tx\n"@],pg,on?"on":"off",hpos-hstart); + DBG(DBGRANGE,@["Range *%d %s at " SIZE_F "\n"@],pg,on?"on":"off",hpos-hstart); range_pos[next_range].pg=pg; range_pos[next_range].pos=hpos-hstart; range_pos[next_range].on=on; @@ -6365,15 +6365,15 @@ void hput_hint(char * str) { size_t s; DBG(DBGBASIC,"Writing hint output %s\n",str); s=hput_banner("hint",str); - DBG(DBGDIR,@["Root entry at 0x%tx\n"@],s); + DBG(DBGDIR,@["Root entry at " SIZE_F "\n"@],s); s+=hput_root(); - DBG(DBGDIR,@["Directory section at 0x%tx\n"@],s); + DBG(DBGDIR,@["Directory section at " SIZE_F "\n"@],s); s+=hput_section(0); - DBG(DBGDIR,@["Definition section at 0x%tx\n"@],s); + DBG(DBGDIR,@["Definition section at " SIZE_F "\n"@],s); s+=hput_section(1); - DBG(DBGDIR,@["Content section at 0x%tx\n"@],s); + DBG(DBGDIR,@["Content section at " SIZE_F "\n"@],s); s+=hput_section(2); - DBG(DBGDIR,@["Auxiliary sections at 0x%tx\n"@],s); + DBG(DBGDIR,@["Auxiliary sections at " SIZE_F "\n"@],s); hput_optional_sections(); } @ @@ -6396,7 +6396,7 @@ and advance the stream position accordingly.\label{HPUT}\label{HGET} \getcode @= -#define HGET_ERROR @/ QUIT(@["HGET overrun in section %d at 0x%tx\n"@],@|section_no,hpos-hstart) +#define HGET_ERROR @/ QUIT(@["HGET overrun in section %d at " SIZE_F "\n"@],@|section_no,hpos-hstart) #define @[HEND@] @[((hpos<=hend)?0:(HGET_ERROR,0))@] #define @[HGET8@] ((hpos= void hput_error(void) {@+if (hpos=HINT_NO_POS) bsize=HINT_NO_POS; - if (bsize= static void hget_root(entry_t *root) -{ DBG(DBGDIR,"Root entry at 0x%tx\n",hpos-hstart); +{ DBG(DBGDIR,"Root entry at " SIZE_F "\n",hpos-hstart); hget_entry(root); root->pos=hpos-hstart; max_section_no=root->section_no; @@ -7168,7 +7168,7 @@ static size_t hput_root(void) dir[0].section_no=max_section_no; hput_entry(&dir[0]); s=hput_data(0, hstart,hpos-hstart); - DBG(DBGDIR,@["Writing root size=0x%tx\n"@],s); + DBG(DBGDIR,@["Writing root size=" SIZE_F "\n"@],s); return s; } @@ -7226,7 +7226,7 @@ static void hput_optional_sections(void) } fclose(f); if (fsize!=dir[i].size) - QUIT(@["File size 0x%tx does not match directory size %u"@],@|fsize,dir[i].size); + QUIT(@["File size " SIZE_F " does not match directory size %u"@],@|fsize,dir[i].size); } } @ @@ -8752,7 +8752,7 @@ There is no good program without good error handling\index{error message}\index{ To print messages\index{message} or indicate errors, I define the following macros: \index{MESSAGE+\.{MESSAGE}}\index{QUIT+\.{QUIT}} -@(error.h@>= +@(hierror.h@>= #ifndef _ERROR_H #define _ERROR_H #include @@ -8772,25 +8772,22 @@ For portability, we first define the output specifier for expressions of type |s \index{DBG+\.{DBG}}\index{SIZE F+\.{SIZE\_F}}\index{DBGTAG+\.{DBGTAG}} \index{RNG+\.{RNG}}\index{TAGERR+\.{TAGERR}} @= -#if 0 -/* use 0x percent tx instead */ #ifdef WIN32 #define SIZE_F "0x%x" #else #define SIZE_F "0x%zx" #endif -#endif #ifdef DEBUG #define @[DBG(FLAGS,...)@] ((debugflags & (FLAGS))?LOG(__VA_ARGS__):0) #else #define @[DBG(FLAGS,...)@] 0 #endif -#define @[DBGTAG(A,P)@] @[DBG(DBGTAGS,@["tag [%s,%d] at 0x%tx\n"@],@|NAME(A),INFO(A),(P)-hstart)@] +#define @[DBGTAG(A,P)@] @[DBG(DBGTAGS,@["tag [%s,%d] at " SIZE_F "\n"@],@|NAME(A),INFO(A),(P)-hstart)@] #define @[RNG(S,N,A,Z)@] @/\ if ((int)(N)<(int)(A)||(int)(N)>(int)(Z)) QUIT(S@, " %d out of range [%d - %d]",N,A,Z) -#define @[TAGERR(A)@] @[QUIT(@["Unknown tag [%s,%d] at 0x%tx\n"@],NAME(A),INFO(A),hpos-hstart)@] +#define @[TAGERR(A)@] @[QUIT(@["Unknown tag [%s,%d] at " SIZE_F "\n"@],NAME(A),INFO(A),hpos-hstart)@] @ The \.{bison} generated parser will need a function |yyerror| for @@ -8865,7 +8862,7 @@ void hff_hpos(void) @ -We will put the |hnode_size| variable into the {\tt hformat.c} file +We will put the |hnode_size| variable into the {\tt tables.c} file using the following function. We add some comments and split negative values into their components, to make the result more readable. @@ -9275,7 +9272,7 @@ The code to skip the end\index{end byte} byte |z| and to check the start\index{s @= HTEGTAG(a); - if (a!=z) QUIT(@["Tag mismatch [%s,%d]!=[%s,%d] at 0x%tx to 0x%x\n"@],@|NAME(a),INFO(a),NAME(z),INFO(z),@| + if (a!=z) QUIT(@["Tag mismatch [%s,%d]!=[%s,%d] at " SIZE_F " to 0x%x\n"@],@|NAME(a),INFO(a),NAME(z),INFO(z),@| hpos-hstart,node_pos-1); @ @@ -9727,7 +9724,7 @@ void hteg_size_boundary(info_t info) { uint32_t n; if (info<2) return; n=HTEG8; - if (n-1!=0x100-info) QUIT(@["List size boundary byte 0x%x does not match info value %d at 0x%tx"@], + if (n-1!=0x100-info) QUIT(@["List size boundary byte 0x%x does not match info value %d at " SIZE_F@], n, info,hpos-hstart); } @@ -9755,7 +9752,7 @@ void hteg_list(list_t *l) l->p=hpos-hstart; hteg_size_boundary(INFO(z)); s=hteg_list_size(INFO(z)); - if (s!=l->s) QUIT(@["List sizes at 0x%tx and 0x%x do not match 0x%x != 0x%x"@], + if (s!=l->s) QUIT(@["List sizes at " SIZE_F " and 0x%x do not match 0x%x != 0x%x"@], hpos-hstart,node_pos-1,s,l->s); @@; } @@ -9851,7 +9848,7 @@ To define basic types in a portable way, we create an include file. The macro |_MSC_VER| (Microsoft Visual C Version)\index{Microsoft Visual C} is defined only if using the respective compiler. \index{false+\\{false}}\index{true+\\{true}}\index{bool+\&{bool}} -@(basetypes.h@>= +@(hibasetypes.h@>= #ifndef __BASETYPES_H__ #define __BASETYPES_H__ #include @@ -9873,7 +9870,6 @@ is defined only if using the respective compiler. #define false (!true) #define __SIZEOF_FLOAT__ 4 #define __SIZEOF_DOUBLE__ 8 -#define INT32_MAX (2147483647) #define PRIx64 "I64x" #pragma @[warning( disable : @[4244@]@t @> @[4996@]@t @> @[4127@])@] #else @@ -9898,11 +9894,11 @@ typedef double float64_t; -\subsection{{\tt hformat.h}}\index{hformat.h+{\tt hformat.h}} -The \.{hformat.h} file contains definitions of types, macros, variables and functions +\subsection{{\tt format.h}}\index{format.h+{\tt format.h}} +The \.{format.h} file contains definitions of types, macros, variables and functions that are needed in other compilation units. -@(hformat.h@>= +@(hiformat.h@>= #ifndef _HFORMAT_H_ #define _HFORMAT_H_ @@; @@ -9926,15 +9922,15 @@ extern signed char hnode_size[0x100]; #endif @ -\subsection{{\tt hformat.c}}\index{hformat.c+{\tt hformat.c}}\index{mkhformat.c+{\tt mkhformat.c}} -For maximum flexibility and efficiency, the file {\tt hformat.c} +\subsection{{\tt tables.c}}\index{tables.c+{\tt tables.c}}\index{mktables.c+{\tt mktables.c}} +For maximum flexibility and efficiency, the file {\tt tables.c} is generated by a \CEE\ program. -Here is the |main| program of {\tt mkhformat}: +Here is the |main| program of {\tt mktables}: -@(mkhformat.c@>= +@(himktables.c@>= #include -#include "basetypes.h" -#include "hformat.h" +#include "hibasetypes.h" +#include "hiformat.h" @@; int max_fixed[32], max_default[32]; @@ -9952,8 +9948,8 @@ int main(void) int i; - printf("#include \"basetypes.h\"\n"@/ - "#include \"hformat.h\"\n\n");@/ + printf("#include \"hibasetypes.h\"\n"@/ + "#include \"hiformat.h\"\n\n");@/ @@; @@ -10001,11 +9997,11 @@ The following code prints the arrays containing the default values. @ -\subsection{{\tt hget.h}}\index{hget.h+{\tt hget.h}} -The \.{hget.h} file contains function prototypes for all the functions +\subsection{{\tt get.h}}\index{get.h+{\tt get.h}} +The \.{get.h} file contains function prototypes for all the functions that read the short format. -@(hget.h@>= +@(higet.h@>= @@; @@; @@; @@ -10049,9 +10045,9 @@ extern uint8_t hff_tag; -\subsection{{\tt hget.c}}\index{hget.c+{\tt hget.c}} -@(hget.c@>= -#include "basetypes.h" +\subsection{{\tt get.c}}\index{get.c+{\tt get.c}} +@(higet.c@>= +#include "hibasetypes.h" #include #include #include @@ -10059,9 +10055,9 @@ extern uint8_t hff_tag; #include #include -#include "error.h" -#include "hformat.h" -#include "hget.h" +#include "hierror.h" +#include "hiformat.h" +#include "higet.h" @@; @@ -10074,12 +10070,12 @@ extern uint8_t hff_tag; @@; @ -\subsection{{\tt hput.h}}\index{hput.h+{\tt hput.h}} -The \.{hput.h} file contains function prototypes for all the functions +\subsection{{\tt put.h}}\index{put.h+{\tt put.h}} +The \.{put.h} file contains function prototypes for all the functions that write the short format. -@(hput.h@>= +@(hiput.h@>= @@; @@; @@; @@ -10148,18 +10144,18 @@ extern int hcompress_depth(int n, int c); @ -\subsection{{\tt hput.c}}\label{writeshort}\index{hput.c+{\tt hput.c}} +\subsection{{\tt put.c}}\label{writeshort}\index{put.c+{\tt put.c}} \noindent -@(hput.c@>= -#include "basetypes.h" +@(hiput.c@>= +#include "hibasetypes.h" #include #include #include #include #include -#include "error.h" -#include "hformat.h" -#include "hput.h" +#include "hierror.h" +#include "hiformat.h" +#include "hiput.h" @@; @@; @@ -10168,18 +10164,18 @@ extern int hcompress_depth(int n, int c); @@; @ -\subsection{{\tt shrink.l}}\index{shrink.l+{\tt shrink.l}}\index{scanning} -The definitions for lex are collected in the file {\tt shrink.l} +\subsection{{\tt lexer.l}}\index{lexer.l+{\tt lexer.l}}\index{scanning} +The definitions for lex are collected in the file {\tt lexer.l} -@(shrink.l@>= +@(hilexer.l@>= %{ -#include "basetypes.h" -#include "error.h" -#include "hformat.h" -#include "hput.h" +#include "hibasetypes.h" +#include "hierror.h" +#include "hiformat.h" +#include "hiput.h" @@; -#include "hishrink-parser.h" +#include "hiparser.h" @@;@+ @@; @@ -10206,20 +10202,20 @@ int yywrap (void )@+{ return 1;@+} -\subsection{{\tt shrink.y}}\index{shrink.y+{\tt shrink.y}}\index{parsing} +\subsection{{\tt parser.y}}\index{parser.y+{\tt parser.y}}\index{parsing} -The grammar rules for bison are collected in the file {\tt shrink.y}. +The grammar rules for bison are collected in the file {\tt parser.y}. % for the option %token-table use the command line parameter -k -@(shrink.y@>= +@(hiparser.y@>= %{ -#include "basetypes.h" +#include "hibasetypes.h" #include #include -#include "error.h" -#include "hformat.h" -#include "hput.h" +#include "hierror.h" +#include "hiformat.h" +#include "hiput.h" extern char **hfont_name; /* in common variables */ @@; @@ -10261,7 +10257,7 @@ extern int yylex(void); \.{shrink} is a \CEE\ program translating a \HINT\ file in long format into a \HINT\ file in short format. @(hishrink.c@>= -#include "basetypes.h" +#include "hibasetypes.h" #include #include #include @@ -10271,10 +10267,10 @@ extern int yylex(void); #endif #include -#include "error.h" -#include "hformat.h" -#include "hput.h" -#include "hishrink-parser.h" +#include "hierror.h" +#include "hiformat.h" +#include "hiput.h" +#include "hiparser.h" extern void yyset_debug(int lex_debug); extern int yylineno; @@ -10334,7 +10330,7 @@ explain_usage: format into a \HINT\ file in long format. @(histretch.c@>= -#include "basetypes.h" +#include "hibasetypes.h" #include #include #include @@ -10345,9 +10341,9 @@ format into a \HINT\ file in long format. #include #endif #include -#include "error.h" -#include "hformat.h" -#include "hget.h" +#include "hierror.h" +#include "hiformat.h" +#include "higet.h" @@; @@; @@ -10399,7 +10395,7 @@ In the above program, the get functions call the write functions and the write functions call some get functions. This requires function declarations to satisfy the define before use requirement of \CEE. Some of the necessary function declarations are already -contained in {\tt hget.h}. The remaining declarations are these: +contained in {\tt get.h}. The remaining declarations are these: @= extern void hget_xdimen_node(xdimen_t *x); @@ -10420,15 +10416,15 @@ extern int hget_txt(void); \.{skip} is a \CEE\ program reading the content section of a \HINT\ file in short format backwards. -@(skip.c@>= -#include "basetypes.h" +@(hiskip.c@>= +#include "hibasetypes.h" #include #include #include #include #include -#include "error.h" -#include "hformat.h" +#include "hierror.h" +#include "hiformat.h" @@; @@; diff --git a/Build/source/texk/web2c/hitexdir/hilexer.c b/Build/source/texk/web2c/hitexdir/hilexer.c new file mode 100644 index 00000000000..228cd613cd1 --- /dev/null +++ b/Build/source/texk/web2c/hitexdir/hilexer.c @@ -0,0 +1,3230 @@ +#line 1 "lexer.c" + +#line 3 "lexer.c" + +#define YY_INT_ALIGNED short int + +/* A lexical scanner generated by flex */ + +/* %not-for-header */ +/* %if-c-only */ +/* %if-not-reentrant */ + +/* %endif */ +/* %endif */ +/* %ok-for-header */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 6 +#define YY_FLEX_SUBMINOR_VERSION 4 +#if YY_FLEX_SUBMINOR_VERSION > 0 +#define FLEX_BETA +#endif + +/* %if-c++-only */ +/* %endif */ + +/* %if-c-only */ + +/* %endif */ + +/* %if-c-only */ + +/* %endif */ + +/* First, we deal with platform-specific or compiler-specific issues. */ + +/* begin standard C headers. */ +/* %if-c-only */ +#include +#include +#include +#include +/* %endif */ + +/* %if-tables-serialization */ +/* %endif */ +/* end standard C headers. */ + +/* %if-c-or-c++ */ +/* flex integer type definitions */ + +#ifndef FLEXINT_H +#define FLEXINT_H + +/* C99 systems have . Non-C99 systems may or may not. */ + +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + +/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, + * if you want the limit (max/min) macros for int types. + */ +#ifndef __STDC_LIMIT_MACROS +#define __STDC_LIMIT_MACROS 1 +#endif + +#include +typedef int8_t flex_int8_t; +typedef uint8_t flex_uint8_t; +typedef int16_t flex_int16_t; +typedef uint16_t flex_uint16_t; +typedef int32_t flex_int32_t; +typedef uint32_t flex_uint32_t; +#else +typedef signed char flex_int8_t; +typedef short int flex_int16_t; +typedef int flex_int32_t; +typedef unsigned char flex_uint8_t; +typedef unsigned short int flex_uint16_t; +typedef unsigned int flex_uint32_t; + +/* Limits of integral types. */ +#ifndef INT8_MIN +#define INT8_MIN (-128) +#endif +#ifndef INT16_MIN +#define INT16_MIN (-32767-1) +#endif +#ifndef INT32_MIN +#define INT32_MIN (-2147483647-1) +#endif +#ifndef INT8_MAX +#define INT8_MAX (127) +#endif +#ifndef INT16_MAX +#define INT16_MAX (32767) +#endif +#ifndef INT32_MAX +#define INT32_MAX (2147483647) +#endif +#ifndef UINT8_MAX +#define UINT8_MAX (255U) +#endif +#ifndef UINT16_MAX +#define UINT16_MAX (65535U) +#endif +#ifndef UINT32_MAX +#define UINT32_MAX (4294967295U) +#endif + +#ifndef SIZE_MAX +#define SIZE_MAX (~(size_t)0) +#endif + +#endif /* ! C99 */ + +#endif /* ! FLEXINT_H */ + +/* %endif */ + +/* begin standard C++ headers. */ +/* %if-c++-only */ +/* %endif */ + +/* TODO: this is always defined, so inline it */ +#define yyconst const + +#if defined(__GNUC__) && __GNUC__ >= 3 +#define yynoreturn __attribute__((__noreturn__)) +#else +#define yynoreturn +#endif + +/* %not-for-header */ +/* Returned upon end-of-file. */ +#define YY_NULL 0 +/* %ok-for-header */ + +/* %not-for-header */ +/* Promotes a possibly negative, possibly signed char to an + * integer in range [0..255] for use as an array index. + */ +#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) +/* %ok-for-header */ + +/* %if-reentrant */ +/* %endif */ + +/* %if-not-reentrant */ + +/* %endif */ + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN (yy_start) = 1 + 2 * +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START (((yy_start) - 1) / 2) +#define YYSTATE YY_START +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#ifndef YY_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k. + * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. + * Ditto for the __ia64__ case accordingly. + */ +#define YY_BUF_SIZE 32768 +#else +#define YY_BUF_SIZE 16384 +#endif /* __ia64__ */ +#endif + +/* The state buf must be large enough to hold one state per character in the main buffer. + */ +#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) + +#ifndef YY_TYPEDEF_YY_BUFFER_STATE +#define YY_TYPEDEF_YY_BUFFER_STATE +typedef struct yy_buffer_state *YY_BUFFER_STATE; +#endif + +#ifndef YY_TYPEDEF_YY_SIZE_T +#define YY_TYPEDEF_YY_SIZE_T +typedef size_t yy_size_t; +#endif + +/* %if-not-reentrant */ +extern int yyleng; +/* %endif */ + +/* %if-c-only */ +/* %if-not-reentrant */ +extern FILE *yyin, *yyout; +/* %endif */ +/* %endif */ + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + + /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires + * access to the local variable yy_act. Since yyless() is a macro, it would break + * existing scanners that call yyless() from OUTSIDE yylex. + * One obvious solution it to make yy_act a global. I tried that, and saw + * a 5% performance hit in a non-yylineno scanner, because yy_act is + * normally declared as a register variable-- so it is not worth it. + */ + #define YY_LESS_LINENO(n) \ + do { \ + int yyl;\ + for ( yyl = n; yyl < yyleng; ++yyl )\ + if ( yytext[yyl] == '\n' )\ + --yylineno;\ + }while(0) + #define YY_LINENO_REWIND_TO(dst) \ + do {\ + const char *p;\ + for ( p = yy_cp-1; p >= (dst); --p)\ + if ( *p == '\n' )\ + --yylineno;\ + }while(0) + +/* Return all but the first "n" matched characters back to the input stream. */ +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + int yyless_macro_arg = (n); \ + YY_LESS_LINENO(yyless_macro_arg);\ + *yy_cp = (yy_hold_char); \ + YY_RESTORE_YY_MORE_OFFSET \ + (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) +#define unput(c) yyunput( c, (yytext_ptr) ) + +#ifndef YY_STRUCT_YY_BUFFER_STATE +#define YY_STRUCT_YY_BUFFER_STATE +struct yy_buffer_state + { +/* %if-c-only */ + FILE *yy_input_file; +/* %endif */ + +/* %if-c++-only */ +/* %endif */ + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + int yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + int yy_bs_lineno; /**< The line count. */ + int yy_bs_column; /**< The column count. */ + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; + +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + + }; +#endif /* !YY_STRUCT_YY_BUFFER_STATE */ + +/* %if-c-only Standard (non-C++) definition */ +/* %not-for-header */ +/* %if-not-reentrant */ + +/* Stack of input buffers. */ +static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ +static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ +static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */ +/* %endif */ +/* %ok-for-header */ + +/* %endif */ + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + * + * Returns the top of the stack, or NULL. + */ +#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ + ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ + : NULL) +/* Same as previous macro, but useful when we know that the buffer stack is not + * NULL or when we need an lvalue. For internal use only. + */ +#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] + +/* %if-c-only Standard (non-C++) definition */ + +/* %if-not-reentrant */ +/* %not-for-header */ +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; +static int yy_n_chars; /* number of characters read into yy_ch_buf */ +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = NULL; +static int yy_init = 0; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; +/* %ok-for-header */ + +/* %endif */ + +void yyrestart ( FILE *input_file ); +void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer ); +YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size ); +void yy_delete_buffer ( YY_BUFFER_STATE b ); +void yy_flush_buffer ( YY_BUFFER_STATE b ); +void yypush_buffer_state ( YY_BUFFER_STATE new_buffer ); +void yypop_buffer_state ( void ); + +static void yyensure_buffer_stack ( void ); +static void yy_load_buffer_state ( void ); +static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file ); +#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER ) + +YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size ); +YY_BUFFER_STATE yy_scan_string ( const char *yy_str ); +YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len ); + +/* %endif */ + +void *yyalloc ( yy_size_t ); +void *yyrealloc ( void *, yy_size_t ); +void yyfree ( void * ); + +#define yy_new_buffer yy_create_buffer +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! YY_CURRENT_BUFFER ){ \ + yyensure_buffer_stack (); \ + YY_CURRENT_BUFFER_LVALUE = \ + yy_create_buffer( yyin, YY_BUF_SIZE ); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ + } +#define yy_set_bol(at_bol) \ + { \ + if ( ! YY_CURRENT_BUFFER ){\ + yyensure_buffer_stack (); \ + YY_CURRENT_BUFFER_LVALUE = \ + yy_create_buffer( yyin, YY_BUF_SIZE ); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ + } +#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) + +/* %% [1.0] yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here */ +/* Begin user sect3 */ + +#define FLEX_DEBUG +typedef flex_uint8_t YY_CHAR; + +FILE *yyin = NULL, *yyout = NULL; + +typedef int yy_state_type; + +extern int yylineno; +int yylineno = 1; + +extern char *yytext; +#ifdef yytext_ptr +#undef yytext_ptr +#endif +#define yytext_ptr yytext + +/* %% [1.5] DFA */ + +/* %if-c-only Standard (non-C++) definition */ + +static yy_state_type yy_get_previous_state ( void ); +static yy_state_type yy_try_NUL_trans ( yy_state_type current_state ); +static int yy_get_next_buffer ( void ); +static void yynoreturn yy_fatal_error ( const char* msg ); + +/* %endif */ + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + (yytext_ptr) = yy_bp; \ +/* %% [2.0] code to fiddle yytext and yyleng for yymore() goes here \ */\ + yyleng = (int) (yy_cp - yy_bp); \ + (yy_hold_char) = *yy_cp; \ + *yy_cp = '\0'; \ +/* %% [3.0] code to copy yytext_ptr to yytext[] goes here, if %array \ */\ + (yy_c_buf_p) = yy_cp; +/* %% [4.0] data tables for the DFA and the user's section 1 definitions go here */ +#define YY_NUM_RULES 126 +#define YY_END_OF_BUFFER 127 +/* This struct is not used in this scanner, + but its presence is necessary. */ +struct yy_trans_info + { + flex_int32_t yy_verify; + flex_int32_t yy_nxt; + }; +static const flex_int16_t yy_accept[371] = + { 0, + 0, 0, 0, 0, 0, 0, 127, 125, 6, 6, + 43, 47, 10, 125, 114, 125, 4, 4, 1, 2, + 41, 124, 124, 124, 124, 124, 124, 124, 31, 124, + 124, 124, 124, 124, 124, 124, 124, 124, 124, 32, + 124, 40, 14, 15, 13, 11, 74, 74, 58, 72, + 48, 73, 49, 50, 74, 126, 126, 126, 126, 0, + 0, 0, 0, 0, 0, 0, 7, 5, 5, 9, + 9, 0, 0, 0, 4, 124, 124, 124, 124, 124, + 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, + 124, 124, 29, 124, 124, 124, 124, 124, 124, 124, + + 28, 124, 97, 124, 124, 124, 124, 27, 124, 124, + 124, 124, 124, 124, 124, 86, 124, 124, 124, 124, + 12, 0, 58, 58, 0, 59, 55, 52, 56, 60, + 53, 54, 57, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 51, 71, 75, 0, 0, 20, 20, + 16, 0, 0, 0, 5, 0, 9, 24, 8, 85, + 124, 124, 124, 106, 124, 124, 124, 124, 124, 124, + 124, 124, 124, 33, 124, 124, 124, 124, 124, 124, + 124, 124, 37, 124, 124, 124, 124, 124, 124, 124, + 124, 124, 120, 107, 124, 98, 124, 124, 95, 124, + + 124, 124, 102, 124, 124, 124, 124, 124, 113, 124, + 124, 124, 124, 59, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 76, 0, 18, 17, 21, 0, + 0, 0, 0, 0, 124, 124, 124, 124, 124, 124, + 124, 124, 124, 124, 94, 124, 34, 124, 122, 44, + 124, 78, 124, 82, 124, 101, 42, 124, 124, 112, + 124, 124, 108, 96, 124, 124, 115, 124, 124, 45, + 124, 39, 124, 124, 124, 124, 79, 124, 84, 124, + 70, 65, 61, 66, 69, 63, 64, 62, 68, 67, + 77, 19, 22, 0, 0, 24, 25, 124, 89, 124, + + 124, 124, 124, 124, 87, 26, 124, 124, 35, 111, + 3, 81, 104, 105, 124, 124, 124, 46, 124, 121, + 124, 116, 124, 124, 124, 100, 83, 124, 23, 0, + 99, 124, 90, 103, 124, 124, 124, 91, 124, 124, + 124, 124, 124, 124, 124, 110, 30, 0, 25, 124, + 123, 124, 124, 124, 88, 124, 109, 36, 118, 80, + 92, 124, 124, 38, 93, 124, 117, 124, 119, 0 + } ; + +static const YY_CHAR yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 4, 4, 2, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 5, 6, 7, 8, 8, 8, 8, 9, 10, + 11, 12, 13, 8, 14, 15, 8, 16, 17, 17, + 17, 17, 17, 17, 17, 18, 18, 8, 8, 19, + 8, 20, 8, 21, 22, 22, 23, 24, 22, 25, + 26, 8, 27, 8, 28, 29, 8, 8, 8, 30, + 8, 31, 32, 8, 8, 8, 8, 8, 8, 8, + 8, 33, 8, 8, 34, 8, 35, 36, 37, 38, + + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 51, 8, 60, 8, 8, 1, 61, 61, 61, + 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, + 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, + 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, + 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, + 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, + 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, + 61, 62, 62, 62, 62, 62, 62, 62, 62, 62, + + 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, + 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, + 62, 62, 62, 63, 63, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 63, 63, 63, 64, + 64, 64, 64, 64, 64, 64, 64, 65, 65, 65, + 65, 65, 65, 65, 65 + } ; + +static const YY_CHAR yy_meta[66] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 1, + 4, 1, 1, 1, 4 + } ; + +static const flex_int16_t yy_base[376] = + { 0, + 0, 0, 65, 130, 194, 258, 629, 630, 630, 630, + 630, 630, 74, 68, 64, 68, 77, 72, 630, 630, + 630, 53, 61, 58, 59, 570, 57, 581, 65, 57, + 0, 587, 73, 74, 100, 106, 107, 104, 112, 113, + 587, 630, 630, 630, 630, 615, 630, 117, 148, 162, + 630, 630, 630, 630, 322, 630, 562, 561, 560, 611, + 610, 609, 556, 555, 554, 165, 630, 630, 107, 154, + 162, 157, 166, 193, 170, 0, 160, 571, 560, 558, + 563, 24, 63, 153, 560, 173, 561, 148, 559, 572, + 567, 570, 550, 564, 550, 184, 566, 180, 168, 106, + + 0, 560, 0, 545, 182, 550, 542, 0, 548, 538, + 548, 556, 549, 539, 554, 539, 539, 552, 547, 542, + 630, 228, 233, 237, 241, 243, 247, 630, 630, 630, + 630, 630, 630, 250, 253, 257, 263, 266, 269, 272, + 276, 279, 282, 630, 630, 630, 523, 522, 630, 573, + 572, 571, 518, 517, 285, 288, 299, 291, 354, 0, + 522, 535, 536, 0, 520, 518, 518, 528, 516, 530, + 529, 530, 531, 519, 511, 509, 523, 511, 502, 522, + 504, 516, 0, 509, 507, 515, 512, 498, 513, 515, + 504, 506, 0, 0, 492, 0, 500, 506, 509, 508, + + 489, 500, 0, 501, 485, 498, 498, 490, 0, 477, + 497, 479, 485, 249, 357, 364, 367, 370, 375, 378, + 388, 396, 399, 402, 630, 470, 630, 521, 630, 520, + 467, 421, 409, 431, 474, 478, 479, 485, 476, 483, + 473, 478, 471, 479, 0, 450, 451, 439, 0, 0, + 450, 0, 446, 0, 451, 0, 0, 439, 429, 0, + 444, 421, 0, 0, 421, 430, 0, 422, 416, 0, + 422, 0, 417, 398, 416, 411, 0, 397, 0, 402, + 630, 630, 630, 630, 630, 630, 630, 630, 630, 630, + 630, 630, 630, 431, 315, 630, 441, 380, 0, 390, + + 379, 382, 380, 381, 0, 0, 356, 371, 0, 0, + 0, 0, 0, 0, 372, 350, 346, 0, 351, 0, + 344, 0, 340, 317, 297, 0, 0, 292, 630, 454, + 0, 289, 0, 0, 281, 280, 279, 0, 285, 265, + 224, 225, 203, 205, 209, 0, 0, 464, 478, 202, + 0, 186, 172, 163, 0, 151, 0, 0, 0, 0, + 0, 140, 100, 0, 0, 109, 0, 61, 0, 630, + 503, 507, 511, 514, 70 + } ; + +static const flex_int16_t yy_def[376] = + { 0, + 370, 1, 371, 371, 372, 372, 370, 370, 370, 370, + 370, 370, 373, 374, 370, 370, 370, 370, 370, 370, + 370, 375, 375, 375, 375, 375, 375, 375, 375, 375, + 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, + 375, 370, 370, 370, 370, 370, 370, 370, 370, 370, + 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, + 370, 370, 370, 370, 370, 374, 370, 370, 370, 370, + 370, 370, 370, 370, 370, 375, 375, 375, 375, 375, + 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, + 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, + + 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, + 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, + 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, + 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, + 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, + 370, 370, 370, 370, 370, 370, 370, 370, 370, 375, + 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, + 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, + 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, + 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, + + 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, + 375, 375, 375, 370, 370, 370, 370, 370, 370, 370, + 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, + 370, 370, 370, 370, 375, 375, 375, 375, 375, 375, + 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, + 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, + 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, + 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, + 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, + 370, 370, 370, 370, 370, 370, 370, 375, 375, 375, + + 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, + 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, + 375, 375, 375, 375, 375, 375, 375, 375, 370, 370, + 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, + 375, 375, 375, 375, 375, 375, 375, 370, 370, 375, + 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, + 375, 375, 375, 375, 375, 375, 375, 375, 375, 0, + 370, 370, 370, 370, 370 + } ; + +static const flex_int16_t yy_nxt[696] = + { 0, + 8, 9, 10, 9, 9, 11, 12, 8, 13, 14, + 8, 15, 16, 16, 8, 17, 18, 18, 19, 20, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 8, 8, 8, 21, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 31, 35, 36, + 31, 37, 38, 39, 31, 40, 31, 41, 31, 42, + 8, 8, 8, 8, 8, 43, 43, 44, 43, 166, + 67, 167, 76, 46, 60, 60, 60, 60, 67, 68, + 69, 69, 62, 70, 71, 71, 72, 75, 75, 75, + 77, 72, 73, 73, 73, 79, 81, 83, 78, 86, + + 89, 84, 168, 92, 93, 87, 82, 96, 99, 80, + 94, 97, 169, 369, 90, 98, 100, 91, 122, 123, + 101, 122, 155, 155, 155, 43, 43, 43, 43, 43, + 43, 43, 44, 43, 74, 63, 64, 65, 46, 102, + 105, 109, 112, 194, 106, 113, 115, 103, 117, 124, + 123, 107, 124, 195, 104, 110, 368, 114, 367, 108, + 116, 111, 118, 122, 123, 119, 122, 67, 72, 73, + 73, 73, 158, 158, 158, 67, 72, 157, 157, 157, + 72, 73, 73, 73, 72, 75, 75, 75, 366, 365, + 43, 43, 43, 43, 43, 48, 49, 160, 50, 170, + + 51, 364, 177, 161, 171, 172, 178, 52, 159, 159, + 159, 156, 53, 54, 159, 159, 159, 159, 174, 186, + 190, 192, 198, 363, 175, 193, 55, 191, 362, 122, + 123, 187, 122, 199, 124, 123, 188, 124, 124, 123, + 361, 124, 125, 126, 214, 125, 360, 214, 125, 126, + 214, 125, 359, 214, 56, 57, 58, 59, 56, 48, + 49, 358, 50, 357, 51, 215, 215, 215, 216, 216, + 216, 52, 217, 217, 217, 356, 53, 54, 218, 218, + 218, 219, 219, 219, 220, 220, 220, 221, 221, 221, + 55, 222, 222, 222, 223, 223, 223, 224, 224, 224, + + 155, 155, 155, 232, 232, 232, 158, 158, 158, 232, + 232, 232, 232, 72, 157, 157, 157, 355, 56, 57, + 58, 59, 56, 125, 126, 354, 127, 353, 128, 233, + 296, 296, 296, 352, 351, 129, 350, 130, 130, 347, + 131, 132, 133, 346, 134, 135, 136, 137, 138, 139, + 140, 141, 142, 143, 144, 345, 145, 145, 145, 145, + 145, 145, 145, 145, 145, 145, 145, 145, 234, 159, + 159, 159, 215, 215, 215, 159, 159, 159, 159, 216, + 216, 216, 217, 217, 217, 218, 218, 218, 344, 281, + 219, 219, 219, 220, 220, 220, 282, 343, 342, 283, + + 341, 340, 284, 221, 221, 221, 339, 285, 338, 337, + 286, 222, 222, 222, 223, 223, 223, 224, 224, 224, + 287, 295, 295, 336, 296, 296, 296, 335, 288, 334, + 333, 289, 332, 331, 290, 234, 232, 232, 232, 329, + 328, 327, 232, 232, 232, 232, 297, 297, 297, 326, + 325, 324, 297, 297, 297, 297, 297, 297, 297, 323, + 322, 321, 297, 297, 297, 297, 348, 348, 320, 349, + 349, 349, 319, 318, 317, 349, 349, 349, 349, 349, + 349, 349, 316, 315, 314, 349, 349, 349, 349, 313, + 312, 311, 310, 349, 349, 349, 309, 308, 330, 349, + + 349, 349, 349, 45, 45, 45, 45, 47, 47, 47, + 47, 61, 61, 61, 66, 307, 66, 66, 306, 305, + 304, 303, 302, 301, 300, 299, 298, 294, 293, 292, + 291, 280, 279, 278, 277, 276, 275, 274, 273, 272, + 271, 270, 269, 268, 267, 266, 265, 264, 263, 262, + 261, 260, 259, 258, 257, 256, 255, 254, 253, 252, + 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, + 241, 240, 239, 238, 237, 236, 235, 231, 230, 229, + 228, 227, 226, 225, 213, 212, 211, 210, 209, 208, + 207, 206, 205, 204, 203, 202, 201, 200, 197, 196, + + 189, 185, 184, 183, 182, 181, 180, 179, 176, 173, + 165, 164, 163, 162, 154, 153, 152, 151, 150, 149, + 148, 147, 146, 121, 120, 95, 88, 85, 370, 7, + 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, + 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, + 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, + 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, + 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, + 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, + 370, 370, 370, 370, 370 + + } ; + +static const flex_int16_t yy_chk[696] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 3, 3, 3, 3, 82, + 14, 82, 375, 3, 13, 13, 13, 13, 14, 15, + 15, 15, 13, 16, 16, 16, 18, 18, 18, 18, + 22, 17, 17, 17, 17, 23, 24, 25, 22, 27, + + 29, 25, 83, 30, 30, 27, 24, 33, 34, 23, + 30, 33, 83, 368, 29, 33, 34, 29, 48, 48, + 34, 48, 69, 69, 69, 3, 3, 3, 3, 3, + 4, 4, 4, 4, 17, 13, 13, 13, 4, 35, + 36, 37, 38, 100, 36, 38, 39, 35, 40, 49, + 49, 36, 49, 100, 35, 37, 366, 38, 363, 36, + 39, 37, 40, 50, 50, 40, 50, 66, 70, 70, + 70, 70, 72, 72, 72, 66, 71, 71, 71, 71, + 73, 73, 73, 73, 75, 75, 75, 75, 362, 356, + 4, 4, 4, 4, 4, 5, 5, 77, 5, 84, + + 5, 354, 88, 77, 84, 84, 88, 5, 74, 74, + 74, 70, 5, 5, 74, 74, 74, 74, 86, 96, + 98, 99, 105, 353, 86, 99, 5, 98, 352, 122, + 122, 96, 122, 105, 123, 123, 96, 123, 124, 124, + 350, 124, 125, 125, 126, 125, 345, 126, 127, 127, + 214, 127, 344, 214, 5, 5, 5, 5, 5, 6, + 6, 343, 6, 342, 6, 134, 134, 134, 135, 135, + 135, 6, 136, 136, 136, 341, 6, 6, 137, 137, + 137, 138, 138, 138, 139, 139, 139, 140, 140, 140, + 6, 141, 141, 141, 142, 142, 142, 143, 143, 143, + + 155, 155, 155, 156, 156, 156, 158, 158, 158, 156, + 156, 156, 156, 157, 157, 157, 157, 340, 6, 6, + 6, 6, 6, 55, 55, 339, 55, 337, 55, 158, + 295, 295, 295, 336, 335, 55, 332, 55, 55, 328, + 55, 55, 55, 325, 55, 55, 55, 55, 55, 55, + 55, 55, 55, 55, 55, 324, 55, 55, 55, 55, + 55, 55, 55, 55, 55, 55, 55, 55, 159, 159, + 159, 159, 215, 215, 215, 159, 159, 159, 159, 216, + 216, 216, 217, 217, 217, 218, 218, 218, 323, 215, + 219, 219, 219, 220, 220, 220, 216, 321, 319, 217, + + 317, 316, 218, 221, 221, 221, 315, 219, 308, 307, + 220, 222, 222, 222, 223, 223, 223, 224, 224, 224, + 221, 233, 233, 304, 233, 233, 233, 303, 222, 302, + 301, 223, 300, 298, 224, 232, 232, 232, 232, 294, + 280, 278, 232, 232, 232, 232, 234, 234, 234, 276, + 275, 274, 234, 234, 234, 234, 297, 297, 297, 273, + 271, 269, 297, 297, 297, 297, 330, 330, 268, 330, + 330, 330, 266, 265, 262, 330, 330, 330, 330, 348, + 348, 348, 261, 259, 258, 348, 348, 348, 348, 255, + 253, 251, 248, 349, 349, 349, 247, 246, 297, 349, + + 349, 349, 349, 371, 371, 371, 371, 372, 372, 372, + 372, 373, 373, 373, 374, 244, 374, 374, 243, 242, + 241, 240, 239, 238, 237, 236, 235, 231, 230, 228, + 226, 213, 212, 211, 210, 208, 207, 206, 205, 204, + 202, 201, 200, 199, 198, 197, 195, 192, 191, 190, + 189, 188, 187, 186, 185, 184, 182, 181, 180, 179, + 178, 177, 176, 175, 174, 173, 172, 171, 170, 169, + 168, 167, 166, 165, 163, 162, 161, 154, 153, 152, + 151, 150, 148, 147, 120, 119, 118, 117, 116, 115, + 114, 113, 112, 111, 110, 109, 107, 106, 104, 102, + + 97, 95, 94, 93, 92, 91, 90, 89, 87, 85, + 81, 80, 79, 78, 65, 64, 63, 62, 61, 60, + 59, 58, 57, 46, 41, 32, 28, 26, 7, 370, + 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, + 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, + 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, + 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, + 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, + 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, + 370, 370, 370, 370, 370 + + } ; + +/* Table of booleans, true if rule could match eol. */ +static const flex_int32_t yy_rule_can_match_eol[127] = + { 0, +0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, }; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +extern int yy_flex_debug; +int yy_flex_debug = 1; + +static const flex_int16_t yy_rule_linenum[126] = + { 0, + 171, 172, 173, 174, 175, 176, 177, 179, 181, 183, + 185, 186, 187, 188, 189, 194, 195, 196, 197, 198, + 199, 200, 201, 203, 205, 207, 208, 209, 210, 212, + 213, 214, 216, 217, 218, 220, 221, 223, 225, 226, + 227, 229, 230, 232, 233, 234, 236, 239, 241, 242, + 244, 245, 246, 247, 248, 249, 250, 252, 253, 255, + 257, 258, 259, 260, 261, 262, 263, 264, 265, 268, + 270, 271, 272, 274, 275, 276, 277, 280, 281, 282, + 284, 285, 286, 287, 288, 289, 290, 292, 293, 294, + 295, 297, 299, 301, 303, 305, 307, 308, 310, 312, + + 313, 314, 315, 317, 319, 320, 321, 323, 325, 327, + 328, 329, 330, 331, 333, 335, 337, 338, 340, 342, + 344, 346, 348, 350, 351 + } ; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +#define yymore() yymore_used_but_not_detected +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET +char *yytext; +#line 1 "lexer.l" +#line 2 "lexer.l" + /*509:*/ + #line 10171 "format.w" + +#include "hibasetypes.h" +#include "hierror.h" +#include "hiformat.h" +#include "hiput.h" + + /*423:*/ +#ifdef DEBUG +#define YYDEBUG 1 +extern int yydebug; +#else +#define YYDEBUG 0 +#endif + /*:423*/ +#include "hiparser.h" + + /*22:*/ +#define SCAN_UDEC(S) yylval.u= strtoul(S,NULL,10) + /*:22*/ /*25:*/ +#define SCAN_HEX(S) yylval.u= strtoul(S,NULL,16) + /*:25*/ /*28:*/ +#define SCAN_DEC(S) yylval.i= strtol(S,NULL,10) + /*:28*/ /*31:*/ +#define MAX_STR (1<<10) +static char str_buffer[MAX_STR]; +static int str_length; +#define STR_START (str_length= 0) +#define STR_PUT(C) (str_buffer[str_length++]= (C)) +#define STR_ADD(C) STR_PUT(C);RNG("String length",str_length,0,MAX_STR-1) +#define STR_END str_buffer[str_length]= 0 +#define SCAN_STR yylval.s= str_buffer + /*:31*/ /*40:*/ +#define SCAN_UTF8_1(S) yylval.u= ((S)[0]&0x7F) + /*:40*/ /*42:*/ +#define SCAN_UTF8_2(S) yylval.u= (((S)[0]&0x1F)<<6)+((S)[1]&0x3F) + /*:42*/ /*44:*/ +#define SCAN_UTF8_3(S) yylval.u= (((S)[0]&0x0F)<<12)+(((S)[1]&0x3F)<<6)+((S)[2]&0x3F) + /*:44*/ /*46:*/ +#define SCAN_UTF8_4(S) yylval.u= (((S)[0]&0x03)<<18)+(((S)[1]&0x3F)<<12)+(((S)[2]&0x3F)<<6)+((S)[3]&0x3F) + /*:46*/ /*57:*/ +#define SCAN_DECFLOAT yylval.f= atof(yytext) + /*:57*/ /*60:*/ +#define SCAN_HEXFLOAT yylval.f= xtof(yytext) + /*:60*/ /*152:*/ +#define SCAN_REF(K) yylval.rf.k= K; yylval.rf.n= atoi(yytext+2) +static int scan_level= 0; +#define SCAN_START yy_push_state(INITIAL);if (1==scan_level++) hpos0= hpos; +#define SCAN_END if (scan_level--) yy_pop_state(); else QUIT("Too many '>' in line %d",yylineno) +#define SCAN_TXT_START BEGIN(TXT) +#define SCAN_TXT_END BEGIN(INITIAL) + /*:152*/ + /*61:*/ + +float64_t xtof(char*x) +{ + #line 1369 "format.w" + int sign,digits,exp; + uint64_t mantissa= 0; + DBG(DBGFLOAT,"converting %s:\n",x); + /*62:*/ + if(*x=='-'){sign= -1;x++;} + else if(*x=='+'){sign= +1;x++;} + else sign= +1; + DBG(DBGFLOAT,"\tsign=%d\n",sign); + /*:62*/ + x= x+2; + /*63:*/ + digits= 0; + while(*x=='0')x++; + while(*x!='.') + {mantissa= mantissa<<4; + if(*x<'A')mantissa= mantissa+*x-'0'; + else mantissa= mantissa+*x-'A'+10; + x++; + digits++; + } + x++; + exp= 0; + while(*x!=0&&*x!='x') + {mantissa= mantissa<<4; + exp= exp-4; + if(*x<'A')mantissa= mantissa+*x-'0'; + else mantissa= mantissa+*x-'A'+10; + x++; + digits++; + } + DBG(DBGFLOAT,"\tdigits=%d mantissa=0x%"PRIx64", exp=%d\n",digits,mantissa,exp); + /*:63*/ + /*64:*/ + if(mantissa==0)return 0.0; + {int s; + s= digits-DBL_M_BITS/4; + if(s>1) + mantissa= mantissa>>(4*(s-1)); + else if(s<1) + mantissa= mantissa<<(4*(1-s)); + exp= exp+4*(digits-1); + DBG(DBGFLOAT,"\tdigits=%d mantissa=0x%"PRIx64", exp=%d\n",digits,mantissa,exp); + while((mantissa>>DBL_M_BITS)>1){mantissa= mantissa>>1;exp++;} + DBG(DBGFLOAT,"\tdigits=%d mantissa=0x%"PRIx64", exp=%d\n",digits,mantissa,exp); + mantissa= mantissa&~((uint64_t)1< +/* %endif */ +/* %if-c++-only */ +/* %endif */ +#endif + +#ifndef YY_EXTRA_TYPE +#define YY_EXTRA_TYPE void * +#endif + +/* %if-c-only Reentrant structure and macros (non-C++). */ +/* %if-reentrant */ +/* %if-c-only */ + +static int yy_init_globals ( void ); + +/* %endif */ +/* %if-reentrant */ +/* %endif */ +/* %endif End reentrant structures and macros. */ + +/* Accessor methods to globals. + These are made visible to non-reentrant scanners for convenience. */ + +int yylex_destroy ( void ); + +int yyget_debug ( void ); + +void yyset_debug ( int debug_flag ); + +YY_EXTRA_TYPE yyget_extra ( void ); + +void yyset_extra ( YY_EXTRA_TYPE user_defined ); + +FILE *yyget_in ( void ); + +void yyset_in ( FILE * _in_str ); + +FILE *yyget_out ( void ); + +void yyset_out ( FILE * _out_str ); + + int yyget_leng ( void ); + +char *yyget_text ( void ); + +int yyget_lineno ( void ); + +void yyset_lineno ( int _line_number ); + +/* %if-bison-bridge */ +/* %endif */ + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap ( void ); +#else +extern int yywrap ( void ); +#endif +#endif + +/* %not-for-header */ +#ifndef YY_NO_UNPUT + +#endif +/* %ok-for-header */ + +/* %endif */ + +#ifndef yytext_ptr +static void yy_flex_strncpy ( char *, const char *, int ); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen ( const char * ); +#endif + +#ifndef YY_NO_INPUT +/* %if-c-only Standard (non-C++) definition */ +/* %not-for-header */ +#ifdef __cplusplus +static int yyinput ( void ); +#else +static int input ( void ); +#endif +/* %ok-for-header */ + +/* %endif */ +#endif + +/* %if-c-only */ + + static int yy_start_stack_ptr = 0; + static int yy_start_stack_depth = 0; + static int *yy_start_stack = NULL; + + static void yy_push_state ( int _new_state ); + + static void yy_pop_state ( void ); + +/* %endif */ + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k */ +#define YY_READ_BUF_SIZE 16384 +#else +#define YY_READ_BUF_SIZE 8192 +#endif /* __ia64__ */ +#endif + +/* Copy whatever the last rule matched to the standard output. */ +#ifndef ECHO +/* %if-c-only Standard (non-C++) definition */ +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) +/* %endif */ +/* %if-c++-only C++ definition */ +/* %endif */ +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ +/* %% [5.0] fread()/read() definition of YY_INPUT goes here unless we're doing C++ \ */\ + if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ + { \ + int c = '*'; \ + int n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else \ + { \ + errno=0; \ + while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ + { \ + if( errno != EINTR) \ + { \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + break; \ + } \ + errno=0; \ + clearerr(yyin); \ + } \ + }\ +\ +/* %if-c++-only C++ definition \ */\ +/* %endif */ + +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +/* %if-c-only */ +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +/* %endif */ +/* %if-c++-only */ +/* %endif */ +#endif + +/* %if-tables-serialization structures and prototypes */ +/* %not-for-header */ +/* %ok-for-header */ + +/* %not-for-header */ +/* %tables-yydmap generated elements */ +/* %endif */ +/* end tables serialization structures and prototypes */ + +/* %ok-for-header */ + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL_IS_OURS 1 +/* %if-c-only Standard (non-C++) definition */ + +extern int yylex (void); + +#define YY_DECL int yylex (void) +/* %endif */ +/* %if-c++-only C++ definition */ +/* %endif */ +#endif /* !YY_DECL */ + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK /*LINTED*/break; +#endif + +/* %% [6.0] YY_RULE_SETUP definition goes here */ +#define YY_RULE_SETUP \ + YY_USER_ACTION + +/* %not-for-header */ +/** The main scanner function which does all the work. + */ +YY_DECL +{ + yy_state_type yy_current_state; + char *yy_cp, *yy_bp; + int yy_act; + + if ( !(yy_init) ) + { + (yy_init) = 1; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! (yy_start) ) + (yy_start) = 1; /* first start state */ + + if ( ! yyin ) +/* %if-c-only */ + yyin = stdin; +/* %endif */ +/* %if-c++-only */ +/* %endif */ + + if ( ! yyout ) +/* %if-c-only */ + yyout = stdout; +/* %endif */ +/* %if-c++-only */ +/* %endif */ + + if ( ! YY_CURRENT_BUFFER ) { + yyensure_buffer_stack (); + YY_CURRENT_BUFFER_LVALUE = + yy_create_buffer( yyin, YY_BUF_SIZE ); + } + + yy_load_buffer_state( ); + } + + { +/* %% [7.0] user's declarations go here */ +#line 168 "lexer.l" + + + /*3:*/ +#line 1295 "lexer.c" + + while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ + { +/* %% [8.0] yymore()-related code goes here */ + yy_cp = (yy_c_buf_p); + + /* Support of yytext. */ + *yy_cp = (yy_hold_char); + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + +/* %% [9.0] code to set up and find next match goes here */ + yy_current_state = (yy_start); +yy_match: + do + { + YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 371 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + ++yy_cp; + } + while ( yy_current_state != 370 ); + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + +yy_find_action: +/* %% [10.0] code to find the action number goes here */ + yy_act = yy_accept[yy_current_state]; + + YY_DO_BEFORE_ACTION; + +/* %% [11.0] code for yylineno update goes here */ + + if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] ) + { + int yyl; + for ( yyl = 0; yyl < yyleng; ++yyl ) + if ( yytext[yyl] == '\n' ) + + yylineno++; +; + } + +do_action: /* This label is used only to access EOF actions. */ + +/* %% [12.0] debug code goes here */ + if ( yy_flex_debug ) + { + if ( yy_act == 0 ) + fprintf( stderr, "--scanner backing up\n" ); + else if ( yy_act < 126 ) + fprintf( stderr, "--accepting rule at line %ld (\"%s\")\n", + (long)yy_rule_linenum[yy_act], yytext ); + else if ( yy_act == 126 ) + fprintf( stderr, "--accepting default rule (\"%s\")\n", + yytext ); + else if ( yy_act == 127 ) + fprintf( stderr, "--(end of buffer or a NUL)\n" ); + else + fprintf( stderr, "--EOF (start condition %d)\n", YY_START ); + } + + switch ( yy_act ) + { /* beginning of action switch */ +/* %% [13.0] actions go here */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = (yy_hold_char); + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 171 "lexer.l" +SCAN_START;return START; + YY_BREAK +case 2: +YY_RULE_SETUP +#line 172 "lexer.l" +SCAN_END;return END; + YY_BREAK +case 3: +YY_RULE_SETUP +#line 173 "lexer.l" +return GLYPH; + YY_BREAK +case 4: +YY_RULE_SETUP +#line 174 "lexer.l" +SCAN_UDEC(yytext);return UNSIGNED; + YY_BREAK +case 5: +YY_RULE_SETUP +#line 175 "lexer.l" +SCAN_UDEC(yytext+1);return REFERENCE; + YY_BREAK +case 6: +/* rule 6 can match eol */ +YY_RULE_SETUP +#line 176 "lexer.l" +; + YY_BREAK +case 7: +/* rule 7 can match eol */ +YY_RULE_SETUP +#line 177 "lexer.l" +; + YY_BREAK +/*:3*/ /*24:*/ +case 8: +YY_RULE_SETUP +#line 179 "lexer.l" +SCAN_HEX(yytext+2);return UNSIGNED; + YY_BREAK +/*:24*/ /*27:*/ +case 9: +YY_RULE_SETUP +#line 181 "lexer.l" +SCAN_DEC(yytext);return SIGNED; + YY_BREAK +/*:27*/ /*34:*/ +case 10: +YY_RULE_SETUP +#line 183 "lexer.l" +STR_START;BEGIN(STR); + YY_BREAK + +case 11: +YY_RULE_SETUP +#line 185 "lexer.l" +STR_END;SCAN_STR;BEGIN(INITIAL);return STRING; + YY_BREAK +case 12: +YY_RULE_SETUP +#line 186 "lexer.l" +STR_ADD('\''); + YY_BREAK +case 13: +YY_RULE_SETUP +#line 187 "lexer.l" +STR_ADD(yytext[0]); + YY_BREAK +case 14: +YY_RULE_SETUP +#line 188 "lexer.l" +RNG("String character",yytext[0],0x20,0x7E); + YY_BREAK +case 15: +/* rule 15 can match eol */ +YY_RULE_SETUP +#line 189 "lexer.l" +QUIT("Unterminated String in line %d",yylineno); + YY_BREAK + +/*:34*/ /*48:*/ +case 16: +YY_RULE_SETUP +#line 194 "lexer.l" +STR_START;STR_PUT('\'');BEGIN(STR); + YY_BREAK +case 17: +YY_RULE_SETUP +#line 195 "lexer.l" +SCAN_UTF8_1(yytext+1);return CHARCODE; + YY_BREAK +case 18: +YY_RULE_SETUP +#line 196 "lexer.l" +STR_START;STR_PUT(yytext[1]);STR_PUT('\'');BEGIN(STR); + YY_BREAK +case 19: +YY_RULE_SETUP +#line 197 "lexer.l" +STR_START;STR_PUT('\'');STR_PUT('\'');BEGIN(STR); + YY_BREAK +case 20: +/* rule 20 can match eol */ +YY_RULE_SETUP +#line 198 "lexer.l" +SCAN_UTF8_1(yytext+1);return CHARCODE; + YY_BREAK +case 21: +YY_RULE_SETUP +#line 199 "lexer.l" +SCAN_UTF8_2(yytext+1);return CHARCODE; + YY_BREAK +case 22: +YY_RULE_SETUP +#line 200 "lexer.l" +SCAN_UTF8_3(yytext+1);return CHARCODE; + YY_BREAK +case 23: +YY_RULE_SETUP +#line 201 "lexer.l" +SCAN_UTF8_4(yytext+1);return CHARCODE; + YY_BREAK +/*:48*/ /*55:*/ +case 24: +YY_RULE_SETUP +#line 203 "lexer.l" +SCAN_DECFLOAT;return FPNUM; + YY_BREAK +/*:55*/ /*59:*/ +case 25: +YY_RULE_SETUP +#line 205 "lexer.l" +SCAN_HEXFLOAT;return FPNUM; + YY_BREAK +/*:59*/ /*80:*/ +case 26: +YY_RULE_SETUP +#line 207 "lexer.l" +return DIMEN; + YY_BREAK +case 27: +YY_RULE_SETUP +#line 208 "lexer.l" +return PT; + YY_BREAK +case 28: +YY_RULE_SETUP +#line 209 "lexer.l" +return MM; + YY_BREAK +case 29: +YY_RULE_SETUP +#line 210 "lexer.l" +return INCH; + YY_BREAK +/*:80*/ /*88:*/ +case 30: +YY_RULE_SETUP +#line 212 "lexer.l" +return XDIMEN; + YY_BREAK +case 31: +YY_RULE_SETUP +#line 213 "lexer.l" +return H; + YY_BREAK +case 32: +YY_RULE_SETUP +#line 214 "lexer.l" +return V; + YY_BREAK +/*:88*/ /*99:*/ +case 33: +YY_RULE_SETUP +#line 216 "lexer.l" +return FIL; + YY_BREAK +case 34: +YY_RULE_SETUP +#line 217 "lexer.l" +return FILL; + YY_BREAK +case 35: +YY_RULE_SETUP +#line 218 "lexer.l" +return FILLL; + YY_BREAK +/*:99*/ /*103:*/ +case 36: +YY_RULE_SETUP +#line 220 "lexer.l" +return PENALTY; + YY_BREAK +case 37: +YY_RULE_SETUP +#line 221 "lexer.l" +return INTEGER; + YY_BREAK +/*:103*/ /*109:*/ +case 38: +YY_RULE_SETUP +#line 223 "lexer.l" +return LANGUAGE; + YY_BREAK +/*:109*/ /*115:*/ +case 39: +YY_RULE_SETUP +#line 225 "lexer.l" +return RULE; + YY_BREAK +case 40: +YY_RULE_SETUP +#line 226 "lexer.l" +return RUNNING; + YY_BREAK +case 41: +YY_RULE_SETUP +#line 227 "lexer.l" +return RUNNING; + YY_BREAK +/*:115*/ /*124:*/ +case 42: +YY_RULE_SETUP +#line 229 "lexer.l" +return KERN; + YY_BREAK +case 43: +YY_RULE_SETUP +#line 230 "lexer.l" +return EXPLICIT; + YY_BREAK +/*:124*/ /*133:*/ +case 44: +YY_RULE_SETUP +#line 232 "lexer.l" +return GLUE; + YY_BREAK +case 45: +YY_RULE_SETUP +#line 233 "lexer.l" +return PLUS; + YY_BREAK +case 46: +YY_RULE_SETUP +#line 234 "lexer.l" +return MINUS; + YY_BREAK +/*:133*/ /*151:*/ +case 47: +YY_RULE_SETUP +#line 236 "lexer.l" +SCAN_TXT_START;return TXT_START; + YY_BREAK + +case 48: +YY_RULE_SETUP +#line 239 "lexer.l" +SCAN_TXT_END;return TXT_END; + YY_BREAK +case 49: +YY_RULE_SETUP +#line 241 "lexer.l" +SCAN_START;return START; + YY_BREAK +case 50: +YY_RULE_SETUP +#line 242 "lexer.l" +QUIT("> not allowed in text mode"); + YY_BREAK +case 51: +YY_RULE_SETUP +#line 244 "lexer.l" +yylval.u= '\\';return TXT_CC; + YY_BREAK +case 52: +YY_RULE_SETUP +#line 245 "lexer.l" +yylval.u= '"';return TXT_CC; + YY_BREAK +case 53: +YY_RULE_SETUP +#line 246 "lexer.l" +yylval.u= '<';return TXT_CC; + YY_BREAK +case 54: +YY_RULE_SETUP +#line 247 "lexer.l" +yylval.u= '>';return TXT_CC; + YY_BREAK +case 55: +YY_RULE_SETUP +#line 248 "lexer.l" +yylval.u= ' ';return TXT_CC; + YY_BREAK +case 56: +YY_RULE_SETUP +#line 249 "lexer.l" +yylval.u= '-';return TXT_CC; + YY_BREAK +case 57: +YY_RULE_SETUP +#line 250 "lexer.l" +return TXT_IGNORE; + YY_BREAK +case 58: +/* rule 58 can match eol */ +YY_RULE_SETUP +#line 252 "lexer.l" +return TXT_FONT_GLUE; + YY_BREAK +case 59: +/* rule 59 can match eol */ +YY_RULE_SETUP +#line 253 "lexer.l" +; + YY_BREAK +case 60: +YY_RULE_SETUP +#line 255 "lexer.l" +yylval.u= yytext[1]-'0';return TXT_FONT; + YY_BREAK +case 61: +YY_RULE_SETUP +#line 257 "lexer.l" +SCAN_REF(font_kind);return TXT_GLOBAL; + YY_BREAK +case 62: +YY_RULE_SETUP +#line 258 "lexer.l" +SCAN_REF(penalty_kind);return TXT_GLOBAL; + YY_BREAK +case 63: +YY_RULE_SETUP +#line 259 "lexer.l" +SCAN_REF(kern_kind);return TXT_GLOBAL; + YY_BREAK +case 64: +YY_RULE_SETUP +#line 260 "lexer.l" +SCAN_REF(ligature_kind);return TXT_GLOBAL; + YY_BREAK +case 65: +YY_RULE_SETUP +#line 261 "lexer.l" +SCAN_REF(disc_kind);return TXT_GLOBAL; + YY_BREAK +case 66: +YY_RULE_SETUP +#line 262 "lexer.l" +SCAN_REF(glue_kind);return TXT_GLOBAL; + YY_BREAK +case 67: +YY_RULE_SETUP +#line 263 "lexer.l" +SCAN_REF(language_kind);return TXT_GLOBAL; + YY_BREAK +case 68: +YY_RULE_SETUP +#line 264 "lexer.l" +SCAN_REF(rule_kind);return TXT_GLOBAL; + YY_BREAK +case 69: +YY_RULE_SETUP +#line 265 "lexer.l" +SCAN_REF(image_kind);return TXT_GLOBAL; + YY_BREAK +case 70: +YY_RULE_SETUP +#line 268 "lexer.l" +SCAN_UDEC(yytext+2);return TXT_CC; + YY_BREAK +case 71: +YY_RULE_SETUP +#line 270 "lexer.l" +yylval.u= yytext[1]-'a';return TXT_LOCAL; + YY_BREAK +case 72: +YY_RULE_SETUP +#line 271 "lexer.l" +return TXT_FONT_GLUE; + YY_BREAK +case 73: +YY_RULE_SETUP +#line 272 "lexer.l" +return TXT_FONT_HYPHEN; + YY_BREAK +case 74: +/* rule 74 can match eol */ +YY_RULE_SETUP +#line 274 "lexer.l" +SCAN_UTF8_1(yytext);return TXT_CC; + YY_BREAK +case 75: +YY_RULE_SETUP +#line 275 "lexer.l" +SCAN_UTF8_2(yytext);return TXT_CC; + YY_BREAK +case 76: +YY_RULE_SETUP +#line 276 "lexer.l" +SCAN_UTF8_3(yytext);return TXT_CC; + YY_BREAK +case 77: +YY_RULE_SETUP +#line 277 "lexer.l" +SCAN_UTF8_4(yytext);return TXT_CC; + YY_BREAK + +/*:151*/ /*162:*/ +case 78: +YY_RULE_SETUP +#line 280 "lexer.l" +return HBOX; + YY_BREAK +case 79: +YY_RULE_SETUP +#line 281 "lexer.l" +return VBOX; + YY_BREAK +case 80: +YY_RULE_SETUP +#line 282 "lexer.l" +return SHIFTED; + YY_BREAK +/*:162*/ /*170:*/ +case 81: +YY_RULE_SETUP +#line 284 "lexer.l" +return HPACK; + YY_BREAK +case 82: +YY_RULE_SETUP +#line 285 "lexer.l" +return HSET; + YY_BREAK +case 83: +YY_RULE_SETUP +#line 286 "lexer.l" +return VPACK; + YY_BREAK +case 84: +YY_RULE_SETUP +#line 287 "lexer.l" +return VSET; + YY_BREAK +case 85: +YY_RULE_SETUP +#line 288 "lexer.l" +return ADD; + YY_BREAK +case 86: +YY_RULE_SETUP +#line 289 "lexer.l" +return TO; + YY_BREAK +case 87: +YY_RULE_SETUP +#line 290 "lexer.l" +return DEPTH; + YY_BREAK +/*:170*/ /*175:*/ +case 88: +YY_RULE_SETUP +#line 292 "lexer.l" +return LEADERS; + YY_BREAK +case 89: +YY_RULE_SETUP +#line 293 "lexer.l" +return ALIGN; + YY_BREAK +case 90: +YY_RULE_SETUP +#line 294 "lexer.l" +return CENTER; + YY_BREAK +case 91: +YY_RULE_SETUP +#line 295 "lexer.l" +return EXPAND; + YY_BREAK +/*:175*/ /*182:*/ +case 92: +YY_RULE_SETUP +#line 297 "lexer.l" +return BASELINE; + YY_BREAK +/*:182*/ /*189:*/ +case 93: +YY_RULE_SETUP +#line 299 "lexer.l" +return LIGATURE; + YY_BREAK +/*:189*/ /*197:*/ +case 94: +YY_RULE_SETUP +#line 301 "lexer.l" +return DISC; + YY_BREAK +/*:197*/ /*205:*/ +case 95: +YY_RULE_SETUP +#line 303 "lexer.l" +return PAR; + YY_BREAK +/*:205*/ /*210:*/ +case 96: +YY_RULE_SETUP +#line 305 "lexer.l" +return MATH; + YY_BREAK +/*:210*/ /*215:*/ +case 97: +YY_RULE_SETUP +#line 307 "lexer.l" +return ON; + YY_BREAK +case 98: +YY_RULE_SETUP +#line 308 "lexer.l" +return OFF; + YY_BREAK +/*:215*/ /*219:*/ +case 99: +YY_RULE_SETUP +#line 310 "lexer.l" +return ADJUST; + YY_BREAK +/*:219*/ /*223:*/ +case 100: +YY_RULE_SETUP +#line 312 "lexer.l" +return TABLE; + YY_BREAK +case 101: +YY_RULE_SETUP +#line 313 "lexer.l" +return ITEM; + YY_BREAK +case 102: +YY_RULE_SETUP +#line 314 "lexer.l" +return ITEM; + YY_BREAK +case 103: +YY_RULE_SETUP +#line 315 "lexer.l" +return ITEM; + YY_BREAK +/*:223*/ /*230:*/ +case 104: +YY_RULE_SETUP +#line 317 "lexer.l" +return IMAGE; + YY_BREAK +/*:230*/ /*247:*/ +case 105: +YY_RULE_SETUP +#line 319 "lexer.l" +return LABEL; + YY_BREAK +case 106: +YY_RULE_SETUP +#line 320 "lexer.l" +return BOT; + YY_BREAK +case 107: +YY_RULE_SETUP +#line 321 "lexer.l" +return MID; + YY_BREAK +/*:247*/ /*261:*/ +case 108: +YY_RULE_SETUP +#line 323 "lexer.l" +return LINK; + YY_BREAK +/*:261*/ /*271:*/ +case 109: +YY_RULE_SETUP +#line 325 "lexer.l" +return OUTLINE; + YY_BREAK +/*:271*/ /*278:*/ +case 110: +YY_RULE_SETUP +#line 327 "lexer.l" +if(section_no==1)return STREAMDEF;else return STREAM; + YY_BREAK +case 111: +YY_RULE_SETUP +#line 328 "lexer.l" +return FIRST; + YY_BREAK +case 112: +YY_RULE_SETUP +#line 329 "lexer.l" +return LAST; + YY_BREAK +case 113: +YY_RULE_SETUP +#line 330 "lexer.l" +return TOP; + YY_BREAK +case 114: +YY_RULE_SETUP +#line 331 "lexer.l" +return NOREFERENCE; + YY_BREAK +/*:278*/ /*288:*/ +case 115: +YY_RULE_SETUP +#line 333 "lexer.l" +return PAGE; + YY_BREAK +/*:288*/ /*296:*/ +case 116: +YY_RULE_SETUP +#line 335 "lexer.l" +return RANGE; + YY_BREAK +/*:296*/ /*323:*/ +case 117: +YY_RULE_SETUP +#line 337 "lexer.l" +return DIRECTORY; + YY_BREAK +case 118: +YY_RULE_SETUP +#line 338 "lexer.l" +return SECTION; + YY_BREAK +/*:323*/ /*342:*/ +case 119: +YY_RULE_SETUP +#line 340 "lexer.l" +return DEFINITIONS; + YY_BREAK +/*:342*/ /*350:*/ +case 120: +YY_RULE_SETUP +#line 342 "lexer.l" +return MAX; + YY_BREAK +/*:350*/ /*365:*/ +case 121: +YY_RULE_SETUP +#line 344 "lexer.l" +return PARAM; + YY_BREAK +/*:365*/ /*374:*/ +case 122: +YY_RULE_SETUP +#line 346 "lexer.l" +return FONT; + YY_BREAK +/*:374*/ /*402:*/ +case 123: +YY_RULE_SETUP +#line 348 "lexer.l" +return CONTENT; + YY_BREAK +/*:402*/ +case 124: +YY_RULE_SETUP +#line 350 "lexer.l" +QUIT("Unexpected keyword '%s' in line %d",yytext,yylineno); + YY_BREAK +case 125: +YY_RULE_SETUP +#line 351 "lexer.l" +QUIT("Unexpected character '%c' (0x%02X) in line %d",yytext[0]>' '?yytext[0]:' ',yytext[0],yylineno); + YY_BREAK +case 126: +YY_RULE_SETUP +#line 353 "lexer.l" +ECHO; + YY_BREAK +#line 2062 "lexer.c" +case YY_STATE_EOF(INITIAL): +case YY_STATE_EOF(STR): +case YY_STATE_EOF(TXT): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = (yy_hold_char); + YY_RESTORE_YY_MORE_OFFSET + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between YY_CURRENT_BUFFER and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; +/* %if-c-only */ + YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; +/* %endif */ +/* %if-c++-only */ +/* %endif */ + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( ); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++(yy_c_buf_p); + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { +/* %% [14.0] code to do back-up for compressed tables and set up yy_cp goes here */ + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer( ) ) + { + case EOB_ACT_END_OF_FILE: + { + (yy_did_buffer_switch_on_eof) = 0; + + if ( yywrap( ) ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! (yy_did_buffer_switch_on_eof) ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + (yy_c_buf_p) = + (yytext_ptr) + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( ); + + yy_cp = (yy_c_buf_p); + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + (yy_c_buf_p) = + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; + + yy_current_state = yy_get_previous_state( ); + + yy_cp = (yy_c_buf_p); + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of user's declarations */ +} /* end of yylex */ +/* %ok-for-header */ + +/* %if-c++-only */ +/* %not-for-header */ +/* %ok-for-header */ + +/* %endif */ + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ +/* %if-c-only */ +static int yy_get_next_buffer (void) +/* %endif */ +/* %if-c++-only */ +/* %endif */ +{ + char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; + char *source = (yytext_ptr); + int number_to_move, i; + int ret_val; + + if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1); + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; + + else + { + int num_to_read = + YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; + + int yy_c_buf_p_offset = + (int) ((yy_c_buf_p) - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yyrealloc( (void *) b->yy_ch_buf, + (yy_size_t) (b->yy_buf_size + 2) ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = NULL; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - + number_to_move - 1; + + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), + (yy_n_chars), num_to_read ); + + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + if ( (yy_n_chars) == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { + /* Extend the array by 50%, plus the number we really need. */ + int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( + (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size ); + if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); + /* "- 2" to take care of EOB's */ + YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); + } + + (yy_n_chars) += number_to_move; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; + + (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; + + return ret_val; +} + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +/* %if-c-only */ +/* %not-for-header */ + static yy_state_type yy_get_previous_state (void) +/* %endif */ +/* %if-c++-only */ +/* %endif */ +{ + yy_state_type yy_current_state; + char *yy_cp; + +/* %% [15.0] code to get the start state into yy_current_state goes here */ + yy_current_state = (yy_start); + + for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) + { +/* %% [16.0] code to find the next state goes here */ + YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 371 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + } + + return yy_current_state; +} + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ +/* %if-c-only */ + static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) +/* %endif */ +/* %if-c++-only */ +/* %endif */ +{ + int yy_is_jam; + /* %% [17.0] code to find the next state, and perhaps do backing up, goes here */ + char *yy_cp = (yy_c_buf_p); + + YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 371 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + yy_is_jam = (yy_current_state == 370); + + return yy_is_jam ? 0 : yy_current_state; +} + +#ifndef YY_NO_UNPUT +/* %if-c-only */ + +/* %endif */ +#endif + +/* %if-c-only */ +#ifndef YY_NO_INPUT +#ifdef __cplusplus + static int yyinput (void) +#else + static int input (void) +#endif + +/* %endif */ +/* %if-c++-only */ +/* %endif */ +{ + int c; + + *(yy_c_buf_p) = (yy_hold_char); + + if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) + /* This was really a NUL. */ + *(yy_c_buf_p) = '\0'; + + else + { /* need more input */ + int offset = (int) ((yy_c_buf_p) - (yytext_ptr)); + ++(yy_c_buf_p); + + switch ( yy_get_next_buffer( ) ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /*FALLTHROUGH*/ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap( ) ) + return 0; + + if ( ! (yy_did_buffer_switch_on_eof) ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + (yy_c_buf_p) = (yytext_ptr) + offset; + break; + } + } + } + + c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ + *(yy_c_buf_p) = '\0'; /* preserve yytext */ + (yy_hold_char) = *++(yy_c_buf_p); + +/* %% [19.0] update BOL and yylineno */ + if ( c == '\n' ) + + yylineno++; +; + + return c; +} +/* %if-c-only */ +#endif /* ifndef YY_NO_INPUT */ +/* %endif */ + +/** Immediately switch to a different input stream. + * @param input_file A readable stream. + * + * @note This function does not reset the start condition to @c INITIAL . + */ +/* %if-c-only */ + void yyrestart (FILE * input_file ) +/* %endif */ +/* %if-c++-only */ +/* %endif */ +{ + + if ( ! YY_CURRENT_BUFFER ){ + yyensure_buffer_stack (); + YY_CURRENT_BUFFER_LVALUE = + yy_create_buffer( yyin, YY_BUF_SIZE ); + } + + yy_init_buffer( YY_CURRENT_BUFFER, input_file ); + yy_load_buffer_state( ); +} + +/* %if-c++-only */ +/* %endif */ + +/** Switch to a different input buffer. + * @param new_buffer The new input buffer. + * + */ +/* %if-c-only */ + void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) +/* %endif */ +/* %if-c++-only */ +/* %endif */ +{ + + /* TODO. We should be able to replace this entire function body + * with + * yypop_buffer_state(); + * yypush_buffer_state(new_buffer); + */ + yyensure_buffer_stack (); + if ( YY_CURRENT_BUFFER == new_buffer ) + return; + + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *(yy_c_buf_p) = (yy_hold_char); + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + YY_CURRENT_BUFFER_LVALUE = new_buffer; + yy_load_buffer_state( ); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + (yy_did_buffer_switch_on_eof) = 1; +} + +/* %if-c-only */ +static void yy_load_buffer_state (void) +/* %endif */ +/* %if-c++-only */ +/* %endif */ +{ + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; +/* %if-c-only */ + yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; +/* %endif */ +/* %if-c++-only */ +/* %endif */ + (yy_hold_char) = *(yy_c_buf_p); +} + +/** Allocate and initialize an input buffer state. + * @param file A readable stream. + * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. + * + * @return the allocated buffer state. + */ +/* %if-c-only */ + YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) +/* %endif */ +/* %if-c++-only */ +/* %endif */ +{ + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; +} + +/* %if-c++-only */ +/* %endif */ + +/** Destroy the buffer. + * @param b a buffer created with yy_create_buffer() + * + */ +/* %if-c-only */ + void yy_delete_buffer (YY_BUFFER_STATE b ) +/* %endif */ +/* %if-c++-only */ +/* %endif */ +{ + + if ( ! b ) + return; + + if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ + YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yyfree( (void *) b->yy_ch_buf ); + + yyfree( (void *) b ); +} + +/* Initializes or reinitializes a buffer. + * This function is sometimes called more than once on the same buffer, + * such as during a yyrestart() or at EOF. + */ +/* %if-c-only */ + static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) +/* %endif */ +/* %if-c++-only */ +/* %endif */ + +{ + int oerrno = errno; + + yy_flush_buffer( b ); + +/* %if-c-only */ + b->yy_input_file = file; +/* %endif */ +/* %if-c++-only */ +/* %endif */ + b->yy_fill_buffer = 1; + + /* If b is the current buffer, then yy_init_buffer was _probably_ + * called from yyrestart() or through yy_get_next_buffer. + * In that case, we don't want to reset the lineno or column. + */ + if (b != YY_CURRENT_BUFFER){ + b->yy_bs_lineno = 1; + b->yy_bs_column = 0; + } + +/* %if-c-only */ + + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; + +/* %endif */ +/* %if-c++-only */ +/* %endif */ + errno = oerrno; +} + +/** Discard all buffered characters. On the next scan, YY_INPUT will be called. + * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. + * + */ +/* %if-c-only */ + void yy_flush_buffer (YY_BUFFER_STATE b ) +/* %endif */ +/* %if-c++-only */ +/* %endif */ +{ + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == YY_CURRENT_BUFFER ) + yy_load_buffer_state( ); +} + +/* %if-c-or-c++ */ +/** Pushes the new state onto the stack. The new state becomes + * the current state. This function will allocate the stack + * if necessary. + * @param new_buffer The new state. + * + */ +/* %if-c-only */ +void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) +/* %endif */ +/* %if-c++-only */ +/* %endif */ +{ + if (new_buffer == NULL) + return; + + yyensure_buffer_stack(); + + /* This block is copied from yy_switch_to_buffer. */ + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *(yy_c_buf_p) = (yy_hold_char); + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + /* Only push if top exists. Otherwise, replace top. */ + if (YY_CURRENT_BUFFER) + (yy_buffer_stack_top)++; + YY_CURRENT_BUFFER_LVALUE = new_buffer; + + /* copied from yy_switch_to_buffer. */ + yy_load_buffer_state( ); + (yy_did_buffer_switch_on_eof) = 1; +} +/* %endif */ + +/* %if-c-or-c++ */ +/** Removes and deletes the top of the stack, if present. + * The next element becomes the new top. + * + */ +/* %if-c-only */ +void yypop_buffer_state (void) +/* %endif */ +/* %if-c++-only */ +/* %endif */ +{ + if (!YY_CURRENT_BUFFER) + return; + + yy_delete_buffer(YY_CURRENT_BUFFER ); + YY_CURRENT_BUFFER_LVALUE = NULL; + if ((yy_buffer_stack_top) > 0) + --(yy_buffer_stack_top); + + if (YY_CURRENT_BUFFER) { + yy_load_buffer_state( ); + (yy_did_buffer_switch_on_eof) = 1; + } +} +/* %endif */ + +/* %if-c-or-c++ */ +/* Allocates the stack if it does not exist. + * Guarantees space for at least one push. + */ +/* %if-c-only */ +static void yyensure_buffer_stack (void) +/* %endif */ +/* %if-c++-only */ +/* %endif */ +{ + yy_size_t num_to_alloc; + + if (!(yy_buffer_stack)) { + + /* First allocation is just for 2 elements, since we don't know if this + * scanner will even need a stack. We use 2 instead of 1 to avoid an + * immediate realloc on the next call. + */ + num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ + (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc + (num_to_alloc * sizeof(struct yy_buffer_state*) + ); + if ( ! (yy_buffer_stack) ) + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); + + memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); + + (yy_buffer_stack_max) = num_to_alloc; + (yy_buffer_stack_top) = 0; + return; + } + + if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ + + /* Increase the buffer to prepare for a possible push. */ + yy_size_t grow_size = 8 /* arbitrary grow size */; + + num_to_alloc = (yy_buffer_stack_max) + grow_size; + (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc + ((yy_buffer_stack), + num_to_alloc * sizeof(struct yy_buffer_state*) + ); + if ( ! (yy_buffer_stack) ) + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); + + /* zero only the new slots.*/ + memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); + (yy_buffer_stack_max) = num_to_alloc; + } +} +/* %endif */ + +/* %if-c-only */ +/** Setup the input buffer state to scan directly from a user-specified character buffer. + * @param base the character buffer + * @param size the size in bytes of the character buffer + * + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) +{ + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return NULL; + + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = NULL; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; +} +/* %endif */ + +/* %if-c-only */ +/** Setup the input buffer state to scan a string. The next call to yylex() will + * scan from a @e copy of @a str. + * @param yystr a NUL-terminated string to scan + * + * @return the newly allocated buffer state object. + * @note If you want to scan bytes that may contain NUL values, then use + * yy_scan_bytes() instead. + */ +YY_BUFFER_STATE yy_scan_string (const char * yystr ) +{ + + return yy_scan_bytes( yystr, (int) strlen(yystr) ); +} +/* %endif */ + +/* %if-c-only */ +/** Setup the input buffer state to scan the given bytes. The next call to yylex() will + * scan from a @e copy of @a bytes. + * @param yybytes the byte buffer to scan + * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. + * + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len ) +{ + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = (yy_size_t) (_yybytes_len + 2); + buf = (char *) yyalloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < _yybytes_len; ++i ) + buf[i] = yybytes[i]; + + buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; +} +/* %endif */ + +/* %if-c-only */ + static void yy_push_state (int _new_state ) +/* %endif */ +/* %if-c++-only */ +/* %endif */ +{ + if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) ) + { + yy_size_t new_size; + + (yy_start_stack_depth) += YY_START_STACK_INCR; + new_size = (yy_size_t) (yy_start_stack_depth) * sizeof( int ); + + if ( ! (yy_start_stack) ) + (yy_start_stack) = (int *) yyalloc( new_size ); + + else + (yy_start_stack) = (int *) yyrealloc( + (void *) (yy_start_stack), new_size ); + + if ( ! (yy_start_stack) ) + YY_FATAL_ERROR( "out of memory expanding start-condition stack" ); + } + + (yy_start_stack)[(yy_start_stack_ptr)++] = YY_START; + + BEGIN(_new_state); +} + +/* %if-c-only */ + static void yy_pop_state (void) +/* %endif */ +/* %if-c++-only */ +/* %endif */ +{ + if ( --(yy_start_stack_ptr) < 0 ) + YY_FATAL_ERROR( "start-condition stack underflow" ); + + BEGIN((yy_start_stack)[(yy_start_stack_ptr)]); +} + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +/* %if-c-only */ +static void yynoreturn yy_fatal_error (const char* msg ) +{ + fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); +} +/* %endif */ +/* %if-c++-only */ +/* %endif */ + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + int yyless_macro_arg = (n); \ + YY_LESS_LINENO(yyless_macro_arg);\ + yytext[yyleng] = (yy_hold_char); \ + (yy_c_buf_p) = yytext + yyless_macro_arg; \ + (yy_hold_char) = *(yy_c_buf_p); \ + *(yy_c_buf_p) = '\0'; \ + yyleng = yyless_macro_arg; \ + } \ + while ( 0 ) + +/* Accessor methods (get/set functions) to struct members. */ + +/* %if-c-only */ +/* %if-reentrant */ +/* %endif */ + +/** Get the current line number. + * + */ +int yyget_lineno (void) +{ + + return yylineno; +} + +/** Get the input stream. + * + */ +FILE *yyget_in (void) +{ + return yyin; +} + +/** Get the output stream. + * + */ +FILE *yyget_out (void) +{ + return yyout; +} + +/** Get the length of the current token. + * + */ +int yyget_leng (void) +{ + return yyleng; +} + +/** Get the current token. + * + */ + +char *yyget_text (void) +{ + return yytext; +} + +/* %if-reentrant */ +/* %endif */ + +/** Set the current line number. + * @param _line_number line number + * + */ +void yyset_lineno (int _line_number ) +{ + + yylineno = _line_number; +} + +/** Set the input stream. This does not discard the current + * input buffer. + * @param _in_str A readable stream. + * + * @see yy_switch_to_buffer + */ +void yyset_in (FILE * _in_str ) +{ + yyin = _in_str ; +} + +void yyset_out (FILE * _out_str ) +{ + yyout = _out_str ; +} + +int yyget_debug (void) +{ + return yy_flex_debug; +} + +void yyset_debug (int _bdebug ) +{ + yy_flex_debug = _bdebug ; +} + +/* %endif */ + +/* %if-reentrant */ +/* %if-bison-bridge */ +/* %endif */ +/* %endif if-c-only */ + +/* %if-c-only */ +static int yy_init_globals (void) +{ + /* Initialization is the same as for the non-reentrant scanner. + * This function is called from yylex_destroy(), so don't allocate here. + */ + + /* We do not touch yylineno unless the option is enabled. */ + yylineno = 1; + + (yy_buffer_stack) = NULL; + (yy_buffer_stack_top) = 0; + (yy_buffer_stack_max) = 0; + (yy_c_buf_p) = NULL; + (yy_init) = 0; + (yy_start) = 0; + + (yy_start_stack_ptr) = 0; + (yy_start_stack_depth) = 0; + (yy_start_stack) = NULL; + +/* Defined in main.c */ +#ifdef YY_STDINIT + yyin = stdin; + yyout = stdout; +#else + yyin = NULL; + yyout = NULL; +#endif + + /* For future reference: Set errno on error, since we are called by + * yylex_init() + */ + return 0; +} +/* %endif */ + +/* %if-c-only SNIP! this currently causes conflicts with the c++ scanner */ +/* yylex_destroy is for both reentrant and non-reentrant scanners. */ +int yylex_destroy (void) +{ + + /* Pop the buffer stack, destroying each element. */ + while(YY_CURRENT_BUFFER){ + yy_delete_buffer( YY_CURRENT_BUFFER ); + YY_CURRENT_BUFFER_LVALUE = NULL; + yypop_buffer_state(); + } + + /* Destroy the stack itself. */ + yyfree((yy_buffer_stack) ); + (yy_buffer_stack) = NULL; + + /* Destroy the start condition stack. */ + yyfree( (yy_start_stack) ); + (yy_start_stack) = NULL; + + /* Reset the globals. This is important in a non-reentrant scanner so the next time + * yylex() is called, initialization will occur. */ + yy_init_globals( ); + +/* %if-reentrant */ +/* %endif */ + return 0; +} +/* %endif */ + +/* + * Internal utility routines. + */ + +#ifndef yytext_ptr +static void yy_flex_strncpy (char* s1, const char * s2, int n ) +{ + + int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; +} +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen (const char * s ) +{ + int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; +} +#endif + +void *yyalloc (yy_size_t size ) +{ + return malloc(size); +} + +void *yyrealloc (void * ptr, yy_size_t size ) +{ + + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return realloc(ptr, size); +} + +void yyfree (void * ptr ) +{ + free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ +} + +/* %if-tables-serialization definitions */ +/* %define-yytables The name for this specific scanner's tables. */ +#define YYTABLES_NAME "yytables" +/* %endif */ + +/* %ok-for-header */ + +#line 353 "lexer.l" + + /*:509*/ + diff --git a/Build/source/texk/web2c/hitexdir/hilexer.l b/Build/source/texk/web2c/hitexdir/hilexer.l new file mode 100644 index 00000000000..1f7280727c9 --- /dev/null +++ b/Build/source/texk/web2c/hitexdir/hilexer.l @@ -0,0 +1,353 @@ + /*509:*/ +%{ + #line 10171 "format.w" + +#include "hibasetypes.h" +#include "hierror.h" +#include "hiformat.h" +#include "hiput.h" + + /*423:*/ +#ifdef DEBUG +#define YYDEBUG 1 +extern int yydebug; +#else +#define YYDEBUG 0 +#endif + /*:423*/ +#include "hiparser.h" + + /*22:*/ +#define SCAN_UDEC(S) yylval.u= strtoul(S,NULL,10) + /*:22*/ /*25:*/ +#define SCAN_HEX(S) yylval.u= strtoul(S,NULL,16) + /*:25*/ /*28:*/ +#define SCAN_DEC(S) yylval.i= strtol(S,NULL,10) + /*:28*/ /*31:*/ +#define MAX_STR (1<<10) +static char str_buffer[MAX_STR]; +static int str_length; +#define STR_START (str_length= 0) +#define STR_PUT(C) (str_buffer[str_length++]= (C)) +#define STR_ADD(C) STR_PUT(C);RNG("String length",str_length,0,MAX_STR-1) +#define STR_END str_buffer[str_length]= 0 +#define SCAN_STR yylval.s= str_buffer + /*:31*/ /*40:*/ +#define SCAN_UTF8_1(S) yylval.u= ((S)[0]&0x7F) + /*:40*/ /*42:*/ +#define SCAN_UTF8_2(S) yylval.u= (((S)[0]&0x1F)<<6)+((S)[1]&0x3F) + /*:42*/ /*44:*/ +#define SCAN_UTF8_3(S) yylval.u= (((S)[0]&0x0F)<<12)+(((S)[1]&0x3F)<<6)+((S)[2]&0x3F) + /*:44*/ /*46:*/ +#define SCAN_UTF8_4(S) yylval.u= (((S)[0]&0x03)<<18)+(((S)[1]&0x3F)<<12)+(((S)[2]&0x3F)<<6)+((S)[3]&0x3F) + /*:46*/ /*57:*/ +#define SCAN_DECFLOAT yylval.f= atof(yytext) + /*:57*/ /*60:*/ +#define SCAN_HEXFLOAT yylval.f= xtof(yytext) + /*:60*/ /*152:*/ +#define SCAN_REF(K) yylval.rf.k= K; yylval.rf.n= atoi(yytext+2) +static int scan_level= 0; +#define SCAN_START yy_push_state(INITIAL);if (1==scan_level++) hpos0= hpos; +#define SCAN_END if (scan_level--) yy_pop_state(); else QUIT("Too many '>' in line %d",yylineno) +#define SCAN_TXT_START BEGIN(TXT) +#define SCAN_TXT_END BEGIN(INITIAL) + /*:152*/ + /*61:*/ + +float64_t xtof(char*x) +{ + #line 1369 "format.w" + int sign,digits,exp; + uint64_t mantissa= 0; + DBG(DBGFLOAT,"converting %s:\n",x); + /*62:*/ + if(*x=='-'){sign= -1;x++;} + else if(*x=='+'){sign= +1;x++;} + else sign= +1; + DBG(DBGFLOAT,"\tsign=%d\n",sign); + /*:62*/ + x= x+2; + /*63:*/ + digits= 0; + while(*x=='0')x++; + while(*x!='.') + {mantissa= mantissa<<4; + if(*x<'A')mantissa= mantissa+*x-'0'; + else mantissa= mantissa+*x-'A'+10; + x++; + digits++; + } + x++; + exp= 0; + while(*x!=0&&*x!='x') + {mantissa= mantissa<<4; + exp= exp-4; + if(*x<'A')mantissa= mantissa+*x-'0'; + else mantissa= mantissa+*x-'A'+10; + x++; + digits++; + } + DBG(DBGFLOAT,"\tdigits=%d mantissa=0x%"PRIx64", exp=%d\n",digits,mantissa,exp); + /*:63*/ + /*64:*/ + if(mantissa==0)return 0.0; + {int s; + s= digits-DBL_M_BITS/4; + if(s>1) + mantissa= mantissa>>(4*(s-1)); + else if(s<1) + mantissa= mantissa<<(4*(1-s)); + exp= exp+4*(digits-1); + DBG(DBGFLOAT,"\tdigits=%d mantissa=0x%"PRIx64", exp=%d\n",digits,mantissa,exp); + while((mantissa>>DBL_M_BITS)>1){mantissa= mantissa>>1;exp++;} + DBG(DBGFLOAT,"\tdigits=%d mantissa=0x%"PRIx64", exp=%d\n",digits,mantissa,exp); + mantissa= mantissa&~((uint64_t)1<" SCAN_END;return END; +glyph return GLYPH; +0|[1-9][0-9]* SCAN_UDEC(yytext);return UNSIGNED; +\*(0|[1-9][0-9]*) SCAN_UDEC(yytext+1);return REFERENCE; +[[:space:]] ; +\([^()\n]*[)\n] ; + /*:3*/ /*24:*/ +0x{HEX}+ SCAN_HEX(yytext+2);return UNSIGNED; + /*:24*/ /*27:*/ +[+-](0|[1-9][0-9]*) SCAN_DEC(yytext);return SIGNED; + /*:27*/ /*34:*/ +' STR_START;BEGIN(STR); +{ +' STR_END;SCAN_STR;BEGIN(INITIAL);return STRING; +'' STR_ADD('\''); +[\x20-\x7E] STR_ADD(yytext[0]); +. RNG("String character",yytext[0],0x20,0x7E); +\n QUIT("Unterminated String in line %d",yylineno); +} + + + /*:34*/ /*48:*/ +''' STR_START;STR_PUT('\'');BEGIN(STR); +'''' SCAN_UTF8_1(yytext+1);return CHARCODE; +'[\x20-\x7E]'' STR_START;STR_PUT(yytext[1]);STR_PUT('\'');BEGIN(STR); +''''' STR_START;STR_PUT('\'');STR_PUT('\'');BEGIN(STR); +'{UTF8_1}' SCAN_UTF8_1(yytext+1);return CHARCODE; +'{UTF8_2}' SCAN_UTF8_2(yytext+1);return CHARCODE; +'{UTF8_3}' SCAN_UTF8_3(yytext+1);return CHARCODE; +'{UTF8_4}' SCAN_UTF8_4(yytext+1);return CHARCODE; + /*:48*/ /*55:*/ +[+-]?[0-9]+\.[0-9]+(e[+-]?[0-9])? SCAN_DECFLOAT;return FPNUM; + /*:55*/ /*59:*/ +[+-]?0x{HEX}+\.{HEX}+(x[+-]?{HEX}+)? SCAN_HEXFLOAT;return FPNUM; + /*:59*/ /*80:*/ +dimen return DIMEN; +pt return PT; +mm return MM; +in return INCH; + /*:80*/ /*88:*/ +xdimen return XDIMEN; +h return H; +v return V; + /*:88*/ /*99:*/ +fil return FIL; +fill return FILL; +filll return FILLL; + /*:99*/ /*103:*/ +penalty return PENALTY; +int return INTEGER; + /*:103*/ /*109:*/ +language return LANGUAGE; + /*:109*/ /*115:*/ +rule return RULE; +"|" return RUNNING; +"_" return RUNNING; + /*:115*/ /*124:*/ +kern return KERN; +! return EXPLICIT; + /*:124*/ /*133:*/ +glue return GLUE; +plus return PLUS; +minus return MINUS; + /*:133*/ /*151:*/ +\" SCAN_TXT_START;return TXT_START; + +{ +\" SCAN_TXT_END;return TXT_END; + +"<" SCAN_START;return START; +">" QUIT("> not allowed in text mode"); + +\\\\ yylval.u= '\\';return TXT_CC; +\\\" yylval.u= '"';return TXT_CC; +\\"<" yylval.u= '<';return TXT_CC; +\\">" yylval.u= '>';return TXT_CC; +\\" " yylval.u= ' ';return TXT_CC; +\\"-" yylval.u= '-';return TXT_CC; +\\"@" return TXT_IGNORE; + +[ \t\r]*(\n[ \t\r]*)+ return TXT_FONT_GLUE; +\\[ \t\r]*\n[ \t\r]* ; + +\\[0-7] yylval.u= yytext[1]-'0';return TXT_FONT; + +\\F[0-9]+\\ SCAN_REF(font_kind);return TXT_GLOBAL; +\\P[0-9]+\\ SCAN_REF(penalty_kind);return TXT_GLOBAL; +\\K[0-9]+\\ SCAN_REF(kern_kind);return TXT_GLOBAL; +\\L[0-9]+\\ SCAN_REF(ligature_kind);return TXT_GLOBAL; +\\D[0-9]+\\ SCAN_REF(disc_kind);return TXT_GLOBAL; +\\G[0-9]+\\ SCAN_REF(glue_kind);return TXT_GLOBAL; +\\S[0-9]+\\ SCAN_REF(language_kind);return TXT_GLOBAL; +\\R[0-9]+\\ SCAN_REF(rule_kind);return TXT_GLOBAL; +\\I[0-9]+\\ SCAN_REF(image_kind);return TXT_GLOBAL; + + +\\C[0-9]+\\ SCAN_UDEC(yytext+2);return TXT_CC; + +\\[a-l] yylval.u= yytext[1]-'a';return TXT_LOCAL; +" " return TXT_FONT_GLUE; +"-" return TXT_FONT_HYPHEN; + +{UTF8_1} SCAN_UTF8_1(yytext);return TXT_CC; +{UTF8_2} SCAN_UTF8_2(yytext);return TXT_CC; +{UTF8_3} SCAN_UTF8_3(yytext);return TXT_CC; +{UTF8_4} SCAN_UTF8_4(yytext);return TXT_CC; +} + /*:151*/ /*162:*/ +hbox return HBOX; +vbox return VBOX; +shifted return SHIFTED; + /*:162*/ /*170:*/ +hpack return HPACK; +hset return HSET; +vpack return VPACK; +vset return VSET; +add return ADD; +to return TO; +depth return DEPTH; + /*:170*/ /*175:*/ +leaders return LEADERS; +align return ALIGN; +center return CENTER; +expand return EXPAND; + /*:175*/ /*182:*/ +baseline return BASELINE; + /*:182*/ /*189:*/ +ligature return LIGATURE; + /*:189*/ /*197:*/ +disc return DISC; + /*:197*/ /*205:*/ +par return PAR; + /*:205*/ /*210:*/ +math return MATH; + /*:210*/ /*215:*/ +on return ON; +off return OFF; + /*:215*/ /*219:*/ +adjust return ADJUST; + /*:219*/ /*223:*/ +table return TABLE; +item return ITEM; +row return ITEM; +column return ITEM; + /*:223*/ /*230:*/ +image return IMAGE; + /*:230*/ /*247:*/ +label return LABEL; +bot return BOT; +mid return MID; + /*:247*/ /*261:*/ +link return LINK; + /*:261*/ /*271:*/ +outline return OUTLINE; + /*:271*/ /*278:*/ +stream if(section_no==1)return STREAMDEF;else return STREAM; +first return FIRST; +last return LAST; +top return TOP; +\* return NOREFERENCE; + /*:278*/ /*288:*/ +page return PAGE; + /*:288*/ /*296:*/ +range return RANGE; + /*:296*/ /*323:*/ +directory return DIRECTORY; +section return SECTION; + /*:323*/ /*342:*/ +definitions return DEFINITIONS; + /*:342*/ /*350:*/ +max return MAX; + /*:350*/ /*365:*/ +param return PARAM; + /*:365*/ /*374:*/ +font return FONT; + /*:374*/ /*402:*/ +content return CONTENT; + /*:402*/ +[a-z]+ QUIT("Unexpected keyword '%s' in line %d",yytext,yylineno); +. QUIT("Unexpected character '%c' (0x%02X) in line %d",yytext[0]>' '?yytext[0]:' ',yytext[0],yylineno); + +%% + /*:509*/ diff --git a/Build/source/texk/web2c/hitexdir/hiparser.c b/Build/source/texk/web2c/hitexdir/hiparser.c new file mode 100644 index 00000000000..947f2141169 --- /dev/null +++ b/Build/source/texk/web2c/hitexdir/hiparser.c @@ -0,0 +1,4132 @@ +/* A Bison parser, made by GNU Bison 3.8.2. */ + +/* Bison implementation for Yacc-like parsers in C + + Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation, + Inc. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +/* As a special exception, you may create a larger work that contains + part or all of the Bison parser skeleton and distribute that work + under terms of your choice, so long as that work isn't itself a + parser generator using the skeleton or a modified version thereof + as a parser skeleton. Alternatively, if you modify or redistribute + the parser skeleton itself, you may (at your option) remove this + special exception, which will cause the skeleton and the resulting + Bison output files to be licensed under the GNU General Public + License without this special exception. + + This special exception was added by the Free Software Foundation in + version 2.2 of Bison. */ + +/* C LALR(1) parser skeleton written by Richard Stallman, by + simplifying the original so-called "semantic" parser. */ + +/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, + especially those whose name start with YY_ or yy_. They are + private implementation details that can be changed or removed. */ + +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +/* Identify Bison output, and Bison version. */ +#define YYBISON 30802 + +/* Bison version string. */ +#define YYBISON_VERSION "3.8.2" + +/* Skeleton name. */ +#define YYSKELETON_NAME "yacc.c" + +/* Pure parsers. */ +#define YYPURE 0 + +/* Push parsers. */ +#define YYPUSH 0 + +/* Pull parsers. */ +#define YYPULL 1 + + + + +/* First part of user prologue. */ +#line 2 "parser.y" + + #line 10212 "format.w" + +#include "hibasetypes.h" +#include +#include +#include "hierror.h" +#include "hiformat.h" +#include "hiput.h" +extern char**hfont_name; + + /*356:*/ +uint32_t definition_bits[0x100/32][32]= { + #line 7578 "format.w" + {0}}; + +#define SET_DBIT(N,K) ((N)>0xFF?1:(definition_bits[N/32][K] |= (1<<((N)&(32-1))))) +#define GET_DBIT(N,K) ((N)>0xFF?1:((definition_bits[N/32][K]>>((N)&(32-1)))&1)) +#define DEF(D,K,N) (D).k= K; (D).n= (N);SET_DBIT((D).n,(D).k);\ + DBG(DBGDEF,"Defining %s %d\n",definition_name[(D).k],(D).n);\ + RNG("Definition",(D).n,max_fixed[(D).k]+1,max_ref[(D).k]); +#define REF(K,N) REF_RNG(K,N);if(!GET_DBIT(N,K)) \ + QUIT("Reference %d to %s before definition",(N),definition_name[K]) + /*:356*/ /*360:*/ +#define DEF_REF(D,K,M,N) DEF(D,K,M);\ +if ((M)>max_default[K]) QUIT("Defining non default reference %d for %s",M,definition_name[K]); \ +if ((N)>max_fixed[K]) QUIT("Defining reference %d for %s by non fixed reference %d",M,definition_name[K],N); + /*:360*/ + +extern void hset_entry(entry_t*e,uint16_t i,uint32_t size, +uint32_t xsize,char*file_name); + + /*423:*/ +#ifdef DEBUG +#define YYDEBUG 1 +extern int yydebug; +#else +#define YYDEBUG 0 +#endif + /*:423*/ +extern int yylex(void); + + /*352:*/ +void hset_max(kind_t k,int n) +{ + #line 7421 "format.w" + DBG(DBGDEF,"Setting max %s to %d\n",definition_name[k],n); + RNG("Maximum",n,max_fixed[k]+1,MAX_REF(k)); + if(n>max_ref[k]) + max_ref[k]= n; + } + /*:352*/ /*363:*/ +void check_param_def(ref_t*df) +{ + #line 7727 "format.w" + if(df->k!=int_kind&&df->k!=dimen_kind&&df->k!=glue_kind) + QUIT("Kind %s not allowed in parameter list",definition_name[df->k]); + if(df->n<=max_fixed[df->k]||max_default[df->k]n) + QUIT("Parameter %d for %s not allowed in parameter list",df->n,definition_name[df->k]); + } + /*:363*/ /*422:*/ +extern int yylineno; +int yyerror(const char*msg) +{ + #line 8799 "format.w" + QUIT(" in line %d %s",yylineno,msg); + return 0; + } + /*:422*/ + + + +#line 144 "parser.c" + +# ifndef YY_CAST +# ifdef __cplusplus +# define YY_CAST(Type, Val) static_cast (Val) +# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast (Val) +# else +# define YY_CAST(Type, Val) ((Type) (Val)) +# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val)) +# endif +# endif +# ifndef YY_NULLPTR +# if defined __cplusplus +# if 201103L <= __cplusplus +# define YY_NULLPTR nullptr +# else +# define YY_NULLPTR 0 +# endif +# else +# define YY_NULLPTR ((void*)0) +# endif +# endif + +#include "hiparser.h" +/* Symbol kind. */ +enum yysymbol_kind_t +{ + YYSYMBOL_YYEMPTY = -2, + YYSYMBOL_YYEOF = 0, /* "end of file" */ + YYSYMBOL_YYerror = 1, /* error */ + YYSYMBOL_YYUNDEF = 2, /* "invalid token" */ + YYSYMBOL_START = 3, /* "<" */ + YYSYMBOL_END = 4, /* ">" */ + YYSYMBOL_GLYPH = 5, /* "glyph" */ + YYSYMBOL_UNSIGNED = 6, /* UNSIGNED */ + YYSYMBOL_REFERENCE = 7, /* REFERENCE */ + YYSYMBOL_SIGNED = 8, /* SIGNED */ + YYSYMBOL_STRING = 9, /* STRING */ + YYSYMBOL_CHARCODE = 10, /* CHARCODE */ + YYSYMBOL_FPNUM = 11, /* FPNUM */ + YYSYMBOL_DIMEN = 12, /* "dimen" */ + YYSYMBOL_PT = 13, /* "pt" */ + YYSYMBOL_MM = 14, /* "mm" */ + YYSYMBOL_INCH = 15, /* "in" */ + YYSYMBOL_XDIMEN = 16, /* "xdimen" */ + YYSYMBOL_H = 17, /* "h" */ + YYSYMBOL_V = 18, /* "v" */ + YYSYMBOL_FIL = 19, /* "fil" */ + YYSYMBOL_FILL = 20, /* "fill" */ + YYSYMBOL_FILLL = 21, /* "filll" */ + YYSYMBOL_PENALTY = 22, /* "penalty" */ + YYSYMBOL_INTEGER = 23, /* "int" */ + YYSYMBOL_LANGUAGE = 24, /* "language" */ + YYSYMBOL_RULE = 25, /* "rule" */ + YYSYMBOL_RUNNING = 26, /* "|" */ + YYSYMBOL_KERN = 27, /* "kern" */ + YYSYMBOL_EXPLICIT = 28, /* "!" */ + YYSYMBOL_GLUE = 29, /* "glue" */ + YYSYMBOL_PLUS = 30, /* "plus" */ + YYSYMBOL_MINUS = 31, /* "minus" */ + YYSYMBOL_TXT_START = 32, /* TXT_START */ + YYSYMBOL_TXT_END = 33, /* TXT_END */ + YYSYMBOL_TXT_IGNORE = 34, /* TXT_IGNORE */ + YYSYMBOL_TXT_FONT_GLUE = 35, /* TXT_FONT_GLUE */ + YYSYMBOL_TXT_FONT_HYPHEN = 36, /* TXT_FONT_HYPHEN */ + YYSYMBOL_TXT_FONT = 37, /* TXT_FONT */ + YYSYMBOL_TXT_LOCAL = 38, /* TXT_LOCAL */ + YYSYMBOL_TXT_GLOBAL = 39, /* TXT_GLOBAL */ + YYSYMBOL_TXT_CC = 40, /* TXT_CC */ + YYSYMBOL_HBOX = 41, /* "hbox" */ + YYSYMBOL_VBOX = 42, /* "vbox" */ + YYSYMBOL_SHIFTED = 43, /* "shifted" */ + YYSYMBOL_HPACK = 44, /* "hpack" */ + YYSYMBOL_HSET = 45, /* "hset" */ + YYSYMBOL_VPACK = 46, /* "vpack" */ + YYSYMBOL_VSET = 47, /* "vset" */ + YYSYMBOL_DEPTH = 48, /* "depth" */ + YYSYMBOL_ADD = 49, /* "add" */ + YYSYMBOL_TO = 50, /* "to" */ + YYSYMBOL_LEADERS = 51, /* "leaders" */ + YYSYMBOL_ALIGN = 52, /* "align" */ + YYSYMBOL_CENTER = 53, /* "center" */ + YYSYMBOL_EXPAND = 54, /* "expand" */ + YYSYMBOL_BASELINE = 55, /* "baseline" */ + YYSYMBOL_LIGATURE = 56, /* "ligature" */ + YYSYMBOL_DISC = 57, /* "disc" */ + YYSYMBOL_PAR = 58, /* "par" */ + YYSYMBOL_MATH = 59, /* "math" */ + YYSYMBOL_ON = 60, /* "on" */ + YYSYMBOL_OFF = 61, /* "off" */ + YYSYMBOL_ADJUST = 62, /* "adjust" */ + YYSYMBOL_TABLE = 63, /* "table" */ + YYSYMBOL_ITEM = 64, /* "item" */ + YYSYMBOL_IMAGE = 65, /* "image" */ + YYSYMBOL_LABEL = 66, /* "label" */ + YYSYMBOL_BOT = 67, /* "bot" */ + YYSYMBOL_MID = 68, /* "mid" */ + YYSYMBOL_LINK = 69, /* "link" */ + YYSYMBOL_OUTLINE = 70, /* "outline" */ + YYSYMBOL_STREAM = 71, /* "stream" */ + YYSYMBOL_STREAMDEF = 72, /* "stream (definition)" */ + YYSYMBOL_FIRST = 73, /* "first" */ + YYSYMBOL_LAST = 74, /* "last" */ + YYSYMBOL_TOP = 75, /* "top" */ + YYSYMBOL_NOREFERENCE = 76, /* "*" */ + YYSYMBOL_PAGE = 77, /* "page" */ + YYSYMBOL_RANGE = 78, /* "range" */ + YYSYMBOL_DIRECTORY = 79, /* "directory" */ + YYSYMBOL_SECTION = 80, /* "entry" */ + YYSYMBOL_DEFINITIONS = 81, /* "definitions" */ + YYSYMBOL_MAX = 82, /* "max" */ + YYSYMBOL_PARAM = 83, /* "param" */ + YYSYMBOL_FONT = 84, /* "font" */ + YYSYMBOL_CONTENT = 85, /* "content" */ + YYSYMBOL_YYACCEPT = 86, /* $accept */ + YYSYMBOL_glyph = 87, /* glyph */ + YYSYMBOL_content_node = 88, /* content_node */ + YYSYMBOL_start = 89, /* start */ + YYSYMBOL_integer = 90, /* integer */ + YYSYMBOL_string = 91, /* string */ + YYSYMBOL_number = 92, /* number */ + YYSYMBOL_dimension = 93, /* dimension */ + YYSYMBOL_xdimen = 94, /* xdimen */ + YYSYMBOL_xdimen_node = 95, /* xdimen_node */ + YYSYMBOL_order = 96, /* order */ + YYSYMBOL_stretch = 97, /* stretch */ + YYSYMBOL_penalty = 98, /* penalty */ + YYSYMBOL_rule_dimension = 99, /* rule_dimension */ + YYSYMBOL_rule = 100, /* rule */ + YYSYMBOL_rule_node = 101, /* rule_node */ + YYSYMBOL_explicit = 102, /* explicit */ + YYSYMBOL_kern = 103, /* kern */ + YYSYMBOL_plus = 104, /* plus */ + YYSYMBOL_minus = 105, /* minus */ + YYSYMBOL_glue = 106, /* glue */ + YYSYMBOL_glue_node = 107, /* glue_node */ + YYSYMBOL_position = 108, /* position */ + YYSYMBOL_content_list = 109, /* content_list */ + YYSYMBOL_estimate = 110, /* estimate */ + YYSYMBOL_list = 111, /* list */ + YYSYMBOL_112_1 = 112, /* $@1 */ + YYSYMBOL_text = 113, /* text */ + YYSYMBOL_txt = 114, /* txt */ + YYSYMBOL_115_2 = 115, /* $@2 */ + YYSYMBOL_box_dimen = 116, /* box_dimen */ + YYSYMBOL_box_shift = 117, /* box_shift */ + YYSYMBOL_box_glue_set = 118, /* box_glue_set */ + YYSYMBOL_box = 119, /* box */ + YYSYMBOL_hbox_node = 120, /* hbox_node */ + YYSYMBOL_vbox_node = 121, /* vbox_node */ + YYSYMBOL_box_flex = 122, /* box_flex */ + YYSYMBOL_xbox = 123, /* xbox */ + YYSYMBOL_box_goal = 124, /* box_goal */ + YYSYMBOL_hpack = 125, /* hpack */ + YYSYMBOL_vpack = 126, /* vpack */ + YYSYMBOL_127_3 = 127, /* $@3 */ + YYSYMBOL_vxbox_node = 128, /* vxbox_node */ + YYSYMBOL_hxbox_node = 129, /* hxbox_node */ + YYSYMBOL_ltype = 130, /* ltype */ + YYSYMBOL_leaders = 131, /* leaders */ + YYSYMBOL_baseline = 132, /* baseline */ + YYSYMBOL_133_4 = 133, /* $@4 */ + YYSYMBOL_cc_list = 134, /* cc_list */ + YYSYMBOL_lig_cc = 135, /* lig_cc */ + YYSYMBOL_ref = 136, /* ref */ + YYSYMBOL_ligature = 137, /* ligature */ + YYSYMBOL_138_5 = 138, /* $@5 */ + YYSYMBOL_replace_count = 139, /* replace_count */ + YYSYMBOL_disc = 140, /* disc */ + YYSYMBOL_disc_node = 141, /* disc_node */ + YYSYMBOL_par_dimen = 142, /* par_dimen */ + YYSYMBOL_par = 143, /* par */ + YYSYMBOL_144_6 = 144, /* $@6 */ + YYSYMBOL_math = 145, /* math */ + YYSYMBOL_on_off = 146, /* on_off */ + YYSYMBOL_span_count = 147, /* span_count */ + YYSYMBOL_table = 148, /* table */ + YYSYMBOL_image_dimen = 149, /* image_dimen */ + YYSYMBOL_image = 150, /* image */ + YYSYMBOL_max_value = 151, /* max_value */ + YYSYMBOL_placement = 152, /* placement */ + YYSYMBOL_def_node = 153, /* def_node */ + YYSYMBOL_stream_link = 154, /* stream_link */ + YYSYMBOL_stream_split = 155, /* stream_split */ + YYSYMBOL_stream_info = 156, /* stream_info */ + YYSYMBOL_157_7 = 157, /* $@7 */ + YYSYMBOL_stream_type = 158, /* stream_type */ + YYSYMBOL_stream_def_node = 159, /* stream_def_node */ + YYSYMBOL_stream_ins_node = 160, /* stream_ins_node */ + YYSYMBOL_stream = 161, /* stream */ + YYSYMBOL_page_priority = 162, /* page_priority */ + YYSYMBOL_stream_def_list = 163, /* stream_def_list */ + YYSYMBOL_page = 164, /* page */ + YYSYMBOL_165_8 = 165, /* $@8 */ + YYSYMBOL_166_9 = 166, /* $@9 */ + YYSYMBOL_hint = 167, /* hint */ + YYSYMBOL_directory_section = 168, /* directory_section */ + YYSYMBOL_169_10 = 169, /* $@10 */ + YYSYMBOL_entry_list = 170, /* entry_list */ + YYSYMBOL_entry = 171, /* entry */ + YYSYMBOL_definition_section = 172, /* definition_section */ + YYSYMBOL_173_11 = 173, /* $@11 */ + YYSYMBOL_definition_list = 174, /* definition_list */ + YYSYMBOL_max_definitions = 175, /* max_definitions */ + YYSYMBOL_max_list = 176, /* max_list */ + YYSYMBOL_def_list = 177, /* def_list */ + YYSYMBOL_parameters = 178, /* parameters */ + YYSYMBOL_empty_param_list = 179, /* empty_param_list */ + YYSYMBOL_non_empty_param_list = 180, /* non_empty_param_list */ + YYSYMBOL_181_12 = 181, /* $@12 */ + YYSYMBOL_font = 182, /* font */ + YYSYMBOL_font_head = 183, /* font_head */ + YYSYMBOL_font_param_list = 184, /* font_param_list */ + YYSYMBOL_font_param = 185, /* font_param */ + YYSYMBOL_fref = 186, /* fref */ + YYSYMBOL_xdimen_ref = 187, /* xdimen_ref */ + YYSYMBOL_param_ref = 188, /* param_ref */ + YYSYMBOL_stream_ref = 189, /* stream_ref */ + YYSYMBOL_content_section = 190, /* content_section */ + YYSYMBOL_191_13 = 191 /* $@13 */ +}; +typedef enum yysymbol_kind_t yysymbol_kind_t; + + + + +#ifdef short +# undef short +#endif + +/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure + and (if available) are included + so that the code can choose integer types of a good width. */ + +#ifndef __PTRDIFF_MAX__ +# include /* INFRINGES ON USER NAME SPACE */ +# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ +# include /* INFRINGES ON USER NAME SPACE */ +# define YY_STDINT_H +# endif +#endif + +/* Narrow types that promote to a signed type and that can represent a + signed or unsigned integer of at least N bits. In tables they can + save space and decrease cache pressure. Promoting to a signed type + helps avoid bugs in integer arithmetic. */ + +#ifdef __INT_LEAST8_MAX__ +typedef __INT_LEAST8_TYPE__ yytype_int8; +#elif defined YY_STDINT_H +typedef int_least8_t yytype_int8; +#else +typedef signed char yytype_int8; +#endif + +#ifdef __INT_LEAST16_MAX__ +typedef __INT_LEAST16_TYPE__ yytype_int16; +#elif defined YY_STDINT_H +typedef int_least16_t yytype_int16; +#else +typedef short yytype_int16; +#endif + +/* Work around bug in HP-UX 11.23, which defines these macros + incorrectly for preprocessor constants. This workaround can likely + be removed in 2023, as HPE has promised support for HP-UX 11.23 + (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of + . */ +#ifdef __hpux +# undef UINT_LEAST8_MAX +# undef UINT_LEAST16_MAX +# define UINT_LEAST8_MAX 255 +# define UINT_LEAST16_MAX 65535 +#endif + +#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__ +typedef __UINT_LEAST8_TYPE__ yytype_uint8; +#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \ + && UINT_LEAST8_MAX <= INT_MAX) +typedef uint_least8_t yytype_uint8; +#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX +typedef unsigned char yytype_uint8; +#else +typedef short yytype_uint8; +#endif + +#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__ +typedef __UINT_LEAST16_TYPE__ yytype_uint16; +#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \ + && UINT_LEAST16_MAX <= INT_MAX) +typedef uint_least16_t yytype_uint16; +#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX +typedef unsigned short yytype_uint16; +#else +typedef int yytype_uint16; +#endif + +#ifndef YYPTRDIFF_T +# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__ +# define YYPTRDIFF_T __PTRDIFF_TYPE__ +# define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__ +# elif defined PTRDIFF_MAX +# ifndef ptrdiff_t +# include /* INFRINGES ON USER NAME SPACE */ +# endif +# define YYPTRDIFF_T ptrdiff_t +# define YYPTRDIFF_MAXIMUM PTRDIFF_MAX +# else +# define YYPTRDIFF_T long +# define YYPTRDIFF_MAXIMUM LONG_MAX +# endif +#endif + +#ifndef YYSIZE_T +# ifdef __SIZE_TYPE__ +# define YYSIZE_T __SIZE_TYPE__ +# elif defined size_t +# define YYSIZE_T size_t +# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# else +# define YYSIZE_T unsigned +# endif +#endif + +#define YYSIZE_MAXIMUM \ + YY_CAST (YYPTRDIFF_T, \ + (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \ + ? YYPTRDIFF_MAXIMUM \ + : YY_CAST (YYSIZE_T, -1))) + +#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) + + +/* Stored state numbers (used for stacks). */ +typedef yytype_int16 yy_state_t; + +/* State numbers in computations. */ +typedef int yy_state_fast_t; + +#ifndef YY_ +# if defined YYENABLE_NLS && YYENABLE_NLS +# if ENABLE_NLS +# include /* INFRINGES ON USER NAME SPACE */ +# define YY_(Msgid) dgettext ("bison-runtime", Msgid) +# endif +# endif +# ifndef YY_ +# define YY_(Msgid) Msgid +# endif +#endif + + +#ifndef YY_ATTRIBUTE_PURE +# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__) +# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__)) +# else +# define YY_ATTRIBUTE_PURE +# endif +#endif + +#ifndef YY_ATTRIBUTE_UNUSED +# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__) +# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__)) +# else +# define YY_ATTRIBUTE_UNUSED +# endif +#endif + +/* Suppress unused-variable warnings by "using" E. */ +#if ! defined lint || defined __GNUC__ +# define YY_USE(E) ((void) (E)) +#else +# define YY_USE(E) /* empty */ +#endif + +/* Suppress an incorrect diagnostic about yylval being uninitialized. */ +#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__ +# if __GNUC__ * 100 + __GNUC_MINOR__ < 407 +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") +# else +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \ + _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") +# endif +# define YY_IGNORE_MAYBE_UNINITIALIZED_END \ + _Pragma ("GCC diagnostic pop") +#else +# define YY_INITIAL_VALUE(Value) Value +#endif +#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN +# define YY_IGNORE_MAYBE_UNINITIALIZED_END +#endif +#ifndef YY_INITIAL_VALUE +# define YY_INITIAL_VALUE(Value) /* Nothing. */ +#endif + +#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__ +# define YY_IGNORE_USELESS_CAST_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"") +# define YY_IGNORE_USELESS_CAST_END \ + _Pragma ("GCC diagnostic pop") +#endif +#ifndef YY_IGNORE_USELESS_CAST_BEGIN +# define YY_IGNORE_USELESS_CAST_BEGIN +# define YY_IGNORE_USELESS_CAST_END +#endif + + +#define YY_ASSERT(E) ((void) (0 && (E))) + +#if 1 + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +# ifdef YYSTACK_USE_ALLOCA +# if YYSTACK_USE_ALLOCA +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# elif defined __BUILTIN_VA_ARG_INCR +# include /* INFRINGES ON USER NAME SPACE */ +# elif defined _AIX +# define YYSTACK_ALLOC __alloca +# elif defined _MSC_VER +# include /* INFRINGES ON USER NAME SPACE */ +# define alloca _alloca +# else +# define YYSTACK_ALLOC alloca +# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS +# include /* INFRINGES ON USER NAME SPACE */ + /* Use EXIT_SUCCESS as a witness for stdlib.h. */ +# ifndef EXIT_SUCCESS +# define EXIT_SUCCESS 0 +# endif +# endif +# endif +# endif +# endif + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's 'empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) +# ifndef YYSTACK_ALLOC_MAXIMUM + /* The OS might guarantee only one guard page at the bottom of the stack, + and a page size can be as small as 4096 bytes. So we cannot safely + invoke alloca (N) if N exceeds 4096. Use a slightly smaller number + to allow for a few compiler-allocated temporary stack slots. */ +# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ +# endif +# else +# define YYSTACK_ALLOC YYMALLOC +# define YYSTACK_FREE YYFREE +# ifndef YYSTACK_ALLOC_MAXIMUM +# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM +# endif +# if (defined __cplusplus && ! defined EXIT_SUCCESS \ + && ! ((defined YYMALLOC || defined malloc) \ + && (defined YYFREE || defined free))) +# include /* INFRINGES ON USER NAME SPACE */ +# ifndef EXIT_SUCCESS +# define EXIT_SUCCESS 0 +# endif +# endif +# ifndef YYMALLOC +# define YYMALLOC malloc +# if ! defined malloc && ! defined EXIT_SUCCESS +void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# ifndef YYFREE +# define YYFREE free +# if ! defined free && ! defined EXIT_SUCCESS +void free (void *); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# endif +#endif /* 1 */ + +#if (! defined yyoverflow \ + && (! defined __cplusplus \ + || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + yy_state_t yyss_alloc; + YYSTYPE yyvs_alloc; +}; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +# define YYSTACK_BYTES(N) \ + ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \ + + YYSTACK_GAP_MAXIMUM) + +# define YYCOPY_NEEDED 1 + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ + do \ + { \ + YYPTRDIFF_T yynewbytes; \ + YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ + Stack = &yyptr->Stack_alloc; \ + yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / YYSIZEOF (*yyptr); \ + } \ + while (0) + +#endif + +#if defined YYCOPY_NEEDED && YYCOPY_NEEDED +/* Copy COUNT objects from SRC to DST. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if defined __GNUC__ && 1 < __GNUC__ +# define YYCOPY(Dst, Src, Count) \ + __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) +# else +# define YYCOPY(Dst, Src, Count) \ + do \ + { \ + YYPTRDIFF_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (Dst)[yyi] = (Src)[yyi]; \ + } \ + while (0) +# endif +# endif +#endif /* !YYCOPY_NEEDED */ + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL 5 +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST 657 + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS 86 +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS 106 +/* YYNRULES -- Number of rules. */ +#define YYNRULES 266 +/* YYNSTATES -- Number of states. */ +#define YYNSTATES 566 + +/* YYMAXUTOK -- Last valid token kind. */ +#define YYMAXUTOK 340 + + +/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM + as returned by yylex, with out-of-bounds checking. */ +#define YYTRANSLATE(YYX) \ + (0 <= (YYX) && (YYX) <= YYMAXUTOK \ + ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ + : YYSYMBOL_YYUNDEF) + +/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM + as returned by yylex. */ +static const yytype_int8 yytranslate[] = +{ + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85 +}; + +#if YYDEBUG +/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ +static const yytype_int16 yyrline[] = +{ + 0, 264, 264, 267, 270, 274, 274, 278, 282, 282, + 288, 290, 292, 294, 297, 300, 304, 307, 310, 313, + 319, 324, 326, 328, 330, 334, 338, 341, 345, 345, + 348, 354, 357, 359, 361, 364, 367, 371, 373, 376, + 378, 381, 384, 388, 394, 397, 398, 399, 402, 405, + 412, 411, 420, 420, 422, 425, 428, 431, 434, 437, + 440, 443, 443, 448, 452, 455, 459, 462, 465, 470, + 474, 477, 480, 480, 482, 485, 488, 492, 495, 498, + 501, 505, 508, 508, 514, 517, 522, 525, 529, 529, + 531, 533, 535, 537, 540, 543, 546, 549, 553, 553, + 562, 567, 567, 570, 573, 576, 579, 579, 586, 590, + 593, 597, 601, 604, 609, 614, 616, 619, 622, 625, + 628, 628, 633, 636, 640, 644, 647, 650, 653, 656, + 659, 662, 665, 668, 672, 676, 678, 681, 685, 689, + 692, 695, 698, 702, 705, 709, 713, 715, 718, 721, + 725, 732, 734, 736, 738, 741, 746, 751, 761, 763, + 766, 769, 769, 773, 775, 777, 779, 783, 789, 794, + 794, 796, 799, 802, 805, 810, 813, 817, 817, 819, + 821, 819, 828, 831, 835, 837, 837, 840, 840, 841, + 846, 846, 853, 853, 855, 880, 880, 882, 885, 888, + 891, 894, 897, 900, 903, 906, 909, 912, 915, 918, + 921, 924, 927, 930, 936, 939, 942, 945, 948, 951, + 954, 957, 960, 963, 966, 969, 972, 975, 980, 983, + 986, 990, 991, 994, 998, 1001, 1001, 1009, 1011, 1016, + 1016, 1019, 1022, 1025, 1028, 1031, 1034, 1037, 1040, 1044, + 1048, 1051, 1054, 1060, 1063, 1067, 1071, 1074, 1077, 1080, + 1083, 1086, 1089, 1092, 1096, 1103, 1103 +}; +#endif + +/** Accessing symbol of state STATE. */ +#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) + +#if 1 +/* The user-facing name of the symbol whose (internal) number is + YYSYMBOL. No bounds checking. */ +static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED; + +/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + "\"end of file\"", "error", "\"invalid token\"", "\"<\"", "\">\"", + "\"glyph\"", "UNSIGNED", "REFERENCE", "SIGNED", "STRING", "CHARCODE", + "FPNUM", "\"dimen\"", "\"pt\"", "\"mm\"", "\"in\"", "\"xdimen\"", + "\"h\"", "\"v\"", "\"fil\"", "\"fill\"", "\"filll\"", "\"penalty\"", + "\"int\"", "\"language\"", "\"rule\"", "\"|\"", "\"kern\"", "\"!\"", + "\"glue\"", "\"plus\"", "\"minus\"", "TXT_START", "TXT_END", + "TXT_IGNORE", "TXT_FONT_GLUE", "TXT_FONT_HYPHEN", "TXT_FONT", + "TXT_LOCAL", "TXT_GLOBAL", "TXT_CC", "\"hbox\"", "\"vbox\"", + "\"shifted\"", "\"hpack\"", "\"hset\"", "\"vpack\"", "\"vset\"", + "\"depth\"", "\"add\"", "\"to\"", "\"leaders\"", "\"align\"", + "\"center\"", "\"expand\"", "\"baseline\"", "\"ligature\"", "\"disc\"", + "\"par\"", "\"math\"", "\"on\"", "\"off\"", "\"adjust\"", "\"table\"", + "\"item\"", "\"image\"", "\"label\"", "\"bot\"", "\"mid\"", "\"link\"", + "\"outline\"", "\"stream\"", "\"stream (definition)\"", "\"first\"", + "\"last\"", "\"top\"", "\"*\"", "\"page\"", "\"range\"", "\"directory\"", + "\"entry\"", "\"definitions\"", "\"max\"", "\"param\"", "\"font\"", + "\"content\"", "$accept", "glyph", "content_node", "start", "integer", + "string", "number", "dimension", "xdimen", "xdimen_node", "order", + "stretch", "penalty", "rule_dimension", "rule", "rule_node", "explicit", + "kern", "plus", "minus", "glue", "glue_node", "position", "content_list", + "estimate", "list", "$@1", "text", "txt", "$@2", "box_dimen", + "box_shift", "box_glue_set", "box", "hbox_node", "vbox_node", "box_flex", + "xbox", "box_goal", "hpack", "vpack", "$@3", "vxbox_node", "hxbox_node", + "ltype", "leaders", "baseline", "$@4", "cc_list", "lig_cc", "ref", + "ligature", "$@5", "replace_count", "disc", "disc_node", "par_dimen", + "par", "$@6", "math", "on_off", "span_count", "table", "image_dimen", + "image", "max_value", "placement", "def_node", "stream_link", + "stream_split", "stream_info", "$@7", "stream_type", "stream_def_node", + "stream_ins_node", "stream", "page_priority", "stream_def_list", "page", + "$@8", "$@9", "hint", "directory_section", "$@10", "entry_list", "entry", + "definition_section", "$@11", "definition_list", "max_definitions", + "max_list", "def_list", "parameters", "empty_param_list", + "non_empty_param_list", "$@12", "font", "font_head", "font_param_list", + "font_param", "fref", "xdimen_ref", "param_ref", "stream_ref", + "content_section", "$@13", YY_NULLPTR +}; + +static const char * +yysymbol_name (yysymbol_kind_t yysymbol) +{ + return yytname[yysymbol]; +} +#endif + +#define YYPACT_NINF (-326) + +#define yypact_value_is_default(Yyn) \ + ((Yyn) == YYPACT_NINF) + +#define YYTABLE_NINF (-1) + +#define yytable_value_is_error(Yyn) \ + 0 + +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +static const yytype_int16 yypact[] = +{ + 48, -4, 110, 113, 107, -326, 52, 137, -326, -326, + 74, -326, -326, 153, -326, 211, 85, -326, -326, 94, + -326, -326, -326, 275, -326, 278, 190, 280, 159, -326, + 313, -326, 31, -326, -326, 585, -326, -326, -326, -326, + -326, -326, -326, -326, 223, 467, -326, 203, 234, 234, + 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, + 234, 234, 240, 248, 116, 219, 253, 140, 210, 229, + 182, 182, 220, 182, 220, 182, 121, 229, 234, 71, + 229, 41, 66, 271, 79, 301, 261, 234, 234, -326, + -326, 268, 270, 279, 284, 286, 288, 294, 297, 315, + 325, 326, 327, 328, 333, 334, 335, 337, 338, 339, + 343, 242, -326, 229, 182, 219, 223, 152, 229, 345, + 182, 234, 210, 348, 223, 350, 223, 82, 251, 323, + 342, 353, -326, -326, -326, 355, 357, 358, -326, -326, + -326, -326, 231, -326, 152, 359, 361, -326, 165, 362, + 182, 341, 372, 373, 182, 220, 375, 377, 182, 264, + 379, 220, 380, 305, 384, 385, -326, 363, 200, 387, + 389, -326, 390, 391, 395, 396, 398, 397, 66, 401, + 234, -326, -326, 404, 234, -326, -326, -326, -326, 405, + -326, 66, 66, -326, 350, 406, 264, 264, 407, -326, + 408, 530, 409, 399, 182, 410, 411, 255, -326, 234, + 80, -326, -326, -326, -326, -326, -326, -326, -326, -326, + -326, -326, -326, -326, -326, -326, -326, -326, -326, -326, + -326, -326, 413, 414, 416, 417, 418, 419, 421, 422, + 423, 427, 429, -326, 430, 432, 433, -326, 435, -326, + -326, 436, 182, 437, 345, -326, -326, -326, 438, 440, + 441, -326, -326, -326, -326, -326, -326, -326, -326, -326, + 152, -326, -326, 234, -326, 442, -326, 302, 182, 420, + -326, -326, 182, 293, -326, -326, -326, 121, 121, 66, + -326, 341, -326, 400, -326, -326, 229, -326, -326, -326, + 345, -326, -326, 345, -326, -326, -326, 176, -326, -326, + -326, 66, -326, -326, 66, -326, 66, 66, -326, 38, + 345, 66, 66, 53, 345, 66, -326, -326, -326, 66, + 66, -326, -326, -326, 445, 182, 341, -326, -326, 446, + 448, 66, 66, -326, -326, -326, -326, 439, 450, -326, + 66, 66, -326, -326, -326, -326, -326, -326, -326, -326, + -326, -326, -326, -326, -326, -326, 452, -326, -326, 451, + -326, 453, -326, 345, 345, -326, -326, -326, -326, 456, + -326, 182, -326, 164, -326, 182, -326, -326, 182, 182, + 66, -326, -326, -326, -326, -326, 420, 121, 182, 458, + 460, 49, -326, -326, -326, 345, -326, -326, 434, -326, + 66, 35, -326, 66, -326, 66, -326, -326, 424, -326, + -326, 345, 66, -326, -326, -326, 324, 66, 66, -326, + -326, 420, -326, -326, -326, 66, -326, 182, -326, 345, + 463, -326, 345, -326, 462, 412, -326, 105, -326, -326, + 454, -326, -326, -326, -326, -326, -326, -326, -326, -326, + -326, 66, 66, -326, -326, -326, 152, -326, -326, -326, + -326, -326, 350, -326, -326, -326, 184, -326, -326, -326, + -326, -326, 466, 39, 345, -326, 182, -326, 210, 234, + 234, 234, 234, 234, 234, 234, 234, -326, -326, -326, + 264, 72, 471, -326, -326, -326, -326, -326, -326, -326, + -326, -326, 399, -326, -326, -326, 39, -326, 66, -326, + -326, 242, 223, 152, 210, 182, 234, 210, 348, 66, + -326, -326, -326, -326, 470, 345, 345, 473, 476, 478, + 182, 480, 481, 482, 483, 484, -326, -326, 489, 345, + -326, -326, -326, -326, -326, -326, -326, -326, -326, 66, + -326, 345, 425, -326, 234, 69 +}; + +/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. + Performed when YYTABLE does not specify something else to do. Zero + means the default is an error. */ +static const yytype_int16 yydefact[] = +{ + 0, 0, 0, 0, 0, 1, 0, 0, 185, 190, + 0, 184, 187, 0, 265, 0, 0, 192, 44, 0, + 186, 188, 195, 0, 45, 0, 0, 0, 4, 191, + 0, 193, 4, 266, 46, 0, 32, 72, 73, 88, + 89, 115, 169, 170, 0, 0, 194, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 33, 0, + 0, 0, 64, 0, 64, 0, 0, 0, 0, 33, + 0, 44, 0, 0, 0, 0, 0, 0, 0, 8, + 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 105, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 33, 0, 0, 47, 0, 154, 0, 0, + 0, 0, 6, 5, 26, 0, 0, 0, 10, 11, + 12, 29, 0, 28, 0, 0, 0, 34, 0, 0, + 19, 37, 0, 0, 0, 64, 0, 0, 0, 0, + 0, 64, 0, 0, 0, 0, 4, 0, 90, 0, + 0, 98, 0, 0, 106, 0, 109, 0, 113, 0, + 116, 250, 44, 0, 44, 135, 136, 234, 251, 0, + 137, 0, 0, 44, 47, 0, 0, 0, 0, 139, + 0, 47, 0, 0, 147, 0, 0, 0, 252, 44, + 0, 189, 199, 208, 198, 203, 204, 202, 206, 207, + 200, 201, 205, 213, 150, 210, 211, 212, 209, 197, + 196, 44, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 106, 0, 0, 0, 179, 0, 48, + 44, 0, 0, 0, 0, 152, 153, 151, 0, 0, + 0, 2, 7, 3, 27, 253, 263, 13, 15, 14, + 0, 31, 259, 0, 35, 0, 36, 0, 0, 39, + 42, 256, 0, 66, 70, 71, 65, 0, 0, 0, + 87, 37, 86, 0, 85, 84, 0, 91, 92, 93, + 0, 97, 261, 0, 100, 262, 257, 0, 108, 110, + 258, 112, 114, 120, 0, 124, 0, 0, 134, 47, + 128, 0, 0, 47, 125, 0, 50, 44, 138, 0, + 0, 145, 140, 142, 0, 0, 37, 260, 149, 0, + 0, 0, 0, 168, 164, 165, 166, 0, 0, 163, + 0, 0, 216, 229, 219, 215, 228, 217, 220, 218, + 230, 221, 222, 223, 224, 225, 175, 227, 231, 233, + 226, 0, 214, 0, 237, 155, 182, 183, 30, 0, + 254, 17, 18, 0, 38, 0, 41, 63, 0, 0, + 0, 80, 78, 79, 77, 81, 39, 0, 0, 0, + 0, 0, 94, 95, 96, 0, 103, 104, 0, 111, + 0, 47, 123, 0, 119, 0, 117, 235, 0, 129, + 130, 131, 0, 126, 127, 44, 0, 0, 0, 141, + 146, 39, 156, 174, 171, 0, 173, 0, 161, 0, + 0, 176, 0, 232, 0, 0, 239, 0, 240, 255, + 0, 21, 22, 23, 24, 25, 40, 67, 68, 69, + 74, 0, 0, 82, 43, 264, 0, 99, 101, 121, + 122, 118, 47, 132, 133, 52, 61, 49, 143, 144, + 148, 172, 0, 0, 0, 157, 0, 238, 33, 0, + 0, 0, 0, 0, 0, 0, 0, 16, 76, 75, + 0, 0, 0, 51, 60, 58, 59, 55, 57, 56, + 54, 53, 0, 20, 159, 158, 0, 162, 0, 180, + 249, 0, 0, 0, 33, 0, 0, 33, 0, 0, + 107, 102, 236, 62, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 83, 160, 0, 0, + 241, 246, 247, 242, 245, 243, 244, 248, 167, 0, + 177, 181, 0, 178, 0, 0 +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const yytype_int16 yypgoto[] = +{ + -326, -326, -65, -23, 97, -79, -83, -13, -62, -232, + -326, -191, -27, -118, -94, 195, -67, -26, -228, -325, + -97, -226, -1, 172, -86, -55, -326, -326, -326, -326, + 198, -36, -326, 431, -111, 201, -326, 428, -147, -326, + -326, -326, -326, -326, -326, 381, 386, -326, -326, -326, + -45, -96, -326, -326, -95, 132, -326, -326, -326, -326, + 300, -326, -326, -326, -93, -326, -326, 139, -7, -326, + -326, -326, -326, -50, -326, -326, -326, -326, -326, -326, + -326, -326, -326, -326, -326, -326, -326, -326, -326, -326, + -326, -326, 42, -89, -227, -326, -326, -326, -326, -326, + -290, -222, -92, -326, -326, -326 +}; + +/* YYDEFGOTO[NTERM-NUM]. */ +static const yytype_int16 yydefgoto[] = +{ + 0, 131, 34, 194, 134, 91, 142, 150, 151, 348, + 455, 384, 135, 144, 145, 36, 176, 149, 279, 386, + 152, 168, 187, 25, 327, 195, 425, 476, 511, 512, + 155, 159, 390, 156, 37, 38, 397, 162, 289, 160, + 164, 500, 39, 40, 300, 169, 172, 303, 501, 408, + 520, 175, 307, 178, 179, 41, 182, 183, 410, 189, + 190, 203, 198, 336, 206, 110, 258, 31, 516, 517, + 349, 483, 350, 42, 43, 340, 442, 561, 248, 366, + 536, 2, 3, 12, 15, 21, 7, 13, 23, 17, + 27, 369, 251, 191, 322, 472, 253, 254, 374, 448, + 521, 184, 192, 209, 11, 18 +}; + +/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule whose + number is the opposite. If YYTABLE_NINF, syntax error. */ +static const yytype_int16 yytable[] = +{ + 30, 148, 35, 113, 114, 115, 116, 117, 118, 119, + 120, 121, 122, 123, 124, 125, 126, 24, 180, 200, + 136, 239, 146, 238, 153, 244, 270, 245, 373, 202, + 246, 170, 173, 174, 177, 181, 188, 237, 163, 250, + 205, 249, 208, 210, 249, 247, 112, 252, 112, 329, + 330, 1, 234, 167, 143, 391, 393, 154, 154, 249, + 154, 201, 154, 396, 171, 392, 394, 277, 233, 166, + 236, 460, 166, 240, 466, 4, 243, 405, 112, 70, + 321, 325, 32, 166, 343, 199, 274, 413, 313, 415, + 70, 71, 317, 314, 70, 316, 167, 62, 193, 147, + 232, 185, 186, 275, 143, 530, 480, 171, 431, 63, + 5, 193, 531, 8, 435, 514, 6, 342, 417, 283, + 341, 417, 129, 311, 166, 291, 130, 489, 112, 490, + 491, 143, 492, 9, 493, 188, 320, 324, 334, 188, + 10, 282, 344, 345, 346, 286, 138, 112, 139, 255, + 256, 140, 378, 344, 345, 346, 16, 257, 138, 14, + 139, 494, 495, 140, 188, 461, 141, 22, 319, 323, + 496, 138, 112, 139, 26, 462, 140, 451, 141, 467, + 35, 273, 406, 452, 453, 454, 407, 347, 138, 403, + 139, 335, 326, 140, 456, 383, 44, 457, 458, 399, + 522, 523, 524, 525, 526, 527, 528, 484, 231, 419, + 111, 422, 235, 423, 19, 20, 486, 503, 504, 505, + 506, 507, 508, 509, 510, 132, 112, 133, 379, 47, + 351, 167, 89, 90, 395, 138, 112, 139, 147, 371, + 140, 112, 181, 181, 267, 268, 269, 127, 132, 368, + 133, 400, 297, 298, 299, 128, 409, 143, 518, 412, + 137, 414, 416, 158, 347, 347, 420, 421, 207, 387, + 424, 161, 211, 161, 427, 428, 212, 401, 28, 29, + 167, 32, 33, 45, 46, 213, 434, 436, 196, 197, + 214, 411, 215, 411, 216, 439, 440, 418, 450, 323, + 217, 418, 383, 218, 549, 383, 383, 204, 112, 548, + 473, 259, 260, 287, 288, 185, 186, 559, 411, 381, + 382, 219, 430, 388, 389, 48, 24, 32, 477, 49, + 261, 220, 221, 222, 223, 459, 50, 51, 52, 224, + 225, 226, 53, 227, 228, 229, 30, 230, 166, 262, + 445, 447, 181, 529, 204, 469, 249, 263, 470, 264, + 471, 265, 266, 271, 54, 272, 276, 474, 55, 56, + 57, 278, 478, 479, 347, 482, 280, 281, 58, 284, + 481, 285, 167, 290, 292, 463, 250, 293, 294, 295, + 59, 301, 296, 302, 304, 305, 60, 61, 418, 306, + 308, 310, 32, 35, 309, 312, 498, 499, 315, 318, + 328, 331, 332, 333, 337, 338, 347, 352, 353, 167, + 354, 355, 356, 357, 475, 358, 359, 360, 542, 539, + 543, 361, 544, 362, 363, 545, 364, 365, 515, 367, + 370, 372, 375, 538, 376, 377, 380, 533, 398, 429, + 432, 385, 433, 143, 28, 437, 438, 540, 441, 444, + 449, 167, 464, 535, 465, 70, 468, 485, 487, 488, + 513, 515, 497, 519, 546, 532, 547, 550, 274, 92, + 551, 243, 552, 93, 553, 554, 555, 556, 557, 35, + 94, 95, 96, 558, 537, 402, 97, 564, 541, 426, + 241, 404, 157, 165, 560, 446, 242, 339, 443, 534, + 143, 563, 167, 347, 502, 0, 0, 0, 98, 565, + 0, 0, 99, 100, 101, 0, 347, 0, 0, 0, + 0, 0, 102, 103, 0, 64, 249, 104, 562, 105, + 0, 0, 347, 0, 106, 107, 0, 0, 0, 0, + 108, 109, 65, 0, 66, 67, 0, 68, 0, 69, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 70, 71, 0, 72, 73, 74, 75, 0, 0, + 0, 76, 0, 0, 0, 77, 78, 79, 80, 81, + 64, 0, 82, 83, 84, 85, 0, 0, 0, 86, + 0, 87, 88, 0, 0, 0, 0, 65, 0, 66, + 67, 0, 68, 0, 69, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 70, 71, 0, 72, + 73, 74, 75, 0, 0, 0, 76, 0, 0, 0, + 77, 78, 79, 80, 81, 0, 0, 82, 83, 84, + 85, 0, 0, 0, 86, 0, 87, 88 +}; + +static const yytype_int16 yycheck[] = +{ + 23, 68, 25, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 60, 61, 18, 80, 84, + 65, 118, 67, 117, 69, 121, 144, 122, 254, 84, + 123, 76, 77, 78, 79, 80, 81, 116, 74, 125, + 85, 6, 87, 88, 6, 124, 7, 126, 7, 196, + 197, 3, 114, 76, 67, 287, 288, 70, 71, 6, + 73, 84, 75, 291, 77, 287, 288, 150, 113, 3, + 115, 396, 3, 118, 25, 79, 121, 303, 7, 41, + 191, 192, 3, 3, 4, 6, 148, 314, 180, 316, + 41, 42, 184, 182, 41, 184, 119, 66, 32, 28, + 113, 60, 61, 148, 117, 33, 431, 120, 336, 78, + 0, 32, 40, 6, 341, 76, 3, 209, 83, 155, + 209, 83, 6, 178, 3, 161, 10, 22, 7, 24, + 25, 144, 27, 81, 29, 180, 191, 192, 203, 184, + 3, 154, 73, 74, 75, 158, 6, 7, 8, 67, + 68, 11, 270, 73, 74, 75, 3, 75, 6, 85, + 8, 56, 57, 11, 209, 397, 26, 82, 191, 192, + 65, 6, 7, 8, 80, 397, 11, 13, 26, 405, + 203, 16, 6, 19, 20, 21, 10, 210, 6, 300, + 8, 204, 193, 11, 385, 278, 6, 388, 389, 296, + 490, 491, 492, 493, 494, 495, 496, 439, 111, 320, + 7, 322, 115, 324, 3, 4, 442, 33, 34, 35, + 36, 37, 38, 39, 40, 6, 7, 8, 273, 70, + 231, 254, 9, 10, 289, 6, 7, 8, 28, 252, + 11, 7, 287, 288, 13, 14, 15, 7, 6, 250, + 8, 296, 52, 53, 54, 7, 311, 270, 484, 314, + 7, 316, 317, 43, 287, 288, 321, 322, 7, 282, + 325, 73, 4, 75, 329, 330, 6, 300, 3, 4, + 303, 3, 4, 3, 4, 6, 341, 342, 17, 18, + 6, 314, 6, 316, 6, 350, 351, 320, 381, 322, + 6, 324, 385, 6, 536, 388, 389, 6, 7, 535, + 421, 60, 61, 49, 50, 60, 61, 549, 341, 17, + 18, 6, 335, 30, 31, 12, 327, 3, 4, 16, + 7, 6, 6, 6, 6, 390, 23, 24, 25, 6, + 6, 6, 29, 6, 6, 6, 369, 4, 3, 7, + 373, 374, 397, 500, 6, 410, 6, 4, 413, 4, + 415, 4, 4, 4, 51, 4, 4, 422, 55, 56, + 57, 30, 427, 428, 397, 437, 4, 4, 65, 4, + 435, 4, 405, 4, 4, 398, 472, 82, 4, 4, + 77, 4, 29, 4, 4, 4, 83, 84, 421, 4, + 4, 4, 3, 426, 6, 4, 461, 462, 4, 4, + 4, 4, 4, 4, 4, 4, 439, 4, 4, 442, + 4, 4, 4, 4, 425, 4, 4, 4, 525, 523, + 526, 4, 527, 4, 4, 528, 4, 4, 483, 4, + 4, 4, 4, 522, 4, 4, 4, 512, 48, 4, + 4, 31, 4, 466, 3, 16, 6, 524, 6, 6, + 4, 484, 4, 518, 4, 41, 32, 4, 6, 57, + 4, 516, 18, 486, 529, 4, 6, 4, 540, 12, + 4, 526, 4, 16, 4, 4, 4, 4, 4, 512, + 23, 24, 25, 4, 521, 300, 29, 72, 524, 327, + 119, 300, 71, 75, 559, 373, 120, 207, 369, 516, + 523, 561, 535, 536, 472, -1, -1, -1, 51, 564, + -1, -1, 55, 56, 57, -1, 549, -1, -1, -1, + -1, -1, 65, 66, -1, 5, 6, 70, 561, 72, + -1, -1, 565, -1, 77, 78, -1, -1, -1, -1, + 83, 84, 22, -1, 24, 25, -1, 27, -1, 29, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 41, 42, -1, 44, 45, 46, 47, -1, -1, + -1, 51, -1, -1, -1, 55, 56, 57, 58, 59, + 5, -1, 62, 63, 64, 65, -1, -1, -1, 69, + -1, 71, 72, -1, -1, -1, -1, 22, -1, 24, + 25, -1, 27, -1, 29, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 41, 42, -1, 44, + 45, 46, 47, -1, -1, -1, 51, -1, -1, -1, + 55, 56, 57, 58, 59, -1, -1, 62, 63, 64, + 65, -1, -1, -1, 69, -1, 71, 72 +}; + +/* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of + state STATE-NUM. */ +static const yytype_uint8 yystos[] = +{ + 0, 3, 167, 168, 79, 0, 3, 172, 6, 81, + 3, 190, 169, 173, 85, 170, 3, 175, 191, 3, + 4, 171, 82, 174, 108, 109, 80, 176, 3, 4, + 89, 153, 3, 4, 88, 89, 101, 120, 121, 128, + 129, 141, 159, 160, 6, 3, 4, 70, 12, 16, + 23, 24, 25, 29, 51, 55, 56, 57, 65, 77, + 83, 84, 66, 78, 5, 22, 24, 25, 27, 29, + 41, 42, 44, 45, 46, 47, 51, 55, 56, 57, + 58, 59, 62, 63, 64, 65, 69, 71, 72, 9, + 10, 91, 12, 16, 23, 24, 25, 29, 51, 55, + 56, 57, 65, 66, 70, 72, 77, 78, 83, 84, + 151, 7, 7, 136, 136, 136, 136, 136, 136, 136, + 136, 136, 136, 136, 136, 136, 136, 7, 7, 6, + 10, 87, 6, 8, 90, 98, 136, 7, 6, 8, + 11, 26, 92, 93, 99, 100, 136, 28, 102, 103, + 93, 94, 106, 136, 93, 116, 119, 119, 43, 117, + 125, 116, 123, 117, 126, 123, 3, 89, 107, 131, + 136, 93, 132, 136, 136, 137, 102, 136, 139, 140, + 94, 136, 142, 143, 187, 60, 61, 108, 136, 145, + 146, 179, 188, 32, 89, 111, 17, 18, 148, 6, + 88, 89, 111, 147, 6, 136, 150, 7, 136, 189, + 136, 4, 6, 6, 6, 6, 6, 6, 6, 6, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, + 4, 90, 93, 136, 94, 90, 136, 91, 100, 106, + 136, 131, 132, 136, 137, 140, 150, 91, 164, 6, + 110, 178, 91, 182, 183, 67, 68, 75, 152, 60, + 61, 7, 7, 4, 4, 4, 4, 13, 14, 15, + 99, 4, 4, 16, 94, 136, 4, 92, 30, 104, + 4, 4, 93, 117, 4, 4, 93, 49, 50, 124, + 4, 117, 4, 82, 4, 4, 29, 52, 53, 54, + 130, 4, 4, 133, 4, 4, 4, 138, 4, 6, + 4, 111, 4, 188, 179, 4, 179, 188, 4, 89, + 111, 120, 180, 89, 111, 120, 108, 110, 4, 124, + 124, 4, 4, 4, 88, 93, 149, 4, 4, 146, + 161, 179, 188, 4, 73, 74, 75, 89, 95, 156, + 158, 108, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 165, 4, 108, 177, + 4, 93, 4, 107, 184, 4, 4, 4, 99, 136, + 4, 17, 18, 92, 97, 31, 105, 93, 30, 31, + 118, 95, 187, 95, 187, 111, 104, 122, 48, 106, + 136, 89, 101, 120, 121, 107, 6, 10, 135, 111, + 144, 89, 111, 180, 111, 180, 111, 83, 89, 120, + 111, 111, 120, 120, 111, 112, 109, 111, 111, 4, + 93, 104, 4, 4, 111, 180, 111, 16, 6, 111, + 111, 6, 162, 153, 6, 89, 141, 89, 185, 4, + 92, 13, 19, 20, 21, 96, 97, 97, 97, 111, + 105, 95, 187, 93, 4, 4, 25, 107, 32, 111, + 111, 111, 181, 120, 111, 108, 113, 4, 111, 111, + 105, 111, 94, 157, 95, 4, 107, 6, 57, 22, + 24, 25, 27, 29, 56, 57, 65, 18, 111, 111, + 127, 134, 178, 33, 34, 35, 36, 37, 38, 39, + 40, 114, 115, 4, 76, 136, 154, 155, 107, 93, + 136, 186, 186, 186, 186, 186, 186, 186, 186, 124, + 33, 40, 4, 88, 154, 111, 166, 98, 91, 100, + 102, 103, 106, 137, 140, 150, 111, 6, 107, 95, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 95, + 111, 163, 89, 159, 72, 136 +}; + +/* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */ +static const yytype_uint8 yyr1[] = +{ + 0, 86, 87, 88, 89, 90, 90, 87, 91, 91, + 92, 92, 92, 93, 93, 93, 94, 94, 94, 94, + 95, 96, 96, 96, 96, 97, 98, 88, 99, 99, + 100, 101, 88, 102, 102, 103, 88, 104, 104, 105, + 105, 106, 88, 107, 108, 109, 109, 110, 110, 111, + 112, 111, 113, 113, 114, 114, 114, 114, 114, 114, + 114, 115, 114, 116, 117, 117, 118, 118, 118, 119, + 120, 121, 88, 88, 122, 123, 123, 124, 124, 124, + 124, 125, 127, 126, 128, 128, 129, 129, 88, 88, + 130, 130, 130, 130, 131, 131, 131, 88, 133, 132, + 88, 134, 134, 135, 135, 136, 138, 137, 88, 139, + 139, 140, 140, 140, 141, 88, 142, 143, 143, 143, + 144, 143, 143, 143, 88, 145, 145, 145, 145, 145, + 145, 145, 145, 145, 88, 146, 146, 145, 88, 147, + 88, 88, 88, 148, 148, 88, 149, 149, 150, 88, + 151, 152, 152, 152, 152, 88, 88, 153, 154, 154, + 155, 157, 156, 158, 158, 158, 158, 159, 160, 88, + 88, 161, 161, 161, 88, 162, 162, 163, 163, 165, + 166, 164, 88, 88, 167, 169, 168, 170, 170, 171, + 173, 172, 174, 174, 175, 176, 176, 151, 151, 151, + 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, + 151, 151, 151, 151, 153, 153, 153, 153, 153, 153, + 153, 153, 153, 153, 153, 153, 153, 153, 153, 153, + 153, 177, 177, 178, 179, 181, 180, 182, 183, 184, + 184, 185, 185, 185, 185, 185, 185, 185, 185, 186, + 187, 188, 189, 88, 88, 88, 88, 88, 88, 88, + 88, 88, 88, 88, 107, 191, 190 +}; + +/* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */ +static const yytype_int8 yyr2[] = +{ + 0, 2, 2, 4, 1, 1, 1, 2, 1, 1, + 1, 1, 1, 2, 2, 2, 5, 3, 3, 1, + 4, 1, 1, 1, 1, 2, 1, 4, 1, 1, + 3, 4, 1, 0, 1, 2, 4, 0, 2, 0, + 2, 3, 4, 4, 0, 1, 2, 0, 1, 4, + 0, 5, 1, 2, 1, 1, 1, 1, 1, 1, + 1, 0, 2, 3, 0, 2, 0, 2, 2, 4, + 4, 4, 1, 1, 2, 5, 5, 2, 2, 2, + 2, 3, 0, 7, 4, 4, 4, 4, 1, 1, + 0, 1, 1, 1, 3, 3, 3, 4, 0, 4, + 4, 0, 2, 1, 1, 1, 0, 6, 4, 1, + 2, 3, 2, 1, 4, 1, 1, 3, 4, 3, + 0, 4, 4, 3, 4, 2, 3, 3, 2, 3, + 3, 3, 4, 4, 4, 1, 1, 1, 4, 1, + 4, 5, 4, 4, 4, 4, 2, 0, 4, 4, + 2, 1, 1, 1, 0, 5, 5, 7, 1, 1, + 3, 0, 4, 1, 1, 1, 1, 10, 4, 1, + 1, 2, 3, 2, 5, 0, 1, 0, 2, 0, + 0, 10, 5, 5, 3, 0, 6, 0, 2, 5, + 0, 6, 0, 2, 4, 0, 4, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 1, 2, 2, 1, 0, 5, 2, 4, 2, + 2, 5, 5, 5, 5, 5, 5, 5, 5, 1, + 1, 1, 1, 4, 5, 6, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 0, 5 +}; + + +enum { YYENOMEM = -2 }; + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab +#define YYNOMEM goto yyexhaustedlab + + +#define YYRECOVERING() (!!yyerrstatus) + +#define YYBACKUP(Token, Value) \ + do \ + if (yychar == YYEMPTY) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + YYPOPSTACK (yylen); \ + yystate = *yyssp; \ + goto yybackup; \ + } \ + else \ + { \ + yyerror (YY_("syntax error: cannot back up")); \ + YYERROR; \ + } \ + while (0) + +/* Backward compatibility with an undocumented macro. + Use YYerror or YYUNDEF. */ +#define YYERRCODE YYUNDEF + + +/* Enable debugging if requested. */ +#if YYDEBUG + +# ifndef YYFPRINTF +# include /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (0) + + + + +# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yy_symbol_print (stderr, \ + Kind, Value); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (0) + + +/*-----------------------------------. +| Print this symbol's value on YYO. | +`-----------------------------------*/ + +static void +yy_symbol_value_print (FILE *yyo, + yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep) +{ + FILE *yyoutput = yyo; + YY_USE (yyoutput); + if (!yyvaluep) + return; + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + YY_USE (yykind); + YY_IGNORE_MAYBE_UNINITIALIZED_END +} + + +/*---------------------------. +| Print this symbol on YYO. | +`---------------------------*/ + +static void +yy_symbol_print (FILE *yyo, + yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep) +{ + YYFPRINTF (yyo, "%s %s (", + yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind)); + + yy_symbol_value_print (yyo, yykind, yyvaluep); + YYFPRINTF (yyo, ")"); +} + +/*------------------------------------------------------------------. +| yy_stack_print -- Print the state stack from its BOTTOM up to its | +| TOP (included). | +`------------------------------------------------------------------*/ + +static void +yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop) +{ + YYFPRINTF (stderr, "Stack now"); + for (; yybottom <= yytop; yybottom++) + { + int yybot = *yybottom; + YYFPRINTF (stderr, " %d", yybot); + } + YYFPRINTF (stderr, "\n"); +} + +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +} while (0) + + +/*------------------------------------------------. +| Report that the YYRULE is going to be reduced. | +`------------------------------------------------*/ + +static void +yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, + int yyrule) +{ + int yylno = yyrline[yyrule]; + int yynrhs = yyr2[yyrule]; + int yyi; + YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n", + yyrule - 1, yylno); + /* The symbols being reduced. */ + for (yyi = 0; yyi < yynrhs; yyi++) + { + YYFPRINTF (stderr, " $%d = ", yyi + 1); + yy_symbol_print (stderr, + YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]), + &yyvsp[(yyi + 1) - (yynrhs)]); + YYFPRINTF (stderr, "\n"); + } +} + +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (yyssp, yyvsp, Rule); \ +} while (0) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !YYDEBUG */ +# define YYDPRINTF(Args) ((void) 0) +# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) +# define YY_STACK_PRINT(Bottom, Top) +# define YY_REDUCE_PRINT(Rule) +#endif /* !YYDEBUG */ + + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH 10000 +#endif + + +/* Context of a parse error. */ +typedef struct +{ + yy_state_t *yyssp; + yysymbol_kind_t yytoken; +} yypcontext_t; + +/* Put in YYARG at most YYARGN of the expected tokens given the + current YYCTX, and return the number of tokens stored in YYARG. If + YYARG is null, return the number of expected tokens (guaranteed to + be less than YYNTOKENS). Return YYENOMEM on memory exhaustion. + Return 0 if there are more than YYARGN expected tokens, yet fill + YYARG up to YYARGN. */ +static int +yypcontext_expected_tokens (const yypcontext_t *yyctx, + yysymbol_kind_t yyarg[], int yyargn) +{ + /* Actual size of YYARG. */ + int yycount = 0; + int yyn = yypact[+*yyctx->yyssp]; + if (!yypact_value_is_default (yyn)) + { + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. In other words, skip the first -YYN actions for + this state because they are default actions. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn + 1; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yyx; + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYSYMBOL_YYerror + && !yytable_value_is_error (yytable[yyx + yyn])) + { + if (!yyarg) + ++yycount; + else if (yycount == yyargn) + return 0; + else + yyarg[yycount++] = YY_CAST (yysymbol_kind_t, yyx); + } + } + if (yyarg && yycount == 0 && 0 < yyargn) + yyarg[0] = YYSYMBOL_YYEMPTY; + return yycount; +} + + + + +#ifndef yystrlen +# if defined __GLIBC__ && defined _STRING_H +# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) +# else +/* Return the length of YYSTR. */ +static YYPTRDIFF_T +yystrlen (const char *yystr) +{ + YYPTRDIFF_T yylen; + for (yylen = 0; yystr[yylen]; yylen++) + continue; + return yylen; +} +# endif +#endif + +#ifndef yystpcpy +# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +static char * +yystpcpy (char *yydest, const char *yysrc) +{ + char *yyd = yydest; + const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +#endif + +#ifndef yytnamerr +/* Copy to YYRES the contents of YYSTR after stripping away unnecessary + quotes and backslashes, so that it's suitable for yyerror. The + heuristic is that double-quoting is unnecessary unless the string + contains an apostrophe, a comma, or backslash (other than + backslash-backslash). YYSTR is taken from yytname. If YYRES is + null, do not copy; instead, return the length of what the result + would have been. */ +static YYPTRDIFF_T +yytnamerr (char *yyres, const char *yystr) +{ + if (*yystr == '"') + { + YYPTRDIFF_T yyn = 0; + char const *yyp = yystr; + for (;;) + switch (*++yyp) + { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + else + goto append; + + append: + default: + if (yyres) + yyres[yyn] = *yyp; + yyn++; + break; + + case '"': + if (yyres) + yyres[yyn] = '\0'; + return yyn; + } + do_not_strip_quotes: ; + } + + if (yyres) + return yystpcpy (yyres, yystr) - yyres; + else + return yystrlen (yystr); +} +#endif + + +static int +yy_syntax_error_arguments (const yypcontext_t *yyctx, + yysymbol_kind_t yyarg[], int yyargn) +{ + /* Actual size of YYARG. */ + int yycount = 0; + /* There are many possibilities here to consider: + - If this state is a consistent state with a default action, then + the only way this function was invoked is if the default action + is an error action. In that case, don't check for expected + tokens because there are none. + - The only way there can be no lookahead present (in yychar) is if + this state is a consistent state with a default action. Thus, + detecting the absence of a lookahead is sufficient to determine + that there is no unexpected or expected token to report. In that + case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this state is a + consistent state with a default action. There might have been a + previous inconsistent state, consistent state with a non-default + action, or user semantic action that manipulated yychar. + - Of course, the expected token list depends on states to have + correct lookahead information, and it depends on the parser not + to perform extra reductions after fetching a lookahead from the + scanner and before detecting a syntax error. Thus, state merging + (from LALR or IELR) and default reductions corrupt the expected + token list. However, the list is correct for canonical LR with + one exception: it will still contain any token that will not be + accepted due to an error action in a later state. + */ + if (yyctx->yytoken != YYSYMBOL_YYEMPTY) + { + int yyn; + if (yyarg) + yyarg[yycount] = yyctx->yytoken; + ++yycount; + yyn = yypcontext_expected_tokens (yyctx, + yyarg ? yyarg + 1 : yyarg, yyargn - 1); + if (yyn == YYENOMEM) + return YYENOMEM; + else + yycount += yyn; + } + return yycount; +} + +/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message + about the unexpected token YYTOKEN for the state stack whose top is + YYSSP. + + Return 0 if *YYMSG was successfully written. Return -1 if *YYMSG is + not large enough to hold the message. In that case, also set + *YYMSG_ALLOC to the required number of bytes. Return YYENOMEM if the + required number of bytes is too large to store. */ +static int +yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg, + const yypcontext_t *yyctx) +{ + enum { YYARGS_MAX = 5 }; + /* Internationalized format string. */ + const char *yyformat = YY_NULLPTR; + /* Arguments of yyformat: reported tokens (one for the "unexpected", + one per "expected"). */ + yysymbol_kind_t yyarg[YYARGS_MAX]; + /* Cumulated lengths of YYARG. */ + YYPTRDIFF_T yysize = 0; + + /* Actual size of YYARG. */ + int yycount = yy_syntax_error_arguments (yyctx, yyarg, YYARGS_MAX); + if (yycount == YYENOMEM) + return YYENOMEM; + + switch (yycount) + { +#define YYCASE_(N, S) \ + case N: \ + yyformat = S; \ + break + default: /* Avoid compiler warnings. */ + YYCASE_(0, YY_("syntax error")); + YYCASE_(1, YY_("syntax error, unexpected %s")); + YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); + YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); + YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); + YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); +#undef YYCASE_ + } + + /* Compute error message size. Don't count the "%s"s, but reserve + room for the terminator. */ + yysize = yystrlen (yyformat) - 2 * yycount + 1; + { + int yyi; + for (yyi = 0; yyi < yycount; ++yyi) + { + YYPTRDIFF_T yysize1 + = yysize + yytnamerr (YY_NULLPTR, yytname[yyarg[yyi]]); + if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) + yysize = yysize1; + else + return YYENOMEM; + } + } + + if (*yymsg_alloc < yysize) + { + *yymsg_alloc = 2 * yysize; + if (! (yysize <= *yymsg_alloc + && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) + *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; + return -1; + } + + /* Avoid sprintf, as that infringes on the user's name space. + Don't have undefined behavior even if the translation + produced a string with the wrong number of "%s"s. */ + { + char *yyp = *yymsg; + int yyi = 0; + while ((*yyp = *yyformat) != '\0') + if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) + { + yyp += yytnamerr (yyp, yytname[yyarg[yyi++]]); + yyformat += 2; + } + else + { + ++yyp; + ++yyformat; + } + } + return 0; +} + + +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +static void +yydestruct (const char *yymsg, + yysymbol_kind_t yykind, YYSTYPE *yyvaluep) +{ + YY_USE (yyvaluep); + if (!yymsg) + yymsg = "Deleting"; + YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp); + + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + YY_USE (yykind); + YY_IGNORE_MAYBE_UNINITIALIZED_END +} + + +/* Lookahead token kind. */ +int yychar; + +/* The semantic value of the lookahead symbol. */ +YYSTYPE yylval; +/* Number of syntax errors so far. */ +int yynerrs; + + + + +/*----------. +| yyparse. | +`----------*/ + +int +yyparse (void) +{ + yy_state_fast_t yystate = 0; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus = 0; + + /* Refer to the stacks through separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* Their size. */ + YYPTRDIFF_T yystacksize = YYINITDEPTH; + + /* The state stack: array, bottom, top. */ + yy_state_t yyssa[YYINITDEPTH]; + yy_state_t *yyss = yyssa; + yy_state_t *yyssp = yyss; + + /* The semantic value stack: array, bottom, top. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs = yyvsa; + YYSTYPE *yyvsp = yyvs; + + int yyn; + /* The return value of yyparse. */ + int yyresult; + /* Lookahead symbol kind. */ + yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY; + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; + + /* Buffer for error messages, and its allocated size. */ + char yymsgbuf[128]; + char *yymsg = yymsgbuf; + YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf; + +#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) + + /* The number of symbols on the RHS of the reduced rule. + Keep to zero when no symbol should be popped. */ + int yylen = 0; + + YYDPRINTF ((stderr, "Starting parse\n")); + + yychar = YYEMPTY; /* Cause a token to be read. */ + + goto yysetstate; + + +/*------------------------------------------------------------. +| yynewstate -- push a new state, which is found in yystate. | +`------------------------------------------------------------*/ +yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. So pushing a state here evens the stacks. */ + yyssp++; + + +/*--------------------------------------------------------------------. +| yysetstate -- set current state (the top of the stack) to yystate. | +`--------------------------------------------------------------------*/ +yysetstate: + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + YY_ASSERT (0 <= yystate && yystate < YYNSTATES); + YY_IGNORE_USELESS_CAST_BEGIN + *yyssp = YY_CAST (yy_state_t, yystate); + YY_IGNORE_USELESS_CAST_END + YY_STACK_PRINT (yyss, yyssp); + + if (yyss + yystacksize - 1 <= yyssp) +#if !defined yyoverflow && !defined YYSTACK_RELOCATE + YYNOMEM; +#else + { + /* Get the current used size of the three stacks, in elements. */ + YYPTRDIFF_T yysize = yyssp - yyss + 1; + +# if defined yyoverflow + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + yy_state_t *yyss1 = yyss; + YYSTYPE *yyvs1 = yyvs; + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ + yyoverflow (YY_("memory exhausted"), + &yyss1, yysize * YYSIZEOF (*yyssp), + &yyvs1, yysize * YYSIZEOF (*yyvsp), + &yystacksize); + yyss = yyss1; + yyvs = yyvs1; + } +# else /* defined YYSTACK_RELOCATE */ + /* Extend the stack our own way. */ + if (YYMAXDEPTH <= yystacksize) + YYNOMEM; + yystacksize *= 2; + if (YYMAXDEPTH < yystacksize) + yystacksize = YYMAXDEPTH; + + { + yy_state_t *yyss1 = yyss; + union yyalloc *yyptr = + YY_CAST (union yyalloc *, + YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); + if (! yyptr) + YYNOMEM; + YYSTACK_RELOCATE (yyss_alloc, yyss); + YYSTACK_RELOCATE (yyvs_alloc, yyvs); +# undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); + } +# endif + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1; + + YY_IGNORE_USELESS_CAST_BEGIN + YYDPRINTF ((stderr, "Stack size increased to %ld\n", + YY_CAST (long, yystacksize))); + YY_IGNORE_USELESS_CAST_END + + if (yyss + yystacksize - 1 <= yyssp) + YYABORT; + } +#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ + + + if (yystate == YYFINAL) + YYACCEPT; + + goto yybackup; + + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + /* Do appropriate processing given the current state. Read a + lookahead token if we need one and don't already have one. */ + + /* First try to decide what to do without reference to lookahead token. */ + yyn = yypact[yystate]; + if (yypact_value_is_default (yyn)) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */ + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token\n")); + yychar = yylex (); + } + + if (yychar <= YYEOF) + { + yychar = YYEOF; + yytoken = YYSYMBOL_YYEOF; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else if (yychar == YYerror) + { + /* The scanner already issued an error message, process directly + to error recovery. But do not keep the error token as + lookahead, it is too special and may lead us to an endless + loop in error recovery. */ + yychar = YYUNDEF; + yytoken = YYSYMBOL_YYerror; + goto yyerrlab1; + } + else + { + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) + goto yydefault; + yyn = yytable[yyn]; + if (yyn <= 0) + { + if (yytable_value_is_error (yyn)) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + + /* Shift the lookahead token. */ + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); + yystate = yyn; + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + *++yyvsp = yylval; + YY_IGNORE_MAYBE_UNINITIALIZED_END + + /* Discard the shifted token. */ + yychar = YYEMPTY; + goto yynewstate; + + +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + +/*-----------------------------. +| yyreduce -- do a reduction. | +`-----------------------------*/ +yyreduce: + /* yyn is the number of a rule to reduce with. */ + yylen = yyr2[yyn]; + + /* If YYLEN is nonzero, implement the default value of the action: + '$$ = $1'. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. Assigning to YYVAL + unconditionally makes the parser a bit smaller, and it avoids a + GCC warning that YYVAL may be used uninitialized. */ + yyval = yyvsp[1-yylen]; + + + YY_REDUCE_PRINT (yyn); + switch (yyn) + { + case 2: /* glyph: UNSIGNED REFERENCE */ +#line 264 "parser.y" + { + #line 418 "format.w" + (yyval.c).c= (yyvsp[-1].u);REF(font_kind,(yyvsp[0].u));(yyval.c).f= (yyvsp[0].u);} +#line 2018 "parser.c" + break; + + case 3: /* content_node: start "glyph" glyph ">" */ +#line 267 "parser.y" + { + #line 419 "format.w" + hput_tags((yyvsp[-3].u),hput_glyph(&((yyvsp[-1].c))));} +#line 2026 "parser.c" + break; + + case 4: /* start: "<" */ +#line 270 "parser.y" + { + #line 420 "format.w" + HPUTNODE;(yyval.u)= (uint32_t)(hpos++-hstart);} +#line 2034 "parser.c" + break; + + case 6: /* integer: UNSIGNED */ +#line 274 "parser.y" + { + #line 941 "format.w" + RNG("number",(yyvsp[0].u),0,0x7FFFFFFF);} +#line 2042 "parser.c" + break; + + case 7: /* glyph: CHARCODE REFERENCE */ +#line 278 "parser.y" + { + #line 1082 "format.w" + (yyval.c).c= (yyvsp[-1].u);REF(font_kind,(yyvsp[0].u));(yyval.c).f= (yyvsp[0].u);} +#line 2050 "parser.c" + break; + + case 9: /* string: CHARCODE */ +#line 282 "parser.y" + { + #line 1187 "format.w" + static char s[2]; + RNG("String element",(yyvsp[0].u),0x20,0x7E); + s[0]= (yyvsp[0].u);s[1]= 0;(yyval.s)= s;} +#line 2060 "parser.c" + break; + + case 10: /* number: UNSIGNED */ +#line 288 "parser.y" + { + #line 1339 "format.w" + (yyval.f)= (float64_t)(yyvsp[0].u);} +#line 2068 "parser.c" + break; + + case 11: /* number: SIGNED */ +#line 290 "parser.y" + { + #line 1339 "format.w" + (yyval.f)= (float64_t)(yyvsp[0].i);} +#line 2076 "parser.c" + break; + + case 13: /* dimension: number "pt" */ +#line 294 "parser.y" + { + #line 1682 "format.w" + (yyval.d)= ROUND((yyvsp[-1].f)*ONE);RNG("Dimension",(yyval.d),-MAX_DIMEN,MAX_DIMEN);} +#line 2084 "parser.c" + break; + + case 14: /* dimension: number "in" */ +#line 297 "parser.y" + { + #line 1683 "format.w" + (yyval.d)= ROUND((yyvsp[-1].f)*ONE*72.27);RNG("Dimension",(yyval.d),-MAX_DIMEN,MAX_DIMEN);} +#line 2092 "parser.c" + break; + + case 15: /* dimension: number "mm" */ +#line 300 "parser.y" + { + #line 1684 "format.w" + (yyval.d)= ROUND((yyvsp[-1].f)*ONE*(72.27/25.4));RNG("Dimension",(yyval.d),-MAX_DIMEN,MAX_DIMEN);} +#line 2100 "parser.c" + break; + + case 16: /* xdimen: dimension number "h" number "v" */ +#line 304 "parser.y" + { + #line 1762 "format.w" + (yyval.xd).w= (yyvsp[-4].d);(yyval.xd).h= (yyvsp[-3].f);(yyval.xd).v= (yyvsp[-1].f);} +#line 2108 "parser.c" + break; + + case 17: /* xdimen: dimension number "h" */ +#line 307 "parser.y" + { + #line 1763 "format.w" + (yyval.xd).w= (yyvsp[-2].d);(yyval.xd).h= (yyvsp[-1].f);(yyval.xd).v= 0.0;} +#line 2116 "parser.c" + break; + + case 18: /* xdimen: dimension number "v" */ +#line 310 "parser.y" + { + #line 1764 "format.w" + (yyval.xd).w= (yyvsp[-2].d);(yyval.xd).h= 0.0;(yyval.xd).v= (yyvsp[-1].f);} +#line 2124 "parser.c" + break; + + case 19: /* xdimen: dimension */ +#line 313 "parser.y" + { + #line 1765 "format.w" + (yyval.xd).w= (yyvsp[0].d);(yyval.xd).h= 0.0;(yyval.xd).v= 0.0;} +#line 2132 "parser.c" + break; + + case 20: /* xdimen_node: start "xdimen" xdimen ">" */ +#line 319 "parser.y" + { + #line 1769 "format.w" + hput_tags((yyvsp[-3].u),hput_xdimen(&((yyvsp[-1].xd))));} +#line 2140 "parser.c" + break; + + case 21: /* order: "pt" */ +#line 324 "parser.y" + { + #line 1947 "format.w" + (yyval.o)= normal_o;} +#line 2148 "parser.c" + break; + + case 22: /* order: "fil" */ +#line 326 "parser.y" + { + #line 1947 "format.w" + (yyval.o)= fil_o;} +#line 2156 "parser.c" + break; + + case 23: /* order: "fill" */ +#line 328 "parser.y" + { + #line 1947 "format.w" + (yyval.o)= fill_o;} +#line 2164 "parser.c" + break; + + case 24: /* order: "filll" */ +#line 330 "parser.y" + { + #line 1947 "format.w" + (yyval.o)= filll_o;} +#line 2172 "parser.c" + break; + + case 25: /* stretch: number order */ +#line 334 "parser.y" + { + #line 1949 "format.w" + (yyval.st).f= (yyvsp[-1].f);(yyval.st).o= (yyvsp[0].o);} +#line 2180 "parser.c" + break; + + case 26: /* penalty: integer */ +#line 338 "parser.y" + { + #line 2003 "format.w" + RNG("Penalty",(yyvsp[0].i),-20000,+20000);(yyval.i)= (yyvsp[0].i);} +#line 2188 "parser.c" + break; + + case 27: /* content_node: start "penalty" penalty ">" */ +#line 341 "parser.y" + { + #line 2004 "format.w" + hput_tags((yyvsp[-3].u),hput_int((yyvsp[-1].i)));} +#line 2196 "parser.c" + break; + + case 29: /* rule_dimension: "|" */ +#line 345 "parser.y" + { + #line 2179 "format.w" + (yyval.d)= RUNNING_DIMEN;} +#line 2204 "parser.c" + break; + + case 30: /* rule: rule_dimension rule_dimension rule_dimension */ +#line 349 "parser.y" +{ + #line 2181 "format.w" + (yyval.r).h= (yyvsp[-2].d);(yyval.r).d= (yyvsp[-1].d);(yyval.r).w= (yyvsp[0].d); + if((yyvsp[0].d)==RUNNING_DIMEN&&((yyvsp[-2].d)==RUNNING_DIMEN||(yyvsp[-1].d)==RUNNING_DIMEN)) + QUIT("Incompatible running dimensions 0x%x 0x%x 0x%x",(yyvsp[-2].d),(yyvsp[-1].d),(yyvsp[0].d));} +#line 2214 "parser.c" + break; + + case 31: /* rule_node: start "rule" rule ">" */ +#line 354 "parser.y" + { + #line 2184 "format.w" + hput_tags((yyvsp[-3].u),hput_rule(&((yyvsp[-1].r))));} +#line 2222 "parser.c" + break; + + case 33: /* explicit: %empty */ +#line 359 "parser.y" + { + #line 2292 "format.w" + (yyval.b)= false;} +#line 2230 "parser.c" + break; + + case 34: /* explicit: "!" */ +#line 361 "parser.y" + { + #line 2292 "format.w" + (yyval.b)= true;} +#line 2238 "parser.c" + break; + + case 35: /* kern: explicit xdimen */ +#line 364 "parser.y" + { + #line 2293 "format.w" + (yyval.kt).x= (yyvsp[-1].b);(yyval.kt).d= (yyvsp[0].xd);} +#line 2246 "parser.c" + break; + + case 36: /* content_node: start "kern" kern ">" */ +#line 367 "parser.y" + { + #line 2294 "format.w" + hput_tags((yyvsp[-3].u),hput_kern(&((yyvsp[-1].kt))));} +#line 2254 "parser.c" + break; + + case 37: /* plus: %empty */ +#line 371 "parser.y" + { + #line 2504 "format.w" + (yyval.st).f= 0.0;(yyval.st).o= 0;} +#line 2262 "parser.c" + break; + + case 38: /* plus: "plus" stretch */ +#line 373 "parser.y" + { + #line 2504 "format.w" + (yyval.st)= (yyvsp[0].st);} +#line 2270 "parser.c" + break; + + case 39: /* minus: %empty */ +#line 376 "parser.y" + { + #line 2505 "format.w" + (yyval.st).f= 0.0;(yyval.st).o= 0;} +#line 2278 "parser.c" + break; + + case 40: /* minus: "minus" stretch */ +#line 378 "parser.y" + { + #line 2505 "format.w" + (yyval.st)= (yyvsp[0].st);} +#line 2286 "parser.c" + break; + + case 41: /* glue: xdimen plus minus */ +#line 381 "parser.y" + { + #line 2506 "format.w" + (yyval.g).w= (yyvsp[-2].xd);(yyval.g).p= (yyvsp[-1].st);(yyval.g).m= (yyvsp[0].st);} +#line 2294 "parser.c" + break; + + case 42: /* content_node: start "glue" glue ">" */ +#line 384 "parser.y" + { + #line 2507 "format.w" + if(ZERO_GLUE((yyvsp[-1].g))){HPUT8(zero_skip_no); + hput_tags((yyvsp[-3].u),TAG(glue_kind,0));}else hput_tags((yyvsp[-3].u),hput_glue(&((yyvsp[-1].g))));} +#line 2303 "parser.c" + break; + + case 43: /* glue_node: start "glue" glue ">" */ +#line 389 "parser.y" +{ + #line 2510 "format.w" + if(ZERO_GLUE((yyvsp[-1].g))){hpos--;(yyval.b)= false;} + else{hput_tags((yyvsp[-3].u),hput_glue(&((yyvsp[-1].g))));(yyval.b)= true;}} +#line 2312 "parser.c" + break; + + case 44: /* position: %empty */ +#line 394 "parser.y" + { + #line 2786 "format.w" + (yyval.u)= hpos-hstart;} +#line 2320 "parser.c" + break; + + case 47: /* estimate: %empty */ +#line 399 "parser.y" + { + #line 2789 "format.w" + hpos+= 2;} +#line 2328 "parser.c" + break; + + case 48: /* estimate: UNSIGNED */ +#line 402 "parser.y" + { + #line 2790 "format.w" + hpos+= hsize_bytes((yyvsp[0].u))+1;} +#line 2336 "parser.c" + break; + + case 49: /* list: start estimate content_list ">" */ +#line 406 "parser.y" +{ + #line 2792 "format.w" + (yyval.l).k= list_kind;(yyval.l).p= (yyvsp[-1].u);(yyval.l).s= (hpos-hstart)-(yyvsp[-1].u); + hput_tags((yyvsp[-3].u),hput_list((yyvsp[-3].u)+1,&((yyval.l))));} +#line 2345 "parser.c" + break; + + case 50: /* $@1: %empty */ +#line 412 "parser.y" +{ + #line 3199 "format.w" + hpos+= 4;} +#line 2353 "parser.c" + break; + + case 51: /* list: TXT_START position $@1 text TXT_END */ +#line 416 "parser.y" +{ + #line 3201 "format.w" + (yyval.l).k= text_kind;(yyval.l).p= (yyvsp[-1].u);(yyval.l).s= (hpos-hstart)-(yyvsp[-1].u); + hput_tags((yyvsp[-3].u),hput_list((yyvsp[-3].u)+1,&((yyval.l))));} +#line 2362 "parser.c" + break; + + case 54: /* txt: TXT_CC */ +#line 422 "parser.y" + { + #line 3205 "format.w" + hput_txt_cc((yyvsp[0].u));} +#line 2370 "parser.c" + break; + + case 55: /* txt: TXT_FONT */ +#line 425 "parser.y" + { + #line 3206 "format.w" + REF(font_kind,(yyvsp[0].u));hput_txt_font((yyvsp[0].u));} +#line 2378 "parser.c" + break; + + case 56: /* txt: TXT_GLOBAL */ +#line 428 "parser.y" + { + #line 3207 "format.w" + REF((yyvsp[0].rf).k,(yyvsp[0].rf).n);hput_txt_global(&((yyvsp[0].rf)));} +#line 2386 "parser.c" + break; + + case 57: /* txt: TXT_LOCAL */ +#line 431 "parser.y" + { + #line 3208 "format.w" + RNG("Font parameter",(yyvsp[0].u),0,11);hput_txt_local((yyvsp[0].u));} +#line 2394 "parser.c" + break; + + case 58: /* txt: TXT_FONT_GLUE */ +#line 434 "parser.y" + { + #line 3209 "format.w" + HPUTX(1);HPUT8(txt_glue);} +#line 2402 "parser.c" + break; + + case 59: /* txt: TXT_FONT_HYPHEN */ +#line 437 "parser.y" + { + #line 3210 "format.w" + HPUTX(1);HPUT8(txt_hyphen);} +#line 2410 "parser.c" + break; + + case 60: /* txt: TXT_IGNORE */ +#line 440 "parser.y" + { + #line 3211 "format.w" + HPUTX(1);HPUT8(txt_ignore);} +#line 2418 "parser.c" + break; + + case 61: /* $@2: %empty */ +#line 443 "parser.y" + { + #line 3212 "format.w" + HPUTX(1);HPUT8(txt_node);} +#line 2426 "parser.c" + break; + + case 63: /* box_dimen: dimension dimension dimension */ +#line 449 "parser.y" +{ + #line 3470 "format.w" + (yyval.info)= hput_box_dimen((yyvsp[-2].d),(yyvsp[-1].d),(yyvsp[0].d));} +#line 2434 "parser.c" + break; + + case 64: /* box_shift: %empty */ +#line 452 "parser.y" + { + #line 3471 "format.w" + (yyval.info)= b000;} +#line 2442 "parser.c" + break; + + case 65: /* box_shift: "shifted" dimension */ +#line 455 "parser.y" + { + #line 3472 "format.w" + (yyval.info)= hput_box_shift((yyvsp[0].d));} +#line 2450 "parser.c" + break; + + case 66: /* box_glue_set: %empty */ +#line 459 "parser.y" + { + #line 3474 "format.w" + (yyval.info)= b000;} +#line 2458 "parser.c" + break; + + case 67: /* box_glue_set: "plus" stretch */ +#line 462 "parser.y" + { + #line 3475 "format.w" + (yyval.info)= hput_box_glue_set(+1,(yyvsp[0].st).f,(yyvsp[0].st).o);} +#line 2466 "parser.c" + break; + + case 68: /* box_glue_set: "minus" stretch */ +#line 465 "parser.y" + { + #line 3476 "format.w" + (yyval.info)= hput_box_glue_set(-1,(yyvsp[0].st).f,(yyvsp[0].st).o);} +#line 2474 "parser.c" + break; + + case 69: /* box: box_dimen box_shift box_glue_set list */ +#line 470 "parser.y" + { + #line 3479 "format.w" + (yyval.info)= (yyvsp[-3].info) |(yyvsp[-2].info) |(yyvsp[-1].info);} +#line 2482 "parser.c" + break; + + case 70: /* hbox_node: start "hbox" box ">" */ +#line 474 "parser.y" + { + #line 3481 "format.w" + hput_tags((yyvsp[-3].u),TAG(hbox_kind,(yyvsp[-1].info)));} +#line 2490 "parser.c" + break; + + case 71: /* vbox_node: start "vbox" box ">" */ +#line 477 "parser.y" + { + #line 3482 "format.w" + hput_tags((yyvsp[-3].u),TAG(vbox_kind,(yyvsp[-1].info)));} +#line 2498 "parser.c" + break; + + case 74: /* box_flex: plus minus */ +#line 482 "parser.y" + { + #line 3663 "format.w" + hput_stretch(&((yyvsp[-1].st)));hput_stretch(&((yyvsp[0].st)));} +#line 2506 "parser.c" + break; + + case 75: /* xbox: box_dimen box_shift box_flex xdimen_ref list */ +#line 485 "parser.y" + { + #line 3664 "format.w" + (yyval.info)= (yyvsp[-4].info) |(yyvsp[-3].info);} +#line 2514 "parser.c" + break; + + case 76: /* xbox: box_dimen box_shift box_flex xdimen_node list */ +#line 488 "parser.y" + { + #line 3665 "format.w" + (yyval.info)= (yyvsp[-4].info) |(yyvsp[-3].info) |b100;} +#line 2522 "parser.c" + break; + + case 77: /* box_goal: "to" xdimen_ref */ +#line 492 "parser.y" + { + #line 3667 "format.w" + (yyval.info)= b000;} +#line 2530 "parser.c" + break; + + case 78: /* box_goal: "add" xdimen_ref */ +#line 495 "parser.y" + { + #line 3668 "format.w" + (yyval.info)= b001;} +#line 2538 "parser.c" + break; + + case 79: /* box_goal: "to" xdimen_node */ +#line 498 "parser.y" + { + #line 3669 "format.w" + (yyval.info)= b100;} +#line 2546 "parser.c" + break; + + case 80: /* box_goal: "add" xdimen_node */ +#line 501 "parser.y" + { + #line 3670 "format.w" + (yyval.info)= b101;} +#line 2554 "parser.c" + break; + + case 81: /* hpack: box_shift box_goal list */ +#line 505 "parser.y" + { + #line 3672 "format.w" + (yyval.info)= (yyvsp[-1].info);} +#line 2562 "parser.c" + break; + + case 82: /* $@3: %empty */ +#line 508 "parser.y" + { + #line 3673 "format.w" + HPUT32((yyvsp[0].d));} +#line 2570 "parser.c" + break; + + case 83: /* vpack: box_shift "max" "depth" dimension $@3 box_goal list */ +#line 510 "parser.y" + { + #line 3673 "format.w" + (yyval.info)= (yyvsp[-6].info) |(yyvsp[-1].info);} +#line 2578 "parser.c" + break; + + case 84: /* vxbox_node: start "vset" xbox ">" */ +#line 514 "parser.y" + { + #line 3675 "format.w" + hput_tags((yyvsp[-3].u),TAG(vset_kind,(yyvsp[-1].info)));} +#line 2586 "parser.c" + break; + + case 85: /* vxbox_node: start "vpack" vpack ">" */ +#line 517 "parser.y" + { + #line 3676 "format.w" + hput_tags((yyvsp[-3].u),TAG(vpack_kind,(yyvsp[-1].info)));} +#line 2594 "parser.c" + break; + + case 86: /* hxbox_node: start "hset" xbox ">" */ +#line 522 "parser.y" + { + #line 3679 "format.w" + hput_tags((yyvsp[-3].u),TAG(hset_kind,(yyvsp[-1].info)));} +#line 2602 "parser.c" + break; + + case 87: /* hxbox_node: start "hpack" hpack ">" */ +#line 525 "parser.y" + { + #line 3680 "format.w" + hput_tags((yyvsp[-3].u),TAG(hpack_kind,(yyvsp[-1].info)));} +#line 2610 "parser.c" + break; + + case 90: /* ltype: %empty */ +#line 531 "parser.y" + { + #line 3790 "format.w" + (yyval.info)= 1;} +#line 2618 "parser.c" + break; + + case 91: /* ltype: "align" */ +#line 533 "parser.y" + { + #line 3790 "format.w" + (yyval.info)= 1;} +#line 2626 "parser.c" + break; + + case 92: /* ltype: "center" */ +#line 535 "parser.y" + { + #line 3790 "format.w" + (yyval.info)= 2;} +#line 2634 "parser.c" + break; + + case 93: /* ltype: "expand" */ +#line 537 "parser.y" + { + #line 3790 "format.w" + (yyval.info)= 3;} +#line 2642 "parser.c" + break; + + case 94: /* leaders: glue_node ltype rule_node */ +#line 540 "parser.y" + { + #line 3791 "format.w" + if((yyvsp[-2].b))(yyval.info)= (yyvsp[-1].info) |b100;else (yyval.info)= (yyvsp[-1].info);} +#line 2650 "parser.c" + break; + + case 95: /* leaders: glue_node ltype hbox_node */ +#line 543 "parser.y" + { + #line 3792 "format.w" + if((yyvsp[-2].b))(yyval.info)= (yyvsp[-1].info) |b100;else (yyval.info)= (yyvsp[-1].info);} +#line 2658 "parser.c" + break; + + case 96: /* leaders: glue_node ltype vbox_node */ +#line 546 "parser.y" + { + #line 3793 "format.w" + if((yyvsp[-2].b))(yyval.info)= (yyvsp[-1].info) |b100;else (yyval.info)= (yyvsp[-1].info);} +#line 2666 "parser.c" + break; + + case 97: /* content_node: start "leaders" leaders ">" */ +#line 549 "parser.y" + { + #line 3794 "format.w" + hput_tags((yyvsp[-3].u),TAG(leaders_kind,(yyvsp[-1].info)));} +#line 2674 "parser.c" + break; + + case 98: /* $@4: %empty */ +#line 553 "parser.y" + { + #line 3900 "format.w" + if((yyvsp[0].d)!=0)HPUT32((yyvsp[0].d));} +#line 2682 "parser.c" + break; + + case 99: /* baseline: dimension $@4 glue_node glue_node */ +#line 556 "parser.y" + { + #line 3901 "format.w" + (yyval.info)= b000;if((yyvsp[-3].d)!=0)(yyval.info) |= b001; + if((yyvsp[-1].b))(yyval.info) |= b100; + if((yyvsp[0].b))(yyval.info) |= b010; + } +#line 2693 "parser.c" + break; + + case 100: /* content_node: start "baseline" baseline ">" */ +#line 563 "parser.y" +{ + #line 3906 "format.w" + if((yyvsp[-1].info)==b000)HPUT8(0);hput_tags((yyvsp[-3].u),TAG(baseline_kind,(yyvsp[-1].info)));} +#line 2701 "parser.c" + break; + + case 102: /* cc_list: cc_list TXT_CC */ +#line 567 "parser.y" + { + #line 3989 "format.w" + hput_utf8((yyvsp[0].u));} +#line 2709 "parser.c" + break; + + case 103: /* lig_cc: UNSIGNED */ +#line 570 "parser.y" + { + #line 3990 "format.w" + RNG("UTF-8 code",(yyvsp[0].u),0,0x1FFFFF);(yyval.u)= hpos-hstart;hput_utf8((yyvsp[0].u));} +#line 2717 "parser.c" + break; + + case 104: /* lig_cc: CHARCODE */ +#line 573 "parser.y" + { + #line 3991 "format.w" + (yyval.u)= hpos-hstart;hput_utf8((yyvsp[0].u));} +#line 2725 "parser.c" + break; + + case 105: /* ref: REFERENCE */ +#line 576 "parser.y" + { + #line 3992 "format.w" + HPUT8((yyvsp[0].u));(yyval.u)= (yyvsp[0].u);} +#line 2733 "parser.c" + break; + + case 106: /* $@5: %empty */ +#line 579 "parser.y" + { + #line 3993 "format.w" + REF(font_kind,(yyvsp[0].u));} +#line 2741 "parser.c" + break; + + case 107: /* ligature: ref $@5 lig_cc TXT_START cc_list TXT_END */ +#line 582 "parser.y" +{ + #line 3994 "format.w" + (yyval.lg).f= (yyvsp[-5].u);(yyval.lg).l.p= (yyvsp[-3].u);(yyval.lg).l.s= (hpos-hstart)-(yyvsp[-3].u); + RNG("Ligature size",(yyval.lg).l.s,0,255);} +#line 2750 "parser.c" + break; + + case 108: /* content_node: start "ligature" ligature ">" */ +#line 586 "parser.y" + { + #line 3996 "format.w" + hput_tags((yyvsp[-3].u),hput_ligature(&((yyvsp[-1].lg))));} +#line 2758 "parser.c" + break; + + case 109: /* replace_count: explicit */ +#line 590 "parser.y" + { + #line 4106 "format.w" + if((yyvsp[0].b)){(yyval.u)= 0x80;HPUT8(0x80);}else (yyval.u)= 0x00;} +#line 2766 "parser.c" + break; + + case 110: /* replace_count: explicit UNSIGNED */ +#line 593 "parser.y" + { + #line 4107 "format.w" + RNG("Replace count",(yyvsp[0].u),0,31); + (yyval.u)= ((yyvsp[0].u)) |(((yyvsp[-1].b))?0x80:0x00);if((yyval.u)!=0)HPUT8((yyval.u));} +#line 2775 "parser.c" + break; + + case 111: /* disc: replace_count list list */ +#line 597 "parser.y" + { + #line 4109 "format.w" + (yyval.dc).r= (yyvsp[-2].u);(yyval.dc).p= (yyvsp[-1].l);(yyval.dc).q= (yyvsp[0].l); + if((yyvsp[0].l).s==0){hpos= hpos-2;if((yyvsp[-1].l).s==0)hpos= hpos-2;}} +#line 2784 "parser.c" + break; + + case 112: /* disc: replace_count list */ +#line 601 "parser.y" + { + #line 4111 "format.w" + (yyval.dc).r= (yyvsp[-1].u);(yyval.dc).p= (yyvsp[0].l);if((yyvsp[0].l).s==0)hpos= hpos-2;(yyval.dc).q.s= 0;} +#line 2792 "parser.c" + break; + + case 113: /* disc: replace_count */ +#line 604 "parser.y" + { + #line 4112 "format.w" + (yyval.dc).r= (yyvsp[0].u);(yyval.dc).p.s= 0;(yyval.dc).q.s= 0;} +#line 2800 "parser.c" + break; + + case 114: /* disc_node: start "disc" disc ">" */ +#line 610 "parser.y" +{ + #line 4116 "format.w" + hput_tags((yyvsp[-3].u),hput_disc(&((yyvsp[-1].dc))));} +#line 2808 "parser.c" + break; + + case 116: /* par_dimen: xdimen */ +#line 616 "parser.y" + { + #line 4268 "format.w" + hput_xdimen_node(&((yyvsp[0].xd)));} +#line 2816 "parser.c" + break; + + case 117: /* par: xdimen_ref param_ref list */ +#line 619 "parser.y" + { + #line 4269 "format.w" + (yyval.info)= b000;} +#line 2824 "parser.c" + break; + + case 118: /* par: xdimen_ref empty_param_list non_empty_param_list list */ +#line 622 "parser.y" + { + #line 4270 "format.w" + (yyval.info)= b010;} +#line 2832 "parser.c" + break; + + case 119: /* par: xdimen_ref empty_param_list list */ +#line 625 "parser.y" + { + #line 4271 "format.w" + (yyval.info)= b010;} +#line 2840 "parser.c" + break; + + case 120: /* $@6: %empty */ +#line 628 "parser.y" + { + #line 4272 "format.w" + hput_xdimen_node(&((yyvsp[-1].xd)));} +#line 2848 "parser.c" + break; + + case 121: /* par: xdimen param_ref $@6 list */ +#line 630 "parser.y" + { + #line 4272 "format.w" + (yyval.info)= b100;} +#line 2856 "parser.c" + break; + + case 122: /* par: par_dimen empty_param_list non_empty_param_list list */ +#line 633 "parser.y" + { + #line 4273 "format.w" + (yyval.info)= b110;} +#line 2864 "parser.c" + break; + + case 123: /* par: par_dimen empty_param_list list */ +#line 636 "parser.y" + { + #line 4274 "format.w" + (yyval.info)= b110;} +#line 2872 "parser.c" + break; + + case 124: /* content_node: start "par" par ">" */ +#line 640 "parser.y" + { + #line 4276 "format.w" + hput_tags((yyvsp[-3].u),TAG(par_kind,(yyvsp[-1].info)));} +#line 2880 "parser.c" + break; + + case 125: /* math: param_ref list */ +#line 644 "parser.y" + { + #line 4342 "format.w" + (yyval.info)= b000;} +#line 2888 "parser.c" + break; + + case 126: /* math: param_ref list hbox_node */ +#line 647 "parser.y" + { + #line 4343 "format.w" + (yyval.info)= b001;} +#line 2896 "parser.c" + break; + + case 127: /* math: param_ref hbox_node list */ +#line 650 "parser.y" + { + #line 4344 "format.w" + (yyval.info)= b010;} +#line 2904 "parser.c" + break; + + case 128: /* math: empty_param_list list */ +#line 653 "parser.y" + { + #line 4345 "format.w" + (yyval.info)= b100;} +#line 2912 "parser.c" + break; + + case 129: /* math: empty_param_list list hbox_node */ +#line 656 "parser.y" + { + #line 4346 "format.w" + (yyval.info)= b101;} +#line 2920 "parser.c" + break; + + case 130: /* math: empty_param_list hbox_node list */ +#line 659 "parser.y" + { + #line 4347 "format.w" + (yyval.info)= b110;} +#line 2928 "parser.c" + break; + + case 131: /* math: empty_param_list non_empty_param_list list */ +#line 662 "parser.y" + { + #line 4348 "format.w" + (yyval.info)= b100;} +#line 2936 "parser.c" + break; + + case 132: /* math: empty_param_list non_empty_param_list list hbox_node */ +#line 665 "parser.y" + { + #line 4349 "format.w" + (yyval.info)= b101;} +#line 2944 "parser.c" + break; + + case 133: /* math: empty_param_list non_empty_param_list hbox_node list */ +#line 668 "parser.y" + { + #line 4350 "format.w" + (yyval.info)= b110;} +#line 2952 "parser.c" + break; + + case 134: /* content_node: start "math" math ">" */ +#line 672 "parser.y" + { + #line 4352 "format.w" + hput_tags((yyvsp[-3].u),TAG(math_kind,(yyvsp[-1].info)));} +#line 2960 "parser.c" + break; + + case 135: /* on_off: "on" */ +#line 676 "parser.y" + { + #line 4402 "format.w" + (yyval.i)= 1;} +#line 2968 "parser.c" + break; + + case 136: /* on_off: "off" */ +#line 678 "parser.y" + { + #line 4402 "format.w" + (yyval.i)= 0;} +#line 2976 "parser.c" + break; + + case 137: /* math: on_off */ +#line 681 "parser.y" + { + #line 4403 "format.w" + (yyval.info)= b011 |((yyvsp[0].i)<<2);} +#line 2984 "parser.c" + break; + + case 138: /* content_node: start "adjust" list ">" */ +#line 685 "parser.y" + { + #line 4434 "format.w" + hput_tags((yyvsp[-3].u),TAG(adjust_kind,1));} +#line 2992 "parser.c" + break; + + case 139: /* span_count: UNSIGNED */ +#line 689 "parser.y" + { + #line 4533 "format.w" + (yyval.info)= hput_span_count((yyvsp[0].u));} +#line 3000 "parser.c" + break; + + case 140: /* content_node: start "item" content_node ">" */ +#line 692 "parser.y" + { + #line 4534 "format.w" + hput_tags((yyvsp[-3].u),TAG(item_kind,1));} +#line 3008 "parser.c" + break; + + case 141: /* content_node: start "item" span_count content_node ">" */ +#line 695 "parser.y" + { + #line 4535 "format.w" + hput_tags((yyvsp[-4].u),TAG(item_kind,(yyvsp[-2].info)));} +#line 3016 "parser.c" + break; + + case 142: /* content_node: start "item" list ">" */ +#line 698 "parser.y" + { + #line 4536 "format.w" + hput_tags((yyvsp[-3].u),TAG(item_kind,b000));} +#line 3024 "parser.c" + break; + + case 143: /* table: "h" box_goal list list */ +#line 702 "parser.y" + { + #line 4538 "format.w" + (yyval.info)= (yyvsp[-2].info);} +#line 3032 "parser.c" + break; + + case 144: /* table: "v" box_goal list list */ +#line 705 "parser.y" + { + #line 4539 "format.w" + (yyval.info)= (yyvsp[-2].info) |b010;} +#line 3040 "parser.c" + break; + + case 145: /* content_node: start "table" table ">" */ +#line 709 "parser.y" + { + #line 4541 "format.w" + hput_tags((yyvsp[-3].u),TAG(table_kind,(yyvsp[-1].info)));} +#line 3048 "parser.c" + break; + + case 146: /* image_dimen: dimension dimension */ +#line 713 "parser.y" + { + #line 4629 "format.w" + (yyval.x).w= (yyvsp[-1].d);(yyval.x).h= (yyvsp[0].d);} +#line 3056 "parser.c" + break; + + case 147: /* image_dimen: %empty */ +#line 715 "parser.y" + { + #line 4629 "format.w" + (yyval.x).w= (yyval.x).h= 0;} +#line 3064 "parser.c" + break; + + case 148: /* image: UNSIGNED image_dimen plus minus */ +#line 718 "parser.y" + { + #line 4630 "format.w" + (yyval.x).w= (yyvsp[-2].x).w;(yyval.x).h= (yyvsp[-2].x).h;(yyval.x).p= (yyvsp[-1].st);(yyval.x).m= (yyvsp[0].st);RNG("Section number",(yyvsp[-3].u),3,max_section_no);(yyval.x).n= (yyvsp[-3].u);} +#line 3072 "parser.c" + break; + + case 149: /* content_node: start "image" image ">" */ +#line 721 "parser.y" + { + #line 4631 "format.w" + hput_tags((yyvsp[-3].u),hput_image(&((yyvsp[-1].x))));} +#line 3080 "parser.c" + break; + + case 150: /* max_value: "outline" UNSIGNED */ +#line 725 "parser.y" + { + #line 4868 "format.w" + max_outline= (yyvsp[0].u); + RNG("max outline",max_outline,0,0xFFFF); + DBG(DBGDEF |DBGLABEL,"Setting max outline to %d\n",max_outline); + } +#line 3091 "parser.c" + break; + + case 151: /* placement: "top" */ +#line 732 "parser.y" + { + #line 4960 "format.w" + (yyval.i)= LABEL_TOP;} +#line 3099 "parser.c" + break; + + case 152: /* placement: "bot" */ +#line 734 "parser.y" + { + #line 4960 "format.w" + (yyval.i)= LABEL_BOT;} +#line 3107 "parser.c" + break; + + case 153: /* placement: "mid" */ +#line 736 "parser.y" + { + #line 4960 "format.w" + (yyval.i)= LABEL_MID;} +#line 3115 "parser.c" + break; + + case 154: /* placement: %empty */ +#line 738 "parser.y" + { + #line 4960 "format.w" + (yyval.i)= LABEL_MID;} +#line 3123 "parser.c" + break; + + case 155: /* content_node: "<" "label" REFERENCE placement ">" */ +#line 742 "parser.y" +{ + #line 4962 "format.w" + hset_label((yyvsp[-2].u),(yyvsp[-1].i));} +#line 3131 "parser.c" + break; + + case 156: /* content_node: start "link" REFERENCE on_off ">" */ +#line 747 "parser.y" +{ + #line 5220 "format.w" + hput_tags((yyvsp[-4].u),hput_link((yyvsp[-2].u),(yyvsp[-1].i)));} +#line 3139 "parser.c" + break; + + case 157: /* def_node: "<" "outline" REFERENCE integer position list ">" */ +#line 751 "parser.y" + { + #line 5350 "format.w" + + static int outline_no= -1; + (yyval.rf).k= outline_kind;(yyval.rf).n= (yyvsp[-4].u); + if((yyvsp[-1].l).s==0)QUIT("Outline with empty title in line %d",yylineno); + outline_no++; + hset_outline(outline_no,(yyvsp[-4].u),(yyvsp[-3].i),(yyvsp[-2].u)); + } +#line 3153 "parser.c" + break; + + case 158: /* stream_link: ref */ +#line 761 "parser.y" + { + #line 5765 "format.w" + REF_RNG(stream_kind,(yyvsp[0].u));} +#line 3161 "parser.c" + break; + + case 159: /* stream_link: "*" */ +#line 763 "parser.y" + { + #line 5765 "format.w" + HPUT8(255);} +#line 3169 "parser.c" + break; + + case 160: /* stream_split: stream_link stream_link UNSIGNED */ +#line 766 "parser.y" + { + #line 5766 "format.w" + RNG("split ratio",(yyvsp[0].u),0,1000);HPUT16((yyvsp[0].u));} +#line 3177 "parser.c" + break; + + case 161: /* $@7: %empty */ +#line 769 "parser.y" + { + #line 5767 "format.w" + RNG("magnification factor",(yyvsp[0].u),0,1000);HPUT16((yyvsp[0].u));} +#line 3185 "parser.c" + break; + + case 163: /* stream_type: stream_info */ +#line 773 "parser.y" + { + #line 5769 "format.w" + (yyval.info)= 0;} +#line 3193 "parser.c" + break; + + case 164: /* stream_type: "first" */ +#line 775 "parser.y" + { + #line 5769 "format.w" + (yyval.info)= 1;} +#line 3201 "parser.c" + break; + + case 165: /* stream_type: "last" */ +#line 777 "parser.y" + { + #line 5769 "format.w" + (yyval.info)= 2;} +#line 3209 "parser.c" + break; + + case 166: /* stream_type: "top" */ +#line 779 "parser.y" + { + #line 5769 "format.w" + (yyval.info)= 3;} +#line 3217 "parser.c" + break; + + case 167: /* stream_def_node: start "stream (definition)" ref stream_type list xdimen_node glue_node list glue_node ">" */ +#line 785 "parser.y" +{ + #line 5773 "format.w" + DEF((yyval.rf),stream_kind,(yyvsp[-7].u));hput_tags((yyvsp[-9].u),TAG(stream_kind,(yyvsp[-6].info) |b100));} +#line 3225 "parser.c" + break; + + case 168: /* stream_ins_node: start "stream (definition)" ref ">" */ +#line 790 "parser.y" +{ + #line 5776 "format.w" + RNG("Stream insertion",(yyvsp[-1].u),0,max_ref[stream_kind]);hput_tags((yyvsp[-3].u),TAG(stream_kind,b100));} +#line 3233 "parser.c" + break; + + case 171: /* stream: empty_param_list list */ +#line 796 "parser.y" + { + #line 5871 "format.w" + (yyval.info)= b010;} +#line 3241 "parser.c" + break; + + case 172: /* stream: empty_param_list non_empty_param_list list */ +#line 799 "parser.y" + { + #line 5872 "format.w" + (yyval.info)= b010;} +#line 3249 "parser.c" + break; + + case 173: /* stream: param_ref list */ +#line 802 "parser.y" + { + #line 5873 "format.w" + (yyval.info)= b000;} +#line 3257 "parser.c" + break; + + case 174: /* content_node: start "stream" stream_ref stream ">" */ +#line 806 "parser.y" +{ + #line 5875 "format.w" + hput_tags((yyvsp[-4].u),TAG(stream_kind,(yyvsp[-1].info)));} +#line 3265 "parser.c" + break; + + case 175: /* page_priority: %empty */ +#line 810 "parser.y" + { + #line 5978 "format.w" + HPUT8(1);} +#line 3273 "parser.c" + break; + + case 176: /* page_priority: UNSIGNED */ +#line 813 "parser.y" + { + #line 5979 "format.w" + RNG("page priority",(yyvsp[0].u),0,255);HPUT8((yyvsp[0].u));} +#line 3281 "parser.c" + break; + + case 179: /* $@8: %empty */ +#line 819 "parser.y" + { + #line 5983 "format.w" + hput_string((yyvsp[0].s));} +#line 3289 "parser.c" + break; + + case 180: /* $@9: %empty */ +#line 821 "parser.y" + { + #line 5983 "format.w" + HPUT32((yyvsp[0].d));} +#line 3297 "parser.c" + break; + + case 182: /* content_node: "<" "range" REFERENCE "on" ">" */ +#line 828 "parser.y" + { + #line 6095 "format.w" + REF(page_kind,(yyvsp[-2].u));hput_range((yyvsp[-2].u),true);} +#line 3305 "parser.c" + break; + + case 183: /* content_node: "<" "range" REFERENCE "off" ">" */ +#line 831 "parser.y" + { + #line 6096 "format.w" + REF(page_kind,(yyvsp[-2].u));hput_range((yyvsp[-2].u),false);} +#line 3313 "parser.c" + break; + + case 185: /* $@10: %empty */ +#line 837 "parser.y" + { + #line 6786 "format.w" + new_directory((yyvsp[0].u)+1);new_output_buffers();} +#line 3321 "parser.c" + break; + + case 189: /* entry: "<" "entry" UNSIGNED string ">" */ +#line 842 "parser.y" +{ + #line 6789 "format.w" + RNG("Section number",(yyvsp[-2].u),3,max_section_no);hset_entry(&(dir[(yyvsp[-2].u)]),(yyvsp[-2].u),0,0,(yyvsp[-1].s));} +#line 3329 "parser.c" + break; + + case 190: /* $@11: %empty */ +#line 846 "parser.y" + { + #line 7277 "format.w" + hput_definitions_start();} +#line 3337 "parser.c" + break; + + case 191: /* definition_section: "<" "definitions" $@11 max_definitions definition_list ">" */ +#line 850 "parser.y" + { + #line 7279 "format.w" + hput_definitions_end();} +#line 3345 "parser.c" + break; + + case 194: /* max_definitions: "<" "max" max_list ">" */ +#line 856 "parser.y" +{ + #line 7395 "format.w" + /*245:*/ + if(max_ref[label_kind]>=0) + ALLOCATE(labels,max_ref[label_kind]+1,label_t); + /*:245*/ /*266:*/ + if(max_outline>=0) + ALLOCATE(outlines,max_outline+1,outline_t); + /*:266*/ /*293:*/ + ALLOCATE(page_on,max_ref[page_kind]+1,int); + ALLOCATE(range_pos,2*(max_ref[range_kind]+1),range_pos_t); + /*:293*/ /*357:*/ + definition_bits[0][int_kind]= (1<<(MAX_INT_DEFAULT+1))-1; + definition_bits[0][dimen_kind]= (1<<(MAX_DIMEN_DEFAULT+1))-1; + definition_bits[0][xdimen_kind]= (1<<(MAX_XDIMEN_DEFAULT+1))-1; + definition_bits[0][glue_kind]= (1<<(MAX_GLUE_DEFAULT+1))-1; + definition_bits[0][baseline_kind]= (1<<(MAX_BASELINE_DEFAULT+1))-1; + definition_bits[0][page_kind]= (1<<(MAX_PAGE_DEFAULT+1))-1; + definition_bits[0][stream_kind]= (1<<(MAX_STREAM_DEFAULT+1))-1; + definition_bits[0][range_kind]= (1<<(MAX_RANGE_DEFAULT+1))-1; + /*:357*/ /*372:*/ + ALLOCATE(hfont_name,max_ref[font_kind]+1,char*); + /*:372*/hput_max_definitions();} +#line 3373 "parser.c" + break; + + case 197: /* max_value: "font" UNSIGNED */ +#line 882 "parser.y" + { + #line 7399 "format.w" + hset_max(font_kind,(yyvsp[0].u));} +#line 3381 "parser.c" + break; + + case 198: /* max_value: "int" UNSIGNED */ +#line 885 "parser.y" + { + #line 7400 "format.w" + hset_max(int_kind,(yyvsp[0].u));} +#line 3389 "parser.c" + break; + + case 199: /* max_value: "dimen" UNSIGNED */ +#line 888 "parser.y" + { + #line 7401 "format.w" + hset_max(dimen_kind,(yyvsp[0].u));} +#line 3397 "parser.c" + break; + + case 200: /* max_value: "ligature" UNSIGNED */ +#line 891 "parser.y" + { + #line 7402 "format.w" + hset_max(ligature_kind,(yyvsp[0].u));} +#line 3405 "parser.c" + break; + + case 201: /* max_value: "disc" UNSIGNED */ +#line 894 "parser.y" + { + #line 7403 "format.w" + hset_max(disc_kind,(yyvsp[0].u));} +#line 3413 "parser.c" + break; + + case 202: /* max_value: "glue" UNSIGNED */ +#line 897 "parser.y" + { + #line 7404 "format.w" + hset_max(glue_kind,(yyvsp[0].u));} +#line 3421 "parser.c" + break; + + case 203: /* max_value: "language" UNSIGNED */ +#line 900 "parser.y" + { + #line 7405 "format.w" + hset_max(language_kind,(yyvsp[0].u));} +#line 3429 "parser.c" + break; + + case 204: /* max_value: "rule" UNSIGNED */ +#line 903 "parser.y" + { + #line 7406 "format.w" + hset_max(rule_kind,(yyvsp[0].u));} +#line 3437 "parser.c" + break; + + case 205: /* max_value: "image" UNSIGNED */ +#line 906 "parser.y" + { + #line 7407 "format.w" + hset_max(image_kind,(yyvsp[0].u));} +#line 3445 "parser.c" + break; + + case 206: /* max_value: "leaders" UNSIGNED */ +#line 909 "parser.y" + { + #line 7408 "format.w" + hset_max(leaders_kind,(yyvsp[0].u));} +#line 3453 "parser.c" + break; + + case 207: /* max_value: "baseline" UNSIGNED */ +#line 912 "parser.y" + { + #line 7409 "format.w" + hset_max(baseline_kind,(yyvsp[0].u));} +#line 3461 "parser.c" + break; + + case 208: /* max_value: "xdimen" UNSIGNED */ +#line 915 "parser.y" + { + #line 7410 "format.w" + hset_max(xdimen_kind,(yyvsp[0].u));} +#line 3469 "parser.c" + break; + + case 209: /* max_value: "param" UNSIGNED */ +#line 918 "parser.y" + { + #line 7411 "format.w" + hset_max(param_kind,(yyvsp[0].u));} +#line 3477 "parser.c" + break; + + case 210: /* max_value: "stream (definition)" UNSIGNED */ +#line 921 "parser.y" + { + #line 7412 "format.w" + hset_max(stream_kind,(yyvsp[0].u));} +#line 3485 "parser.c" + break; + + case 211: /* max_value: "page" UNSIGNED */ +#line 924 "parser.y" + { + #line 7413 "format.w" + hset_max(page_kind,(yyvsp[0].u));} +#line 3493 "parser.c" + break; + + case 212: /* max_value: "range" UNSIGNED */ +#line 927 "parser.y" + { + #line 7414 "format.w" + hset_max(range_kind,(yyvsp[0].u));} +#line 3501 "parser.c" + break; + + case 213: /* max_value: "label" UNSIGNED */ +#line 930 "parser.y" + { + #line 7415 "format.w" + hset_max(label_kind,(yyvsp[0].u));} +#line 3509 "parser.c" + break; + + case 214: /* def_node: start "font" ref font ">" */ +#line 936 "parser.y" + { + #line 7612 "format.w" + DEF((yyval.rf),font_kind,(yyvsp[-2].u));hput_tags((yyvsp[-4].u),(yyvsp[-1].info));} +#line 3517 "parser.c" + break; + + case 215: /* def_node: start "int" ref integer ">" */ +#line 939 "parser.y" + { + #line 7613 "format.w" + DEF((yyval.rf),int_kind,(yyvsp[-2].u));hput_tags((yyvsp[-4].u),hput_int((yyvsp[-1].i)));} +#line 3525 "parser.c" + break; + + case 216: /* def_node: start "dimen" ref dimension ">" */ +#line 942 "parser.y" + { + #line 7614 "format.w" + DEF((yyval.rf),dimen_kind,(yyvsp[-2].u));hput_tags((yyvsp[-4].u),hput_dimen((yyvsp[-1].d)));} +#line 3533 "parser.c" + break; + + case 217: /* def_node: start "language" ref string ">" */ +#line 945 "parser.y" + { + #line 7615 "format.w" + DEF((yyval.rf),language_kind,(yyvsp[-2].u));hput_string((yyvsp[-1].s));hput_tags((yyvsp[-4].u),TAG(language_kind,0));} +#line 3541 "parser.c" + break; + + case 218: /* def_node: start "glue" ref glue ">" */ +#line 948 "parser.y" + { + #line 7616 "format.w" + DEF((yyval.rf),glue_kind,(yyvsp[-2].u));hput_tags((yyvsp[-4].u),hput_glue(&((yyvsp[-1].g))));} +#line 3549 "parser.c" + break; + + case 219: /* def_node: start "xdimen" ref xdimen ">" */ +#line 951 "parser.y" + { + #line 7617 "format.w" + DEF((yyval.rf),xdimen_kind,(yyvsp[-2].u));hput_tags((yyvsp[-4].u),hput_xdimen(&((yyvsp[-1].xd))));} +#line 3557 "parser.c" + break; + + case 220: /* def_node: start "rule" ref rule ">" */ +#line 954 "parser.y" + { + #line 7618 "format.w" + DEF((yyval.rf),rule_kind,(yyvsp[-2].u));hput_tags((yyvsp[-4].u),hput_rule(&((yyvsp[-1].r))));} +#line 3565 "parser.c" + break; + + case 221: /* def_node: start "leaders" ref leaders ">" */ +#line 957 "parser.y" + { + #line 7619 "format.w" + DEF((yyval.rf),leaders_kind,(yyvsp[-2].u));hput_tags((yyvsp[-4].u),TAG(leaders_kind,(yyvsp[-1].info)));} +#line 3573 "parser.c" + break; + + case 222: /* def_node: start "baseline" ref baseline ">" */ +#line 960 "parser.y" + { + #line 7620 "format.w" + DEF((yyval.rf),baseline_kind,(yyvsp[-2].u));hput_tags((yyvsp[-4].u),TAG(baseline_kind,(yyvsp[-1].info)));} +#line 3581 "parser.c" + break; + + case 223: /* def_node: start "ligature" ref ligature ">" */ +#line 963 "parser.y" + { + #line 7621 "format.w" + DEF((yyval.rf),ligature_kind,(yyvsp[-2].u));hput_tags((yyvsp[-4].u),hput_ligature(&((yyvsp[-1].lg))));} +#line 3589 "parser.c" + break; + + case 224: /* def_node: start "disc" ref disc ">" */ +#line 966 "parser.y" + { + #line 7622 "format.w" + DEF((yyval.rf),disc_kind,(yyvsp[-2].u));hput_tags((yyvsp[-4].u),hput_disc(&((yyvsp[-1].dc))));} +#line 3597 "parser.c" + break; + + case 225: /* def_node: start "image" ref image ">" */ +#line 969 "parser.y" + { + #line 7623 "format.w" + DEF((yyval.rf),image_kind,(yyvsp[-2].u));hput_tags((yyvsp[-4].u),hput_image(&((yyvsp[-1].x))));} +#line 3605 "parser.c" + break; + + case 226: /* def_node: start "param" ref parameters ">" */ +#line 972 "parser.y" + { + #line 7624 "format.w" + DEF((yyval.rf),param_kind,(yyvsp[-2].u));hput_tags((yyvsp[-4].u),hput_list((yyvsp[-4].u)+2,&((yyvsp[-1].l))));} +#line 3613 "parser.c" + break; + + case 227: /* def_node: start "page" ref page ">" */ +#line 975 "parser.y" + { + #line 7625 "format.w" + DEF((yyval.rf),page_kind,(yyvsp[-2].u));hput_tags((yyvsp[-4].u),TAG(page_kind,0));} +#line 3621 "parser.c" + break; + + case 228: /* def_node: start "int" ref ref ">" */ +#line 980 "parser.y" + { + #line 7644 "format.w" + DEF_REF((yyval.rf),int_kind,(yyvsp[-2].u),(yyvsp[-1].u));hput_tags((yyvsp[-4].u),TAG(int_kind,0));} +#line 3629 "parser.c" + break; + + case 229: /* def_node: start "dimen" ref ref ">" */ +#line 983 "parser.y" + { + #line 7645 "format.w" + DEF_REF((yyval.rf),dimen_kind,(yyvsp[-2].u),(yyvsp[-1].u));hput_tags((yyvsp[-4].u),TAG(dimen_kind,0));} +#line 3637 "parser.c" + break; + + case 230: /* def_node: start "glue" ref ref ">" */ +#line 986 "parser.y" + { + #line 7646 "format.w" + DEF_REF((yyval.rf),glue_kind,(yyvsp[-2].u),(yyvsp[-1].u));hput_tags((yyvsp[-4].u),TAG(glue_kind,0));} +#line 3645 "parser.c" + break; + + case 232: /* def_list: def_list def_node */ +#line 991 "parser.y" + { + #line 7760 "format.w" + check_param_def(&((yyvsp[0].rf)));} +#line 3653 "parser.c" + break; + + case 233: /* parameters: estimate def_list */ +#line 994 "parser.y" + { + #line 7761 "format.w" + (yyval.l).p= (yyvsp[0].u);(yyval.l).k= param_kind;(yyval.l).s= (hpos-hstart)-(yyvsp[0].u);} +#line 3661 "parser.c" + break; + + case 234: /* empty_param_list: position */ +#line 998 "parser.y" + { + #line 7782 "format.w" + HPUTX(2);hpos++;hput_tags((yyvsp[0].u),TAG(param_kind,1));} +#line 3669 "parser.c" + break; + + case 235: /* $@12: %empty */ +#line 1001 "parser.y" + { + #line 7783 "format.w" + hpos= hpos-2;} +#line 3677 "parser.c" + break; + + case 236: /* non_empty_param_list: start "param" $@12 parameters ">" */ +#line 1004 "parser.y" +{ + #line 7784 "format.w" + hput_tags((yyvsp[-4].u)-2,hput_list((yyvsp[-4].u)-1,&((yyvsp[-1].l))));} +#line 3685 "parser.c" + break; + + case 238: /* font_head: string dimension UNSIGNED UNSIGNED */ +#line 1012 "parser.y" +{ + #line 7926 "format.w" + uint8_t f= (yyvsp[-4].u);SET_DBIT(f,font_kind);hfont_name[f]= strdup((yyvsp[-3].s));(yyval.info)= hput_font_head(f,hfont_name[f],(yyvsp[-2].d),(yyvsp[-1].u),(yyvsp[0].u));} +#line 3693 "parser.c" + break; + + case 241: /* font_param: start "penalty" fref penalty ">" */ +#line 1019 "parser.y" + { + #line 7931 "format.w" + hput_tags((yyvsp[-4].u),hput_int((yyvsp[-1].i)));} +#line 3701 "parser.c" + break; + + case 242: /* font_param: start "kern" fref kern ">" */ +#line 1022 "parser.y" + { + #line 7932 "format.w" + hput_tags((yyvsp[-4].u),hput_kern(&((yyvsp[-1].kt))));} +#line 3709 "parser.c" + break; + + case 243: /* font_param: start "ligature" fref ligature ">" */ +#line 1025 "parser.y" + { + #line 7933 "format.w" + hput_tags((yyvsp[-4].u),hput_ligature(&((yyvsp[-1].lg))));} +#line 3717 "parser.c" + break; + + case 244: /* font_param: start "disc" fref disc ">" */ +#line 1028 "parser.y" + { + #line 7934 "format.w" + hput_tags((yyvsp[-4].u),hput_disc(&((yyvsp[-1].dc))));} +#line 3725 "parser.c" + break; + + case 245: /* font_param: start "glue" fref glue ">" */ +#line 1031 "parser.y" + { + #line 7935 "format.w" + hput_tags((yyvsp[-4].u),hput_glue(&((yyvsp[-1].g))));} +#line 3733 "parser.c" + break; + + case 246: /* font_param: start "language" fref string ">" */ +#line 1034 "parser.y" + { + #line 7936 "format.w" + hput_string((yyvsp[-1].s));hput_tags((yyvsp[-4].u),TAG(language_kind,0));} +#line 3741 "parser.c" + break; + + case 247: /* font_param: start "rule" fref rule ">" */ +#line 1037 "parser.y" + { + #line 7937 "format.w" + hput_tags((yyvsp[-4].u),hput_rule(&((yyvsp[-1].r))));} +#line 3749 "parser.c" + break; + + case 248: /* font_param: start "image" fref image ">" */ +#line 1040 "parser.y" + { + #line 7938 "format.w" + hput_tags((yyvsp[-4].u),hput_image(&((yyvsp[-1].x))));} +#line 3757 "parser.c" + break; + + case 249: /* fref: ref */ +#line 1044 "parser.y" + { + #line 7940 "format.w" + RNG("Font parameter",(yyvsp[0].u),0,MAX_FONT_PARAMS);} +#line 3765 "parser.c" + break; + + case 250: /* xdimen_ref: ref */ +#line 1048 "parser.y" + { + #line 8013 "format.w" + REF(xdimen_kind,(yyvsp[0].u));} +#line 3773 "parser.c" + break; + + case 251: /* param_ref: ref */ +#line 1051 "parser.y" + { + #line 8014 "format.w" + REF(param_kind,(yyvsp[0].u));} +#line 3781 "parser.c" + break; + + case 252: /* stream_ref: ref */ +#line 1054 "parser.y" + { + #line 8015 "format.w" + REF_RNG(stream_kind,(yyvsp[0].u));} +#line 3789 "parser.c" + break; + + case 253: /* content_node: start "penalty" ref ">" */ +#line 1060 "parser.y" + { + #line 8019 "format.w" + REF(penalty_kind,(yyvsp[-1].u));hput_tags((yyvsp[-3].u),TAG(penalty_kind,0));} +#line 3797 "parser.c" + break; + + case 254: /* content_node: start "kern" explicit ref ">" */ +#line 1064 "parser.y" +{ + #line 8021 "format.w" + REF(dimen_kind,(yyvsp[-1].u));hput_tags((yyvsp[-4].u),TAG(kern_kind,((yyvsp[-2].b))?b100:b000));} +#line 3805 "parser.c" + break; + + case 255: /* content_node: start "kern" explicit "xdimen" ref ">" */ +#line 1068 "parser.y" +{ + #line 8023 "format.w" + REF(xdimen_kind,(yyvsp[-1].u));hput_tags((yyvsp[-5].u),TAG(kern_kind,((yyvsp[-3].b))?b101:b001));} +#line 3813 "parser.c" + break; + + case 256: /* content_node: start "glue" ref ">" */ +#line 1071 "parser.y" + { + #line 8024 "format.w" + REF(glue_kind,(yyvsp[-1].u));hput_tags((yyvsp[-3].u),TAG(glue_kind,0));} +#line 3821 "parser.c" + break; + + case 257: /* content_node: start "ligature" ref ">" */ +#line 1074 "parser.y" + { + #line 8025 "format.w" + REF(ligature_kind,(yyvsp[-1].u));hput_tags((yyvsp[-3].u),TAG(ligature_kind,0));} +#line 3829 "parser.c" + break; + + case 258: /* content_node: start "disc" ref ">" */ +#line 1077 "parser.y" + { + #line 8026 "format.w" + REF(disc_kind,(yyvsp[-1].u));hput_tags((yyvsp[-3].u),TAG(disc_kind,0));} +#line 3837 "parser.c" + break; + + case 259: /* content_node: start "rule" ref ">" */ +#line 1080 "parser.y" + { + #line 8027 "format.w" + REF(rule_kind,(yyvsp[-1].u));hput_tags((yyvsp[-3].u),TAG(rule_kind,0));} +#line 3845 "parser.c" + break; + + case 260: /* content_node: start "image" ref ">" */ +#line 1083 "parser.y" + { + #line 8028 "format.w" + REF(image_kind,(yyvsp[-1].u));hput_tags((yyvsp[-3].u),TAG(image_kind,0));} +#line 3853 "parser.c" + break; + + case 261: /* content_node: start "leaders" ref ">" */ +#line 1086 "parser.y" + { + #line 8029 "format.w" + REF(leaders_kind,(yyvsp[-1].u));hput_tags((yyvsp[-3].u),TAG(leaders_kind,0));} +#line 3861 "parser.c" + break; + + case 262: /* content_node: start "baseline" ref ">" */ +#line 1089 "parser.y" + { + #line 8030 "format.w" + REF(baseline_kind,(yyvsp[-1].u));hput_tags((yyvsp[-3].u),TAG(baseline_kind,0));} +#line 3869 "parser.c" + break; + + case 263: /* content_node: start "language" REFERENCE ">" */ +#line 1092 "parser.y" + { + #line 8031 "format.w" + REF(language_kind,(yyvsp[-1].u));hput_tags((yyvsp[-3].u),hput_language((yyvsp[-1].u)));} +#line 3877 "parser.c" + break; + + case 264: /* glue_node: start "glue" ref ">" */ +#line 1096 "parser.y" + { + #line 8033 "format.w" + REF(glue_kind,(yyvsp[-1].u)); + if((yyvsp[-1].u)==zero_skip_no){hpos= hpos-2;(yyval.b)= false;} + else{hput_tags((yyvsp[-3].u),TAG(glue_kind,0));(yyval.b)= true;}} +#line 3887 "parser.c" + break; + + case 265: /* $@13: %empty */ +#line 1103 "parser.y" + { + #line 8464 "format.w" + hput_content_start();} +#line 3895 "parser.c" + break; + + case 266: /* content_section: "<" "content" $@13 content_list ">" */ +#line 1106 "parser.y" +{ + #line 8465 "format.w" + hput_content_end();hput_range_defs();hput_label_defs();} +#line 3903 "parser.c" + break; + + +#line 3907 "parser.c" + + default: break; + } + /* User semantic actions sometimes alter yychar, and that requires + that yytoken be updated with the new translation. We take the + approach of translating immediately before every use of yytoken. + One alternative is translating here after every semantic action, + but that translation would be missed if the semantic action invokes + YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or + if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an + incorrect destructor might then be invoked immediately. In the + case of YYERROR or YYBACKUP, subsequent parser actions might lead + to an incorrect destructor call or verbose syntax error message + before the lookahead is translated. */ + YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc); + + YYPOPSTACK (yylen); + yylen = 0; + + *++yyvsp = yyval; + + /* Now 'shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ + { + const int yylhs = yyr1[yyn] - YYNTOKENS; + const int yyi = yypgoto[yylhs] + *yyssp; + yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp + ? yytable[yyi] + : yydefgoto[yylhs]); + } + + goto yynewstate; + + +/*--------------------------------------. +| yyerrlab -- here on detecting error. | +`--------------------------------------*/ +yyerrlab: + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; + { + yypcontext_t yyctx + = {yyssp, yytoken}; + char const *yymsgp = YY_("syntax error"); + int yysyntax_error_status; + yysyntax_error_status = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx); + if (yysyntax_error_status == 0) + yymsgp = yymsg; + else if (yysyntax_error_status == -1) + { + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); + yymsg = YY_CAST (char *, + YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc))); + if (yymsg) + { + yysyntax_error_status + = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx); + yymsgp = yymsg; + } + else + { + yymsg = yymsgbuf; + yymsg_alloc = sizeof yymsgbuf; + yysyntax_error_status = YYENOMEM; + } + } + yyerror (yymsgp); + if (yysyntax_error_status == YYENOMEM) + YYNOMEM; + } + } + + if (yyerrstatus == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + if (yychar <= YYEOF) + { + /* Return failure if at end of input. */ + if (yychar == YYEOF) + YYABORT; + } + else + { + yydestruct ("Error: discarding", + yytoken, &yylval); + yychar = YYEMPTY; + } + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + goto yyerrlab1; + + +/*---------------------------------------------------. +| yyerrorlab -- error raised explicitly by YYERROR. | +`---------------------------------------------------*/ +yyerrorlab: + /* Pacify compilers when the user code never invokes YYERROR and the + label yyerrorlab therefore never appears in user code. */ + if (0) + YYERROR; + ++yynerrs; + + /* Do not reclaim the symbols of the rule whose action triggered + this YYERROR. */ + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + yystate = *yyssp; + goto yyerrlab1; + + +/*-------------------------------------------------------------. +| yyerrlab1 -- common code for both syntax error and YYERROR. | +`-------------------------------------------------------------*/ +yyerrlab1: + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + /* Pop stack until we find a state that shifts the error token. */ + for (;;) + { + yyn = yypact[yystate]; + if (!yypact_value_is_default (yyn)) + { + yyn += YYSYMBOL_YYerror; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; + + + yydestruct ("Error: popping", + YY_ACCESSING_SYMBOL (yystate), yyvsp); + YYPOPSTACK (1); + yystate = *yyssp; + YY_STACK_PRINT (yyss, yyssp); + } + + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + *++yyvsp = yylval; + YY_IGNORE_MAYBE_UNINITIALIZED_END + + + /* Shift the error token. */ + YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp); + + yystate = yyn; + goto yynewstate; + + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturnlab; + + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yyresult = 1; + goto yyreturnlab; + + +/*-----------------------------------------------------------. +| yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. | +`-----------------------------------------------------------*/ +yyexhaustedlab: + yyerror (YY_("memory exhausted")); + yyresult = 2; + goto yyreturnlab; + + +/*----------------------------------------------------------. +| yyreturnlab -- parsing is finished, clean up and return. | +`----------------------------------------------------------*/ +yyreturnlab: + if (yychar != YYEMPTY) + { + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = YYTRANSLATE (yychar); + yydestruct ("Cleanup: discarding lookahead", + yytoken, &yylval); + } + /* Do not reclaim the symbols of the rule whose action triggered + this YYABORT or YYACCEPT. */ + YYPOPSTACK (yylen); + YY_STACK_PRINT (yyss, yyssp); + while (yyssp != yyss) + { + yydestruct ("Cleanup: popping", + YY_ACCESSING_SYMBOL (+*yyssp), yyvsp); + YYPOPSTACK (1); + } +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); + return yyresult; +} + +#line 1110 "parser.y" + + /*:510*/ diff --git a/Build/source/texk/web2c/hitexdir/hiparser.h b/Build/source/texk/web2c/hitexdir/hiparser.h new file mode 100644 index 00000000000..511228663eb --- /dev/null +++ b/Build/source/texk/web2c/hitexdir/hiparser.h @@ -0,0 +1,173 @@ +/* A Bison parser, made by GNU Bison 3.8.2. */ + +/* Bison interface for Yacc-like parsers in C + + Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation, + Inc. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +/* As a special exception, you may create a larger work that contains + part or all of the Bison parser skeleton and distribute that work + under terms of your choice, so long as that work isn't itself a + parser generator using the skeleton or a modified version thereof + as a parser skeleton. Alternatively, if you modify or redistribute + the parser skeleton itself, you may (at your option) remove this + special exception, which will cause the skeleton and the resulting + Bison output files to be licensed under the GNU General Public + License without this special exception. + + This special exception was added by the Free Software Foundation in + version 2.2 of Bison. */ + +/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, + especially those whose name start with YY_ or yy_. They are + private implementation details that can be changed or removed. */ + +#ifndef YY_YY_PARSER_H_INCLUDED +# define YY_YY_PARSER_H_INCLUDED +/* Debug traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif +#if YYDEBUG +extern int yydebug; +#endif + +/* Token kinds. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + enum yytokentype + { + YYEMPTY = -2, + YYEOF = 0, /* "end of file" */ + YYerror = 256, /* error */ + YYUNDEF = 257, /* "invalid token" */ + START = 258, /* "<" */ + END = 259, /* ">" */ + GLYPH = 260, /* "glyph" */ + UNSIGNED = 261, /* UNSIGNED */ + REFERENCE = 262, /* REFERENCE */ + SIGNED = 263, /* SIGNED */ + STRING = 264, /* STRING */ + CHARCODE = 265, /* CHARCODE */ + FPNUM = 266, /* FPNUM */ + DIMEN = 267, /* "dimen" */ + PT = 268, /* "pt" */ + MM = 269, /* "mm" */ + INCH = 270, /* "in" */ + XDIMEN = 271, /* "xdimen" */ + H = 272, /* "h" */ + V = 273, /* "v" */ + FIL = 274, /* "fil" */ + FILL = 275, /* "fill" */ + FILLL = 276, /* "filll" */ + PENALTY = 277, /* "penalty" */ + INTEGER = 278, /* "int" */ + LANGUAGE = 279, /* "language" */ + RULE = 280, /* "rule" */ + RUNNING = 281, /* "|" */ + KERN = 282, /* "kern" */ + EXPLICIT = 283, /* "!" */ + GLUE = 284, /* "glue" */ + PLUS = 285, /* "plus" */ + MINUS = 286, /* "minus" */ + TXT_START = 287, /* TXT_START */ + TXT_END = 288, /* TXT_END */ + TXT_IGNORE = 289, /* TXT_IGNORE */ + TXT_FONT_GLUE = 290, /* TXT_FONT_GLUE */ + TXT_FONT_HYPHEN = 291, /* TXT_FONT_HYPHEN */ + TXT_FONT = 292, /* TXT_FONT */ + TXT_LOCAL = 293, /* TXT_LOCAL */ + TXT_GLOBAL = 294, /* TXT_GLOBAL */ + TXT_CC = 295, /* TXT_CC */ + HBOX = 296, /* "hbox" */ + VBOX = 297, /* "vbox" */ + SHIFTED = 298, /* "shifted" */ + HPACK = 299, /* "hpack" */ + HSET = 300, /* "hset" */ + VPACK = 301, /* "vpack" */ + VSET = 302, /* "vset" */ + DEPTH = 303, /* "depth" */ + ADD = 304, /* "add" */ + TO = 305, /* "to" */ + LEADERS = 306, /* "leaders" */ + ALIGN = 307, /* "align" */ + CENTER = 308, /* "center" */ + EXPAND = 309, /* "expand" */ + BASELINE = 310, /* "baseline" */ + LIGATURE = 311, /* "ligature" */ + DISC = 312, /* "disc" */ + PAR = 313, /* "par" */ + MATH = 314, /* "math" */ + ON = 315, /* "on" */ + OFF = 316, /* "off" */ + ADJUST = 317, /* "adjust" */ + TABLE = 318, /* "table" */ + ITEM = 319, /* "item" */ + IMAGE = 320, /* "image" */ + LABEL = 321, /* "label" */ + BOT = 322, /* "bot" */ + MID = 323, /* "mid" */ + LINK = 324, /* "link" */ + OUTLINE = 325, /* "outline" */ + STREAM = 326, /* "stream" */ + STREAMDEF = 327, /* "stream (definition)" */ + FIRST = 328, /* "first" */ + LAST = 329, /* "last" */ + TOP = 330, /* "top" */ + NOREFERENCE = 331, /* "*" */ + PAGE = 332, /* "page" */ + RANGE = 333, /* "range" */ + DIRECTORY = 334, /* "directory" */ + SECTION = 335, /* "entry" */ + DEFINITIONS = 336, /* "definitions" */ + MAX = 337, /* "max" */ + PARAM = 338, /* "param" */ + FONT = 339, /* "font" */ + CONTENT = 340 /* "content" */ + }; + typedef enum yytokentype yytoken_kind_t; +#endif + +/* Value type. */ +#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED +union YYSTYPE +{ +#line 79 "parser.y" + + #line 10237 "format.w" + uint32_t u; int32_t i; char *s; float64_t f; glyph_t c; + dimen_t d;stretch_t st;xdimen_t xd;kern_t kt; + rule_t r;glue_t g;image_t x; + list_t l;box_t h;disc_t dc;lig_t lg; + ref_t rf;info_t info;order_t o;bool b; + + +#line 159 "hiparser.h" + +}; +typedef union YYSTYPE YYSTYPE; +# define YYSTYPE_IS_TRIVIAL 1 +# define YYSTYPE_IS_DECLARED 1 +#endif + + +extern YYSTYPE yylval; + + +int yyparse (void); + + +#endif /* !YY_YY_PARSER_H_INCLUDED */ diff --git a/Build/source/texk/web2c/hitexdir/hiparser.y b/Build/source/texk/web2c/hitexdir/hiparser.y new file mode 100644 index 00000000000..dc1ab177ccb --- /dev/null +++ b/Build/source/texk/web2c/hitexdir/hiparser.y @@ -0,0 +1,1111 @@ + /*510:*/ +%{ + #line 10212 "format.w" + +#include "hibasetypes.h" +#include +#include +#include "hierror.h" +#include "hiformat.h" +#include "hiput.h" +extern char**hfont_name; + + /*356:*/ +uint32_t definition_bits[0x100/32][32]= { + #line 7578 "format.w" + {0}}; + +#define SET_DBIT(N,K) ((N)>0xFF?1:(definition_bits[N/32][K] |= (1<<((N)&(32-1))))) +#define GET_DBIT(N,K) ((N)>0xFF?1:((definition_bits[N/32][K]>>((N)&(32-1)))&1)) +#define DEF(D,K,N) (D).k= K; (D).n= (N);SET_DBIT((D).n,(D).k);\ + DBG(DBGDEF,"Defining %s %d\n",definition_name[(D).k],(D).n);\ + RNG("Definition",(D).n,max_fixed[(D).k]+1,max_ref[(D).k]); +#define REF(K,N) REF_RNG(K,N);if(!GET_DBIT(N,K)) \ + QUIT("Reference %d to %s before definition",(N),definition_name[K]) + /*:356*/ /*360:*/ +#define DEF_REF(D,K,M,N) DEF(D,K,M);\ +if ((M)>max_default[K]) QUIT("Defining non default reference %d for %s",M,definition_name[K]); \ +if ((N)>max_fixed[K]) QUIT("Defining reference %d for %s by non fixed reference %d",M,definition_name[K],N); + /*:360*/ + +extern void hset_entry(entry_t*e,uint16_t i,uint32_t size, +uint32_t xsize,char*file_name); + + /*423:*/ +#ifdef DEBUG +#define YYDEBUG 1 +extern int yydebug; +#else +#define YYDEBUG 0 +#endif + /*:423*/ +extern int yylex(void); + + /*352:*/ +void hset_max(kind_t k,int n) +{ + #line 7421 "format.w" + DBG(DBGDEF,"Setting max %s to %d\n",definition_name[k],n); + RNG("Maximum",n,max_fixed[k]+1,MAX_REF(k)); + if(n>max_ref[k]) + max_ref[k]= n; + } + /*:352*/ /*363:*/ +void check_param_def(ref_t*df) +{ + #line 7727 "format.w" + if(df->k!=int_kind&&df->k!=dimen_kind&&df->k!=glue_kind) + QUIT("Kind %s not allowed in parameter list",definition_name[df->k]); + if(df->n<=max_fixed[df->k]||max_default[df->k]n) + QUIT("Parameter %d for %s not allowed in parameter list",df->n,definition_name[df->k]); + } + /*:363*/ /*422:*/ +extern int yylineno; +int yyerror(const char*msg) +{ + #line 8799 "format.w" + QUIT(" in line %d %s",yylineno,msg); + return 0; + } + /*:422*/ + + +%} + + + + + +%union { + #line 10237 "format.w" + uint32_t u; int32_t i; char *s; float64_t f; glyph_t c; + dimen_t d;stretch_t st;xdimen_t xd;kern_t kt; + rule_t r;glue_t g;image_t x; + list_t l;box_t h;disc_t dc;lig_t lg; + ref_t rf;info_t info;order_t o;bool b; + } + + + +%error_verbose +%start hint + + /*2:*/ +%token START "<" +%token END ">" +%token GLYPH "glyph" +%token UNSIGNED +%token REFERENCE + /*:2*/ /*4:*/ +%type start +%type glyph + /*:4*/ /*26:*/ +%token SIGNED +%type integer + /*:26*/ /*33:*/ +%token STRING + /*:33*/ /*47:*/ +%token CHARCODE + /*:47*/ /*49:*/ +%type string + /*:49*/ /*54:*/ +%token FPNUM +%type number + /*:54*/ /*79:*/ +%token DIMEN "dimen" +%token PT "pt" +%token MM "mm" +%token INCH "in" +%type dimension + /*:79*/ /*87:*/ +%token XDIMEN "xdimen" +%token H "h" +%token V "v" +%type xdimen + /*:87*/ /*98:*/ +%token FIL "fil" +%token FILL "fill" +%token FILLL "filll" +%type stretch +%type order + /*:98*/ /*102:*/ +%token PENALTY "penalty" +%token INTEGER "int" +%type penalty + /*:102*/ /*108:*/ +%token LANGUAGE "language" + /*:108*/ /*114:*/ +%token RULE "rule" +%token RUNNING "|" +%type rule_dimension +%type rule + /*:114*/ /*123:*/ +%token KERN "kern" +%token EXPLICIT "!" +%type explicit +%type kern + /*:123*/ /*132:*/ +%token GLUE "glue" +%token PLUS "plus" +%token MINUS "minus" +%type glue +%type glue_node +%type plus minus + /*:132*/ /*141:*/ +%type list +%type position content_list + /*:141*/ /*150:*/ +%token TXT_START TXT_END TXT_IGNORE +%token TXT_FONT_GLUE TXT_FONT_HYPHEN +%token TXT_FONT TXT_LOCAL +%token TXT_GLOBAL +%token TXT_CC +%type text + /*:150*/ /*161:*/ +%token HBOX "hbox" +%token VBOX "vbox" +%token SHIFTED "shifted" +%type box box_dimen box_shift box_glue_set + + /*:161*/ /*169:*/ +%token HPACK "hpack" +%token HSET "hset" +%token VPACK "vpack" +%token VSET "vset" +%token DEPTH "depth" +%token ADD "add" +%token TO "to" +%type xbox box_goal hpack vpack + /*:169*/ /*174:*/ +%token LEADERS "leaders" +%token ALIGN "align" +%token CENTER "center" +%token EXPAND "expand" +%type leaders +%type ltype + /*:174*/ /*181:*/ +%token BASELINE "baseline" +%type baseline + /*:181*/ /*188:*/ +%token LIGATURE "ligature" +%type lig_cc +%type ligature +%type ref + /*:188*/ /*196:*/ +%token DISC "disc" +%type disc +%type replace_count + /*:196*/ /*204:*/ +%token PAR "par" +%type par + /*:204*/ /*209:*/ +%token MATH "math" +%type math + /*:209*/ /*214:*/ +%token ON "on" +%token OFF "off" +%type on_off + /*:214*/ /*218:*/ +%token ADJUST "adjust" + /*:218*/ /*222:*/ +%token TABLE "table" +%token ITEM "item" +%type table span_count + /*:222*/ /*229:*/ +%token IMAGE "image" +%type image image_dimen + /*:229*/ /*246:*/ +%token LABEL "label" +%token BOT "bot" +%token MID "mid" +%type placement + /*:246*/ /*260:*/ +%token LINK "link" + /*:260*/ /*270:*/ +%token OUTLINE "outline" + /*:270*/ /*277:*/ +%token STREAM "stream" +%token STREAMDEF "stream (definition)" +%token FIRST "first" +%token LAST "last" +%token TOP "top" +%token NOREFERENCE "*" +%type stream_type +%type stream_ref +%type stream_def_node + /*:277*/ /*283:*/ +%type stream + /*:283*/ /*287:*/ +%token PAGE "page" + /*:287*/ /*295:*/ +%token RANGE "range" + /*:295*/ /*322:*/ +%token DIRECTORY "directory" +%token SECTION "entry" + /*:322*/ /*341:*/ +%token DEFINITIONS "definitions" + /*:341*/ /*349:*/ +%token MAX "max" + /*:349*/ /*358:*/ + +%type def_node + /*:358*/ /*364:*/ +%token PARAM "param" +%type def_list +%type parameters + /*:364*/ /*373:*/ +%token FONT "font" +%type font font_head + /*:373*/ /*401:*/ +%token CONTENT "content" + /*:401*/ +%% + /*5:*/ +glyph:UNSIGNED REFERENCE{ + #line 418 "format.w" + $$.c= $1;REF(font_kind,$2);$$.f= $2;}; +content_node:start GLYPH glyph END{ + #line 419 "format.w" + hput_tags($1,hput_glyph(&($3)));}; +start:START{ + #line 420 "format.w" + HPUTNODE;$$= (uint32_t)(hpos++-hstart);} + /*:5*/ /*29:*/ +integer:SIGNED |UNSIGNED{ + #line 941 "format.w" + RNG("number",$1,0,0x7FFFFFFF);}; + /*:29*/ /*38:*/ +glyph:CHARCODE REFERENCE{ + #line 1082 "format.w" + $$.c= $1;REF(font_kind,$2);$$.f= $2;}; + /*:38*/ /*50:*/ +string:STRING |CHARCODE{ + #line 1187 "format.w" + static char s[2]; + RNG("String element",$1,0x20,0x7E); + s[0]= $1;s[1]= 0;$$= s;}; + /*:50*/ /*58:*/ +number:UNSIGNED{ + #line 1339 "format.w" + $$= (float64_t)$1;} |SIGNED{ + #line 1339 "format.w" + $$= (float64_t)$1;} |FPNUM; + /*:58*/ /*82:*/ +dimension:number PT{ + #line 1682 "format.w" + $$= ROUND($1*ONE);RNG("Dimension",$$,-MAX_DIMEN,MAX_DIMEN);} + |number INCH{ + #line 1683 "format.w" + $$= ROUND($1*ONE*72.27);RNG("Dimension",$$,-MAX_DIMEN,MAX_DIMEN);} + |number MM{ + #line 1684 "format.w" + $$= ROUND($1*ONE*(72.27/25.4));RNG("Dimension",$$,-MAX_DIMEN,MAX_DIMEN);}; + /*:82*/ /*89:*/ +xdimen:dimension number H number V{ + #line 1762 "format.w" + $$.w= $1;$$.h= $2;$$.v= $4;} + |dimension number H{ + #line 1763 "format.w" + $$.w= $1;$$.h= $2;$$.v= 0.0;} + |dimension number V{ + #line 1764 "format.w" + $$.w= $1;$$.h= 0.0;$$.v= $2;} + |dimension{ + #line 1765 "format.w" + $$.w= $1;$$.h= 0.0;$$.v= 0.0;}; + + + +xdimen_node:start XDIMEN xdimen END{ + #line 1769 "format.w" + hput_tags($1,hput_xdimen(&($3)));}; + /*:89*/ /*100:*/ + +order:PT{ + #line 1947 "format.w" + $$= normal_o;} |FIL{ + #line 1947 "format.w" + $$= fil_o;} |FILL{ + #line 1947 "format.w" + $$= fill_o;} |FILLL{ + #line 1947 "format.w" + $$= filll_o;}; + +stretch:number order{ + #line 1949 "format.w" + $$.f= $1;$$.o= $2;}; + /*:100*/ /*104:*/ +penalty:integer{ + #line 2003 "format.w" + RNG("Penalty",$1,-20000,+20000);$$= $1;}; +content_node:start PENALTY penalty END{ + #line 2004 "format.w" + hput_tags($1,hput_int($3));}; + /*:104*/ /*116:*/ +rule_dimension:dimension |RUNNING{ + #line 2179 "format.w" + $$= RUNNING_DIMEN;}; +rule:rule_dimension rule_dimension rule_dimension +{ + #line 2181 "format.w" + $$.h= $1;$$.d= $2;$$.w= $3; + if($3==RUNNING_DIMEN&&($1==RUNNING_DIMEN||$2==RUNNING_DIMEN)) + QUIT("Incompatible running dimensions 0x%x 0x%x 0x%x",$1,$2,$3);}; +rule_node:start RULE rule END{ + #line 2184 "format.w" + hput_tags($1,hput_rule(&($3)));}; +content_node:rule_node; + /*:116*/ /*125:*/ +explicit:{ + #line 2292 "format.w" + $$= false;} |EXPLICIT{ + #line 2292 "format.w" + $$= true;}; +kern:explicit xdimen{ + #line 2293 "format.w" + $$.x= $1;$$.d= $2;}; +content_node:start KERN kern END{ + #line 2294 "format.w" + hput_tags($1,hput_kern(&($3)));} + /*:125*/ /*134:*/ +plus:{ + #line 2504 "format.w" + $$.f= 0.0;$$.o= 0;} |PLUS stretch{ + #line 2504 "format.w" + $$= $2;}; +minus:{ + #line 2505 "format.w" + $$.f= 0.0;$$.o= 0;} |MINUS stretch{ + #line 2505 "format.w" + $$= $2;}; +glue:xdimen plus minus{ + #line 2506 "format.w" + $$.w= $1;$$.p= $2;$$.m= $3;}; +content_node:start GLUE glue END{ + #line 2507 "format.w" + if(ZERO_GLUE($3)){HPUT8(zero_skip_no); + hput_tags($1,TAG(glue_kind,0));}else hput_tags($1,hput_glue(&($3)));}; +glue_node:start GLUE glue END +{ + #line 2510 "format.w" + if(ZERO_GLUE($3)){hpos--;$$= false;} + else{hput_tags($1,hput_glue(&($3)));$$= true;}}; + /*:134*/ /*142:*/ +position:{ + #line 2786 "format.w" + $$= hpos-hstart;}; +content_list:position + |content_list content_node; +estimate:{ + #line 2789 "format.w" + hpos+= 2;} + |UNSIGNED{ + #line 2790 "format.w" + hpos+= hsize_bytes($1)+1;}; +list:start estimate content_list END +{ + #line 2792 "format.w" + $$.k= list_kind;$$.p= $3;$$.s= (hpos-hstart)-$3; + hput_tags($1,hput_list($1+1,&($$)));}; + /*:142*/ /*153:*/ +list:TXT_START position +{ + #line 3199 "format.w" + hpos+= 4;} +text TXT_END +{ + #line 3201 "format.w" + $$.k= text_kind;$$.p= $4;$$.s= (hpos-hstart)-$4; + hput_tags($2,hput_list($2+1,&($$)));}; +text:position |text txt; + +txt:TXT_CC{ + #line 3205 "format.w" + hput_txt_cc($1);} + |TXT_FONT{ + #line 3206 "format.w" + REF(font_kind,$1);hput_txt_font($1);} + |TXT_GLOBAL{ + #line 3207 "format.w" + REF($1.k,$1.n);hput_txt_global(&($1));} + |TXT_LOCAL{ + #line 3208 "format.w" + RNG("Font parameter",$1,0,11);hput_txt_local($1);} + |TXT_FONT_GLUE{ + #line 3209 "format.w" + HPUTX(1);HPUT8(txt_glue);} + |TXT_FONT_HYPHEN{ + #line 3210 "format.w" + HPUTX(1);HPUT8(txt_hyphen);} + |TXT_IGNORE{ + #line 3211 "format.w" + HPUTX(1);HPUT8(txt_ignore);} + |{ + #line 3212 "format.w" + HPUTX(1);HPUT8(txt_node);}content_node; + /*:153*/ /*163:*/ + +box_dimen:dimension dimension dimension +{ + #line 3470 "format.w" + $$= hput_box_dimen($1,$2,$3);}; +box_shift:{ + #line 3471 "format.w" + $$= b000;} + |SHIFTED dimension{ + #line 3472 "format.w" + $$= hput_box_shift($2);}; + +box_glue_set:{ + #line 3474 "format.w" + $$= b000;} + |PLUS stretch{ + #line 3475 "format.w" + $$= hput_box_glue_set(+1,$2.f,$2.o);} + |MINUS stretch{ + #line 3476 "format.w" + $$= hput_box_glue_set(-1,$2.f,$2.o);}; + + +box:box_dimen box_shift box_glue_set list{ + #line 3479 "format.w" + $$= $1 |$2 |$3;}; + +hbox_node:start HBOX box END{ + #line 3481 "format.w" + hput_tags($1,TAG(hbox_kind,$3));}; +vbox_node:start VBOX box END{ + #line 3482 "format.w" + hput_tags($1,TAG(vbox_kind,$3));}; +content_node:hbox_node |vbox_node; + /*:163*/ /*171:*/ +box_flex:plus minus{ + #line 3663 "format.w" + hput_stretch(&($1));hput_stretch(&($2));}; +xbox:box_dimen box_shift box_flex xdimen_ref list{ + #line 3664 "format.w" + $$= $1 |$2;} + |box_dimen box_shift box_flex xdimen_node list{ + #line 3665 "format.w" + $$= $1 |$2 |b100;}; + +box_goal:TO xdimen_ref{ + #line 3667 "format.w" + $$= b000;} + |ADD xdimen_ref{ + #line 3668 "format.w" + $$= b001;} + |TO xdimen_node{ + #line 3669 "format.w" + $$= b100;} + |ADD xdimen_node{ + #line 3670 "format.w" + $$= b101;}; + +hpack:box_shift box_goal list{ + #line 3672 "format.w" + $$= $2;}; +vpack:box_shift MAX DEPTH dimension{ + #line 3673 "format.w" + HPUT32($4);}box_goal list{ + #line 3673 "format.w" + $$= $1 |$6;}; + +vxbox_node:start VSET xbox END{ + #line 3675 "format.w" + hput_tags($1,TAG(vset_kind,$3));} + |start VPACK vpack END{ + #line 3676 "format.w" + hput_tags($1,TAG(vpack_kind,$3));}; + + +hxbox_node:start HSET xbox END{ + #line 3679 "format.w" + hput_tags($1,TAG(hset_kind,$3));} + |start HPACK hpack END{ + #line 3680 "format.w" + hput_tags($1,TAG(hpack_kind,$3));}; + +content_node:vxbox_node |hxbox_node; + /*:171*/ /*176:*/ +ltype:{ + #line 3790 "format.w" + $$= 1;} |ALIGN{ + #line 3790 "format.w" + $$= 1;} |CENTER{ + #line 3790 "format.w" + $$= 2;} |EXPAND{ + #line 3790 "format.w" + $$= 3;}; +leaders:glue_node ltype rule_node{ + #line 3791 "format.w" + if($1)$$= $2 |b100;else $$= $2;} + |glue_node ltype hbox_node{ + #line 3792 "format.w" + if($1)$$= $2 |b100;else $$= $2;} + |glue_node ltype vbox_node{ + #line 3793 "format.w" + if($1)$$= $2 |b100;else $$= $2;}; +content_node:start LEADERS leaders END{ + #line 3794 "format.w" + hput_tags($1,TAG(leaders_kind,$3));} + /*:176*/ /*183:*/ +baseline:dimension{ + #line 3900 "format.w" + if($1!=0)HPUT32($1);} +glue_node glue_node{ + #line 3901 "format.w" + $$= b000;if($1!=0)$$ |= b001; + if($3)$$ |= b100; + if($4)$$ |= b010; + }; +content_node:start BASELINE baseline END +{ + #line 3906 "format.w" + if($3==b000)HPUT8(0);hput_tags($1,TAG(baseline_kind,$3));}; + /*:183*/ /*190:*/ +cc_list: |cc_list TXT_CC{ + #line 3989 "format.w" + hput_utf8($2);}; +lig_cc:UNSIGNED{ + #line 3990 "format.w" + RNG("UTF-8 code",$1,0,0x1FFFFF);$$= hpos-hstart;hput_utf8($1);}; +lig_cc:CHARCODE{ + #line 3991 "format.w" + $$= hpos-hstart;hput_utf8($1);}; +ref:REFERENCE{ + #line 3992 "format.w" + HPUT8($1);$$= $1;}; +ligature:ref{ + #line 3993 "format.w" + REF(font_kind,$1);}lig_cc TXT_START cc_list TXT_END +{ + #line 3994 "format.w" + $$.f= $1;$$.l.p= $3;$$.l.s= (hpos-hstart)-$3; + RNG("Ligature size",$$.l.s,0,255);}; +content_node:start LIGATURE ligature END{ + #line 3996 "format.w" + hput_tags($1,hput_ligature(&($3)));}; + /*:190*/ /*198:*/ +replace_count:explicit{ + #line 4106 "format.w" + if($1){$$= 0x80;HPUT8(0x80);}else $$= 0x00;} + |explicit UNSIGNED{ + #line 4107 "format.w" + RNG("Replace count",$2,0,31); + $$= ($2) |(($1)?0x80:0x00);if($$!=0)HPUT8($$);}; +disc:replace_count list list{ + #line 4109 "format.w" + $$.r= $1;$$.p= $2;$$.q= $3; + if($3.s==0){hpos= hpos-2;if($2.s==0)hpos= hpos-2;}} + |replace_count list{ + #line 4111 "format.w" + $$.r= $1;$$.p= $2;if($2.s==0)hpos= hpos-2;$$.q.s= 0;} + |replace_count{ + #line 4112 "format.w" + $$.r= $1;$$.p.s= 0;$$.q.s= 0;}; + + +disc_node:start DISC disc END +{ + #line 4116 "format.w" + hput_tags($1,hput_disc(&($3)));}; + +content_node:disc_node; + /*:198*/ /*206:*/ +par_dimen:xdimen{ + #line 4268 "format.w" + hput_xdimen_node(&($1));}; +par:xdimen_ref param_ref list{ + #line 4269 "format.w" + $$= b000;} + |xdimen_ref empty_param_list non_empty_param_list list{ + #line 4270 "format.w" + $$= b010;} + |xdimen_ref empty_param_list list{ + #line 4271 "format.w" + $$= b010;} + |xdimen param_ref{ + #line 4272 "format.w" + hput_xdimen_node(&($1));}list{ + #line 4272 "format.w" + $$= b100;} + |par_dimen empty_param_list non_empty_param_list list{ + #line 4273 "format.w" + $$= b110;} + |par_dimen empty_param_list list{ + #line 4274 "format.w" + $$= b110;}; + +content_node:start PAR par END{ + #line 4276 "format.w" + hput_tags($1,TAG(par_kind,$3));}; + /*:206*/ /*211:*/ +math:param_ref list{ + #line 4342 "format.w" + $$= b000;} + |param_ref list hbox_node{ + #line 4343 "format.w" + $$= b001;} + |param_ref hbox_node list{ + #line 4344 "format.w" + $$= b010;} + |empty_param_list list{ + #line 4345 "format.w" + $$= b100;} + |empty_param_list list hbox_node{ + #line 4346 "format.w" + $$= b101;} + |empty_param_list hbox_node list{ + #line 4347 "format.w" + $$= b110;} + |empty_param_list non_empty_param_list list{ + #line 4348 "format.w" + $$= b100;} + |empty_param_list non_empty_param_list list hbox_node{ + #line 4349 "format.w" + $$= b101;} + |empty_param_list non_empty_param_list hbox_node list{ + #line 4350 "format.w" + $$= b110;}; + +content_node:start MATH math END{ + #line 4352 "format.w" + hput_tags($1,TAG(math_kind,$3));}; + /*:211*/ /*216:*/ +on_off:ON{ + #line 4402 "format.w" + $$= 1;} |OFF{ + #line 4402 "format.w" + $$= 0;}; +math:on_off{ + #line 4403 "format.w" + $$= b011 |($1<<2);}; + /*:216*/ /*220:*/ +content_node:start ADJUST list END{ + #line 4434 "format.w" + hput_tags($1,TAG(adjust_kind,1));}; + /*:220*/ /*224:*/ +span_count:UNSIGNED{ + #line 4533 "format.w" + $$= hput_span_count($1);}; +content_node:start ITEM content_node END{ + #line 4534 "format.w" + hput_tags($1,TAG(item_kind,1));}; +content_node:start ITEM span_count content_node END{ + #line 4535 "format.w" + hput_tags($1,TAG(item_kind,$3));}; +content_node:start ITEM list END{ + #line 4536 "format.w" + hput_tags($1,TAG(item_kind,b000));}; + +table:H box_goal list list{ + #line 4538 "format.w" + $$= $2;}; +table:V box_goal list list{ + #line 4539 "format.w" + $$= $2 |b010;}; + +content_node:start TABLE table END{ + #line 4541 "format.w" + hput_tags($1,TAG(table_kind,$3));}; + /*:224*/ /*231:*/ +image_dimen:dimension dimension{ + #line 4629 "format.w" + $$.w= $1;$$.h= $2;} |{ + #line 4629 "format.w" + $$.w= $$.h= 0;}; +image:UNSIGNED image_dimen plus minus{ + #line 4630 "format.w" + $$.w= $2.w;$$.h= $2.h;$$.p= $3;$$.m= $4;RNG("Section number",$1,3,max_section_no);$$.n= $1;}; +content_node:start IMAGE image END{ + #line 4631 "format.w" + hput_tags($1,hput_image(&($3)));} + /*:231*/ /*241:*/ +max_value:OUTLINE UNSIGNED{ + #line 4868 "format.w" + max_outline= $2; + RNG("max outline",max_outline,0,0xFFFF); + DBG(DBGDEF |DBGLABEL,"Setting max outline to %d\n",max_outline); + }; + /*:241*/ /*248:*/ +placement:TOP{ + #line 4960 "format.w" + $$= LABEL_TOP;} |BOT{ + #line 4960 "format.w" + $$= LABEL_BOT;} |MID{ + #line 4960 "format.w" + $$= LABEL_MID;} |{ + #line 4960 "format.w" + $$= LABEL_MID;}; +content_node:START LABEL REFERENCE placement END +{ + #line 4962 "format.w" + hset_label($3,$4);} + /*:248*/ /*262:*/ +content_node:start LINK REFERENCE on_off END +{ + #line 5220 "format.w" + hput_tags($1,hput_link($3,$4));}; + /*:262*/ /*272:*/ +def_node:START OUTLINE REFERENCE integer position list END{ + #line 5350 "format.w" + + static int outline_no= -1; + $$.k= outline_kind;$$.n= $3; + if($6.s==0)QUIT("Outline with empty title in line %d",yylineno); + outline_no++; + hset_outline(outline_no,$3,$4,$5); + }; + /*:272*/ /*279:*/ +stream_link:ref{ + #line 5765 "format.w" + REF_RNG(stream_kind,$1);} |NOREFERENCE{ + #line 5765 "format.w" + HPUT8(255);}; +stream_split:stream_link stream_link UNSIGNED{ + #line 5766 "format.w" + RNG("split ratio",$3,0,1000);HPUT16($3);}; +stream_info:xdimen_node UNSIGNED{ + #line 5767 "format.w" + RNG("magnification factor",$2,0,1000);HPUT16($2);}stream_split; + +stream_type:stream_info{ + #line 5769 "format.w" + $$= 0;} |FIRST{ + #line 5769 "format.w" + $$= 1;} |LAST{ + #line 5769 "format.w" + $$= 2;} |TOP{ + #line 5769 "format.w" + $$= 3;}; + +stream_def_node:start STREAMDEF ref stream_type +list xdimen_node glue_node list glue_node END +{ + #line 5773 "format.w" + DEF($$,stream_kind,$3);hput_tags($1,TAG(stream_kind,$4 |b100));}; + +stream_ins_node:start STREAMDEF ref END +{ + #line 5776 "format.w" + RNG("Stream insertion",$3,0,max_ref[stream_kind]);hput_tags($1,TAG(stream_kind,b100));}; + +content_node:stream_def_node |stream_ins_node; + /*:279*/ /*284:*/ +stream:empty_param_list list{ + #line 5871 "format.w" + $$= b010;} + |empty_param_list non_empty_param_list list{ + #line 5872 "format.w" + $$= b010;} + |param_ref list{ + #line 5873 "format.w" + $$= b000;}; +content_node:start STREAM stream_ref stream END +{ + #line 5875 "format.w" + hput_tags($1,TAG(stream_kind,$4));}; + /*:284*/ /*289:*/ +page_priority:{ + #line 5978 "format.w" + HPUT8(1);} + |UNSIGNED{ + #line 5979 "format.w" + RNG("page priority",$1,0,255);HPUT8($1);}; + +stream_def_list: |stream_def_list stream_def_node; + +page:string{ + #line 5983 "format.w" + hput_string($1);}page_priority glue_node dimension{ + #line 5983 "format.w" + HPUT32($5);} +xdimen_node xdimen_node +list stream_def_list; + /*:289*/ /*297:*/ + +content_node:START RANGE REFERENCE ON END{ + #line 6095 "format.w" + REF(page_kind,$3);hput_range($3,true);} + |START RANGE REFERENCE OFF END{ + #line 6096 "format.w" + REF(page_kind,$3);hput_range($3,false);}; + /*:297*/ /*308:*/ +hint:directory_section definition_section content_section; + /*:308*/ /*324:*/ +directory_section:START DIRECTORY UNSIGNED{ + #line 6786 "format.w" + new_directory($3+1);new_output_buffers();}entry_list END; +entry_list: |entry_list entry; +entry:START SECTION UNSIGNED string END +{ + #line 6789 "format.w" + RNG("Section number",$3,3,max_section_no);hset_entry(&(dir[$3]),$3,0,0,$4);}; + /*:324*/ /*343:*/ +definition_section:START DEFINITIONS{ + #line 7277 "format.w" + hput_definitions_start();} +max_definitions definition_list +END{ + #line 7279 "format.w" + hput_definitions_end();}; +definition_list: |definition_list def_node; + /*:343*/ /*351:*/ +max_definitions:START MAX max_list END +{ + #line 7395 "format.w" + /*245:*/ + if(max_ref[label_kind]>=0) + ALLOCATE(labels,max_ref[label_kind]+1,label_t); + /*:245*/ /*266:*/ + if(max_outline>=0) + ALLOCATE(outlines,max_outline+1,outline_t); + /*:266*/ /*293:*/ + ALLOCATE(page_on,max_ref[page_kind]+1,int); + ALLOCATE(range_pos,2*(max_ref[range_kind]+1),range_pos_t); + /*:293*/ /*357:*/ + definition_bits[0][int_kind]= (1<<(MAX_INT_DEFAULT+1))-1; + definition_bits[0][dimen_kind]= (1<<(MAX_DIMEN_DEFAULT+1))-1; + definition_bits[0][xdimen_kind]= (1<<(MAX_XDIMEN_DEFAULT+1))-1; + definition_bits[0][glue_kind]= (1<<(MAX_GLUE_DEFAULT+1))-1; + definition_bits[0][baseline_kind]= (1<<(MAX_BASELINE_DEFAULT+1))-1; + definition_bits[0][page_kind]= (1<<(MAX_PAGE_DEFAULT+1))-1; + definition_bits[0][stream_kind]= (1<<(MAX_STREAM_DEFAULT+1))-1; + definition_bits[0][range_kind]= (1<<(MAX_RANGE_DEFAULT+1))-1; + /*:357*/ /*372:*/ + ALLOCATE(hfont_name,max_ref[font_kind]+1,char*); + /*:372*/hput_max_definitions();}; + +max_list: |max_list START max_value END; + +max_value:FONT UNSIGNED{ + #line 7399 "format.w" + hset_max(font_kind,$2);} + |INTEGER UNSIGNED{ + #line 7400 "format.w" + hset_max(int_kind,$2);} + |DIMEN UNSIGNED{ + #line 7401 "format.w" + hset_max(dimen_kind,$2);} + |LIGATURE UNSIGNED{ + #line 7402 "format.w" + hset_max(ligature_kind,$2);} + |DISC UNSIGNED{ + #line 7403 "format.w" + hset_max(disc_kind,$2);} + |GLUE UNSIGNED{ + #line 7404 "format.w" + hset_max(glue_kind,$2);} + |LANGUAGE UNSIGNED{ + #line 7405 "format.w" + hset_max(language_kind,$2);} + |RULE UNSIGNED{ + #line 7406 "format.w" + hset_max(rule_kind,$2);} + |IMAGE UNSIGNED{ + #line 7407 "format.w" + hset_max(image_kind,$2);} + |LEADERS UNSIGNED{ + #line 7408 "format.w" + hset_max(leaders_kind,$2);} + |BASELINE UNSIGNED{ + #line 7409 "format.w" + hset_max(baseline_kind,$2);} + |XDIMEN UNSIGNED{ + #line 7410 "format.w" + hset_max(xdimen_kind,$2);} + |PARAM UNSIGNED{ + #line 7411 "format.w" + hset_max(param_kind,$2);} + |STREAMDEF UNSIGNED{ + #line 7412 "format.w" + hset_max(stream_kind,$2);} + |PAGE UNSIGNED{ + #line 7413 "format.w" + hset_max(page_kind,$2);} + |RANGE UNSIGNED{ + #line 7414 "format.w" + hset_max(range_kind,$2);} + |LABEL UNSIGNED{ + #line 7415 "format.w" + hset_max(label_kind,$2);}; + + /*:351*/ /*359:*/ +def_node: +start FONT ref font END{ + #line 7612 "format.w" + DEF($$,font_kind,$3);hput_tags($1,$4);} + |start INTEGER ref integer END{ + #line 7613 "format.w" + DEF($$,int_kind,$3);hput_tags($1,hput_int($4));} + |start DIMEN ref dimension END{ + #line 7614 "format.w" + DEF($$,dimen_kind,$3);hput_tags($1,hput_dimen($4));} + |start LANGUAGE ref string END{ + #line 7615 "format.w" + DEF($$,language_kind,$3);hput_string($4);hput_tags($1,TAG(language_kind,0));} + |start GLUE ref glue END{ + #line 7616 "format.w" + DEF($$,glue_kind,$3);hput_tags($1,hput_glue(&($4)));} + |start XDIMEN ref xdimen END{ + #line 7617 "format.w" + DEF($$,xdimen_kind,$3);hput_tags($1,hput_xdimen(&($4)));} + |start RULE ref rule END{ + #line 7618 "format.w" + DEF($$,rule_kind,$3);hput_tags($1,hput_rule(&($4)));} + |start LEADERS ref leaders END{ + #line 7619 "format.w" + DEF($$,leaders_kind,$3);hput_tags($1,TAG(leaders_kind,$4));} + |start BASELINE ref baseline END{ + #line 7620 "format.w" + DEF($$,baseline_kind,$3);hput_tags($1,TAG(baseline_kind,$4));} + |start LIGATURE ref ligature END{ + #line 7621 "format.w" + DEF($$,ligature_kind,$3);hput_tags($1,hput_ligature(&($4)));} + |start DISC ref disc END{ + #line 7622 "format.w" + DEF($$,disc_kind,$3);hput_tags($1,hput_disc(&($4)));} + |start IMAGE ref image END{ + #line 7623 "format.w" + DEF($$,image_kind,$3);hput_tags($1,hput_image(&($4)));} + |start PARAM ref parameters END{ + #line 7624 "format.w" + DEF($$,param_kind,$3);hput_tags($1,hput_list($1+2,&($4)));} + |start PAGE ref page END{ + #line 7625 "format.w" + DEF($$,page_kind,$3);hput_tags($1,TAG(page_kind,0));}; + /*:359*/ /*361:*/ +def_node: +start INTEGER ref ref END{ + #line 7644 "format.w" + DEF_REF($$,int_kind,$3,$4);hput_tags($1,TAG(int_kind,0));} + |start DIMEN ref ref END{ + #line 7645 "format.w" + DEF_REF($$,dimen_kind,$3,$4);hput_tags($1,TAG(dimen_kind,0));} + |start GLUE ref ref END{ + #line 7646 "format.w" + DEF_REF($$,glue_kind,$3,$4);hput_tags($1,TAG(glue_kind,0));}; + /*:361*/ /*366:*/ +def_list:position + |def_list def_node{ + #line 7760 "format.w" + check_param_def(&($2));}; +parameters:estimate def_list{ + #line 7761 "format.w" + $$.p= $2;$$.k= param_kind;$$.s= (hpos-hstart)-$2;}; + /*:366*/ /*367:*/ +empty_param_list:position{ + #line 7782 "format.w" + HPUTX(2);hpos++;hput_tags($1,TAG(param_kind,1));}; +non_empty_param_list:start PARAM{ + #line 7783 "format.w" + hpos= hpos-2;}parameters END +{ + #line 7784 "format.w" + hput_tags($1-2,hput_list($1-1,&($4)));}; + /*:367*/ /*375:*/ + +font:font_head font_param_list; + +font_head:string dimension UNSIGNED UNSIGNED +{ + #line 7926 "format.w" + uint8_t f= $0;SET_DBIT(f,font_kind);hfont_name[f]= strdup($1);$$= hput_font_head(f,hfont_name[f],$2,$3,$4);}; + +font_param_list:glue_node disc_node |font_param_list font_param; + +font_param: +start PENALTY fref penalty END{ + #line 7931 "format.w" + hput_tags($1,hput_int($4));} + |start KERN fref kern END{ + #line 7932 "format.w" + hput_tags($1,hput_kern(&($4)));} + |start LIGATURE fref ligature END{ + #line 7933 "format.w" + hput_tags($1,hput_ligature(&($4)));} + |start DISC fref disc END{ + #line 7934 "format.w" + hput_tags($1,hput_disc(&($4)));} + |start GLUE fref glue END{ + #line 7935 "format.w" + hput_tags($1,hput_glue(&($4)));} + |start LANGUAGE fref string END{ + #line 7936 "format.w" + hput_string($4);hput_tags($1,TAG(language_kind,0));} + |start RULE fref rule END{ + #line 7937 "format.w" + hput_tags($1,hput_rule(&($4)));} + |start IMAGE fref image END{ + #line 7938 "format.w" + hput_tags($1,hput_image(&($4)));}; + +fref:ref{ + #line 7940 "format.w" + RNG("Font parameter",$1,0,MAX_FONT_PARAMS);}; + /*:375*/ /*378:*/ +xdimen_ref:ref{ + #line 8013 "format.w" + REF(xdimen_kind,$1);}; +param_ref:ref{ + #line 8014 "format.w" + REF(param_kind,$1);}; +stream_ref:ref{ + #line 8015 "format.w" + REF_RNG(stream_kind,$1);}; + + +content_node: +start PENALTY ref END{ + #line 8019 "format.w" + REF(penalty_kind,$3);hput_tags($1,TAG(penalty_kind,0));} + |start KERN explicit ref END +{ + #line 8021 "format.w" + REF(dimen_kind,$4);hput_tags($1,TAG(kern_kind,($3)?b100:b000));} + |start KERN explicit XDIMEN ref END +{ + #line 8023 "format.w" + REF(xdimen_kind,$5);hput_tags($1,TAG(kern_kind,($3)?b101:b001));} + |start GLUE ref END{ + #line 8024 "format.w" + REF(glue_kind,$3);hput_tags($1,TAG(glue_kind,0));} + |start LIGATURE ref END{ + #line 8025 "format.w" + REF(ligature_kind,$3);hput_tags($1,TAG(ligature_kind,0));} + |start DISC ref END{ + #line 8026 "format.w" + REF(disc_kind,$3);hput_tags($1,TAG(disc_kind,0));} + |start RULE ref END{ + #line 8027 "format.w" + REF(rule_kind,$3);hput_tags($1,TAG(rule_kind,0));} + |start IMAGE ref END{ + #line 8028 "format.w" + REF(image_kind,$3);hput_tags($1,TAG(image_kind,0));} + |start LEADERS ref END{ + #line 8029 "format.w" + REF(leaders_kind,$3);hput_tags($1,TAG(leaders_kind,0));} + |start BASELINE ref END{ + #line 8030 "format.w" + REF(baseline_kind,$3);hput_tags($1,TAG(baseline_kind,0));} + |start LANGUAGE REFERENCE END{ + #line 8031 "format.w" + REF(language_kind,$3);hput_tags($1,hput_language($3));}; + +glue_node:start GLUE ref END{ + #line 8033 "format.w" + REF(glue_kind,$3); + if($3==zero_skip_no){hpos= hpos-2;$$= false;} + else{hput_tags($1,TAG(glue_kind,0));$$= true;}}; + + /*:378*/ /*403:*/ +content_section:START CONTENT{ + #line 8464 "format.w" + hput_content_start();}content_list END +{ + #line 8465 "format.w" + hput_content_end();hput_range_defs();hput_label_defs();}; + /*:403*/ +%% + /*:510*/ diff --git a/Build/source/texk/web2c/hitexdir/hishrink-lexer.c b/Build/source/texk/web2c/hitexdir/hishrink-lexer.c deleted file mode 100644 index 22a3f4fa4d9..00000000000 --- a/Build/source/texk/web2c/hitexdir/hishrink-lexer.c +++ /dev/null @@ -1,3206 +0,0 @@ -#line 2 "shrink.lex.c" - -#line 4 "shrink.lex.c" - -#define YY_INT_ALIGNED short int - -/* A lexical scanner generated by flex */ - -/* %not-for-header */ - -/* %if-c-only */ -/* %if-not-reentrant */ - -/* %endif */ -/* %endif */ -/* %ok-for-header */ - -#define FLEX_SCANNER -#define YY_FLEX_MAJOR_VERSION 2 -#define YY_FLEX_MINOR_VERSION 5 -#define YY_FLEX_SUBMINOR_VERSION 37 -#if YY_FLEX_SUBMINOR_VERSION > 0 -#define FLEX_BETA -#endif - -/* %if-c++-only */ -/* %endif */ - -/* %if-c-only */ - -/* %endif */ - -/* %if-c-only */ - -/* %endif */ - -/* First, we deal with platform-specific or compiler-specific issues. */ - -/* begin standard C headers. */ -/* %if-c-only */ -#include -#include -#include -#include -/* %endif */ - -/* %if-tables-serialization */ -/* %endif */ -/* end standard C headers. */ - -/* %if-c-or-c++ */ -/* flex integer type definitions */ - -#ifndef FLEXINT_H -#define FLEXINT_H - -/* C99 systems have . Non-C99 systems may or may not. */ - -#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L - -/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, - * if you want the limit (max/min) macros for int types. - */ -#ifndef __STDC_LIMIT_MACROS -#define __STDC_LIMIT_MACROS 1 -#endif - -#include -typedef int8_t flex_int8_t; -typedef uint8_t flex_uint8_t; -typedef int16_t flex_int16_t; -typedef uint16_t flex_uint16_t; -typedef int32_t flex_int32_t; -typedef uint32_t flex_uint32_t; -#else -typedef signed char flex_int8_t; -typedef short int flex_int16_t; -typedef int flex_int32_t; -typedef unsigned char flex_uint8_t; -typedef unsigned short int flex_uint16_t; -typedef unsigned int flex_uint32_t; - -/* Limits of integral types. */ -#ifndef INT8_MIN -#define INT8_MIN (-128) -#endif -#ifndef INT16_MIN -#define INT16_MIN (-32767-1) -#endif -#ifndef INT32_MIN -#define INT32_MIN (-2147483647-1) -#endif -#ifndef INT8_MAX -#define INT8_MAX (127) -#endif -#ifndef INT16_MAX -#define INT16_MAX (32767) -#endif -#ifndef INT32_MAX -#define INT32_MAX (2147483647) -#endif -#ifndef UINT8_MAX -#define UINT8_MAX (255U) -#endif -#ifndef UINT16_MAX -#define UINT16_MAX (65535U) -#endif -#ifndef UINT32_MAX -#define UINT32_MAX (4294967295U) -#endif - -#endif /* ! C99 */ - -#endif /* ! FLEXINT_H */ - -/* %endif */ - -/* %if-c++-only */ -/* %endif */ - -#ifdef __cplusplus - -/* The "const" storage-class-modifier is valid. */ -#define YY_USE_CONST - -#else /* ! __cplusplus */ - -/* C99 requires __STDC__ to be defined as 1. */ -#if defined (__STDC__) - -#define YY_USE_CONST - -#endif /* defined (__STDC__) */ -#endif /* ! __cplusplus */ - -#ifdef YY_USE_CONST -#define yyconst const -#else -#define yyconst -#endif - -/* %not-for-header */ - -/* Returned upon end-of-file. */ -#define YY_NULL 0 -/* %ok-for-header */ - -/* %not-for-header */ - -/* Promotes a possibly negative, possibly signed char to an unsigned - * integer for use as an array index. If the signed char is negative, - * we want to instead treat it as an 8-bit unsigned char, hence the - * double cast. - */ -#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) -/* %ok-for-header */ - -/* %if-reentrant */ -/* %endif */ - -/* %if-not-reentrant */ - -/* %endif */ - -/* Enter a start condition. This macro really ought to take a parameter, - * but we do it the disgusting crufty way forced on us by the ()-less - * definition of BEGIN. - */ -#define BEGIN (yy_start) = 1 + 2 * - -/* Translate the current start state into a value that can be later handed - * to BEGIN to return to the state. The YYSTATE alias is for lex - * compatibility. - */ -#define YY_START (((yy_start) - 1) / 2) -#define YYSTATE YY_START - -/* Action number for EOF rule of a given start state. */ -#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) - -/* Special action meaning "start processing a new file". */ -#define YY_NEW_FILE yyrestart(yyin ) - -#define YY_END_OF_BUFFER_CHAR 0 - -/* Size of default input buffer. */ -#ifndef YY_BUF_SIZE -#define YY_BUF_SIZE 16384 -#endif - -/* The state buf must be large enough to hold one state per character in the main buffer. - */ -#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) - -#ifndef YY_TYPEDEF_YY_BUFFER_STATE -#define YY_TYPEDEF_YY_BUFFER_STATE -typedef struct yy_buffer_state *YY_BUFFER_STATE; -#endif - -#ifndef YY_TYPEDEF_YY_SIZE_T -#define YY_TYPEDEF_YY_SIZE_T -typedef size_t yy_size_t; -#endif - -/* %if-not-reentrant */ -extern yy_size_t yyleng; -/* %endif */ - -/* %if-c-only */ -/* %if-not-reentrant */ -extern FILE *yyin, *yyout; -/* %endif */ -/* %endif */ - -#define EOB_ACT_CONTINUE_SCAN 0 -#define EOB_ACT_END_OF_FILE 1 -#define EOB_ACT_LAST_MATCH 2 - - /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires - * access to the local variable yy_act. Since yyless() is a macro, it would break - * existing scanners that call yyless() from OUTSIDE yylex. - * One obvious solution it to make yy_act a global. I tried that, and saw - * a 5% performance hit in a non-yylineno scanner, because yy_act is - * normally declared as a register variable-- so it is not worth it. - */ - #define YY_LESS_LINENO(n) \ - do { \ - int yyl;\ - for ( yyl = n; yyl < yyleng; ++yyl )\ - if ( yytext[yyl] == '\n' )\ - --yylineno;\ - }while(0) - -/* Return all but the first "n" matched characters back to the input stream. */ -#define yyless(n) \ - do \ - { \ - /* Undo effects of setting up yytext. */ \ - int yyless_macro_arg = (n); \ - YY_LESS_LINENO(yyless_macro_arg);\ - *yy_cp = (yy_hold_char); \ - YY_RESTORE_YY_MORE_OFFSET \ - (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ - YY_DO_BEFORE_ACTION; /* set up yytext again */ \ - } \ - while ( 0 ) - -#define unput(c) yyunput( c, (yytext_ptr) ) - -#ifndef YY_STRUCT_YY_BUFFER_STATE -#define YY_STRUCT_YY_BUFFER_STATE -struct yy_buffer_state - { -/* %if-c-only */ - FILE *yy_input_file; -/* %endif */ - -/* %if-c++-only */ -/* %endif */ - - char *yy_ch_buf; /* input buffer */ - char *yy_buf_pos; /* current position in input buffer */ - - /* Size of input buffer in bytes, not including room for EOB - * characters. - */ - yy_size_t yy_buf_size; - - /* Number of characters read into yy_ch_buf, not including EOB - * characters. - */ - yy_size_t yy_n_chars; - - /* Whether we "own" the buffer - i.e., we know we created it, - * and can realloc() it to grow it, and should free() it to - * delete it. - */ - int yy_is_our_buffer; - - /* Whether this is an "interactive" input source; if so, and - * if we're using stdio for input, then we want to use getc() - * instead of fread(), to make sure we stop fetching input after - * each newline. - */ - int yy_is_interactive; - - /* Whether we're considered to be at the beginning of a line. - * If so, '^' rules will be active on the next match, otherwise - * not. - */ - int yy_at_bol; - - int yy_bs_lineno; /**< The line count. */ - int yy_bs_column; /**< The column count. */ - - /* Whether to try to fill the input buffer when we reach the - * end of it. - */ - int yy_fill_buffer; - - int yy_buffer_status; - -#define YY_BUFFER_NEW 0 -#define YY_BUFFER_NORMAL 1 - /* When an EOF's been seen but there's still some text to process - * then we mark the buffer as YY_EOF_PENDING, to indicate that we - * shouldn't try reading from the input source any more. We might - * still have a bunch of tokens to match, though, because of - * possible backing-up. - * - * When we actually see the EOF, we change the status to "new" - * (via yyrestart()), so that the user can continue scanning by - * just pointing yyin at a new input file. - */ -#define YY_BUFFER_EOF_PENDING 2 - - }; -#endif /* !YY_STRUCT_YY_BUFFER_STATE */ - -/* %if-c-only Standard (non-C++) definition */ -/* %not-for-header */ - -/* %if-not-reentrant */ - -/* Stack of input buffers. */ -static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ -static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ -static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */ -/* %endif */ -/* %ok-for-header */ - -/* %endif */ - -/* We provide macros for accessing buffer states in case in the - * future we want to put the buffer states in a more general - * "scanner state". - * - * Returns the top of the stack, or NULL. - */ -#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ - ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ - : NULL) - -/* Same as previous macro, but useful when we know that the buffer stack is not - * NULL or when we need an lvalue. For internal use only. - */ -#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] - -/* %if-c-only Standard (non-C++) definition */ - -/* %if-not-reentrant */ -/* %not-for-header */ - -/* yy_hold_char holds the character lost when yytext is formed. */ -static char yy_hold_char; -static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */ -yy_size_t yyleng; - -/* Points to current character in buffer. */ -static char *yy_c_buf_p = (char *) 0; -static int yy_init = 0; /* whether we need to initialize */ -static int yy_start = 0; /* start state number */ - -/* Flag which is used to allow yywrap()'s to do buffer switches - * instead of setting up a fresh yyin. A bit of a hack ... - */ -static int yy_did_buffer_switch_on_eof; -/* %ok-for-header */ - -/* %endif */ - -void yyrestart (FILE *input_file ); -void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ); -YY_BUFFER_STATE yy_create_buffer (FILE *file,int size ); -void yy_delete_buffer (YY_BUFFER_STATE b ); -void yy_flush_buffer (YY_BUFFER_STATE b ); -void yypush_buffer_state (YY_BUFFER_STATE new_buffer ); -void yypop_buffer_state (void ); - -static void yyensure_buffer_stack (void ); -static void yy_load_buffer_state (void ); -static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file ); - -#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER ) - -YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size ); -YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str ); -YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,yy_size_t len ); - -/* %endif */ - -void *yyalloc (yy_size_t ); -void *yyrealloc (void *,yy_size_t ); -void yyfree (void * ); - -#define yy_new_buffer yy_create_buffer - -#define yy_set_interactive(is_interactive) \ - { \ - if ( ! YY_CURRENT_BUFFER ){ \ - yyensure_buffer_stack (); \ - YY_CURRENT_BUFFER_LVALUE = \ - yy_create_buffer(yyin,YY_BUF_SIZE ); \ - } \ - YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ - } - -#define yy_set_bol(at_bol) \ - { \ - if ( ! YY_CURRENT_BUFFER ){\ - yyensure_buffer_stack (); \ - YY_CURRENT_BUFFER_LVALUE = \ - yy_create_buffer(yyin,YY_BUF_SIZE ); \ - } \ - YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ - } - -#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) - -/* %% [1.0] yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here */ -/* Begin user sect3 */ - -#define FLEX_DEBUG - -typedef unsigned char YY_CHAR; - -FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; - -typedef int yy_state_type; - -extern int yylineno; - -int yylineno = 1; - -extern char *yytext; -#define yytext_ptr yytext - -/* %if-c-only Standard (non-C++) definition */ - -static yy_state_type yy_get_previous_state (void ); -static yy_state_type yy_try_NUL_trans (yy_state_type current_state ); -static int yy_get_next_buffer (void ); -static void yy_fatal_error (yyconst char msg[] ); - -/* %endif */ - -/* Done after the current pattern has been matched and before the - * corresponding action - sets up yytext. - */ -#define YY_DO_BEFORE_ACTION \ - (yytext_ptr) = yy_bp; \ -/* %% [2.0] code to fiddle yytext and yyleng for yymore() goes here \ */\ - yyleng = (size_t) (yy_cp - yy_bp); \ - (yy_hold_char) = *yy_cp; \ - *yy_cp = '\0'; \ -/* %% [3.0] code to copy yytext_ptr to yytext[] goes here, if %array \ */\ - (yy_c_buf_p) = yy_cp; - -/* %% [4.0] data tables for the DFA and the user's section 1 definitions go here */ -#define YY_NUM_RULES 126 -#define YY_END_OF_BUFFER 127 -/* This struct is not used in this scanner, - but its presence is necessary. */ -struct yy_trans_info - { - flex_int32_t yy_verify; - flex_int32_t yy_nxt; - }; -static yyconst flex_int16_t yy_accept[371] = - { 0, - 0, 0, 0, 0, 0, 0, 127, 125, 6, 6, - 43, 47, 10, 125, 114, 125, 4, 4, 1, 2, - 41, 124, 124, 124, 124, 124, 124, 124, 31, 124, - 124, 124, 124, 124, 124, 124, 124, 124, 124, 32, - 124, 40, 14, 15, 13, 11, 74, 74, 58, 72, - 48, 73, 49, 50, 74, 126, 126, 126, 126, 0, - 0, 0, 0, 0, 0, 0, 7, 5, 5, 9, - 9, 0, 0, 0, 4, 124, 124, 124, 124, 124, - 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, - 124, 124, 29, 124, 124, 124, 124, 124, 124, 124, - - 28, 124, 97, 124, 124, 124, 124, 27, 124, 124, - 124, 124, 124, 124, 124, 86, 124, 124, 124, 124, - 12, 0, 58, 58, 0, 59, 55, 52, 56, 60, - 53, 54, 57, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 51, 71, 75, 0, 0, 20, 20, - 16, 0, 0, 0, 5, 0, 9, 24, 8, 85, - 124, 124, 124, 106, 124, 124, 124, 124, 124, 124, - 124, 124, 124, 33, 124, 124, 124, 124, 124, 124, - 124, 124, 37, 124, 124, 124, 124, 124, 124, 124, - 124, 124, 120, 107, 124, 98, 124, 124, 95, 124, - - 124, 124, 102, 124, 124, 124, 124, 124, 113, 124, - 124, 124, 124, 59, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 76, 0, 18, 17, 21, 0, - 0, 0, 0, 0, 124, 124, 124, 124, 124, 124, - 124, 124, 124, 124, 94, 124, 34, 124, 122, 44, - 124, 78, 124, 82, 124, 101, 42, 124, 124, 112, - 124, 124, 108, 96, 124, 124, 115, 124, 124, 45, - 124, 39, 124, 124, 124, 124, 79, 124, 84, 124, - 70, 65, 61, 66, 69, 63, 64, 62, 68, 67, - 77, 19, 22, 0, 0, 24, 25, 124, 89, 124, - - 124, 124, 124, 124, 87, 26, 124, 124, 35, 111, - 3, 81, 104, 105, 124, 124, 124, 46, 124, 121, - 124, 116, 124, 124, 124, 100, 83, 124, 23, 0, - 99, 124, 90, 103, 124, 124, 124, 91, 124, 124, - 124, 124, 124, 124, 124, 110, 30, 0, 25, 124, - 123, 124, 124, 124, 88, 124, 109, 36, 118, 80, - 92, 124, 124, 38, 93, 124, 117, 124, 119, 0 - } ; - -static yyconst flex_int32_t yy_ec[256] = - { 0, - 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, - 4, 4, 2, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 5, 6, 7, 8, 8, 8, 8, 9, 10, - 11, 12, 13, 8, 14, 15, 8, 16, 17, 17, - 17, 17, 17, 17, 17, 18, 18, 8, 8, 19, - 8, 20, 8, 21, 22, 22, 23, 24, 22, 25, - 26, 8, 27, 8, 28, 29, 8, 8, 8, 30, - 8, 31, 32, 8, 8, 8, 8, 8, 8, 8, - 8, 33, 8, 8, 34, 8, 35, 36, 37, 38, - - 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, - 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, - 59, 51, 8, 60, 8, 8, 1, 61, 61, 61, - 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, - 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, - 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, - 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, - 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, - 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, - 61, 62, 62, 62, 62, 62, 62, 62, 62, 62, - - 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, - 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, - 62, 62, 62, 63, 63, 63, 63, 63, 63, 63, - 63, 63, 63, 63, 63, 63, 63, 63, 63, 64, - 64, 64, 64, 64, 64, 64, 64, 65, 65, 65, - 65, 65, 65, 65, 65 - } ; - -static yyconst flex_int32_t yy_meta[66] = - { 0, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 3, 3, 3, 3, 3, 1, - 4, 1, 1, 1, 4 - } ; - -static yyconst flex_int16_t yy_base[376] = - { 0, - 0, 0, 65, 130, 194, 258, 629, 630, 630, 630, - 630, 630, 74, 68, 64, 68, 77, 72, 630, 630, - 630, 53, 61, 58, 59, 570, 57, 581, 65, 57, - 0, 587, 73, 74, 100, 106, 107, 104, 112, 113, - 587, 630, 630, 630, 630, 615, 630, 117, 148, 162, - 630, 630, 630, 630, 322, 630, 562, 561, 560, 611, - 610, 609, 556, 555, 554, 165, 630, 630, 107, 154, - 162, 157, 166, 193, 170, 0, 160, 571, 560, 558, - 563, 24, 63, 153, 560, 173, 561, 148, 559, 572, - 567, 570, 550, 564, 550, 184, 566, 180, 168, 106, - - 0, 560, 0, 545, 182, 550, 542, 0, 548, 538, - 548, 556, 549, 539, 554, 539, 539, 552, 547, 542, - 630, 228, 233, 237, 241, 243, 247, 630, 630, 630, - 630, 630, 630, 250, 253, 257, 263, 266, 269, 272, - 276, 279, 282, 630, 630, 630, 523, 522, 630, 573, - 572, 571, 518, 517, 285, 288, 299, 291, 354, 0, - 522, 535, 536, 0, 520, 518, 518, 528, 516, 530, - 529, 530, 531, 519, 511, 509, 523, 511, 502, 522, - 504, 516, 0, 509, 507, 515, 512, 498, 513, 515, - 504, 506, 0, 0, 492, 0, 500, 506, 509, 508, - - 489, 500, 0, 501, 485, 498, 498, 490, 0, 477, - 497, 479, 485, 249, 357, 364, 367, 370, 375, 378, - 388, 396, 399, 402, 630, 470, 630, 521, 630, 520, - 467, 421, 409, 431, 474, 478, 479, 485, 476, 483, - 473, 478, 471, 479, 0, 450, 451, 439, 0, 0, - 450, 0, 446, 0, 451, 0, 0, 439, 429, 0, - 444, 421, 0, 0, 421, 430, 0, 422, 416, 0, - 422, 0, 417, 398, 416, 411, 0, 397, 0, 402, - 630, 630, 630, 630, 630, 630, 630, 630, 630, 630, - 630, 630, 630, 431, 315, 630, 441, 380, 0, 390, - - 379, 382, 380, 381, 0, 0, 356, 371, 0, 0, - 0, 0, 0, 0, 372, 350, 346, 0, 351, 0, - 344, 0, 340, 317, 297, 0, 0, 292, 630, 454, - 0, 289, 0, 0, 281, 280, 279, 0, 285, 265, - 224, 225, 203, 205, 209, 0, 0, 464, 478, 202, - 0, 186, 172, 163, 0, 151, 0, 0, 0, 0, - 0, 140, 100, 0, 0, 109, 0, 61, 0, 630, - 503, 507, 511, 514, 70 - } ; - -static yyconst flex_int16_t yy_def[376] = - { 0, - 370, 1, 371, 371, 372, 372, 370, 370, 370, 370, - 370, 370, 373, 374, 370, 370, 370, 370, 370, 370, - 370, 375, 375, 375, 375, 375, 375, 375, 375, 375, - 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, - 375, 370, 370, 370, 370, 370, 370, 370, 370, 370, - 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, - 370, 370, 370, 370, 370, 374, 370, 370, 370, 370, - 370, 370, 370, 370, 370, 375, 375, 375, 375, 375, - 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, - 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, - - 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, - 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, - 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, - 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, - 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, - 370, 370, 370, 370, 370, 370, 370, 370, 370, 375, - 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, - 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, - 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, - 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, - - 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, - 375, 375, 375, 370, 370, 370, 370, 370, 370, 370, - 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, - 370, 370, 370, 370, 375, 375, 375, 375, 375, 375, - 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, - 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, - 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, - 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, - 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, - 370, 370, 370, 370, 370, 370, 370, 375, 375, 375, - - 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, - 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, - 375, 375, 375, 375, 375, 375, 375, 375, 370, 370, - 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, - 375, 375, 375, 375, 375, 375, 375, 370, 370, 375, - 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, - 375, 375, 375, 375, 375, 375, 375, 375, 375, 0, - 370, 370, 370, 370, 370 - } ; - -static yyconst flex_int16_t yy_nxt[696] = - { 0, - 8, 9, 10, 9, 9, 11, 12, 8, 13, 14, - 8, 15, 16, 16, 8, 17, 18, 18, 19, 20, - 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, - 8, 8, 8, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 30, 31, 32, 33, 34, 31, 35, 36, - 31, 37, 38, 39, 31, 40, 31, 41, 31, 42, - 8, 8, 8, 8, 8, 43, 43, 44, 43, 166, - 67, 167, 76, 46, 60, 60, 60, 60, 67, 68, - 69, 69, 62, 70, 71, 71, 72, 75, 75, 75, - 77, 72, 73, 73, 73, 79, 81, 83, 78, 86, - - 89, 84, 168, 92, 93, 87, 82, 96, 99, 80, - 94, 97, 169, 369, 90, 98, 100, 91, 122, 123, - 101, 122, 155, 155, 155, 43, 43, 43, 43, 43, - 43, 43, 44, 43, 74, 63, 64, 65, 46, 102, - 105, 109, 112, 194, 106, 113, 115, 103, 117, 124, - 123, 107, 124, 195, 104, 110, 368, 114, 367, 108, - 116, 111, 118, 122, 123, 119, 122, 67, 72, 73, - 73, 73, 158, 158, 158, 67, 72, 157, 157, 157, - 72, 73, 73, 73, 72, 75, 75, 75, 366, 365, - 43, 43, 43, 43, 43, 48, 49, 160, 50, 170, - - 51, 364, 177, 161, 171, 172, 178, 52, 159, 159, - 159, 156, 53, 54, 159, 159, 159, 159, 174, 186, - 190, 192, 198, 363, 175, 193, 55, 191, 362, 122, - 123, 187, 122, 199, 124, 123, 188, 124, 124, 123, - 361, 124, 125, 126, 214, 125, 360, 214, 125, 126, - 214, 125, 359, 214, 56, 57, 58, 59, 56, 48, - 49, 358, 50, 357, 51, 215, 215, 215, 216, 216, - 216, 52, 217, 217, 217, 356, 53, 54, 218, 218, - 218, 219, 219, 219, 220, 220, 220, 221, 221, 221, - 55, 222, 222, 222, 223, 223, 223, 224, 224, 224, - - 155, 155, 155, 232, 232, 232, 158, 158, 158, 232, - 232, 232, 232, 72, 157, 157, 157, 355, 56, 57, - 58, 59, 56, 125, 126, 354, 127, 353, 128, 233, - 296, 296, 296, 352, 351, 129, 350, 130, 130, 347, - 131, 132, 133, 346, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 345, 145, 145, 145, 145, - 145, 145, 145, 145, 145, 145, 145, 145, 234, 159, - 159, 159, 215, 215, 215, 159, 159, 159, 159, 216, - 216, 216, 217, 217, 217, 218, 218, 218, 344, 281, - 219, 219, 219, 220, 220, 220, 282, 343, 342, 283, - - 341, 340, 284, 221, 221, 221, 339, 285, 338, 337, - 286, 222, 222, 222, 223, 223, 223, 224, 224, 224, - 287, 295, 295, 336, 296, 296, 296, 335, 288, 334, - 333, 289, 332, 331, 290, 234, 232, 232, 232, 329, - 328, 327, 232, 232, 232, 232, 297, 297, 297, 326, - 325, 324, 297, 297, 297, 297, 297, 297, 297, 323, - 322, 321, 297, 297, 297, 297, 348, 348, 320, 349, - 349, 349, 319, 318, 317, 349, 349, 349, 349, 349, - 349, 349, 316, 315, 314, 349, 349, 349, 349, 313, - 312, 311, 310, 349, 349, 349, 309, 308, 330, 349, - - 349, 349, 349, 45, 45, 45, 45, 47, 47, 47, - 47, 61, 61, 61, 66, 307, 66, 66, 306, 305, - 304, 303, 302, 301, 300, 299, 298, 294, 293, 292, - 291, 280, 279, 278, 277, 276, 275, 274, 273, 272, - 271, 270, 269, 268, 267, 266, 265, 264, 263, 262, - 261, 260, 259, 258, 257, 256, 255, 254, 253, 252, - 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, - 241, 240, 239, 238, 237, 236, 235, 231, 230, 229, - 228, 227, 226, 225, 213, 212, 211, 210, 209, 208, - 207, 206, 205, 204, 203, 202, 201, 200, 197, 196, - - 189, 185, 184, 183, 182, 181, 180, 179, 176, 173, - 165, 164, 163, 162, 154, 153, 152, 151, 150, 149, - 148, 147, 146, 121, 120, 95, 88, 85, 370, 7, - 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, - 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, - 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, - 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, - 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, - 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, - 370, 370, 370, 370, 370 - - } ; - -static yyconst flex_int16_t yy_chk[696] = - { 0, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 3, 3, 3, 3, 82, - 14, 82, 375, 3, 13, 13, 13, 13, 14, 15, - 15, 15, 13, 16, 16, 16, 18, 18, 18, 18, - 22, 17, 17, 17, 17, 23, 24, 25, 22, 27, - - 29, 25, 83, 30, 30, 27, 24, 33, 34, 23, - 30, 33, 83, 368, 29, 33, 34, 29, 48, 48, - 34, 48, 69, 69, 69, 3, 3, 3, 3, 3, - 4, 4, 4, 4, 17, 13, 13, 13, 4, 35, - 36, 37, 38, 100, 36, 38, 39, 35, 40, 49, - 49, 36, 49, 100, 35, 37, 366, 38, 363, 36, - 39, 37, 40, 50, 50, 40, 50, 66, 70, 70, - 70, 70, 72, 72, 72, 66, 71, 71, 71, 71, - 73, 73, 73, 73, 75, 75, 75, 75, 362, 356, - 4, 4, 4, 4, 4, 5, 5, 77, 5, 84, - - 5, 354, 88, 77, 84, 84, 88, 5, 74, 74, - 74, 70, 5, 5, 74, 74, 74, 74, 86, 96, - 98, 99, 105, 353, 86, 99, 5, 98, 352, 122, - 122, 96, 122, 105, 123, 123, 96, 123, 124, 124, - 350, 124, 125, 125, 126, 125, 345, 126, 127, 127, - 214, 127, 344, 214, 5, 5, 5, 5, 5, 6, - 6, 343, 6, 342, 6, 134, 134, 134, 135, 135, - 135, 6, 136, 136, 136, 341, 6, 6, 137, 137, - 137, 138, 138, 138, 139, 139, 139, 140, 140, 140, - 6, 141, 141, 141, 142, 142, 142, 143, 143, 143, - - 155, 155, 155, 156, 156, 156, 158, 158, 158, 156, - 156, 156, 156, 157, 157, 157, 157, 340, 6, 6, - 6, 6, 6, 55, 55, 339, 55, 337, 55, 158, - 295, 295, 295, 336, 335, 55, 332, 55, 55, 328, - 55, 55, 55, 325, 55, 55, 55, 55, 55, 55, - 55, 55, 55, 55, 55, 324, 55, 55, 55, 55, - 55, 55, 55, 55, 55, 55, 55, 55, 159, 159, - 159, 159, 215, 215, 215, 159, 159, 159, 159, 216, - 216, 216, 217, 217, 217, 218, 218, 218, 323, 215, - 219, 219, 219, 220, 220, 220, 216, 321, 319, 217, - - 317, 316, 218, 221, 221, 221, 315, 219, 308, 307, - 220, 222, 222, 222, 223, 223, 223, 224, 224, 224, - 221, 233, 233, 304, 233, 233, 233, 303, 222, 302, - 301, 223, 300, 298, 224, 232, 232, 232, 232, 294, - 280, 278, 232, 232, 232, 232, 234, 234, 234, 276, - 275, 274, 234, 234, 234, 234, 297, 297, 297, 273, - 271, 269, 297, 297, 297, 297, 330, 330, 268, 330, - 330, 330, 266, 265, 262, 330, 330, 330, 330, 348, - 348, 348, 261, 259, 258, 348, 348, 348, 348, 255, - 253, 251, 248, 349, 349, 349, 247, 246, 297, 349, - - 349, 349, 349, 371, 371, 371, 371, 372, 372, 372, - 372, 373, 373, 373, 374, 244, 374, 374, 243, 242, - 241, 240, 239, 238, 237, 236, 235, 231, 230, 228, - 226, 213, 212, 211, 210, 208, 207, 206, 205, 204, - 202, 201, 200, 199, 198, 197, 195, 192, 191, 190, - 189, 188, 187, 186, 185, 184, 182, 181, 180, 179, - 178, 177, 176, 175, 174, 173, 172, 171, 170, 169, - 168, 167, 166, 165, 163, 162, 161, 154, 153, 152, - 151, 150, 148, 147, 120, 119, 118, 117, 116, 115, - 114, 113, 112, 111, 110, 109, 107, 106, 104, 102, - - 97, 95, 94, 93, 92, 91, 90, 89, 87, 85, - 81, 80, 79, 78, 65, 64, 63, 62, 61, 60, - 59, 58, 57, 46, 41, 32, 28, 26, 7, 370, - 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, - 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, - 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, - 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, - 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, - 370, 370, 370, 370, 370, 370, 370, 370, 370, 370, - 370, 370, 370, 370, 370 - - } ; - -/* Table of booleans, true if rule could match eol. */ -static yyconst flex_int32_t yy_rule_can_match_eol[127] = - { 0, -0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, - 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, }; - -static yy_state_type yy_last_accepting_state; -static char *yy_last_accepting_cpos; - -extern int yy_flex_debug; -int yy_flex_debug = 1; - -static yyconst flex_int16_t yy_rule_linenum[126] = - { 0, - 170, 171, 172, 173, 174, 175, 176, 178, 180, 182, - 184, 185, 186, 187, 188, 193, 194, 195, 196, 197, - 198, 199, 200, 202, 204, 206, 207, 208, 209, 211, - 212, 213, 215, 216, 217, 219, 220, 222, 224, 225, - 226, 228, 229, 231, 232, 233, 235, 238, 240, 241, - 243, 244, 245, 246, 247, 248, 249, 251, 252, 254, - 256, 257, 258, 259, 260, 261, 262, 263, 264, 267, - 269, 270, 271, 273, 274, 275, 276, 279, 280, 281, - 283, 284, 285, 286, 287, 288, 289, 291, 292, 293, - 294, 296, 298, 300, 302, 304, 306, 307, 309, 311, - - 312, 313, 314, 316, 318, 319, 320, 322, 324, 326, - 327, 328, 329, 330, 332, 334, 336, 337, 339, 341, - 343, 345, 347, 349, 350 - } ; - -/* The intent behind this definition is that it'll catch - * any uses of REJECT which flex missed. - */ -#define REJECT reject_used_but_not_detected -#define yymore() yymore_used_but_not_detected -#define YY_MORE_ADJ 0 -#define YY_RESTORE_YY_MORE_OFFSET -char *yytext; -#line 1 "shrink.l" -/*509:*/ -#line 3 "shrink.l" - #line 10175 "format.w" - -#include "basetypes.h" -#include "error.h" -#include "hformat.h" -#include "hput.h" - - /*423:*/ -#ifdef DEBUG -#define YYDEBUG 1 -extern int yydebug; -#else -#define YYDEBUG 0 -#endif - /*:423*/ -#include "hishrink-parser.h" - - /*22:*/ -#define SCAN_UDEC(S) yylval.u= strtoul(S,NULL,10) - /*:22*/ /*25:*/ -#define SCAN_HEX(S) yylval.u= strtoul(S,NULL,16) - /*:25*/ /*28:*/ -#define SCAN_DEC(S) yylval.i= strtol(S,NULL,10) - /*:28*/ /*31:*/ -#define MAX_STR (1<<10) -static char str_buffer[MAX_STR]; -static int str_length; -#define STR_START (str_length= 0) -#define STR_PUT(C) (str_buffer[str_length++]= (C)) -#define STR_ADD(C) STR_PUT(C);RNG("String length",str_length,0,MAX_STR-1) -#define STR_END str_buffer[str_length]= 0 -#define SCAN_STR yylval.s= str_buffer - /*:31*/ /*40:*/ -#define SCAN_UTF8_1(S) yylval.u= ((S)[0]&0x7F) - /*:40*/ /*42:*/ -#define SCAN_UTF8_2(S) yylval.u= (((S)[0]&0x1F)<<6)+((S)[1]&0x3F) - /*:42*/ /*44:*/ -#define SCAN_UTF8_3(S) yylval.u= (((S)[0]&0x0F)<<12)+(((S)[1]&0x3F)<<6)+((S)[2]&0x3F) - /*:44*/ /*46:*/ -#define SCAN_UTF8_4(S) yylval.u= (((S)[0]&0x03)<<18)+(((S)[1]&0x3F)<<12)+(((S)[2]&0x3F)<<6)+((S)[3]&0x3F) - /*:46*/ /*57:*/ -#define SCAN_DECFLOAT yylval.f= atof(yytext) - /*:57*/ /*60:*/ -#define SCAN_HEXFLOAT yylval.f= xtof(yytext) - /*:60*/ /*152:*/ -#define SCAN_REF(K) yylval.rf.k= K; yylval.rf.n= atoi(yytext+2) -static int scan_level= 0; -#define SCAN_START yy_push_state(INITIAL);if (1==scan_level++) hpos0= hpos; -#define SCAN_END if (scan_level--) yy_pop_state(); else QUIT("Too many '>' in line %d",yylineno) -#define SCAN_TXT_START BEGIN(TXT) -#define SCAN_TXT_END BEGIN(INITIAL) - /*:152*/ - /*61:*/ - -float64_t xtof(char*x) -{ - #line 1369 "format.w" - int sign,digits,exp; - uint64_t mantissa= 0; - DBG(DBGFLOAT,"converting %s:\n",x); - /*62:*/ - if(*x=='-'){sign= -1;x++;} - else if(*x=='+'){sign= +1;x++;} - else sign= +1; - DBG(DBGFLOAT,"\tsign=%d\n",sign); - /*:62*/ - x= x+2; - /*63:*/ - digits= 0; - while(*x=='0')x++; - while(*x!='.') - {mantissa= mantissa<<4; - if(*x<'A')mantissa= mantissa+*x-'0'; - else mantissa= mantissa+*x-'A'+10; - x++; - digits++; - } - x++; - exp= 0; - while(*x!=0&&*x!='x') - {mantissa= mantissa<<4; - exp= exp-4; - if(*x<'A')mantissa= mantissa+*x-'0'; - else mantissa= mantissa+*x-'A'+10; - x++; - digits++; - } - DBG(DBGFLOAT,"\tdigits=%d mantissa=0x%"PRIx64", exp=%d\n",digits,mantissa,exp); - /*:63*/ - /*64:*/ - if(mantissa==0)return 0.0; - {int s; - s= digits-DBL_M_BITS/4; - if(s>1) - mantissa= mantissa>>(4*(s-1)); - else if(s<1) - mantissa= mantissa<<(4*(1-s)); - exp= exp+4*(digits-1); - DBG(DBGFLOAT,"\tdigits=%d mantissa=0x%"PRIx64", exp=%d\n",digits,mantissa,exp); - while((mantissa>>DBL_M_BITS)>1){mantissa= mantissa>>1;exp++;} - DBG(DBGFLOAT,"\tdigits=%d mantissa=0x%"PRIx64", exp=%d\n",digits,mantissa,exp); - mantissa= mantissa&~((uint64_t)1< -/* %endif */ -/* %if-c++-only */ -/* %endif */ -#endif - -#ifndef YY_EXTRA_TYPE -#define YY_EXTRA_TYPE void * -#endif - -/* %if-c-only Reentrant structure and macros (non-C++). */ -/* %if-reentrant */ -/* %if-c-only */ - -static int yy_init_globals (void ); - -/* %endif */ -/* %if-reentrant */ -/* %endif */ -/* %endif End reentrant structures and macros. */ - -/* Accessor methods to globals. - These are made visible to non-reentrant scanners for convenience. */ - -int yylex_destroy (void ); - -int yyget_debug (void ); - -void yyset_debug (int debug_flag ); - -YY_EXTRA_TYPE yyget_extra (void ); - -void yyset_extra (YY_EXTRA_TYPE user_defined ); - -FILE *yyget_in (void ); - -void yyset_in (FILE * in_str ); - -FILE *yyget_out (void ); - -void yyset_out (FILE * out_str ); - -yy_size_t yyget_leng (void ); - -char *yyget_text (void ); - -int yyget_lineno (void ); - -void yyset_lineno (int line_number ); - -/* %if-bison-bridge */ -/* %endif */ - -/* Macros after this point can all be overridden by user definitions in - * section 1. - */ - -#ifndef YY_SKIP_YYWRAP -#ifdef __cplusplus -extern "C" int yywrap (void ); -#else -extern int yywrap (void ); -#endif -#endif - -/* %not-for-header */ - -/* %ok-for-header */ - -/* %endif */ - -#ifndef yytext_ptr -static void yy_flex_strncpy (char *,yyconst char *,int ); -#endif - -#ifdef YY_NEED_STRLEN -static int yy_flex_strlen (yyconst char * ); -#endif - -#ifndef YY_NO_INPUT -/* %if-c-only Standard (non-C++) definition */ -/* %not-for-header */ - -#ifdef __cplusplus -static int yyinput (void ); -#else -static int input (void ); -#endif -/* %ok-for-header */ - -/* %endif */ -#endif - -/* %if-c-only */ - - static int yy_start_stack_ptr = 0; - static int yy_start_stack_depth = 0; - static int *yy_start_stack = NULL; - - static void yy_push_state (int new_state ); - - static void yy_pop_state (void ); - -/* %endif */ - -/* Amount of stuff to slurp up with each read. */ -#ifndef YY_READ_BUF_SIZE -#define YY_READ_BUF_SIZE 8192 -#endif - -/* Copy whatever the last rule matched to the standard output. */ -#ifndef ECHO -/* %if-c-only Standard (non-C++) definition */ -/* This used to be an fputs(), but since the string might contain NUL's, - * we now use fwrite(). - */ -#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0) -/* %endif */ -/* %if-c++-only C++ definition */ -/* %endif */ -#endif - -/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, - * is returned in "result". - */ -#ifndef YY_INPUT -#define YY_INPUT(buf,result,max_size) \ -/* %% [5.0] fread()/read() definition of YY_INPUT goes here unless we're doing C++ \ */\ - if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ - { \ - int c = '*'; \ - size_t n; \ - for ( n = 0; n < max_size && \ - (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ - buf[n] = (char) c; \ - if ( c == '\n' ) \ - buf[n++] = (char) c; \ - if ( c == EOF && ferror( yyin ) ) \ - YY_FATAL_ERROR( "input in flex scanner failed" ); \ - result = n; \ - } \ - else \ - { \ - errno=0; \ - while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ - { \ - if( errno != EINTR) \ - { \ - YY_FATAL_ERROR( "input in flex scanner failed" ); \ - break; \ - } \ - errno=0; \ - clearerr(yyin); \ - } \ - }\ -\ -/* %if-c++-only C++ definition \ */\ -/* %endif */ - -#endif - -/* No semi-colon after return; correct usage is to write "yyterminate();" - - * we don't want an extra ';' after the "return" because that will cause - * some compilers to complain about unreachable statements. - */ -#ifndef yyterminate -#define yyterminate() return YY_NULL -#endif - -/* Number of entries by which start-condition stack grows. */ -#ifndef YY_START_STACK_INCR -#define YY_START_STACK_INCR 25 -#endif - -/* Report a fatal error. */ -#ifndef YY_FATAL_ERROR -/* %if-c-only */ -#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) -/* %endif */ -/* %if-c++-only */ -/* %endif */ -#endif - -/* %if-tables-serialization structures and prototypes */ -/* %not-for-header */ - -/* %ok-for-header */ - -/* %not-for-header */ - -/* %tables-yydmap generated elements */ -/* %endif */ -/* end tables serialization structures and prototypes */ - -/* %ok-for-header */ - -/* Default declaration of generated scanner - a define so the user can - * easily add parameters. - */ -#ifndef YY_DECL -#define YY_DECL_IS_OURS 1 -/* %if-c-only Standard (non-C++) definition */ - -extern int yylex (void); - -#define YY_DECL int yylex (void) -/* %endif */ -/* %if-c++-only C++ definition */ -/* %endif */ -#endif /* !YY_DECL */ - -/* Code executed at the beginning of each rule, after yytext and yyleng - * have been set up. - */ -#ifndef YY_USER_ACTION -#define YY_USER_ACTION -#endif - -/* Code executed at the end of each rule. */ -#ifndef YY_BREAK -#define YY_BREAK break; -#endif - -/* %% [6.0] YY_RULE_SETUP definition goes here */ -#define YY_RULE_SETUP \ - YY_USER_ACTION - -/* %not-for-header */ - -/** The main scanner function which does all the work. - */ -YY_DECL -{ - register yy_state_type yy_current_state; - register char *yy_cp, *yy_bp; - register int yy_act; - -/* %% [7.0] user's declarations go here */ -#line 167 "shrink.l" - - - /*3:*/ -#line 1263 "shrink.lex.c" - - if ( !(yy_init) ) - { - (yy_init) = 1; - -#ifdef YY_USER_INIT - YY_USER_INIT; -#endif - - if ( ! (yy_start) ) - (yy_start) = 1; /* first start state */ - - if ( ! yyin ) -/* %if-c-only */ - yyin = stdin; -/* %endif */ -/* %if-c++-only */ -/* %endif */ - - if ( ! yyout ) -/* %if-c-only */ - yyout = stdout; -/* %endif */ -/* %if-c++-only */ -/* %endif */ - - if ( ! YY_CURRENT_BUFFER ) { - yyensure_buffer_stack (); - YY_CURRENT_BUFFER_LVALUE = - yy_create_buffer(yyin,YY_BUF_SIZE ); - } - - yy_load_buffer_state( ); - } - - while ( 1 ) /* loops until end-of-file is reached */ - { -/* %% [8.0] yymore()-related code goes here */ - yy_cp = (yy_c_buf_p); - - /* Support of yytext. */ - *yy_cp = (yy_hold_char); - - /* yy_bp points to the position in yy_ch_buf of the start of - * the current run. - */ - yy_bp = yy_cp; - -/* %% [9.0] code to set up and find next match goes here */ - yy_current_state = (yy_start); -yy_match: - do - { - register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; - if ( yy_accept[yy_current_state] ) - { - (yy_last_accepting_state) = yy_current_state; - (yy_last_accepting_cpos) = yy_cp; - } - while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) - { - yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 371 ) - yy_c = yy_meta[(unsigned int) yy_c]; - } - yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; - ++yy_cp; - } - while ( yy_current_state != 370 ); - yy_cp = (yy_last_accepting_cpos); - yy_current_state = (yy_last_accepting_state); - -yy_find_action: -/* %% [10.0] code to find the action number goes here */ - yy_act = yy_accept[yy_current_state]; - - YY_DO_BEFORE_ACTION; - -/* %% [11.0] code for yylineno update goes here */ - - if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] ) - { - int yyl; - for ( yyl = 0; yyl < yyleng; ++yyl ) - if ( yytext[yyl] == '\n' ) - - yylineno++; -; - } - -do_action: /* This label is used only to access EOF actions. */ - -/* %% [12.0] debug code goes here */ - if ( yy_flex_debug ) - { - if ( yy_act == 0 ) - fprintf( stderr, "--scanner backing up\n" ); - else if ( yy_act < 126 ) - fprintf( stderr, "--accepting rule at line %ld (\"%s\")\n", - (long)yy_rule_linenum[yy_act], yytext ); - else if ( yy_act == 126 ) - fprintf( stderr, "--accepting default rule (\"%s\")\n", - yytext ); - else if ( yy_act == 127 ) - fprintf( stderr, "--(end of buffer or a NUL)\n" ); - else - fprintf( stderr, "--EOF (start condition %d)\n", YY_START ); - } - - switch ( yy_act ) - { /* beginning of action switch */ -/* %% [13.0] actions go here */ - case 0: /* must back up */ - /* undo the effects of YY_DO_BEFORE_ACTION */ - *yy_cp = (yy_hold_char); - yy_cp = (yy_last_accepting_cpos); - yy_current_state = (yy_last_accepting_state); - goto yy_find_action; - -case 1: -YY_RULE_SETUP -#line 170 "shrink.l" -SCAN_START;return START; - YY_BREAK -case 2: -YY_RULE_SETUP -#line 171 "shrink.l" -SCAN_END;return END; - YY_BREAK -case 3: -YY_RULE_SETUP -#line 172 "shrink.l" -return GLYPH; - YY_BREAK -case 4: -YY_RULE_SETUP -#line 173 "shrink.l" -SCAN_UDEC(yytext);return UNSIGNED; - YY_BREAK -case 5: -YY_RULE_SETUP -#line 174 "shrink.l" -SCAN_UDEC(yytext+1);return REFERENCE; - YY_BREAK -case 6: -/* rule 6 can match eol */ -YY_RULE_SETUP -#line 175 "shrink.l" -; - YY_BREAK -case 7: -/* rule 7 can match eol */ -YY_RULE_SETUP -#line 176 "shrink.l" -; - YY_BREAK -/*:3*/ /*24:*/ -case 8: -YY_RULE_SETUP -#line 178 "shrink.l" -SCAN_HEX(yytext+2);return UNSIGNED; - YY_BREAK -/*:24*/ /*27:*/ -case 9: -YY_RULE_SETUP -#line 180 "shrink.l" -SCAN_DEC(yytext);return SIGNED; - YY_BREAK -/*:27*/ /*34:*/ -case 10: -YY_RULE_SETUP -#line 182 "shrink.l" -STR_START;BEGIN(STR); - YY_BREAK - -case 11: -YY_RULE_SETUP -#line 184 "shrink.l" -STR_END;SCAN_STR;BEGIN(INITIAL);return STRING; - YY_BREAK -case 12: -YY_RULE_SETUP -#line 185 "shrink.l" -STR_ADD('\''); - YY_BREAK -case 13: -YY_RULE_SETUP -#line 186 "shrink.l" -STR_ADD(yytext[0]); - YY_BREAK -case 14: -YY_RULE_SETUP -#line 187 "shrink.l" -RNG("String character",yytext[0],0x20,0x7E); - YY_BREAK -case 15: -/* rule 15 can match eol */ -YY_RULE_SETUP -#line 188 "shrink.l" -QUIT("Unterminated String in line %d",yylineno); - YY_BREAK - -/*:34*/ /*48:*/ -case 16: -YY_RULE_SETUP -#line 193 "shrink.l" -STR_START;STR_PUT('\'');BEGIN(STR); - YY_BREAK -case 17: -YY_RULE_SETUP -#line 194 "shrink.l" -SCAN_UTF8_1(yytext+1);return CHARCODE; - YY_BREAK -case 18: -YY_RULE_SETUP -#line 195 "shrink.l" -STR_START;STR_PUT(yytext[1]);STR_PUT('\'');BEGIN(STR); - YY_BREAK -case 19: -YY_RULE_SETUP -#line 196 "shrink.l" -STR_START;STR_PUT('\'');STR_PUT('\'');BEGIN(STR); - YY_BREAK -case 20: -/* rule 20 can match eol */ -YY_RULE_SETUP -#line 197 "shrink.l" -SCAN_UTF8_1(yytext+1);return CHARCODE; - YY_BREAK -case 21: -YY_RULE_SETUP -#line 198 "shrink.l" -SCAN_UTF8_2(yytext+1);return CHARCODE; - YY_BREAK -case 22: -YY_RULE_SETUP -#line 199 "shrink.l" -SCAN_UTF8_3(yytext+1);return CHARCODE; - YY_BREAK -case 23: -YY_RULE_SETUP -#line 200 "shrink.l" -SCAN_UTF8_4(yytext+1);return CHARCODE; - YY_BREAK -/*:48*/ /*55:*/ -case 24: -YY_RULE_SETUP -#line 202 "shrink.l" -SCAN_DECFLOAT;return FPNUM; - YY_BREAK -/*:55*/ /*59:*/ -case 25: -YY_RULE_SETUP -#line 204 "shrink.l" -SCAN_HEXFLOAT;return FPNUM; - YY_BREAK -/*:59*/ /*80:*/ -case 26: -YY_RULE_SETUP -#line 206 "shrink.l" -return DIMEN; - YY_BREAK -case 27: -YY_RULE_SETUP -#line 207 "shrink.l" -return PT; - YY_BREAK -case 28: -YY_RULE_SETUP -#line 208 "shrink.l" -return MM; - YY_BREAK -case 29: -YY_RULE_SETUP -#line 209 "shrink.l" -return INCH; - YY_BREAK -/*:80*/ /*88:*/ -case 30: -YY_RULE_SETUP -#line 211 "shrink.l" -return XDIMEN; - YY_BREAK -case 31: -YY_RULE_SETUP -#line 212 "shrink.l" -return H; - YY_BREAK -case 32: -YY_RULE_SETUP -#line 213 "shrink.l" -return V; - YY_BREAK -/*:88*/ /*99:*/ -case 33: -YY_RULE_SETUP -#line 215 "shrink.l" -return FIL; - YY_BREAK -case 34: -YY_RULE_SETUP -#line 216 "shrink.l" -return FILL; - YY_BREAK -case 35: -YY_RULE_SETUP -#line 217 "shrink.l" -return FILLL; - YY_BREAK -/*:99*/ /*103:*/ -case 36: -YY_RULE_SETUP -#line 219 "shrink.l" -return PENALTY; - YY_BREAK -case 37: -YY_RULE_SETUP -#line 220 "shrink.l" -return INTEGER; - YY_BREAK -/*:103*/ /*109:*/ -case 38: -YY_RULE_SETUP -#line 222 "shrink.l" -return LANGUAGE; - YY_BREAK -/*:109*/ /*115:*/ -case 39: -YY_RULE_SETUP -#line 224 "shrink.l" -return RULE; - YY_BREAK -case 40: -YY_RULE_SETUP -#line 225 "shrink.l" -return RUNNING; - YY_BREAK -case 41: -YY_RULE_SETUP -#line 226 "shrink.l" -return RUNNING; - YY_BREAK -/*:115*/ /*124:*/ -case 42: -YY_RULE_SETUP -#line 228 "shrink.l" -return KERN; - YY_BREAK -case 43: -YY_RULE_SETUP -#line 229 "shrink.l" -return EXPLICIT; - YY_BREAK -/*:124*/ /*133:*/ -case 44: -YY_RULE_SETUP -#line 231 "shrink.l" -return GLUE; - YY_BREAK -case 45: -YY_RULE_SETUP -#line 232 "shrink.l" -return PLUS; - YY_BREAK -case 46: -YY_RULE_SETUP -#line 233 "shrink.l" -return MINUS; - YY_BREAK -/*:133*/ /*151:*/ -case 47: -YY_RULE_SETUP -#line 235 "shrink.l" -SCAN_TXT_START;return TXT_START; - YY_BREAK - -case 48: -YY_RULE_SETUP -#line 238 "shrink.l" -SCAN_TXT_END;return TXT_END; - YY_BREAK -case 49: -YY_RULE_SETUP -#line 240 "shrink.l" -SCAN_START;return START; - YY_BREAK -case 50: -YY_RULE_SETUP -#line 241 "shrink.l" -QUIT("> not allowed in text mode"); - YY_BREAK -case 51: -YY_RULE_SETUP -#line 243 "shrink.l" -yylval.u= '\\';return TXT_CC; - YY_BREAK -case 52: -YY_RULE_SETUP -#line 244 "shrink.l" -yylval.u= '"';return TXT_CC; - YY_BREAK -case 53: -YY_RULE_SETUP -#line 245 "shrink.l" -yylval.u= '<';return TXT_CC; - YY_BREAK -case 54: -YY_RULE_SETUP -#line 246 "shrink.l" -yylval.u= '>';return TXT_CC; - YY_BREAK -case 55: -YY_RULE_SETUP -#line 247 "shrink.l" -yylval.u= ' ';return TXT_CC; - YY_BREAK -case 56: -YY_RULE_SETUP -#line 248 "shrink.l" -yylval.u= '-';return TXT_CC; - YY_BREAK -case 57: -YY_RULE_SETUP -#line 249 "shrink.l" -return TXT_IGNORE; - YY_BREAK -case 58: -/* rule 58 can match eol */ -YY_RULE_SETUP -#line 251 "shrink.l" -return TXT_FONT_GLUE; - YY_BREAK -case 59: -/* rule 59 can match eol */ -YY_RULE_SETUP -#line 252 "shrink.l" -; - YY_BREAK -case 60: -YY_RULE_SETUP -#line 254 "shrink.l" -yylval.u= yytext[1]-'0';return TXT_FONT; - YY_BREAK -case 61: -YY_RULE_SETUP -#line 256 "shrink.l" -SCAN_REF(font_kind);return TXT_GLOBAL; - YY_BREAK -case 62: -YY_RULE_SETUP -#line 257 "shrink.l" -SCAN_REF(penalty_kind);return TXT_GLOBAL; - YY_BREAK -case 63: -YY_RULE_SETUP -#line 258 "shrink.l" -SCAN_REF(kern_kind);return TXT_GLOBAL; - YY_BREAK -case 64: -YY_RULE_SETUP -#line 259 "shrink.l" -SCAN_REF(ligature_kind);return TXT_GLOBAL; - YY_BREAK -case 65: -YY_RULE_SETUP -#line 260 "shrink.l" -SCAN_REF(disc_kind);return TXT_GLOBAL; - YY_BREAK -case 66: -YY_RULE_SETUP -#line 261 "shrink.l" -SCAN_REF(glue_kind);return TXT_GLOBAL; - YY_BREAK -case 67: -YY_RULE_SETUP -#line 262 "shrink.l" -SCAN_REF(language_kind);return TXT_GLOBAL; - YY_BREAK -case 68: -YY_RULE_SETUP -#line 263 "shrink.l" -SCAN_REF(rule_kind);return TXT_GLOBAL; - YY_BREAK -case 69: -YY_RULE_SETUP -#line 264 "shrink.l" -SCAN_REF(image_kind);return TXT_GLOBAL; - YY_BREAK -case 70: -YY_RULE_SETUP -#line 267 "shrink.l" -SCAN_UDEC(yytext+2);return TXT_CC; - YY_BREAK -case 71: -YY_RULE_SETUP -#line 269 "shrink.l" -yylval.u= yytext[1]-'a';return TXT_LOCAL; - YY_BREAK -case 72: -YY_RULE_SETUP -#line 270 "shrink.l" -return TXT_FONT_GLUE; - YY_BREAK -case 73: -YY_RULE_SETUP -#line 271 "shrink.l" -return TXT_FONT_HYPHEN; - YY_BREAK -case 74: -/* rule 74 can match eol */ -YY_RULE_SETUP -#line 273 "shrink.l" -SCAN_UTF8_1(yytext);return TXT_CC; - YY_BREAK -case 75: -YY_RULE_SETUP -#line 274 "shrink.l" -SCAN_UTF8_2(yytext);return TXT_CC; - YY_BREAK -case 76: -YY_RULE_SETUP -#line 275 "shrink.l" -SCAN_UTF8_3(yytext);return TXT_CC; - YY_BREAK -case 77: -YY_RULE_SETUP -#line 276 "shrink.l" -SCAN_UTF8_4(yytext);return TXT_CC; - YY_BREAK - -/*:151*/ /*162:*/ -case 78: -YY_RULE_SETUP -#line 279 "shrink.l" -return HBOX; - YY_BREAK -case 79: -YY_RULE_SETUP -#line 280 "shrink.l" -return VBOX; - YY_BREAK -case 80: -YY_RULE_SETUP -#line 281 "shrink.l" -return SHIFTED; - YY_BREAK -/*:162*/ /*170:*/ -case 81: -YY_RULE_SETUP -#line 283 "shrink.l" -return HPACK; - YY_BREAK -case 82: -YY_RULE_SETUP -#line 284 "shrink.l" -return HSET; - YY_BREAK -case 83: -YY_RULE_SETUP -#line 285 "shrink.l" -return VPACK; - YY_BREAK -case 84: -YY_RULE_SETUP -#line 286 "shrink.l" -return VSET; - YY_BREAK -case 85: -YY_RULE_SETUP -#line 287 "shrink.l" -return ADD; - YY_BREAK -case 86: -YY_RULE_SETUP -#line 288 "shrink.l" -return TO; - YY_BREAK -case 87: -YY_RULE_SETUP -#line 289 "shrink.l" -return DEPTH; - YY_BREAK -/*:170*/ /*175:*/ -case 88: -YY_RULE_SETUP -#line 291 "shrink.l" -return LEADERS; - YY_BREAK -case 89: -YY_RULE_SETUP -#line 292 "shrink.l" -return ALIGN; - YY_BREAK -case 90: -YY_RULE_SETUP -#line 293 "shrink.l" -return CENTER; - YY_BREAK -case 91: -YY_RULE_SETUP -#line 294 "shrink.l" -return EXPAND; - YY_BREAK -/*:175*/ /*182:*/ -case 92: -YY_RULE_SETUP -#line 296 "shrink.l" -return BASELINE; - YY_BREAK -/*:182*/ /*189:*/ -case 93: -YY_RULE_SETUP -#line 298 "shrink.l" -return LIGATURE; - YY_BREAK -/*:189*/ /*197:*/ -case 94: -YY_RULE_SETUP -#line 300 "shrink.l" -return DISC; - YY_BREAK -/*:197*/ /*205:*/ -case 95: -YY_RULE_SETUP -#line 302 "shrink.l" -return PAR; - YY_BREAK -/*:205*/ /*210:*/ -case 96: -YY_RULE_SETUP -#line 304 "shrink.l" -return MATH; - YY_BREAK -/*:210*/ /*215:*/ -case 97: -YY_RULE_SETUP -#line 306 "shrink.l" -return ON; - YY_BREAK -case 98: -YY_RULE_SETUP -#line 307 "shrink.l" -return OFF; - YY_BREAK -/*:215*/ /*219:*/ -case 99: -YY_RULE_SETUP -#line 309 "shrink.l" -return ADJUST; - YY_BREAK -/*:219*/ /*223:*/ -case 100: -YY_RULE_SETUP -#line 311 "shrink.l" -return TABLE; - YY_BREAK -case 101: -YY_RULE_SETUP -#line 312 "shrink.l" -return ITEM; - YY_BREAK -case 102: -YY_RULE_SETUP -#line 313 "shrink.l" -return ITEM; - YY_BREAK -case 103: -YY_RULE_SETUP -#line 314 "shrink.l" -return ITEM; - YY_BREAK -/*:223*/ /*230:*/ -case 104: -YY_RULE_SETUP -#line 316 "shrink.l" -return IMAGE; - YY_BREAK -/*:230*/ /*247:*/ -case 105: -YY_RULE_SETUP -#line 318 "shrink.l" -return LABEL; - YY_BREAK -case 106: -YY_RULE_SETUP -#line 319 "shrink.l" -return BOT; - YY_BREAK -case 107: -YY_RULE_SETUP -#line 320 "shrink.l" -return MID; - YY_BREAK -/*:247*/ /*261:*/ -case 108: -YY_RULE_SETUP -#line 322 "shrink.l" -return LINK; - YY_BREAK -/*:261*/ /*271:*/ -case 109: -YY_RULE_SETUP -#line 324 "shrink.l" -return OUTLINE; - YY_BREAK -/*:271*/ /*278:*/ -case 110: -YY_RULE_SETUP -#line 326 "shrink.l" -if(section_no==1)return STREAMDEF;else return STREAM; - YY_BREAK -case 111: -YY_RULE_SETUP -#line 327 "shrink.l" -return FIRST; - YY_BREAK -case 112: -YY_RULE_SETUP -#line 328 "shrink.l" -return LAST; - YY_BREAK -case 113: -YY_RULE_SETUP -#line 329 "shrink.l" -return TOP; - YY_BREAK -case 114: -YY_RULE_SETUP -#line 330 "shrink.l" -return NOREFERENCE; - YY_BREAK -/*:278*/ /*288:*/ -case 115: -YY_RULE_SETUP -#line 332 "shrink.l" -return PAGE; - YY_BREAK -/*:288*/ /*296:*/ -case 116: -YY_RULE_SETUP -#line 334 "shrink.l" -return RANGE; - YY_BREAK -/*:296*/ /*323:*/ -case 117: -YY_RULE_SETUP -#line 336 "shrink.l" -return DIRECTORY; - YY_BREAK -case 118: -YY_RULE_SETUP -#line 337 "shrink.l" -return SECTION; - YY_BREAK -/*:323*/ /*342:*/ -case 119: -YY_RULE_SETUP -#line 339 "shrink.l" -return DEFINITIONS; - YY_BREAK -/*:342*/ /*350:*/ -case 120: -YY_RULE_SETUP -#line 341 "shrink.l" -return MAX; - YY_BREAK -/*:350*/ /*365:*/ -case 121: -YY_RULE_SETUP -#line 343 "shrink.l" -return PARAM; - YY_BREAK -/*:365*/ /*374:*/ -case 122: -YY_RULE_SETUP -#line 345 "shrink.l" -return FONT; - YY_BREAK -/*:374*/ /*402:*/ -case 123: -YY_RULE_SETUP -#line 347 "shrink.l" -return CONTENT; - YY_BREAK -/*:402*/ -case 124: -YY_RULE_SETUP -#line 349 "shrink.l" -QUIT("Unexpected keyword '%s' in line %d",yytext,yylineno); - YY_BREAK -case 125: -YY_RULE_SETUP -#line 350 "shrink.l" -QUIT("Unexpected character '%c' (0x%02X) in line %d",yytext[0]>' '?yytext[0]:' ',yytext[0],yylineno); - YY_BREAK -case 126: -YY_RULE_SETUP -#line 352 "shrink.l" -ECHO; - YY_BREAK -#line 2064 "shrink.lex.c" -case YY_STATE_EOF(INITIAL): -case YY_STATE_EOF(STR): -case YY_STATE_EOF(TXT): - yyterminate(); - - case YY_END_OF_BUFFER: - { - /* Amount of text matched not including the EOB char. */ - int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; - - /* Undo the effects of YY_DO_BEFORE_ACTION. */ - *yy_cp = (yy_hold_char); - YY_RESTORE_YY_MORE_OFFSET - - if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) - { - /* We're scanning a new file or input source. It's - * possible that this happened because the user - * just pointed yyin at a new source and called - * yylex(). If so, then we have to assure - * consistency between YY_CURRENT_BUFFER and our - * globals. Here is the right place to do so, because - * this is the first action (other than possibly a - * back-up) that will match for the new input source. - */ - (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; - YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; - YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; - } - - /* Note that here we test for yy_c_buf_p "<=" to the position - * of the first EOB in the buffer, since yy_c_buf_p will - * already have been incremented past the NUL character - * (since all states make transitions on EOB to the - * end-of-buffer state). Contrast this with the test - * in input(). - */ - if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) - { /* This was really a NUL. */ - yy_state_type yy_next_state; - - (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; - - yy_current_state = yy_get_previous_state( ); - - /* Okay, we're now positioned to make the NUL - * transition. We couldn't have - * yy_get_previous_state() go ahead and do it - * for us because it doesn't know how to deal - * with the possibility of jamming (and we don't - * want to build jamming into it because then it - * will run more slowly). - */ - - yy_next_state = yy_try_NUL_trans( yy_current_state ); - - yy_bp = (yytext_ptr) + YY_MORE_ADJ; - - if ( yy_next_state ) - { - /* Consume the NUL. */ - yy_cp = ++(yy_c_buf_p); - yy_current_state = yy_next_state; - goto yy_match; - } - - else - { -/* %% [14.0] code to do back-up for compressed tables and set up yy_cp goes here */ - yy_cp = (yy_last_accepting_cpos); - yy_current_state = (yy_last_accepting_state); - goto yy_find_action; - } - } - - else switch ( yy_get_next_buffer( ) ) - { - case EOB_ACT_END_OF_FILE: - { - (yy_did_buffer_switch_on_eof) = 0; - - if ( yywrap( ) ) - { - /* Note: because we've taken care in - * yy_get_next_buffer() to have set up - * yytext, we can now set up - * yy_c_buf_p so that if some total - * hoser (like flex itself) wants to - * call the scanner after we return the - * YY_NULL, it'll still work - another - * YY_NULL will get returned. - */ - (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; - - yy_act = YY_STATE_EOF(YY_START); - goto do_action; - } - - else - { - if ( ! (yy_did_buffer_switch_on_eof) ) - YY_NEW_FILE; - } - break; - } - - case EOB_ACT_CONTINUE_SCAN: - (yy_c_buf_p) = - (yytext_ptr) + yy_amount_of_matched_text; - - yy_current_state = yy_get_previous_state( ); - - yy_cp = (yy_c_buf_p); - yy_bp = (yytext_ptr) + YY_MORE_ADJ; - goto yy_match; - - case EOB_ACT_LAST_MATCH: - (yy_c_buf_p) = - &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; - - yy_current_state = yy_get_previous_state( ); - - yy_cp = (yy_c_buf_p); - yy_bp = (yytext_ptr) + YY_MORE_ADJ; - goto yy_find_action; - } - break; - } - - default: - YY_FATAL_ERROR( - "fatal flex scanner internal error--no action found" ); - } /* end of action switch */ - } /* end of scanning one token */ -} /* end of yylex */ -/* %ok-for-header */ - -/* %if-c++-only */ -/* %not-for-header */ - -/* %ok-for-header */ - -/* %endif */ - -/* yy_get_next_buffer - try to read in a new buffer - * - * Returns a code representing an action: - * EOB_ACT_LAST_MATCH - - * EOB_ACT_CONTINUE_SCAN - continue scanning from current position - * EOB_ACT_END_OF_FILE - end of file - */ -/* %if-c-only */ -static int yy_get_next_buffer (void) -/* %endif */ -/* %if-c++-only */ -/* %endif */ -{ - register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; - register char *source = (yytext_ptr); - register int number_to_move, i; - int ret_val; - - if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) - YY_FATAL_ERROR( - "fatal flex scanner internal error--end of buffer missed" ); - - if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) - { /* Don't try to fill the buffer, so this is an EOF. */ - if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) - { - /* We matched a single character, the EOB, so - * treat this as a final EOF. - */ - return EOB_ACT_END_OF_FILE; - } - - else - { - /* We matched some text prior to the EOB, first - * process it. - */ - return EOB_ACT_LAST_MATCH; - } - } - - /* Try to read more data. */ - - /* First move last chars to start of buffer. */ - number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1; - - for ( i = 0; i < number_to_move; ++i ) - *(dest++) = *(source++); - - if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) - /* don't do the read, it's not guaranteed to return an EOF, - * just force an EOF - */ - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; - - else - { - yy_size_t num_to_read = - YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; - - while ( num_to_read <= 0 ) - { /* Not enough room in the buffer - grow it. */ - - /* just a shorter name for the current buffer */ - YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; - - int yy_c_buf_p_offset = - (int) ((yy_c_buf_p) - b->yy_ch_buf); - - if ( b->yy_is_our_buffer ) - { - yy_size_t new_size = b->yy_buf_size * 2; - - if ( new_size <= 0 ) - b->yy_buf_size += b->yy_buf_size / 8; - else - b->yy_buf_size *= 2; - - b->yy_ch_buf = (char *) - /* Include room in for 2 EOB chars. */ - yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ); - } - else - /* Can't grow it, we don't own it. */ - b->yy_ch_buf = 0; - - if ( ! b->yy_ch_buf ) - YY_FATAL_ERROR( - "fatal error - scanner input buffer overflow" ); - - (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; - - num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - - number_to_move - 1; - - } - - if ( num_to_read > YY_READ_BUF_SIZE ) - num_to_read = YY_READ_BUF_SIZE; - - /* Read in more data. */ - YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), - (yy_n_chars), num_to_read ); - - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); - } - - if ( (yy_n_chars) == 0 ) - { - if ( number_to_move == YY_MORE_ADJ ) - { - ret_val = EOB_ACT_END_OF_FILE; - yyrestart(yyin ); - } - - else - { - ret_val = EOB_ACT_LAST_MATCH; - YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = - YY_BUFFER_EOF_PENDING; - } - } - - else - ret_val = EOB_ACT_CONTINUE_SCAN; - - if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { - /* Extend the array by 50%, plus the number we really need. */ - yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ); - if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) - YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); - } - - (yy_n_chars) += number_to_move; - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; - - (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; - - return ret_val; -} - -/* yy_get_previous_state - get the state just before the EOB char was reached */ - -/* %if-c-only */ -/* %not-for-header */ - - static yy_state_type yy_get_previous_state (void) -/* %endif */ -/* %if-c++-only */ -/* %endif */ -{ - register yy_state_type yy_current_state; - register char *yy_cp; - -/* %% [15.0] code to get the start state into yy_current_state goes here */ - yy_current_state = (yy_start); - - for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) - { -/* %% [16.0] code to find the next state goes here */ - register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); - if ( yy_accept[yy_current_state] ) - { - (yy_last_accepting_state) = yy_current_state; - (yy_last_accepting_cpos) = yy_cp; - } - while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) - { - yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 371 ) - yy_c = yy_meta[(unsigned int) yy_c]; - } - yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; - } - - return yy_current_state; -} - -/* yy_try_NUL_trans - try to make a transition on the NUL character - * - * synopsis - * next_state = yy_try_NUL_trans( current_state ); - */ -/* %if-c-only */ - static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) -/* %endif */ -/* %if-c++-only */ -/* %endif */ -{ - register int yy_is_jam; - /* %% [17.0] code to find the next state, and perhaps do backing up, goes here */ - register char *yy_cp = (yy_c_buf_p); - - register YY_CHAR yy_c = 1; - if ( yy_accept[yy_current_state] ) - { - (yy_last_accepting_state) = yy_current_state; - (yy_last_accepting_cpos) = yy_cp; - } - while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) - { - yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 371 ) - yy_c = yy_meta[(unsigned int) yy_c]; - } - yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; - yy_is_jam = (yy_current_state == 370); - - return yy_is_jam ? 0 : yy_current_state; -} - -/* %if-c-only */ - -/* %endif */ - -/* %if-c-only */ -#ifndef YY_NO_INPUT -#ifdef __cplusplus - static int yyinput (void) -#else - static int input (void) -#endif - -/* %endif */ -/* %if-c++-only */ -/* %endif */ -{ - int c; - - *(yy_c_buf_p) = (yy_hold_char); - - if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) - { - /* yy_c_buf_p now points to the character we want to return. - * If this occurs *before* the EOB characters, then it's a - * valid NUL; if not, then we've hit the end of the buffer. - */ - if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) - /* This was really a NUL. */ - *(yy_c_buf_p) = '\0'; - - else - { /* need more input */ - yy_size_t offset = (yy_c_buf_p) - (yytext_ptr); - ++(yy_c_buf_p); - - switch ( yy_get_next_buffer( ) ) - { - case EOB_ACT_LAST_MATCH: - /* This happens because yy_g_n_b() - * sees that we've accumulated a - * token and flags that we need to - * try matching the token before - * proceeding. But for input(), - * there's no matching to consider. - * So convert the EOB_ACT_LAST_MATCH - * to EOB_ACT_END_OF_FILE. - */ - - /* Reset buffer status. */ - yyrestart(yyin ); - - /*FALLTHROUGH*/ - - case EOB_ACT_END_OF_FILE: - { - if ( yywrap( ) ) - return EOF; - - if ( ! (yy_did_buffer_switch_on_eof) ) - YY_NEW_FILE; -#ifdef __cplusplus - return yyinput(); -#else - return input(); -#endif - } - - case EOB_ACT_CONTINUE_SCAN: - (yy_c_buf_p) = (yytext_ptr) + offset; - break; - } - } - } - - c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ - *(yy_c_buf_p) = '\0'; /* preserve yytext */ - (yy_hold_char) = *++(yy_c_buf_p); - -/* %% [19.0] update BOL and yylineno */ - if ( c == '\n' ) - - yylineno++; -; - - return c; -} -/* %if-c-only */ -#endif /* ifndef YY_NO_INPUT */ -/* %endif */ - -/** Immediately switch to a different input stream. - * @param input_file A readable stream. - * - * @note This function does not reset the start condition to @c INITIAL . - */ -/* %if-c-only */ - void yyrestart (FILE * input_file ) -/* %endif */ -/* %if-c++-only */ -/* %endif */ -{ - - if ( ! YY_CURRENT_BUFFER ){ - yyensure_buffer_stack (); - YY_CURRENT_BUFFER_LVALUE = - yy_create_buffer(yyin,YY_BUF_SIZE ); - } - - yy_init_buffer(YY_CURRENT_BUFFER,input_file ); - yy_load_buffer_state( ); -} - -/** Switch to a different input buffer. - * @param new_buffer The new input buffer. - * - */ -/* %if-c-only */ - void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) -/* %endif */ -/* %if-c++-only */ -/* %endif */ -{ - - /* TODO. We should be able to replace this entire function body - * with - * yypop_buffer_state(); - * yypush_buffer_state(new_buffer); - */ - yyensure_buffer_stack (); - if ( YY_CURRENT_BUFFER == new_buffer ) - return; - - if ( YY_CURRENT_BUFFER ) - { - /* Flush out information for old buffer. */ - *(yy_c_buf_p) = (yy_hold_char); - YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); - } - - YY_CURRENT_BUFFER_LVALUE = new_buffer; - yy_load_buffer_state( ); - - /* We don't actually know whether we did this switch during - * EOF (yywrap()) processing, but the only time this flag - * is looked at is after yywrap() is called, so it's safe - * to go ahead and always set it. - */ - (yy_did_buffer_switch_on_eof) = 1; -} - -/* %if-c-only */ -static void yy_load_buffer_state (void) -/* %endif */ -/* %if-c++-only */ -/* %endif */ -{ - (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; - (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; - yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; - (yy_hold_char) = *(yy_c_buf_p); -} - -/** Allocate and initialize an input buffer state. - * @param file A readable stream. - * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. - * - * @return the allocated buffer state. - */ -/* %if-c-only */ - YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) -/* %endif */ -/* %if-c++-only */ -/* %endif */ -{ - YY_BUFFER_STATE b; - - b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); - if ( ! b ) - YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); - - b->yy_buf_size = size; - - /* yy_ch_buf has to be 2 characters longer than the size given because - * we need to put in 2 end-of-buffer characters. - */ - b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 ); - if ( ! b->yy_ch_buf ) - YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); - - b->yy_is_our_buffer = 1; - - yy_init_buffer(b,file ); - - return b; -} - -/** Destroy the buffer. - * @param b a buffer created with yy_create_buffer() - * - */ -/* %if-c-only */ - void yy_delete_buffer (YY_BUFFER_STATE b ) -/* %endif */ -/* %if-c++-only */ -/* %endif */ -{ - - if ( ! b ) - return; - - if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ - YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; - - if ( b->yy_is_our_buffer ) - yyfree((void *) b->yy_ch_buf ); - - yyfree((void *) b ); -} - -/* Initializes or reinitializes a buffer. - * This function is sometimes called more than once on the same buffer, - * such as during a yyrestart() or at EOF. - */ -/* %if-c-only */ - static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) -/* %endif */ -/* %if-c++-only */ -/* %endif */ - -{ - int oerrno = errno; - - yy_flush_buffer(b ); - - b->yy_input_file = file; - b->yy_fill_buffer = 1; - - /* If b is the current buffer, then yy_init_buffer was _probably_ - * called from yyrestart() or through yy_get_next_buffer. - * In that case, we don't want to reset the lineno or column. - */ - if (b != YY_CURRENT_BUFFER){ - b->yy_bs_lineno = 1; - b->yy_bs_column = 0; - } - -/* %if-c-only */ - - b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; - -/* %endif */ -/* %if-c++-only */ -/* %endif */ - errno = oerrno; -} - -/** Discard all buffered characters. On the next scan, YY_INPUT will be called. - * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. - * - */ -/* %if-c-only */ - void yy_flush_buffer (YY_BUFFER_STATE b ) -/* %endif */ -/* %if-c++-only */ -/* %endif */ -{ - if ( ! b ) - return; - - b->yy_n_chars = 0; - - /* We always need two end-of-buffer characters. The first causes - * a transition to the end-of-buffer state. The second causes - * a jam in that state. - */ - b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; - b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; - - b->yy_buf_pos = &b->yy_ch_buf[0]; - - b->yy_at_bol = 1; - b->yy_buffer_status = YY_BUFFER_NEW; - - if ( b == YY_CURRENT_BUFFER ) - yy_load_buffer_state( ); -} - -/* %if-c-or-c++ */ -/** Pushes the new state onto the stack. The new state becomes - * the current state. This function will allocate the stack - * if necessary. - * @param new_buffer The new state. - * - */ -/* %if-c-only */ -void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) -/* %endif */ -/* %if-c++-only */ -/* %endif */ -{ - if (new_buffer == NULL) - return; - - yyensure_buffer_stack(); - - /* This block is copied from yy_switch_to_buffer. */ - if ( YY_CURRENT_BUFFER ) - { - /* Flush out information for old buffer. */ - *(yy_c_buf_p) = (yy_hold_char); - YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); - } - - /* Only push if top exists. Otherwise, replace top. */ - if (YY_CURRENT_BUFFER) - (yy_buffer_stack_top)++; - YY_CURRENT_BUFFER_LVALUE = new_buffer; - - /* copied from yy_switch_to_buffer. */ - yy_load_buffer_state( ); - (yy_did_buffer_switch_on_eof) = 1; -} -/* %endif */ - -/* %if-c-or-c++ */ -/** Removes and deletes the top of the stack, if present. - * The next element becomes the new top. - * - */ -/* %if-c-only */ -void yypop_buffer_state (void) -/* %endif */ -/* %if-c++-only */ -/* %endif */ -{ - if (!YY_CURRENT_BUFFER) - return; - - yy_delete_buffer(YY_CURRENT_BUFFER ); - YY_CURRENT_BUFFER_LVALUE = NULL; - if ((yy_buffer_stack_top) > 0) - --(yy_buffer_stack_top); - - if (YY_CURRENT_BUFFER) { - yy_load_buffer_state( ); - (yy_did_buffer_switch_on_eof) = 1; - } -} -/* %endif */ - -/* %if-c-or-c++ */ -/* Allocates the stack if it does not exist. - * Guarantees space for at least one push. - */ -/* %if-c-only */ -static void yyensure_buffer_stack (void) -/* %endif */ -/* %if-c++-only */ -/* %endif */ -{ - yy_size_t num_to_alloc; - - if (!(yy_buffer_stack)) { - - /* First allocation is just for 2 elements, since we don't know if this - * scanner will even need a stack. We use 2 instead of 1 to avoid an - * immediate realloc on the next call. - */ - num_to_alloc = 1; - (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc - (num_to_alloc * sizeof(struct yy_buffer_state*) - ); - if ( ! (yy_buffer_stack) ) - YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); - - memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); - - (yy_buffer_stack_max) = num_to_alloc; - (yy_buffer_stack_top) = 0; - return; - } - - if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ - - /* Increase the buffer to prepare for a possible push. */ - int grow_size = 8 /* arbitrary grow size */; - - num_to_alloc = (yy_buffer_stack_max) + grow_size; - (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc - ((yy_buffer_stack), - num_to_alloc * sizeof(struct yy_buffer_state*) - ); - if ( ! (yy_buffer_stack) ) - YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); - - /* zero only the new slots.*/ - memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); - (yy_buffer_stack_max) = num_to_alloc; - } -} -/* %endif */ - -/* %if-c-only */ -/** Setup the input buffer state to scan directly from a user-specified character buffer. - * @param base the character buffer - * @param size the size in bytes of the character buffer - * - * @return the newly allocated buffer state object. - */ -YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) -{ - YY_BUFFER_STATE b; - - if ( size < 2 || - base[size-2] != YY_END_OF_BUFFER_CHAR || - base[size-1] != YY_END_OF_BUFFER_CHAR ) - /* They forgot to leave room for the EOB's. */ - return 0; - - b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); - if ( ! b ) - YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); - - b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ - b->yy_buf_pos = b->yy_ch_buf = base; - b->yy_is_our_buffer = 0; - b->yy_input_file = 0; - b->yy_n_chars = b->yy_buf_size; - b->yy_is_interactive = 0; - b->yy_at_bol = 1; - b->yy_fill_buffer = 0; - b->yy_buffer_status = YY_BUFFER_NEW; - - yy_switch_to_buffer(b ); - - return b; -} -/* %endif */ - -/* %if-c-only */ -/** Setup the input buffer state to scan a string. The next call to yylex() will - * scan from a @e copy of @a str. - * @param yystr a NUL-terminated string to scan - * - * @return the newly allocated buffer state object. - * @note If you want to scan bytes that may contain NUL values, then use - * yy_scan_bytes() instead. - */ -YY_BUFFER_STATE yy_scan_string (yyconst char * yystr ) -{ - - return yy_scan_bytes(yystr,strlen(yystr) ); -} -/* %endif */ - -/* %if-c-only */ -/** Setup the input buffer state to scan the given bytes. The next call to yylex() will - * scan from a @e copy of @a bytes. - * @param yybytes the byte buffer to scan - * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. - * - * @return the newly allocated buffer state object. - */ -YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len ) -{ - YY_BUFFER_STATE b; - char *buf; - yy_size_t n; - int i; - - /* Get memory for full buffer, including space for trailing EOB's. */ - n = _yybytes_len + 2; - buf = (char *) yyalloc(n ); - if ( ! buf ) - YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); - - for ( i = 0; i < _yybytes_len; ++i ) - buf[i] = yybytes[i]; - - buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; - - b = yy_scan_buffer(buf,n ); - if ( ! b ) - YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); - - /* It's okay to grow etc. this buffer, and we should throw it - * away when we're done. - */ - b->yy_is_our_buffer = 1; - - return b; -} -/* %endif */ - -/* %if-c-only */ - static void yy_push_state (int new_state ) -/* %endif */ -/* %if-c++-only */ -/* %endif */ -{ - if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) ) - { - yy_size_t new_size; - - (yy_start_stack_depth) += YY_START_STACK_INCR; - new_size = (yy_start_stack_depth) * sizeof( int ); - - if ( ! (yy_start_stack) ) - (yy_start_stack) = (int *) yyalloc(new_size ); - - else - (yy_start_stack) = (int *) yyrealloc((void *) (yy_start_stack),new_size ); - - if ( ! (yy_start_stack) ) - YY_FATAL_ERROR( "out of memory expanding start-condition stack" ); - } - - (yy_start_stack)[(yy_start_stack_ptr)++] = YY_START; - - BEGIN(new_state); -} - -/* %if-c-only */ - static void yy_pop_state (void) -/* %endif */ -/* %if-c++-only */ -/* %endif */ -{ - if ( --(yy_start_stack_ptr) < 0 ) - YY_FATAL_ERROR( "start-condition stack underflow" ); - - BEGIN((yy_start_stack)[(yy_start_stack_ptr)]); -} - -#ifndef YY_EXIT_FAILURE -#define YY_EXIT_FAILURE 2 -#endif - -/* %if-c-only */ -static void yy_fatal_error (yyconst char* msg ) -{ - (void) fprintf( stderr, "%s\n", msg ); - exit( YY_EXIT_FAILURE ); -} -/* %endif */ -/* %if-c++-only */ -/* %endif */ - -/* Redefine yyless() so it works in section 3 code. */ - -#undef yyless -#define yyless(n) \ - do \ - { \ - /* Undo effects of setting up yytext. */ \ - int yyless_macro_arg = (n); \ - YY_LESS_LINENO(yyless_macro_arg);\ - yytext[yyleng] = (yy_hold_char); \ - (yy_c_buf_p) = yytext + yyless_macro_arg; \ - (yy_hold_char) = *(yy_c_buf_p); \ - *(yy_c_buf_p) = '\0'; \ - yyleng = yyless_macro_arg; \ - } \ - while ( 0 ) - -/* Accessor methods (get/set functions) to struct members. */ - -/* %if-c-only */ -/* %if-reentrant */ -/* %endif */ - -/** Get the current line number. - * - */ -int yyget_lineno (void) -{ - - return yylineno; -} - -/** Get the input stream. - * - */ -FILE *yyget_in (void) -{ - return yyin; -} - -/** Get the output stream. - * - */ -FILE *yyget_out (void) -{ - return yyout; -} - -/** Get the length of the current token. - * - */ -yy_size_t yyget_leng (void) -{ - return yyleng; -} - -/** Get the current token. - * - */ - -char *yyget_text (void) -{ - return yytext; -} - -/* %if-reentrant */ -/* %endif */ - -/** Set the current line number. - * @param line_number - * - */ -void yyset_lineno (int line_number ) -{ - - yylineno = line_number; -} - -/** Set the input stream. This does not discard the current - * input buffer. - * @param in_str A readable stream. - * - * @see yy_switch_to_buffer - */ -void yyset_in (FILE * in_str ) -{ - yyin = in_str ; -} - -void yyset_out (FILE * out_str ) -{ - yyout = out_str ; -} - -int yyget_debug (void) -{ - return yy_flex_debug; -} - -void yyset_debug (int bdebug ) -{ - yy_flex_debug = bdebug ; -} - -/* %endif */ - -/* %if-reentrant */ -/* %if-bison-bridge */ -/* %endif */ -/* %endif if-c-only */ - -/* %if-c-only */ -static int yy_init_globals (void) -{ - /* Initialization is the same as for the non-reentrant scanner. - * This function is called from yylex_destroy(), so don't allocate here. - */ - - /* We do not touch yylineno unless the option is enabled. */ - yylineno = 1; - - (yy_buffer_stack) = 0; - (yy_buffer_stack_top) = 0; - (yy_buffer_stack_max) = 0; - (yy_c_buf_p) = (char *) 0; - (yy_init) = 0; - (yy_start) = 0; - - (yy_start_stack_ptr) = 0; - (yy_start_stack_depth) = 0; - (yy_start_stack) = NULL; - -/* Defined in main.c */ -#ifdef YY_STDINIT - yyin = stdin; - yyout = stdout; -#else - yyin = (FILE *) 0; - yyout = (FILE *) 0; -#endif - - /* For future reference: Set errno on error, since we are called by - * yylex_init() - */ - return 0; -} -/* %endif */ - -/* %if-c-only SNIP! this currently causes conflicts with the c++ scanner */ -/* yylex_destroy is for both reentrant and non-reentrant scanners. */ -int yylex_destroy (void) -{ - - /* Pop the buffer stack, destroying each element. */ - while(YY_CURRENT_BUFFER){ - yy_delete_buffer(YY_CURRENT_BUFFER ); - YY_CURRENT_BUFFER_LVALUE = NULL; - yypop_buffer_state(); - } - - /* Destroy the stack itself. */ - yyfree((yy_buffer_stack) ); - (yy_buffer_stack) = NULL; - - /* Destroy the start condition stack. */ - yyfree((yy_start_stack) ); - (yy_start_stack) = NULL; - - /* Reset the globals. This is important in a non-reentrant scanner so the next time - * yylex() is called, initialization will occur. */ - yy_init_globals( ); - -/* %if-reentrant */ -/* %endif */ - return 0; -} -/* %endif */ - -/* - * Internal utility routines. - */ - -#ifndef yytext_ptr -static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ) -{ - register int i; - for ( i = 0; i < n; ++i ) - s1[i] = s2[i]; -} -#endif - -#ifdef YY_NEED_STRLEN -static int yy_flex_strlen (yyconst char * s ) -{ - register int n; - for ( n = 0; s[n]; ++n ) - ; - - return n; -} -#endif - -void *yyalloc (yy_size_t size ) -{ - return (void *) malloc( size ); -} - -void *yyrealloc (void * ptr, yy_size_t size ) -{ - /* The cast to (char *) in the following accommodates both - * implementations that use char* generic pointers, and those - * that use void* generic pointers. It works with the latter - * because both ANSI C and C++ allow castless assignment from - * any pointer type to void*, and deal with argument conversions - * as though doing an assignment. - */ - return (void *) realloc( (char *) ptr, size ); -} - -void yyfree (void * ptr ) -{ - free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ -} - -/* %if-tables-serialization definitions */ -/* %define-yytables The name for this specific scanner's tables. */ -#define YYTABLES_NAME "yytables" -/* %endif */ - -/* %ok-for-header */ - -#line 352 "shrink.l" - - - /*:509*/ - diff --git a/Build/source/texk/web2c/hitexdir/hishrink-parser.c b/Build/source/texk/web2c/hitexdir/hishrink-parser.c deleted file mode 100644 index 913a5ab5684..00000000000 --- a/Build/source/texk/web2c/hitexdir/hishrink-parser.c +++ /dev/null @@ -1,3896 +0,0 @@ -/* A Bison parser, made by GNU Bison 3.8.2. */ - -/* Bison implementation for Yacc-like parsers in C - - Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation, - Inc. - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see . */ - -/* As a special exception, you may create a larger work that contains - part or all of the Bison parser skeleton and distribute that work - under terms of your choice, so long as that work isn't itself a - parser generator using the skeleton or a modified version thereof - as a parser skeleton. Alternatively, if you modify or redistribute - the parser skeleton itself, you may (at your option) remove this - special exception, which will cause the skeleton and the resulting - Bison output files to be licensed under the GNU General Public - License without this special exception. - - This special exception was added by the Free Software Foundation in - version 2.2 of Bison. */ - -/* C LALR(1) parser skeleton written by Richard Stallman, by - simplifying the original so-called "semantic" parser. */ - -/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, - especially those whose name start with YY_ or yy_. They are - private implementation details that can be changed or removed. */ - -/* All symbols defined below should begin with yy or YY, to avoid - infringing on user name space. This should be done even for local - variables, as they might otherwise be expanded by user macros. - There are some unavoidable exceptions within include files to - define necessary library symbols; they are noted "INFRINGES ON - USER NAME SPACE" below. */ - -/* Identify Bison output, and Bison version. */ -#define YYBISON 30802 - -/* Bison version string. */ -#define YYBISON_VERSION "3.8.2" - -/* Skeleton name. */ -#define YYSKELETON_NAME "yacc.c" - -/* Pure parsers. */ -#define YYPURE 0 - -/* Push parsers. */ -#define YYPUSH 0 - -/* Pull parsers. */ -#define YYPULL 1 - - - - -/* First part of user prologue. */ -#line 3 "../../../texk/web2c/hitexdir/hishrink-parser.y" - -#include "basetypes.h" -#include -#include -#include "error.h" -#include "hformat.h" -#include "hput.h" -extern char**hfont_name; - -/*356:*/ - -uint32_t definition_bits[0x100/32][32]= {{0}}; - -#define SET_DBIT(N,K) ((N)> 0xFF?1:(definition_bits[N/32][K]|= (1<<((N)&(32-1))))) -#define GET_DBIT(N,K) ((N)> 0xFF?1:((definition_bits[N/32][K]>>((N)&(32-1)))&1)) -#define DEF(D,K,N) (D).k= K; (D).n= (N);SET_DBIT((D).n,(D).k);\ - DBG(DBGDEF,"Defining %s %d\n",definition_name[(D).k],(D).n);\ - RNG("Definition",(D).n,max_fixed[(D).k]+1,max_ref[(D).k]); -#define REF(K,N) REF_RNG(K,N);if(!GET_DBIT(N,K)) \ - QUIT("Reference %d to %s before definition",(N),definition_name[K]) -/*:356*//*360:*/ - -#define DEF_REF(D,K,M,N) DEF(D,K,M);\ -if ((M)> max_default[K]) QUIT("Defining non default reference %d for %s",M,definition_name[K]); \ -if ((N)> max_fixed[K]) QUIT("Defining reference %d for %s by non fixed reference %d",M,definition_name[K],N); -/*:360*/ - - -extern void hset_entry(entry_t*e,uint16_t i,uint32_t size, -uint32_t xsize,char*file_name); - -/*423:*/ - -#ifdef DEBUG -#define YYDEBUG 1 -extern int yydebug; -#else -#define YYDEBUG 0 -#endif -/*:423*/ - -extern int yylex(void); - -/*352:*/ - -void hset_max(kind_t k,int n) -{DBG(DBGDEF,"Setting max %s to %d\n",definition_name[k],n); -RNG("Maximum",n,max_fixed[k]+1,MAX_REF(k)); -if(n> max_ref[k]) -max_ref[k]= n; -} -/*:352*//*363:*/ - -void check_param_def(ref_t*df) -{if(df->k!=int_kind&&df->k!=dimen_kind&&df->k!=glue_kind) -QUIT("Kind %s not allowed in parameter list",definition_name[df->k]); -if(df->n<=max_fixed[df->k]||max_default[df->k]n) -QUIT("Parameter %d for %s not allowed in parameter list",df->n,definition_name[df->k]); -} -/*:363*//*422:*/ - -extern int yylineno; -int yyerror(const char*msg) -{QUIT(" in line %d %s",yylineno,msg); -return 0; -} -/*:422*/ - - - -#line 142 "../../../texk/web2c/hitexdir/hishrink-parser.c" - -# ifndef YY_CAST -# ifdef __cplusplus -# define YY_CAST(Type, Val) static_cast (Val) -# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast (Val) -# else -# define YY_CAST(Type, Val) ((Type) (Val)) -# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val)) -# endif -# endif -# ifndef YY_NULLPTR -# if defined __cplusplus -# if 201103L <= __cplusplus -# define YY_NULLPTR nullptr -# else -# define YY_NULLPTR 0 -# endif -# else -# define YY_NULLPTR ((void*)0) -# endif -# endif - -/* Use api.header.include to #include this header - instead of duplicating it here. */ -#ifndef YY_YY__TEXK_WEB_C_HITEXDIR_HISHRINK_PARSER_H_INCLUDED -# define YY_YY__TEXK_WEB_C_HITEXDIR_HISHRINK_PARSER_H_INCLUDED -/* Debug traces. */ -#ifndef YYDEBUG -# define YYDEBUG 0 -#endif -#if YYDEBUG -extern int yydebug; -#endif - -/* Token kinds. */ -#ifndef YYTOKENTYPE -# define YYTOKENTYPE - enum yytokentype - { - YYEMPTY = -2, - YYEOF = 0, /* "end of file" */ - YYerror = 256, /* error */ - YYUNDEF = 257, /* "invalid token" */ - START = 258, /* "<" */ - END = 259, /* ">" */ - GLYPH = 260, /* "glyph" */ - UNSIGNED = 261, /* UNSIGNED */ - REFERENCE = 262, /* REFERENCE */ - SIGNED = 263, /* SIGNED */ - STRING = 264, /* STRING */ - CHARCODE = 265, /* CHARCODE */ - FPNUM = 266, /* FPNUM */ - DIMEN = 267, /* "dimen" */ - PT = 268, /* "pt" */ - MM = 269, /* "mm" */ - INCH = 270, /* "in" */ - XDIMEN = 271, /* "xdimen" */ - H = 272, /* "h" */ - V = 273, /* "v" */ - FIL = 274, /* "fil" */ - FILL = 275, /* "fill" */ - FILLL = 276, /* "filll" */ - PENALTY = 277, /* "penalty" */ - INTEGER = 278, /* "int" */ - LANGUAGE = 279, /* "language" */ - RULE = 280, /* "rule" */ - RUNNING = 281, /* "|" */ - KERN = 282, /* "kern" */ - EXPLICIT = 283, /* "!" */ - GLUE = 284, /* "glue" */ - PLUS = 285, /* "plus" */ - MINUS = 286, /* "minus" */ - TXT_START = 287, /* TXT_START */ - TXT_END = 288, /* TXT_END */ - TXT_IGNORE = 289, /* TXT_IGNORE */ - TXT_FONT_GLUE = 290, /* TXT_FONT_GLUE */ - TXT_FONT_HYPHEN = 291, /* TXT_FONT_HYPHEN */ - TXT_FONT = 292, /* TXT_FONT */ - TXT_LOCAL = 293, /* TXT_LOCAL */ - TXT_GLOBAL = 294, /* TXT_GLOBAL */ - TXT_CC = 295, /* TXT_CC */ - HBOX = 296, /* "hbox" */ - VBOX = 297, /* "vbox" */ - SHIFTED = 298, /* "shifted" */ - HPACK = 299, /* "hpack" */ - HSET = 300, /* "hset" */ - VPACK = 301, /* "vpack" */ - VSET = 302, /* "vset" */ - DEPTH = 303, /* "depth" */ - ADD = 304, /* "add" */ - TO = 305, /* "to" */ - LEADERS = 306, /* "leaders" */ - ALIGN = 307, /* "align" */ - CENTER = 308, /* "center" */ - EXPAND = 309, /* "expand" */ - BASELINE = 310, /* "baseline" */ - LIGATURE = 311, /* "ligature" */ - DISC = 312, /* "disc" */ - PAR = 313, /* "par" */ - MATH = 314, /* "math" */ - ON = 315, /* "on" */ - OFF = 316, /* "off" */ - ADJUST = 317, /* "adjust" */ - TABLE = 318, /* "table" */ - ITEM = 319, /* "item" */ - IMAGE = 320, /* "image" */ - LABEL = 321, /* "label" */ - BOT = 322, /* "bot" */ - MID = 323, /* "mid" */ - LINK = 324, /* "link" */ - OUTLINE = 325, /* "outline" */ - STREAM = 326, /* "stream" */ - STREAMDEF = 327, /* "stream (definition)" */ - FIRST = 328, /* "first" */ - LAST = 329, /* "last" */ - TOP = 330, /* "top" */ - NOREFERENCE = 331, /* "*" */ - PAGE = 332, /* "page" */ - RANGE = 333, /* "range" */ - DIRECTORY = 334, /* "directory" */ - SECTION = 335, /* "entry" */ - DEFINITIONS = 336, /* "definitions" */ - MAX = 337, /* "max" */ - PARAM = 338, /* "param" */ - FONT = 339, /* "font" */ - CONTENT = 340 /* "content" */ - }; - typedef enum yytokentype yytoken_kind_t; -#endif -/* Token kinds. */ -#define YYEMPTY -2 -#define YYEOF 0 -#define YYerror 256 -#define YYUNDEF 257 -#define START 258 -#define END 259 -#define GLYPH 260 -#define UNSIGNED 261 -#define REFERENCE 262 -#define SIGNED 263 -#define STRING 264 -#define CHARCODE 265 -#define FPNUM 266 -#define DIMEN 267 -#define PT 268 -#define MM 269 -#define INCH 270 -#define XDIMEN 271 -#define H 272 -#define V 273 -#define FIL 274 -#define FILL 275 -#define FILLL 276 -#define PENALTY 277 -#define INTEGER 278 -#define LANGUAGE 279 -#define RULE 280 -#define RUNNING 281 -#define KERN 282 -#define EXPLICIT 283 -#define GLUE 284 -#define PLUS 285 -#define MINUS 286 -#define TXT_START 287 -#define TXT_END 288 -#define TXT_IGNORE 289 -#define TXT_FONT_GLUE 290 -#define TXT_FONT_HYPHEN 291 -#define TXT_FONT 292 -#define TXT_LOCAL 293 -#define TXT_GLOBAL 294 -#define TXT_CC 295 -#define HBOX 296 -#define VBOX 297 -#define SHIFTED 298 -#define HPACK 299 -#define HSET 300 -#define VPACK 301 -#define VSET 302 -#define DEPTH 303 -#define ADD 304 -#define TO 305 -#define LEADERS 306 -#define ALIGN 307 -#define CENTER 308 -#define EXPAND 309 -#define BASELINE 310 -#define LIGATURE 311 -#define DISC 312 -#define PAR 313 -#define MATH 314 -#define ON 315 -#define OFF 316 -#define ADJUST 317 -#define TABLE 318 -#define ITEM 319 -#define IMAGE 320 -#define LABEL 321 -#define BOT 322 -#define MID 323 -#define LINK 324 -#define OUTLINE 325 -#define STREAM 326 -#define STREAMDEF 327 -#define FIRST 328 -#define LAST 329 -#define TOP 330 -#define NOREFERENCE 331 -#define PAGE 332 -#define RANGE 333 -#define DIRECTORY 334 -#define SECTION 335 -#define DEFINITIONS 336 -#define MAX 337 -#define PARAM 338 -#define FONT 339 -#define CONTENT 340 - -/* Value type. */ -#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED -union YYSTYPE -{ -#line 78 "../../../texk/web2c/hitexdir/hishrink-parser.y" -uint32_t u;int32_t i;char*s;float64_t f;glyph_t c; -dimen_t d;stretch_t st;xdimen_t xd;kern_t kt; -rule_t r;glue_t g;image_t x; -list_t l;box_t h;disc_t dc;lig_t lg; -ref_t rf;info_t info;order_t o;bool b; - -#line 372 "../../../texk/web2c/hitexdir/hishrink-parser.c" - -}; -typedef union YYSTYPE YYSTYPE; -# define YYSTYPE_IS_TRIVIAL 1 -# define YYSTYPE_IS_DECLARED 1 -#endif - - -extern YYSTYPE yylval; - - -int yyparse (void); - - -#endif /* !YY_YY__TEXK_WEB_C_HITEXDIR_HISHRINK_PARSER_H_INCLUDED */ -/* Symbol kind. */ -enum yysymbol_kind_t -{ - YYSYMBOL_YYEMPTY = -2, - YYSYMBOL_YYEOF = 0, /* "end of file" */ - YYSYMBOL_YYerror = 1, /* error */ - YYSYMBOL_YYUNDEF = 2, /* "invalid token" */ - YYSYMBOL_START = 3, /* "<" */ - YYSYMBOL_END = 4, /* ">" */ - YYSYMBOL_GLYPH = 5, /* "glyph" */ - YYSYMBOL_UNSIGNED = 6, /* UNSIGNED */ - YYSYMBOL_REFERENCE = 7, /* REFERENCE */ - YYSYMBOL_SIGNED = 8, /* SIGNED */ - YYSYMBOL_STRING = 9, /* STRING */ - YYSYMBOL_CHARCODE = 10, /* CHARCODE */ - YYSYMBOL_FPNUM = 11, /* FPNUM */ - YYSYMBOL_DIMEN = 12, /* "dimen" */ - YYSYMBOL_PT = 13, /* "pt" */ - YYSYMBOL_MM = 14, /* "mm" */ - YYSYMBOL_INCH = 15, /* "in" */ - YYSYMBOL_XDIMEN = 16, /* "xdimen" */ - YYSYMBOL_H = 17, /* "h" */ - YYSYMBOL_V = 18, /* "v" */ - YYSYMBOL_FIL = 19, /* "fil" */ - YYSYMBOL_FILL = 20, /* "fill" */ - YYSYMBOL_FILLL = 21, /* "filll" */ - YYSYMBOL_PENALTY = 22, /* "penalty" */ - YYSYMBOL_INTEGER = 23, /* "int" */ - YYSYMBOL_LANGUAGE = 24, /* "language" */ - YYSYMBOL_RULE = 25, /* "rule" */ - YYSYMBOL_RUNNING = 26, /* "|" */ - YYSYMBOL_KERN = 27, /* "kern" */ - YYSYMBOL_EXPLICIT = 28, /* "!" */ - YYSYMBOL_GLUE = 29, /* "glue" */ - YYSYMBOL_PLUS = 30, /* "plus" */ - YYSYMBOL_MINUS = 31, /* "minus" */ - YYSYMBOL_TXT_START = 32, /* TXT_START */ - YYSYMBOL_TXT_END = 33, /* TXT_END */ - YYSYMBOL_TXT_IGNORE = 34, /* TXT_IGNORE */ - YYSYMBOL_TXT_FONT_GLUE = 35, /* TXT_FONT_GLUE */ - YYSYMBOL_TXT_FONT_HYPHEN = 36, /* TXT_FONT_HYPHEN */ - YYSYMBOL_TXT_FONT = 37, /* TXT_FONT */ - YYSYMBOL_TXT_LOCAL = 38, /* TXT_LOCAL */ - YYSYMBOL_TXT_GLOBAL = 39, /* TXT_GLOBAL */ - YYSYMBOL_TXT_CC = 40, /* TXT_CC */ - YYSYMBOL_HBOX = 41, /* "hbox" */ - YYSYMBOL_VBOX = 42, /* "vbox" */ - YYSYMBOL_SHIFTED = 43, /* "shifted" */ - YYSYMBOL_HPACK = 44, /* "hpack" */ - YYSYMBOL_HSET = 45, /* "hset" */ - YYSYMBOL_VPACK = 46, /* "vpack" */ - YYSYMBOL_VSET = 47, /* "vset" */ - YYSYMBOL_DEPTH = 48, /* "depth" */ - YYSYMBOL_ADD = 49, /* "add" */ - YYSYMBOL_TO = 50, /* "to" */ - YYSYMBOL_LEADERS = 51, /* "leaders" */ - YYSYMBOL_ALIGN = 52, /* "align" */ - YYSYMBOL_CENTER = 53, /* "center" */ - YYSYMBOL_EXPAND = 54, /* "expand" */ - YYSYMBOL_BASELINE = 55, /* "baseline" */ - YYSYMBOL_LIGATURE = 56, /* "ligature" */ - YYSYMBOL_DISC = 57, /* "disc" */ - YYSYMBOL_PAR = 58, /* "par" */ - YYSYMBOL_MATH = 59, /* "math" */ - YYSYMBOL_ON = 60, /* "on" */ - YYSYMBOL_OFF = 61, /* "off" */ - YYSYMBOL_ADJUST = 62, /* "adjust" */ - YYSYMBOL_TABLE = 63, /* "table" */ - YYSYMBOL_ITEM = 64, /* "item" */ - YYSYMBOL_IMAGE = 65, /* "image" */ - YYSYMBOL_LABEL = 66, /* "label" */ - YYSYMBOL_BOT = 67, /* "bot" */ - YYSYMBOL_MID = 68, /* "mid" */ - YYSYMBOL_LINK = 69, /* "link" */ - YYSYMBOL_OUTLINE = 70, /* "outline" */ - YYSYMBOL_STREAM = 71, /* "stream" */ - YYSYMBOL_STREAMDEF = 72, /* "stream (definition)" */ - YYSYMBOL_FIRST = 73, /* "first" */ - YYSYMBOL_LAST = 74, /* "last" */ - YYSYMBOL_TOP = 75, /* "top" */ - YYSYMBOL_NOREFERENCE = 76, /* "*" */ - YYSYMBOL_PAGE = 77, /* "page" */ - YYSYMBOL_RANGE = 78, /* "range" */ - YYSYMBOL_DIRECTORY = 79, /* "directory" */ - YYSYMBOL_SECTION = 80, /* "entry" */ - YYSYMBOL_DEFINITIONS = 81, /* "definitions" */ - YYSYMBOL_MAX = 82, /* "max" */ - YYSYMBOL_PARAM = 83, /* "param" */ - YYSYMBOL_FONT = 84, /* "font" */ - YYSYMBOL_CONTENT = 85, /* "content" */ - YYSYMBOL_YYACCEPT = 86, /* $accept */ - YYSYMBOL_glyph = 87, /* glyph */ - YYSYMBOL_content_node = 88, /* content_node */ - YYSYMBOL_start = 89, /* start */ - YYSYMBOL_integer = 90, /* integer */ - YYSYMBOL_string = 91, /* string */ - YYSYMBOL_number = 92, /* number */ - YYSYMBOL_dimension = 93, /* dimension */ - YYSYMBOL_xdimen = 94, /* xdimen */ - YYSYMBOL_xdimen_node = 95, /* xdimen_node */ - YYSYMBOL_order = 96, /* order */ - YYSYMBOL_stretch = 97, /* stretch */ - YYSYMBOL_penalty = 98, /* penalty */ - YYSYMBOL_rule_dimension = 99, /* rule_dimension */ - YYSYMBOL_rule = 100, /* rule */ - YYSYMBOL_rule_node = 101, /* rule_node */ - YYSYMBOL_explicit = 102, /* explicit */ - YYSYMBOL_kern = 103, /* kern */ - YYSYMBOL_plus = 104, /* plus */ - YYSYMBOL_minus = 105, /* minus */ - YYSYMBOL_glue = 106, /* glue */ - YYSYMBOL_glue_node = 107, /* glue_node */ - YYSYMBOL_position = 108, /* position */ - YYSYMBOL_content_list = 109, /* content_list */ - YYSYMBOL_estimate = 110, /* estimate */ - YYSYMBOL_list = 111, /* list */ - YYSYMBOL_112_1 = 112, /* $@1 */ - YYSYMBOL_text = 113, /* text */ - YYSYMBOL_txt = 114, /* txt */ - YYSYMBOL_115_2 = 115, /* $@2 */ - YYSYMBOL_box_dimen = 116, /* box_dimen */ - YYSYMBOL_box_shift = 117, /* box_shift */ - YYSYMBOL_box_glue_set = 118, /* box_glue_set */ - YYSYMBOL_box = 119, /* box */ - YYSYMBOL_hbox_node = 120, /* hbox_node */ - YYSYMBOL_vbox_node = 121, /* vbox_node */ - YYSYMBOL_box_flex = 122, /* box_flex */ - YYSYMBOL_xbox = 123, /* xbox */ - YYSYMBOL_box_goal = 124, /* box_goal */ - YYSYMBOL_hpack = 125, /* hpack */ - YYSYMBOL_vpack = 126, /* vpack */ - YYSYMBOL_127_3 = 127, /* $@3 */ - YYSYMBOL_vxbox_node = 128, /* vxbox_node */ - YYSYMBOL_hxbox_node = 129, /* hxbox_node */ - YYSYMBOL_ltype = 130, /* ltype */ - YYSYMBOL_leaders = 131, /* leaders */ - YYSYMBOL_baseline = 132, /* baseline */ - YYSYMBOL_133_4 = 133, /* $@4 */ - YYSYMBOL_cc_list = 134, /* cc_list */ - YYSYMBOL_lig_cc = 135, /* lig_cc */ - YYSYMBOL_ref = 136, /* ref */ - YYSYMBOL_ligature = 137, /* ligature */ - YYSYMBOL_138_5 = 138, /* $@5 */ - YYSYMBOL_replace_count = 139, /* replace_count */ - YYSYMBOL_disc = 140, /* disc */ - YYSYMBOL_disc_node = 141, /* disc_node */ - YYSYMBOL_par_dimen = 142, /* par_dimen */ - YYSYMBOL_par = 143, /* par */ - YYSYMBOL_144_6 = 144, /* $@6 */ - YYSYMBOL_math = 145, /* math */ - YYSYMBOL_on_off = 146, /* on_off */ - YYSYMBOL_span_count = 147, /* span_count */ - YYSYMBOL_table = 148, /* table */ - YYSYMBOL_image_dimen = 149, /* image_dimen */ - YYSYMBOL_image = 150, /* image */ - YYSYMBOL_max_value = 151, /* max_value */ - YYSYMBOL_placement = 152, /* placement */ - YYSYMBOL_def_node = 153, /* def_node */ - YYSYMBOL_stream_link = 154, /* stream_link */ - YYSYMBOL_stream_split = 155, /* stream_split */ - YYSYMBOL_stream_info = 156, /* stream_info */ - YYSYMBOL_157_7 = 157, /* $@7 */ - YYSYMBOL_stream_type = 158, /* stream_type */ - YYSYMBOL_stream_def_node = 159, /* stream_def_node */ - YYSYMBOL_stream_ins_node = 160, /* stream_ins_node */ - YYSYMBOL_stream = 161, /* stream */ - YYSYMBOL_page_priority = 162, /* page_priority */ - YYSYMBOL_stream_def_list = 163, /* stream_def_list */ - YYSYMBOL_page = 164, /* page */ - YYSYMBOL_165_8 = 165, /* $@8 */ - YYSYMBOL_166_9 = 166, /* $@9 */ - YYSYMBOL_hint = 167, /* hint */ - YYSYMBOL_directory_section = 168, /* directory_section */ - YYSYMBOL_169_10 = 169, /* $@10 */ - YYSYMBOL_entry_list = 170, /* entry_list */ - YYSYMBOL_entry = 171, /* entry */ - YYSYMBOL_definition_section = 172, /* definition_section */ - YYSYMBOL_173_11 = 173, /* $@11 */ - YYSYMBOL_definition_list = 174, /* definition_list */ - YYSYMBOL_max_definitions = 175, /* max_definitions */ - YYSYMBOL_max_list = 176, /* max_list */ - YYSYMBOL_def_list = 177, /* def_list */ - YYSYMBOL_parameters = 178, /* parameters */ - YYSYMBOL_empty_param_list = 179, /* empty_param_list */ - YYSYMBOL_non_empty_param_list = 180, /* non_empty_param_list */ - YYSYMBOL_181_12 = 181, /* $@12 */ - YYSYMBOL_font = 182, /* font */ - YYSYMBOL_font_head = 183, /* font_head */ - YYSYMBOL_font_param_list = 184, /* font_param_list */ - YYSYMBOL_font_param = 185, /* font_param */ - YYSYMBOL_fref = 186, /* fref */ - YYSYMBOL_xdimen_ref = 187, /* xdimen_ref */ - YYSYMBOL_param_ref = 188, /* param_ref */ - YYSYMBOL_stream_ref = 189, /* stream_ref */ - YYSYMBOL_content_section = 190, /* content_section */ - YYSYMBOL_191_13 = 191 /* $@13 */ -}; -typedef enum yysymbol_kind_t yysymbol_kind_t; - - - - -#ifdef short -# undef short -#endif - -/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure - and (if available) are included - so that the code can choose integer types of a good width. */ - -#ifndef __PTRDIFF_MAX__ -# include /* INFRINGES ON USER NAME SPACE */ -# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ -# include /* INFRINGES ON USER NAME SPACE */ -# define YY_STDINT_H -# endif -#endif - -/* Narrow types that promote to a signed type and that can represent a - signed or unsigned integer of at least N bits. In tables they can - save space and decrease cache pressure. Promoting to a signed type - helps avoid bugs in integer arithmetic. */ - -#ifdef __INT_LEAST8_MAX__ -typedef __INT_LEAST8_TYPE__ yytype_int8; -#elif defined YY_STDINT_H -typedef int_least8_t yytype_int8; -#else -typedef signed char yytype_int8; -#endif - -#ifdef __INT_LEAST16_MAX__ -typedef __INT_LEAST16_TYPE__ yytype_int16; -#elif defined YY_STDINT_H -typedef int_least16_t yytype_int16; -#else -typedef short yytype_int16; -#endif - -/* Work around bug in HP-UX 11.23, which defines these macros - incorrectly for preprocessor constants. This workaround can likely - be removed in 2023, as HPE has promised support for HP-UX 11.23 - (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of - . */ -#ifdef __hpux -# undef UINT_LEAST8_MAX -# undef UINT_LEAST16_MAX -# define UINT_LEAST8_MAX 255 -# define UINT_LEAST16_MAX 65535 -#endif - -#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__ -typedef __UINT_LEAST8_TYPE__ yytype_uint8; -#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \ - && UINT_LEAST8_MAX <= INT_MAX) -typedef uint_least8_t yytype_uint8; -#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX -typedef unsigned char yytype_uint8; -#else -typedef short yytype_uint8; -#endif - -#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__ -typedef __UINT_LEAST16_TYPE__ yytype_uint16; -#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \ - && UINT_LEAST16_MAX <= INT_MAX) -typedef uint_least16_t yytype_uint16; -#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX -typedef unsigned short yytype_uint16; -#else -typedef int yytype_uint16; -#endif - -#ifndef YYPTRDIFF_T -# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__ -# define YYPTRDIFF_T __PTRDIFF_TYPE__ -# define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__ -# elif defined PTRDIFF_MAX -# ifndef ptrdiff_t -# include /* INFRINGES ON USER NAME SPACE */ -# endif -# define YYPTRDIFF_T ptrdiff_t -# define YYPTRDIFF_MAXIMUM PTRDIFF_MAX -# else -# define YYPTRDIFF_T long -# define YYPTRDIFF_MAXIMUM LONG_MAX -# endif -#endif - -#ifndef YYSIZE_T -# ifdef __SIZE_TYPE__ -# define YYSIZE_T __SIZE_TYPE__ -# elif defined size_t -# define YYSIZE_T size_t -# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ -# include /* INFRINGES ON USER NAME SPACE */ -# define YYSIZE_T size_t -# else -# define YYSIZE_T unsigned -# endif -#endif - -#define YYSIZE_MAXIMUM \ - YY_CAST (YYPTRDIFF_T, \ - (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \ - ? YYPTRDIFF_MAXIMUM \ - : YY_CAST (YYSIZE_T, -1))) - -#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) - - -/* Stored state numbers (used for stacks). */ -typedef yytype_int16 yy_state_t; - -/* State numbers in computations. */ -typedef int yy_state_fast_t; - -#ifndef YY_ -# if defined YYENABLE_NLS && YYENABLE_NLS -# if ENABLE_NLS -# include /* INFRINGES ON USER NAME SPACE */ -# define YY_(Msgid) dgettext ("bison-runtime", Msgid) -# endif -# endif -# ifndef YY_ -# define YY_(Msgid) Msgid -# endif -#endif - - -#ifndef YY_ATTRIBUTE_PURE -# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__) -# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__)) -# else -# define YY_ATTRIBUTE_PURE -# endif -#endif - -#ifndef YY_ATTRIBUTE_UNUSED -# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__) -# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__)) -# else -# define YY_ATTRIBUTE_UNUSED -# endif -#endif - -/* Suppress unused-variable warnings by "using" E. */ -#if ! defined lint || defined __GNUC__ -# define YY_USE(E) ((void) (E)) -#else -# define YY_USE(E) /* empty */ -#endif - -/* Suppress an incorrect diagnostic about yylval being uninitialized. */ -#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__ -# if __GNUC__ * 100 + __GNUC_MINOR__ < 407 -# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ - _Pragma ("GCC diagnostic push") \ - _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") -# else -# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ - _Pragma ("GCC diagnostic push") \ - _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \ - _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") -# endif -# define YY_IGNORE_MAYBE_UNINITIALIZED_END \ - _Pragma ("GCC diagnostic pop") -#else -# define YY_INITIAL_VALUE(Value) Value -#endif -#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN -# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN -# define YY_IGNORE_MAYBE_UNINITIALIZED_END -#endif -#ifndef YY_INITIAL_VALUE -# define YY_INITIAL_VALUE(Value) /* Nothing. */ -#endif - -#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__ -# define YY_IGNORE_USELESS_CAST_BEGIN \ - _Pragma ("GCC diagnostic push") \ - _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"") -# define YY_IGNORE_USELESS_CAST_END \ - _Pragma ("GCC diagnostic pop") -#endif -#ifndef YY_IGNORE_USELESS_CAST_BEGIN -# define YY_IGNORE_USELESS_CAST_BEGIN -# define YY_IGNORE_USELESS_CAST_END -#endif - - -#define YY_ASSERT(E) ((void) (0 && (E))) - -#if 1 - -/* The parser invokes alloca or malloc; define the necessary symbols. */ - -# ifdef YYSTACK_USE_ALLOCA -# if YYSTACK_USE_ALLOCA -# ifdef __GNUC__ -# define YYSTACK_ALLOC __builtin_alloca -# elif defined __BUILTIN_VA_ARG_INCR -# include /* INFRINGES ON USER NAME SPACE */ -# elif defined _AIX -# define YYSTACK_ALLOC __alloca -# elif defined _MSC_VER -# include /* INFRINGES ON USER NAME SPACE */ -# define alloca _alloca -# else -# define YYSTACK_ALLOC alloca -# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS -# include /* INFRINGES ON USER NAME SPACE */ - /* Use EXIT_SUCCESS as a witness for stdlib.h. */ -# ifndef EXIT_SUCCESS -# define EXIT_SUCCESS 0 -# endif -# endif -# endif -# endif -# endif - -# ifdef YYSTACK_ALLOC - /* Pacify GCC's 'empty if-body' warning. */ -# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) -# ifndef YYSTACK_ALLOC_MAXIMUM - /* The OS might guarantee only one guard page at the bottom of the stack, - and a page size can be as small as 4096 bytes. So we cannot safely - invoke alloca (N) if N exceeds 4096. Use a slightly smaller number - to allow for a few compiler-allocated temporary stack slots. */ -# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ -# endif -# else -# define YYSTACK_ALLOC YYMALLOC -# define YYSTACK_FREE YYFREE -# ifndef YYSTACK_ALLOC_MAXIMUM -# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM -# endif -# if (defined __cplusplus && ! defined EXIT_SUCCESS \ - && ! ((defined YYMALLOC || defined malloc) \ - && (defined YYFREE || defined free))) -# include /* INFRINGES ON USER NAME SPACE */ -# ifndef EXIT_SUCCESS -# define EXIT_SUCCESS 0 -# endif -# endif -# ifndef YYMALLOC -# define YYMALLOC malloc -# if ! defined malloc && ! defined EXIT_SUCCESS -void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ -# endif -# endif -# ifndef YYFREE -# define YYFREE free -# if ! defined free && ! defined EXIT_SUCCESS -void free (void *); /* INFRINGES ON USER NAME SPACE */ -# endif -# endif -# endif -#endif /* 1 */ - -#if (! defined yyoverflow \ - && (! defined __cplusplus \ - || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) - -/* A type that is properly aligned for any stack member. */ -union yyalloc -{ - yy_state_t yyss_alloc; - YYSTYPE yyvs_alloc; -}; - -/* The size of the maximum gap between one aligned stack and the next. */ -# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) - -/* The size of an array large to enough to hold all stacks, each with - N elements. */ -# define YYSTACK_BYTES(N) \ - ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \ - + YYSTACK_GAP_MAXIMUM) - -# define YYCOPY_NEEDED 1 - -/* Relocate STACK from its old location to the new one. The - local variables YYSIZE and YYSTACKSIZE give the old and new number of - elements in the stack, and YYPTR gives the new location of the - stack. Advance YYPTR to a properly aligned location for the next - stack. */ -# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ - do \ - { \ - YYPTRDIFF_T yynewbytes; \ - YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ - Stack = &yyptr->Stack_alloc; \ - yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ - yyptr += yynewbytes / YYSIZEOF (*yyptr); \ - } \ - while (0) - -#endif - -#if defined YYCOPY_NEEDED && YYCOPY_NEEDED -/* Copy COUNT objects from SRC to DST. The source and destination do - not overlap. */ -# ifndef YYCOPY -# if defined __GNUC__ && 1 < __GNUC__ -# define YYCOPY(Dst, Src, Count) \ - __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) -# else -# define YYCOPY(Dst, Src, Count) \ - do \ - { \ - YYPTRDIFF_T yyi; \ - for (yyi = 0; yyi < (Count); yyi++) \ - (Dst)[yyi] = (Src)[yyi]; \ - } \ - while (0) -# endif -# endif -#endif /* !YYCOPY_NEEDED */ - -/* YYFINAL -- State number of the termination state. */ -#define YYFINAL 5 -/* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 657 - -/* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 86 -/* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 106 -/* YYNRULES -- Number of rules. */ -#define YYNRULES 266 -/* YYNSTATES -- Number of states. */ -#define YYNSTATES 566 - -/* YYMAXUTOK -- Last valid token kind. */ -#define YYMAXUTOK 340 - - -/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM - as returned by yylex, with out-of-bounds checking. */ -#define YYTRANSLATE(YYX) \ - (0 <= (YYX) && (YYX) <= YYMAXUTOK \ - ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ - : YYSYMBOL_YYUNDEF) - -/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM - as returned by yylex. */ -static const yytype_int8 yytranslate[] = -{ - 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, - 85 -}; - -#if YYDEBUG -/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ -static const yytype_int16 yyrline[] = -{ - 0, 306, 306, 307, 308, 311, 311, 314, 317, 317, - 322, 322, 322, 325, 326, 327, 330, 331, 332, 333, - 337, 341, 341, 341, 341, 343, 346, 347, 350, 350, - 351, 355, 356, 359, 359, 360, 361, 364, 364, 365, - 365, 366, 367, 369, 374, 375, 376, 377, 378, 379, - 385, 384, 389, 389, 391, 392, 393, 394, 395, 396, - 397, 398, 398, 402, 404, 405, 407, 408, 409, 412, - 414, 415, 416, 416, 419, 420, 421, 423, 424, 425, - 426, 428, 429, 429, 431, 432, 435, 436, 438, 438, - 441, 441, 441, 441, 442, 443, 444, 445, 448, 448, - 453, 457, 457, 458, 459, 460, 461, 461, 464, 467, - 468, 470, 472, 473, 476, 479, 482, 483, 484, 485, - 486, 486, 487, 488, 490, 493, 494, 495, 496, 497, - 498, 499, 500, 501, 503, 506, 506, 507, 510, 513, - 514, 515, 516, 518, 519, 521, 524, 524, 525, 526, - 529, 535, 535, 535, 535, 536, 540, 544, 553, 553, - 554, 555, 555, 557, 557, 557, 557, 559, 563, 566, - 566, 569, 570, 571, 572, 576, 577, 579, 579, 581, - 581, 581, 587, 588, 591, 594, 594, 595, 595, 596, - 600, 600, 603, 603, 606, 635, 635, 637, 638, 639, - 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, - 650, 651, 652, 653, 658, 659, 660, 661, 662, 663, - 664, 665, 666, 667, 668, 669, 670, 671, 675, 676, - 677, 680, 681, 682, 685, 686, 686, 691, 693, 696, - 696, 699, 700, 701, 702, 703, 704, 705, 706, 708, - 711, 712, 713, 717, 718, 720, 722, 723, 724, 725, - 726, 727, 728, 729, 731, 737, 737 -}; -#endif - -/** Accessing symbol of state STATE. */ -#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) - -#if 1 -/* The user-facing name of the symbol whose (internal) number is - YYSYMBOL. No bounds checking. */ -static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED; - -/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. - First, the terminals, then, starting at YYNTOKENS, nonterminals. */ -static const char *const yytname[] = -{ - "\"end of file\"", "error", "\"invalid token\"", "\"<\"", "\">\"", - "\"glyph\"", "UNSIGNED", "REFERENCE", "SIGNED", "STRING", "CHARCODE", - "FPNUM", "\"dimen\"", "\"pt\"", "\"mm\"", "\"in\"", "\"xdimen\"", - "\"h\"", "\"v\"", "\"fil\"", "\"fill\"", "\"filll\"", "\"penalty\"", - "\"int\"", "\"language\"", "\"rule\"", "\"|\"", "\"kern\"", "\"!\"", - "\"glue\"", "\"plus\"", "\"minus\"", "TXT_START", "TXT_END", - "TXT_IGNORE", "TXT_FONT_GLUE", "TXT_FONT_HYPHEN", "TXT_FONT", - "TXT_LOCAL", "TXT_GLOBAL", "TXT_CC", "\"hbox\"", "\"vbox\"", - "\"shifted\"", "\"hpack\"", "\"hset\"", "\"vpack\"", "\"vset\"", - "\"depth\"", "\"add\"", "\"to\"", "\"leaders\"", "\"align\"", - "\"center\"", "\"expand\"", "\"baseline\"", "\"ligature\"", "\"disc\"", - "\"par\"", "\"math\"", "\"on\"", "\"off\"", "\"adjust\"", "\"table\"", - "\"item\"", "\"image\"", "\"label\"", "\"bot\"", "\"mid\"", "\"link\"", - "\"outline\"", "\"stream\"", "\"stream (definition)\"", "\"first\"", - "\"last\"", "\"top\"", "\"*\"", "\"page\"", "\"range\"", "\"directory\"", - "\"entry\"", "\"definitions\"", "\"max\"", "\"param\"", "\"font\"", - "\"content\"", "$accept", "glyph", "content_node", "start", "integer", - "string", "number", "dimension", "xdimen", "xdimen_node", "order", - "stretch", "penalty", "rule_dimension", "rule", "rule_node", "explicit", - "kern", "plus", "minus", "glue", "glue_node", "position", "content_list", - "estimate", "list", "$@1", "text", "txt", "$@2", "box_dimen", - "box_shift", "box_glue_set", "box", "hbox_node", "vbox_node", "box_flex", - "xbox", "box_goal", "hpack", "vpack", "$@3", "vxbox_node", "hxbox_node", - "ltype", "leaders", "baseline", "$@4", "cc_list", "lig_cc", "ref", - "ligature", "$@5", "replace_count", "disc", "disc_node", "par_dimen", - "par", "$@6", "math", "on_off", "span_count", "table", "image_dimen", - "image", "max_value", "placement", "def_node", "stream_link", - "stream_split", "stream_info", "$@7", "stream_type", "stream_def_node", - "stream_ins_node", "stream", "page_priority", "stream_def_list", "page", - "$@8", "$@9", "hint", "directory_section", "$@10", "entry_list", "entry", - "definition_section", "$@11", "definition_list", "max_definitions", - "max_list", "def_list", "parameters", "empty_param_list", - "non_empty_param_list", "$@12", "font", "font_head", "font_param_list", - "font_param", "fref", "xdimen_ref", "param_ref", "stream_ref", - "content_section", "$@13", YY_NULLPTR -}; - -static const char * -yysymbol_name (yysymbol_kind_t yysymbol) -{ - return yytname[yysymbol]; -} -#endif - -#define YYPACT_NINF (-326) - -#define yypact_value_is_default(Yyn) \ - ((Yyn) == YYPACT_NINF) - -#define YYTABLE_NINF (-1) - -#define yytable_value_is_error(Yyn) \ - 0 - -/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing - STATE-NUM. */ -static const yytype_int16 yypact[] = -{ - 48, -4, 110, 113, 107, -326, 52, 137, -326, -326, - 74, -326, -326, 153, -326, 211, 85, -326, -326, 94, - -326, -326, -326, 275, -326, 278, 190, 280, 159, -326, - 313, -326, 31, -326, -326, 585, -326, -326, -326, -326, - -326, -326, -326, -326, 223, 467, -326, 203, 234, 234, - 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, - 234, 234, 240, 248, 116, 219, 253, 140, 210, 229, - 182, 182, 220, 182, 220, 182, 121, 229, 234, 71, - 229, 41, 66, 271, 79, 301, 261, 234, 234, -326, - -326, 268, 270, 279, 284, 286, 288, 294, 297, 315, - 325, 326, 327, 328, 333, 334, 335, 337, 338, 339, - 343, 242, -326, 229, 182, 219, 223, 152, 229, 345, - 182, 234, 210, 348, 223, 350, 223, 82, 251, 323, - 342, 353, -326, -326, -326, 355, 357, 358, -326, -326, - -326, -326, 231, -326, 152, 359, 361, -326, 165, 362, - 182, 341, 372, 373, 182, 220, 375, 377, 182, 264, - 379, 220, 380, 305, 384, 385, -326, 363, 200, 387, - 389, -326, 390, 391, 395, 396, 398, 397, 66, 401, - 234, -326, -326, 404, 234, -326, -326, -326, -326, 405, - -326, 66, 66, -326, 350, 406, 264, 264, 407, -326, - 408, 530, 409, 399, 182, 410, 411, 255, -326, 234, - 80, -326, -326, -326, -326, -326, -326, -326, -326, -326, - -326, -326, -326, -326, -326, -326, -326, -326, -326, -326, - -326, -326, 413, 414, 416, 417, 418, 419, 421, 422, - 423, 427, 429, -326, 430, 432, 433, -326, 435, -326, - -326, 436, 182, 437, 345, -326, -326, -326, 438, 440, - 441, -326, -326, -326, -326, -326, -326, -326, -326, -326, - 152, -326, -326, 234, -326, 442, -326, 302, 182, 420, - -326, -326, 182, 293, -326, -326, -326, 121, 121, 66, - -326, 341, -326, 400, -326, -326, 229, -326, -326, -326, - 345, -326, -326, 345, -326, -326, -326, 176, -326, -326, - -326, 66, -326, -326, 66, -326, 66, 66, -326, 38, - 345, 66, 66, 53, 345, 66, -326, -326, -326, 66, - 66, -326, -326, -326, 445, 182, 341, -326, -326, 446, - 448, 66, 66, -326, -326, -326, -326, 439, 450, -326, - 66, 66, -326, -326, -326, -326, -326, -326, -326, -326, - -326, -326, -326, -326, -326, -326, 452, -326, -326, 451, - -326, 453, -326, 345, 345, -326, -326, -326, -326, 456, - -326, 182, -326, 164, -326, 182, -326, -326, 182, 182, - 66, -326, -326, -326, -326, -326, 420, 121, 182, 458, - 460, 49, -326, -326, -326, 345, -326, -326, 434, -326, - 66, 35, -326, 66, -326, 66, -326, -326, 424, -326, - -326, 345, 66, -326, -326, -326, 324, 66, 66, -326, - -326, 420, -326, -326, -326, 66, -326, 182, -326, 345, - 463, -326, 345, -326, 462, 412, -326, 105, -326, -326, - 454, -326, -326, -326, -326, -326, -326, -326, -326, -326, - -326, 66, 66, -326, -326, -326, 152, -326, -326, -326, - -326, -326, 350, -326, -326, -326, 184, -326, -326, -326, - -326, -326, 466, 39, 345, -326, 182, -326, 210, 234, - 234, 234, 234, 234, 234, 234, 234, -326, -326, -326, - 264, 72, 471, -326, -326, -326, -326, -326, -326, -326, - -326, -326, 399, -326, -326, -326, 39, -326, 66, -326, - -326, 242, 223, 152, 210, 182, 234, 210, 348, 66, - -326, -326, -326, -326, 470, 345, 345, 473, 476, 478, - 182, 480, 481, 482, 483, 484, -326, -326, 489, 345, - -326, -326, -326, -326, -326, -326, -326, -326, -326, 66, - -326, 345, 425, -326, 234, 69 -}; - -/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. - Performed when YYTABLE does not specify something else to do. Zero - means the default is an error. */ -static const yytype_int16 yydefact[] = -{ - 0, 0, 0, 0, 0, 1, 0, 0, 185, 190, - 0, 184, 187, 0, 265, 0, 0, 192, 44, 0, - 186, 188, 195, 0, 45, 0, 0, 0, 4, 191, - 0, 193, 4, 266, 46, 0, 32, 72, 73, 88, - 89, 115, 169, 170, 0, 0, 194, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 33, 0, - 0, 0, 64, 0, 64, 0, 0, 0, 0, 33, - 0, 44, 0, 0, 0, 0, 0, 0, 0, 8, - 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 105, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 33, 0, 0, 47, 0, 154, 0, 0, - 0, 0, 6, 5, 26, 0, 0, 0, 10, 11, - 12, 29, 0, 28, 0, 0, 0, 34, 0, 0, - 19, 37, 0, 0, 0, 64, 0, 0, 0, 0, - 0, 64, 0, 0, 0, 0, 4, 0, 90, 0, - 0, 98, 0, 0, 106, 0, 109, 0, 113, 0, - 116, 250, 44, 0, 44, 135, 136, 234, 251, 0, - 137, 0, 0, 44, 47, 0, 0, 0, 0, 139, - 0, 47, 0, 0, 147, 0, 0, 0, 252, 44, - 0, 189, 199, 208, 198, 203, 204, 202, 206, 207, - 200, 201, 205, 213, 150, 210, 211, 212, 209, 197, - 196, 44, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 106, 0, 0, 0, 179, 0, 48, - 44, 0, 0, 0, 0, 152, 153, 151, 0, 0, - 0, 2, 7, 3, 27, 253, 263, 13, 15, 14, - 0, 31, 259, 0, 35, 0, 36, 0, 0, 39, - 42, 256, 0, 66, 70, 71, 65, 0, 0, 0, - 87, 37, 86, 0, 85, 84, 0, 91, 92, 93, - 0, 97, 261, 0, 100, 262, 257, 0, 108, 110, - 258, 112, 114, 120, 0, 124, 0, 0, 134, 47, - 128, 0, 0, 47, 125, 0, 50, 44, 138, 0, - 0, 145, 140, 142, 0, 0, 37, 260, 149, 0, - 0, 0, 0, 168, 164, 165, 166, 0, 0, 163, - 0, 0, 216, 229, 219, 215, 228, 217, 220, 218, - 230, 221, 222, 223, 224, 225, 175, 227, 231, 233, - 226, 0, 214, 0, 237, 155, 182, 183, 30, 0, - 254, 17, 18, 0, 38, 0, 41, 63, 0, 0, - 0, 80, 78, 79, 77, 81, 39, 0, 0, 0, - 0, 0, 94, 95, 96, 0, 103, 104, 0, 111, - 0, 47, 123, 0, 119, 0, 117, 235, 0, 129, - 130, 131, 0, 126, 127, 44, 0, 0, 0, 141, - 146, 39, 156, 174, 171, 0, 173, 0, 161, 0, - 0, 176, 0, 232, 0, 0, 239, 0, 240, 255, - 0, 21, 22, 23, 24, 25, 40, 67, 68, 69, - 74, 0, 0, 82, 43, 264, 0, 99, 101, 121, - 122, 118, 47, 132, 133, 52, 61, 49, 143, 144, - 148, 172, 0, 0, 0, 157, 0, 238, 33, 0, - 0, 0, 0, 0, 0, 0, 0, 16, 76, 75, - 0, 0, 0, 51, 60, 58, 59, 55, 57, 56, - 54, 53, 0, 20, 159, 158, 0, 162, 0, 180, - 249, 0, 0, 0, 33, 0, 0, 33, 0, 0, - 107, 102, 236, 62, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 83, 160, 0, 0, - 241, 246, 247, 242, 245, 243, 244, 248, 167, 0, - 177, 181, 0, 178, 0, 0 -}; - -/* YYPGOTO[NTERM-NUM]. */ -static const yytype_int16 yypgoto[] = -{ - -326, -326, -65, -23, 97, -79, -83, -13, -62, -232, - -326, -191, -27, -118, -94, 195, -67, -26, -228, -325, - -97, -226, -1, 172, -86, -55, -326, -326, -326, -326, - 198, -36, -326, 431, -111, 201, -326, 428, -147, -326, - -326, -326, -326, -326, -326, 381, 386, -326, -326, -326, - -45, -96, -326, -326, -95, 132, -326, -326, -326, -326, - 300, -326, -326, -326, -93, -326, -326, 139, -7, -326, - -326, -326, -326, -50, -326, -326, -326, -326, -326, -326, - -326, -326, -326, -326, -326, -326, -326, -326, -326, -326, - -326, -326, 42, -89, -227, -326, -326, -326, -326, -326, - -290, -222, -92, -326, -326, -326 -}; - -/* YYDEFGOTO[NTERM-NUM]. */ -static const yytype_int16 yydefgoto[] = -{ - 0, 131, 34, 194, 134, 91, 142, 150, 151, 348, - 455, 384, 135, 144, 145, 36, 176, 149, 279, 386, - 152, 168, 187, 25, 327, 195, 425, 476, 511, 512, - 155, 159, 390, 156, 37, 38, 397, 162, 289, 160, - 164, 500, 39, 40, 300, 169, 172, 303, 501, 408, - 520, 175, 307, 178, 179, 41, 182, 183, 410, 189, - 190, 203, 198, 336, 206, 110, 258, 31, 516, 517, - 349, 483, 350, 42, 43, 340, 442, 561, 248, 366, - 536, 2, 3, 12, 15, 21, 7, 13, 23, 17, - 27, 369, 251, 191, 322, 472, 253, 254, 374, 448, - 521, 184, 192, 209, 11, 18 -}; - -/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If - positive, shift that token. If negative, reduce the rule whose - number is the opposite. If YYTABLE_NINF, syntax error. */ -static const yytype_int16 yytable[] = -{ - 30, 148, 35, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 122, 123, 124, 125, 126, 24, 180, 200, - 136, 239, 146, 238, 153, 244, 270, 245, 373, 202, - 246, 170, 173, 174, 177, 181, 188, 237, 163, 250, - 205, 249, 208, 210, 249, 247, 112, 252, 112, 329, - 330, 1, 234, 167, 143, 391, 393, 154, 154, 249, - 154, 201, 154, 396, 171, 392, 394, 277, 233, 166, - 236, 460, 166, 240, 466, 4, 243, 405, 112, 70, - 321, 325, 32, 166, 343, 199, 274, 413, 313, 415, - 70, 71, 317, 314, 70, 316, 167, 62, 193, 147, - 232, 185, 186, 275, 143, 530, 480, 171, 431, 63, - 5, 193, 531, 8, 435, 514, 6, 342, 417, 283, - 341, 417, 129, 311, 166, 291, 130, 489, 112, 490, - 491, 143, 492, 9, 493, 188, 320, 324, 334, 188, - 10, 282, 344, 345, 346, 286, 138, 112, 139, 255, - 256, 140, 378, 344, 345, 346, 16, 257, 138, 14, - 139, 494, 495, 140, 188, 461, 141, 22, 319, 323, - 496, 138, 112, 139, 26, 462, 140, 451, 141, 467, - 35, 273, 406, 452, 453, 454, 407, 347, 138, 403, - 139, 335, 326, 140, 456, 383, 44, 457, 458, 399, - 522, 523, 524, 525, 526, 527, 528, 484, 231, 419, - 111, 422, 235, 423, 19, 20, 486, 503, 504, 505, - 506, 507, 508, 509, 510, 132, 112, 133, 379, 47, - 351, 167, 89, 90, 395, 138, 112, 139, 147, 371, - 140, 112, 181, 181, 267, 268, 269, 127, 132, 368, - 133, 400, 297, 298, 299, 128, 409, 143, 518, 412, - 137, 414, 416, 158, 347, 347, 420, 421, 207, 387, - 424, 161, 211, 161, 427, 428, 212, 401, 28, 29, - 167, 32, 33, 45, 46, 213, 434, 436, 196, 197, - 214, 411, 215, 411, 216, 439, 440, 418, 450, 323, - 217, 418, 383, 218, 549, 383, 383, 204, 112, 548, - 473, 259, 260, 287, 288, 185, 186, 559, 411, 381, - 382, 219, 430, 388, 389, 48, 24, 32, 477, 49, - 261, 220, 221, 222, 223, 459, 50, 51, 52, 224, - 225, 226, 53, 227, 228, 229, 30, 230, 166, 262, - 445, 447, 181, 529, 204, 469, 249, 263, 470, 264, - 471, 265, 266, 271, 54, 272, 276, 474, 55, 56, - 57, 278, 478, 479, 347, 482, 280, 281, 58, 284, - 481, 285, 167, 290, 292, 463, 250, 293, 294, 295, - 59, 301, 296, 302, 304, 305, 60, 61, 418, 306, - 308, 310, 32, 35, 309, 312, 498, 499, 315, 318, - 328, 331, 332, 333, 337, 338, 347, 352, 353, 167, - 354, 355, 356, 357, 475, 358, 359, 360, 542, 539, - 543, 361, 544, 362, 363, 545, 364, 365, 515, 367, - 370, 372, 375, 538, 376, 377, 380, 533, 398, 429, - 432, 385, 433, 143, 28, 437, 438, 540, 441, 444, - 449, 167, 464, 535, 465, 70, 468, 485, 487, 488, - 513, 515, 497, 519, 546, 532, 547, 550, 274, 92, - 551, 243, 552, 93, 553, 554, 555, 556, 557, 35, - 94, 95, 96, 558, 537, 402, 97, 564, 541, 426, - 241, 404, 157, 165, 560, 446, 242, 339, 443, 534, - 143, 563, 167, 347, 502, 0, 0, 0, 98, 565, - 0, 0, 99, 100, 101, 0, 347, 0, 0, 0, - 0, 0, 102, 103, 0, 64, 249, 104, 562, 105, - 0, 0, 347, 0, 106, 107, 0, 0, 0, 0, - 108, 109, 65, 0, 66, 67, 0, 68, 0, 69, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 70, 71, 0, 72, 73, 74, 75, 0, 0, - 0, 76, 0, 0, 0, 77, 78, 79, 80, 81, - 64, 0, 82, 83, 84, 85, 0, 0, 0, 86, - 0, 87, 88, 0, 0, 0, 0, 65, 0, 66, - 67, 0, 68, 0, 69, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 70, 71, 0, 72, - 73, 74, 75, 0, 0, 0, 76, 0, 0, 0, - 77, 78, 79, 80, 81, 0, 0, 82, 83, 84, - 85, 0, 0, 0, 86, 0, 87, 88 -}; - -static const yytype_int16 yycheck[] = -{ - 23, 68, 25, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 59, 60, 61, 18, 80, 84, - 65, 118, 67, 117, 69, 121, 144, 122, 254, 84, - 123, 76, 77, 78, 79, 80, 81, 116, 74, 125, - 85, 6, 87, 88, 6, 124, 7, 126, 7, 196, - 197, 3, 114, 76, 67, 287, 288, 70, 71, 6, - 73, 84, 75, 291, 77, 287, 288, 150, 113, 3, - 115, 396, 3, 118, 25, 79, 121, 303, 7, 41, - 191, 192, 3, 3, 4, 6, 148, 314, 180, 316, - 41, 42, 184, 182, 41, 184, 119, 66, 32, 28, - 113, 60, 61, 148, 117, 33, 431, 120, 336, 78, - 0, 32, 40, 6, 341, 76, 3, 209, 83, 155, - 209, 83, 6, 178, 3, 161, 10, 22, 7, 24, - 25, 144, 27, 81, 29, 180, 191, 192, 203, 184, - 3, 154, 73, 74, 75, 158, 6, 7, 8, 67, - 68, 11, 270, 73, 74, 75, 3, 75, 6, 85, - 8, 56, 57, 11, 209, 397, 26, 82, 191, 192, - 65, 6, 7, 8, 80, 397, 11, 13, 26, 405, - 203, 16, 6, 19, 20, 21, 10, 210, 6, 300, - 8, 204, 193, 11, 385, 278, 6, 388, 389, 296, - 490, 491, 492, 493, 494, 495, 496, 439, 111, 320, - 7, 322, 115, 324, 3, 4, 442, 33, 34, 35, - 36, 37, 38, 39, 40, 6, 7, 8, 273, 70, - 231, 254, 9, 10, 289, 6, 7, 8, 28, 252, - 11, 7, 287, 288, 13, 14, 15, 7, 6, 250, - 8, 296, 52, 53, 54, 7, 311, 270, 484, 314, - 7, 316, 317, 43, 287, 288, 321, 322, 7, 282, - 325, 73, 4, 75, 329, 330, 6, 300, 3, 4, - 303, 3, 4, 3, 4, 6, 341, 342, 17, 18, - 6, 314, 6, 316, 6, 350, 351, 320, 381, 322, - 6, 324, 385, 6, 536, 388, 389, 6, 7, 535, - 421, 60, 61, 49, 50, 60, 61, 549, 341, 17, - 18, 6, 335, 30, 31, 12, 327, 3, 4, 16, - 7, 6, 6, 6, 6, 390, 23, 24, 25, 6, - 6, 6, 29, 6, 6, 6, 369, 4, 3, 7, - 373, 374, 397, 500, 6, 410, 6, 4, 413, 4, - 415, 4, 4, 4, 51, 4, 4, 422, 55, 56, - 57, 30, 427, 428, 397, 437, 4, 4, 65, 4, - 435, 4, 405, 4, 4, 398, 472, 82, 4, 4, - 77, 4, 29, 4, 4, 4, 83, 84, 421, 4, - 4, 4, 3, 426, 6, 4, 461, 462, 4, 4, - 4, 4, 4, 4, 4, 4, 439, 4, 4, 442, - 4, 4, 4, 4, 425, 4, 4, 4, 525, 523, - 526, 4, 527, 4, 4, 528, 4, 4, 483, 4, - 4, 4, 4, 522, 4, 4, 4, 512, 48, 4, - 4, 31, 4, 466, 3, 16, 6, 524, 6, 6, - 4, 484, 4, 518, 4, 41, 32, 4, 6, 57, - 4, 516, 18, 486, 529, 4, 6, 4, 540, 12, - 4, 526, 4, 16, 4, 4, 4, 4, 4, 512, - 23, 24, 25, 4, 521, 300, 29, 72, 524, 327, - 119, 300, 71, 75, 559, 373, 120, 207, 369, 516, - 523, 561, 535, 536, 472, -1, -1, -1, 51, 564, - -1, -1, 55, 56, 57, -1, 549, -1, -1, -1, - -1, -1, 65, 66, -1, 5, 6, 70, 561, 72, - -1, -1, 565, -1, 77, 78, -1, -1, -1, -1, - 83, 84, 22, -1, 24, 25, -1, 27, -1, 29, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 41, 42, -1, 44, 45, 46, 47, -1, -1, - -1, 51, -1, -1, -1, 55, 56, 57, 58, 59, - 5, -1, 62, 63, 64, 65, -1, -1, -1, 69, - -1, 71, 72, -1, -1, -1, -1, 22, -1, 24, - 25, -1, 27, -1, 29, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 41, 42, -1, 44, - 45, 46, 47, -1, -1, -1, 51, -1, -1, -1, - 55, 56, 57, 58, 59, -1, -1, 62, 63, 64, - 65, -1, -1, -1, 69, -1, 71, 72 -}; - -/* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of - state STATE-NUM. */ -static const yytype_uint8 yystos[] = -{ - 0, 3, 167, 168, 79, 0, 3, 172, 6, 81, - 3, 190, 169, 173, 85, 170, 3, 175, 191, 3, - 4, 171, 82, 174, 108, 109, 80, 176, 3, 4, - 89, 153, 3, 4, 88, 89, 101, 120, 121, 128, - 129, 141, 159, 160, 6, 3, 4, 70, 12, 16, - 23, 24, 25, 29, 51, 55, 56, 57, 65, 77, - 83, 84, 66, 78, 5, 22, 24, 25, 27, 29, - 41, 42, 44, 45, 46, 47, 51, 55, 56, 57, - 58, 59, 62, 63, 64, 65, 69, 71, 72, 9, - 10, 91, 12, 16, 23, 24, 25, 29, 51, 55, - 56, 57, 65, 66, 70, 72, 77, 78, 83, 84, - 151, 7, 7, 136, 136, 136, 136, 136, 136, 136, - 136, 136, 136, 136, 136, 136, 136, 7, 7, 6, - 10, 87, 6, 8, 90, 98, 136, 7, 6, 8, - 11, 26, 92, 93, 99, 100, 136, 28, 102, 103, - 93, 94, 106, 136, 93, 116, 119, 119, 43, 117, - 125, 116, 123, 117, 126, 123, 3, 89, 107, 131, - 136, 93, 132, 136, 136, 137, 102, 136, 139, 140, - 94, 136, 142, 143, 187, 60, 61, 108, 136, 145, - 146, 179, 188, 32, 89, 111, 17, 18, 148, 6, - 88, 89, 111, 147, 6, 136, 150, 7, 136, 189, - 136, 4, 6, 6, 6, 6, 6, 6, 6, 6, - 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, - 4, 90, 93, 136, 94, 90, 136, 91, 100, 106, - 136, 131, 132, 136, 137, 140, 150, 91, 164, 6, - 110, 178, 91, 182, 183, 67, 68, 75, 152, 60, - 61, 7, 7, 4, 4, 4, 4, 13, 14, 15, - 99, 4, 4, 16, 94, 136, 4, 92, 30, 104, - 4, 4, 93, 117, 4, 4, 93, 49, 50, 124, - 4, 117, 4, 82, 4, 4, 29, 52, 53, 54, - 130, 4, 4, 133, 4, 4, 4, 138, 4, 6, - 4, 111, 4, 188, 179, 4, 179, 188, 4, 89, - 111, 120, 180, 89, 111, 120, 108, 110, 4, 124, - 124, 4, 4, 4, 88, 93, 149, 4, 4, 146, - 161, 179, 188, 4, 73, 74, 75, 89, 95, 156, - 158, 108, 4, 4, 4, 4, 4, 4, 4, 4, - 4, 4, 4, 4, 4, 4, 165, 4, 108, 177, - 4, 93, 4, 107, 184, 4, 4, 4, 99, 136, - 4, 17, 18, 92, 97, 31, 105, 93, 30, 31, - 118, 95, 187, 95, 187, 111, 104, 122, 48, 106, - 136, 89, 101, 120, 121, 107, 6, 10, 135, 111, - 144, 89, 111, 180, 111, 180, 111, 83, 89, 120, - 111, 111, 120, 120, 111, 112, 109, 111, 111, 4, - 93, 104, 4, 4, 111, 180, 111, 16, 6, 111, - 111, 6, 162, 153, 6, 89, 141, 89, 185, 4, - 92, 13, 19, 20, 21, 96, 97, 97, 97, 111, - 105, 95, 187, 93, 4, 4, 25, 107, 32, 111, - 111, 111, 181, 120, 111, 108, 113, 4, 111, 111, - 105, 111, 94, 157, 95, 4, 107, 6, 57, 22, - 24, 25, 27, 29, 56, 57, 65, 18, 111, 111, - 127, 134, 178, 33, 34, 35, 36, 37, 38, 39, - 40, 114, 115, 4, 76, 136, 154, 155, 107, 93, - 136, 186, 186, 186, 186, 186, 186, 186, 186, 124, - 33, 40, 4, 88, 154, 111, 166, 98, 91, 100, - 102, 103, 106, 137, 140, 150, 111, 6, 107, 95, - 4, 4, 4, 4, 4, 4, 4, 4, 4, 95, - 111, 163, 89, 159, 72, 136 -}; - -/* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */ -static const yytype_uint8 yyr1[] = -{ - 0, 86, 87, 88, 89, 90, 90, 87, 91, 91, - 92, 92, 92, 93, 93, 93, 94, 94, 94, 94, - 95, 96, 96, 96, 96, 97, 98, 88, 99, 99, - 100, 101, 88, 102, 102, 103, 88, 104, 104, 105, - 105, 106, 88, 107, 108, 109, 109, 110, 110, 111, - 112, 111, 113, 113, 114, 114, 114, 114, 114, 114, - 114, 115, 114, 116, 117, 117, 118, 118, 118, 119, - 120, 121, 88, 88, 122, 123, 123, 124, 124, 124, - 124, 125, 127, 126, 128, 128, 129, 129, 88, 88, - 130, 130, 130, 130, 131, 131, 131, 88, 133, 132, - 88, 134, 134, 135, 135, 136, 138, 137, 88, 139, - 139, 140, 140, 140, 141, 88, 142, 143, 143, 143, - 144, 143, 143, 143, 88, 145, 145, 145, 145, 145, - 145, 145, 145, 145, 88, 146, 146, 145, 88, 147, - 88, 88, 88, 148, 148, 88, 149, 149, 150, 88, - 151, 152, 152, 152, 152, 88, 88, 153, 154, 154, - 155, 157, 156, 158, 158, 158, 158, 159, 160, 88, - 88, 161, 161, 161, 88, 162, 162, 163, 163, 165, - 166, 164, 88, 88, 167, 169, 168, 170, 170, 171, - 173, 172, 174, 174, 175, 176, 176, 151, 151, 151, - 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, - 151, 151, 151, 151, 153, 153, 153, 153, 153, 153, - 153, 153, 153, 153, 153, 153, 153, 153, 153, 153, - 153, 177, 177, 178, 179, 181, 180, 182, 183, 184, - 184, 185, 185, 185, 185, 185, 185, 185, 185, 186, - 187, 188, 189, 88, 88, 88, 88, 88, 88, 88, - 88, 88, 88, 88, 107, 191, 190 -}; - -/* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */ -static const yytype_int8 yyr2[] = -{ - 0, 2, 2, 4, 1, 1, 1, 2, 1, 1, - 1, 1, 1, 2, 2, 2, 5, 3, 3, 1, - 4, 1, 1, 1, 1, 2, 1, 4, 1, 1, - 3, 4, 1, 0, 1, 2, 4, 0, 2, 0, - 2, 3, 4, 4, 0, 1, 2, 0, 1, 4, - 0, 5, 1, 2, 1, 1, 1, 1, 1, 1, - 1, 0, 2, 3, 0, 2, 0, 2, 2, 4, - 4, 4, 1, 1, 2, 5, 5, 2, 2, 2, - 2, 3, 0, 7, 4, 4, 4, 4, 1, 1, - 0, 1, 1, 1, 3, 3, 3, 4, 0, 4, - 4, 0, 2, 1, 1, 1, 0, 6, 4, 1, - 2, 3, 2, 1, 4, 1, 1, 3, 4, 3, - 0, 4, 4, 3, 4, 2, 3, 3, 2, 3, - 3, 3, 4, 4, 4, 1, 1, 1, 4, 1, - 4, 5, 4, 4, 4, 4, 2, 0, 4, 4, - 2, 1, 1, 1, 0, 5, 5, 7, 1, 1, - 3, 0, 4, 1, 1, 1, 1, 10, 4, 1, - 1, 2, 3, 2, 5, 0, 1, 0, 2, 0, - 0, 10, 5, 5, 3, 0, 6, 0, 2, 5, - 0, 6, 0, 2, 4, 0, 4, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 5, 5, 5, 5, 5, 5, - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, - 5, 1, 2, 2, 1, 0, 5, 2, 4, 2, - 2, 5, 5, 5, 5, 5, 5, 5, 5, 1, - 1, 1, 1, 4, 5, 6, 4, 4, 4, 4, - 4, 4, 4, 4, 4, 0, 5 -}; - - -enum { YYENOMEM = -2 }; - -#define yyerrok (yyerrstatus = 0) -#define yyclearin (yychar = YYEMPTY) - -#define YYACCEPT goto yyacceptlab -#define YYABORT goto yyabortlab -#define YYERROR goto yyerrorlab -#define YYNOMEM goto yyexhaustedlab - - -#define YYRECOVERING() (!!yyerrstatus) - -#define YYBACKUP(Token, Value) \ - do \ - if (yychar == YYEMPTY) \ - { \ - yychar = (Token); \ - yylval = (Value); \ - YYPOPSTACK (yylen); \ - yystate = *yyssp; \ - goto yybackup; \ - } \ - else \ - { \ - yyerror (YY_("syntax error: cannot back up")); \ - YYERROR; \ - } \ - while (0) - -/* Backward compatibility with an undocumented macro. - Use YYerror or YYUNDEF. */ -#define YYERRCODE YYUNDEF - - -/* Enable debugging if requested. */ -#if YYDEBUG - -# ifndef YYFPRINTF -# include /* INFRINGES ON USER NAME SPACE */ -# define YYFPRINTF fprintf -# endif - -# define YYDPRINTF(Args) \ -do { \ - if (yydebug) \ - YYFPRINTF Args; \ -} while (0) - - - - -# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \ -do { \ - if (yydebug) \ - { \ - YYFPRINTF (stderr, "%s ", Title); \ - yy_symbol_print (stderr, \ - Kind, Value); \ - YYFPRINTF (stderr, "\n"); \ - } \ -} while (0) - - -/*-----------------------------------. -| Print this symbol's value on YYO. | -`-----------------------------------*/ - -static void -yy_symbol_value_print (FILE *yyo, - yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep) -{ - FILE *yyoutput = yyo; - YY_USE (yyoutput); - if (!yyvaluep) - return; - YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN - YY_USE (yykind); - YY_IGNORE_MAYBE_UNINITIALIZED_END -} - - -/*---------------------------. -| Print this symbol on YYO. | -`---------------------------*/ - -static void -yy_symbol_print (FILE *yyo, - yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep) -{ - YYFPRINTF (yyo, "%s %s (", - yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind)); - - yy_symbol_value_print (yyo, yykind, yyvaluep); - YYFPRINTF (yyo, ")"); -} - -/*------------------------------------------------------------------. -| yy_stack_print -- Print the state stack from its BOTTOM up to its | -| TOP (included). | -`------------------------------------------------------------------*/ - -static void -yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop) -{ - YYFPRINTF (stderr, "Stack now"); - for (; yybottom <= yytop; yybottom++) - { - int yybot = *yybottom; - YYFPRINTF (stderr, " %d", yybot); - } - YYFPRINTF (stderr, "\n"); -} - -# define YY_STACK_PRINT(Bottom, Top) \ -do { \ - if (yydebug) \ - yy_stack_print ((Bottom), (Top)); \ -} while (0) - - -/*------------------------------------------------. -| Report that the YYRULE is going to be reduced. | -`------------------------------------------------*/ - -static void -yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, - int yyrule) -{ - int yylno = yyrline[yyrule]; - int yynrhs = yyr2[yyrule]; - int yyi; - YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n", - yyrule - 1, yylno); - /* The symbols being reduced. */ - for (yyi = 0; yyi < yynrhs; yyi++) - { - YYFPRINTF (stderr, " $%d = ", yyi + 1); - yy_symbol_print (stderr, - YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]), - &yyvsp[(yyi + 1) - (yynrhs)]); - YYFPRINTF (stderr, "\n"); - } -} - -# define YY_REDUCE_PRINT(Rule) \ -do { \ - if (yydebug) \ - yy_reduce_print (yyssp, yyvsp, Rule); \ -} while (0) - -/* Nonzero means print parse trace. It is left uninitialized so that - multiple parsers can coexist. */ -int yydebug; -#else /* !YYDEBUG */ -# define YYDPRINTF(Args) ((void) 0) -# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) -# define YY_STACK_PRINT(Bottom, Top) -# define YY_REDUCE_PRINT(Rule) -#endif /* !YYDEBUG */ - - -/* YYINITDEPTH -- initial size of the parser's stacks. */ -#ifndef YYINITDEPTH -# define YYINITDEPTH 200 -#endif - -/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only - if the built-in stack extension method is used). - - Do not make this value too large; the results are undefined if - YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) - evaluated with infinite-precision integer arithmetic. */ - -#ifndef YYMAXDEPTH -# define YYMAXDEPTH 10000 -#endif - - -/* Context of a parse error. */ -typedef struct -{ - yy_state_t *yyssp; - yysymbol_kind_t yytoken; -} yypcontext_t; - -/* Put in YYARG at most YYARGN of the expected tokens given the - current YYCTX, and return the number of tokens stored in YYARG. If - YYARG is null, return the number of expected tokens (guaranteed to - be less than YYNTOKENS). Return YYENOMEM on memory exhaustion. - Return 0 if there are more than YYARGN expected tokens, yet fill - YYARG up to YYARGN. */ -static int -yypcontext_expected_tokens (const yypcontext_t *yyctx, - yysymbol_kind_t yyarg[], int yyargn) -{ - /* Actual size of YYARG. */ - int yycount = 0; - int yyn = yypact[+*yyctx->yyssp]; - if (!yypact_value_is_default (yyn)) - { - /* Start YYX at -YYN if negative to avoid negative indexes in - YYCHECK. In other words, skip the first -YYN actions for - this state because they are default actions. */ - int yyxbegin = yyn < 0 ? -yyn : 0; - /* Stay within bounds of both yycheck and yytname. */ - int yychecklim = YYLAST - yyn + 1; - int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; - int yyx; - for (yyx = yyxbegin; yyx < yyxend; ++yyx) - if (yycheck[yyx + yyn] == yyx && yyx != YYSYMBOL_YYerror - && !yytable_value_is_error (yytable[yyx + yyn])) - { - if (!yyarg) - ++yycount; - else if (yycount == yyargn) - return 0; - else - yyarg[yycount++] = YY_CAST (yysymbol_kind_t, yyx); - } - } - if (yyarg && yycount == 0 && 0 < yyargn) - yyarg[0] = YYSYMBOL_YYEMPTY; - return yycount; -} - - - - -#ifndef yystrlen -# if defined __GLIBC__ && defined _STRING_H -# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) -# else -/* Return the length of YYSTR. */ -static YYPTRDIFF_T -yystrlen (const char *yystr) -{ - YYPTRDIFF_T yylen; - for (yylen = 0; yystr[yylen]; yylen++) - continue; - return yylen; -} -# endif -#endif - -#ifndef yystpcpy -# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE -# define yystpcpy stpcpy -# else -/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in - YYDEST. */ -static char * -yystpcpy (char *yydest, const char *yysrc) -{ - char *yyd = yydest; - const char *yys = yysrc; - - while ((*yyd++ = *yys++) != '\0') - continue; - - return yyd - 1; -} -# endif -#endif - -#ifndef yytnamerr -/* Copy to YYRES the contents of YYSTR after stripping away unnecessary - quotes and backslashes, so that it's suitable for yyerror. The - heuristic is that double-quoting is unnecessary unless the string - contains an apostrophe, a comma, or backslash (other than - backslash-backslash). YYSTR is taken from yytname. If YYRES is - null, do not copy; instead, return the length of what the result - would have been. */ -static YYPTRDIFF_T -yytnamerr (char *yyres, const char *yystr) -{ - if (*yystr == '"') - { - YYPTRDIFF_T yyn = 0; - char const *yyp = yystr; - for (;;) - switch (*++yyp) - { - case '\'': - case ',': - goto do_not_strip_quotes; - - case '\\': - if (*++yyp != '\\') - goto do_not_strip_quotes; - else - goto append; - - append: - default: - if (yyres) - yyres[yyn] = *yyp; - yyn++; - break; - - case '"': - if (yyres) - yyres[yyn] = '\0'; - return yyn; - } - do_not_strip_quotes: ; - } - - if (yyres) - return yystpcpy (yyres, yystr) - yyres; - else - return yystrlen (yystr); -} -#endif - - -static int -yy_syntax_error_arguments (const yypcontext_t *yyctx, - yysymbol_kind_t yyarg[], int yyargn) -{ - /* Actual size of YYARG. */ - int yycount = 0; - /* There are many possibilities here to consider: - - If this state is a consistent state with a default action, then - the only way this function was invoked is if the default action - is an error action. In that case, don't check for expected - tokens because there are none. - - The only way there can be no lookahead present (in yychar) is if - this state is a consistent state with a default action. Thus, - detecting the absence of a lookahead is sufficient to determine - that there is no unexpected or expected token to report. In that - case, just report a simple "syntax error". - - Don't assume there isn't a lookahead just because this state is a - consistent state with a default action. There might have been a - previous inconsistent state, consistent state with a non-default - action, or user semantic action that manipulated yychar. - - Of course, the expected token list depends on states to have - correct lookahead information, and it depends on the parser not - to perform extra reductions after fetching a lookahead from the - scanner and before detecting a syntax error. Thus, state merging - (from LALR or IELR) and default reductions corrupt the expected - token list. However, the list is correct for canonical LR with - one exception: it will still contain any token that will not be - accepted due to an error action in a later state. - */ - if (yyctx->yytoken != YYSYMBOL_YYEMPTY) - { - int yyn; - if (yyarg) - yyarg[yycount] = yyctx->yytoken; - ++yycount; - yyn = yypcontext_expected_tokens (yyctx, - yyarg ? yyarg + 1 : yyarg, yyargn - 1); - if (yyn == YYENOMEM) - return YYENOMEM; - else - yycount += yyn; - } - return yycount; -} - -/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message - about the unexpected token YYTOKEN for the state stack whose top is - YYSSP. - - Return 0 if *YYMSG was successfully written. Return -1 if *YYMSG is - not large enough to hold the message. In that case, also set - *YYMSG_ALLOC to the required number of bytes. Return YYENOMEM if the - required number of bytes is too large to store. */ -static int -yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg, - const yypcontext_t *yyctx) -{ - enum { YYARGS_MAX = 5 }; - /* Internationalized format string. */ - const char *yyformat = YY_NULLPTR; - /* Arguments of yyformat: reported tokens (one for the "unexpected", - one per "expected"). */ - yysymbol_kind_t yyarg[YYARGS_MAX]; - /* Cumulated lengths of YYARG. */ - YYPTRDIFF_T yysize = 0; - - /* Actual size of YYARG. */ - int yycount = yy_syntax_error_arguments (yyctx, yyarg, YYARGS_MAX); - if (yycount == YYENOMEM) - return YYENOMEM; - - switch (yycount) - { -#define YYCASE_(N, S) \ - case N: \ - yyformat = S; \ - break - default: /* Avoid compiler warnings. */ - YYCASE_(0, YY_("syntax error")); - YYCASE_(1, YY_("syntax error, unexpected %s")); - YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); - YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); - YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); - YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); -#undef YYCASE_ - } - - /* Compute error message size. Don't count the "%s"s, but reserve - room for the terminator. */ - yysize = yystrlen (yyformat) - 2 * yycount + 1; - { - int yyi; - for (yyi = 0; yyi < yycount; ++yyi) - { - YYPTRDIFF_T yysize1 - = yysize + yytnamerr (YY_NULLPTR, yytname[yyarg[yyi]]); - if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) - yysize = yysize1; - else - return YYENOMEM; - } - } - - if (*yymsg_alloc < yysize) - { - *yymsg_alloc = 2 * yysize; - if (! (yysize <= *yymsg_alloc - && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) - *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; - return -1; - } - - /* Avoid sprintf, as that infringes on the user's name space. - Don't have undefined behavior even if the translation - produced a string with the wrong number of "%s"s. */ - { - char *yyp = *yymsg; - int yyi = 0; - while ((*yyp = *yyformat) != '\0') - if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) - { - yyp += yytnamerr (yyp, yytname[yyarg[yyi++]]); - yyformat += 2; - } - else - { - ++yyp; - ++yyformat; - } - } - return 0; -} - - -/*-----------------------------------------------. -| Release the memory associated to this symbol. | -`-----------------------------------------------*/ - -static void -yydestruct (const char *yymsg, - yysymbol_kind_t yykind, YYSTYPE *yyvaluep) -{ - YY_USE (yyvaluep); - if (!yymsg) - yymsg = "Deleting"; - YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp); - - YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN - YY_USE (yykind); - YY_IGNORE_MAYBE_UNINITIALIZED_END -} - - -/* Lookahead token kind. */ -int yychar; - -/* The semantic value of the lookahead symbol. */ -YYSTYPE yylval; -/* Number of syntax errors so far. */ -int yynerrs; - - - - -/*----------. -| yyparse. | -`----------*/ - -int -yyparse (void) -{ - yy_state_fast_t yystate = 0; - /* Number of tokens to shift before error messages enabled. */ - int yyerrstatus = 0; - - /* Refer to the stacks through separate pointers, to allow yyoverflow - to reallocate them elsewhere. */ - - /* Their size. */ - YYPTRDIFF_T yystacksize = YYINITDEPTH; - - /* The state stack: array, bottom, top. */ - yy_state_t yyssa[YYINITDEPTH]; - yy_state_t *yyss = yyssa; - yy_state_t *yyssp = yyss; - - /* The semantic value stack: array, bottom, top. */ - YYSTYPE yyvsa[YYINITDEPTH]; - YYSTYPE *yyvs = yyvsa; - YYSTYPE *yyvsp = yyvs; - - int yyn; - /* The return value of yyparse. */ - int yyresult; - /* Lookahead symbol kind. */ - yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY; - /* The variables used to return semantic value and location from the - action routines. */ - YYSTYPE yyval; - - /* Buffer for error messages, and its allocated size. */ - char yymsgbuf[128]; - char *yymsg = yymsgbuf; - YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf; - -#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) - - /* The number of symbols on the RHS of the reduced rule. - Keep to zero when no symbol should be popped. */ - int yylen = 0; - - YYDPRINTF ((stderr, "Starting parse\n")); - - yychar = YYEMPTY; /* Cause a token to be read. */ - - goto yysetstate; - - -/*------------------------------------------------------------. -| yynewstate -- push a new state, which is found in yystate. | -`------------------------------------------------------------*/ -yynewstate: - /* In all cases, when you get here, the value and location stacks - have just been pushed. So pushing a state here evens the stacks. */ - yyssp++; - - -/*--------------------------------------------------------------------. -| yysetstate -- set current state (the top of the stack) to yystate. | -`--------------------------------------------------------------------*/ -yysetstate: - YYDPRINTF ((stderr, "Entering state %d\n", yystate)); - YY_ASSERT (0 <= yystate && yystate < YYNSTATES); - YY_IGNORE_USELESS_CAST_BEGIN - *yyssp = YY_CAST (yy_state_t, yystate); - YY_IGNORE_USELESS_CAST_END - YY_STACK_PRINT (yyss, yyssp); - - if (yyss + yystacksize - 1 <= yyssp) -#if !defined yyoverflow && !defined YYSTACK_RELOCATE - YYNOMEM; -#else - { - /* Get the current used size of the three stacks, in elements. */ - YYPTRDIFF_T yysize = yyssp - yyss + 1; - -# if defined yyoverflow - { - /* Give user a chance to reallocate the stack. Use copies of - these so that the &'s don't force the real ones into - memory. */ - yy_state_t *yyss1 = yyss; - YYSTYPE *yyvs1 = yyvs; - - /* Each stack pointer address is followed by the size of the - data in use in that stack, in bytes. This used to be a - conditional around just the two extra args, but that might - be undefined if yyoverflow is a macro. */ - yyoverflow (YY_("memory exhausted"), - &yyss1, yysize * YYSIZEOF (*yyssp), - &yyvs1, yysize * YYSIZEOF (*yyvsp), - &yystacksize); - yyss = yyss1; - yyvs = yyvs1; - } -# else /* defined YYSTACK_RELOCATE */ - /* Extend the stack our own way. */ - if (YYMAXDEPTH <= yystacksize) - YYNOMEM; - yystacksize *= 2; - if (YYMAXDEPTH < yystacksize) - yystacksize = YYMAXDEPTH; - - { - yy_state_t *yyss1 = yyss; - union yyalloc *yyptr = - YY_CAST (union yyalloc *, - YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); - if (! yyptr) - YYNOMEM; - YYSTACK_RELOCATE (yyss_alloc, yyss); - YYSTACK_RELOCATE (yyvs_alloc, yyvs); -# undef YYSTACK_RELOCATE - if (yyss1 != yyssa) - YYSTACK_FREE (yyss1); - } -# endif - - yyssp = yyss + yysize - 1; - yyvsp = yyvs + yysize - 1; - - YY_IGNORE_USELESS_CAST_BEGIN - YYDPRINTF ((stderr, "Stack size increased to %ld\n", - YY_CAST (long, yystacksize))); - YY_IGNORE_USELESS_CAST_END - - if (yyss + yystacksize - 1 <= yyssp) - YYABORT; - } -#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ - - - if (yystate == YYFINAL) - YYACCEPT; - - goto yybackup; - - -/*-----------. -| yybackup. | -`-----------*/ -yybackup: - /* Do appropriate processing given the current state. Read a - lookahead token if we need one and don't already have one. */ - - /* First try to decide what to do without reference to lookahead token. */ - yyn = yypact[yystate]; - if (yypact_value_is_default (yyn)) - goto yydefault; - - /* Not known => get a lookahead token if don't already have one. */ - - /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */ - if (yychar == YYEMPTY) - { - YYDPRINTF ((stderr, "Reading a token\n")); - yychar = yylex (); - } - - if (yychar <= YYEOF) - { - yychar = YYEOF; - yytoken = YYSYMBOL_YYEOF; - YYDPRINTF ((stderr, "Now at end of input.\n")); - } - else if (yychar == YYerror) - { - /* The scanner already issued an error message, process directly - to error recovery. But do not keep the error token as - lookahead, it is too special and may lead us to an endless - loop in error recovery. */ - yychar = YYUNDEF; - yytoken = YYSYMBOL_YYerror; - goto yyerrlab1; - } - else - { - yytoken = YYTRANSLATE (yychar); - YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); - } - - /* If the proper action on seeing token YYTOKEN is to reduce or to - detect an error, take that action. */ - yyn += yytoken; - if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) - goto yydefault; - yyn = yytable[yyn]; - if (yyn <= 0) - { - if (yytable_value_is_error (yyn)) - goto yyerrlab; - yyn = -yyn; - goto yyreduce; - } - - /* Count tokens shifted since error; after three, turn off error - status. */ - if (yyerrstatus) - yyerrstatus--; - - /* Shift the lookahead token. */ - YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); - yystate = yyn; - YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN - *++yyvsp = yylval; - YY_IGNORE_MAYBE_UNINITIALIZED_END - - /* Discard the shifted token. */ - yychar = YYEMPTY; - goto yynewstate; - - -/*-----------------------------------------------------------. -| yydefault -- do the default action for the current state. | -`-----------------------------------------------------------*/ -yydefault: - yyn = yydefact[yystate]; - if (yyn == 0) - goto yyerrlab; - goto yyreduce; - - -/*-----------------------------. -| yyreduce -- do a reduction. | -`-----------------------------*/ -yyreduce: - /* yyn is the number of a rule to reduce with. */ - yylen = yyr2[yyn]; - - /* If YYLEN is nonzero, implement the default value of the action: - '$$ = $1'. - - Otherwise, the following line sets YYVAL to garbage. - This behavior is undocumented and Bison - users should not rely upon it. Assigning to YYVAL - unconditionally makes the parser a bit smaller, and it avoids a - GCC warning that YYVAL may be used uninitialized. */ - yyval = yyvsp[1-yylen]; - - - YY_REDUCE_PRINT (yyn); - switch (yyn) - { - case 2: /* glyph: UNSIGNED REFERENCE */ -#line 306 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.c).c= (yyvsp[-1].u);REF(font_kind,(yyvsp[0].u));(yyval.c).f= (yyvsp[0].u);} -#line 2236 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 3: /* content_node: start "glyph" glyph ">" */ -#line 307 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_tags((yyvsp[-3].u),hput_glyph(&((yyvsp[-1].c))));} -#line 2242 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 4: /* start: "<" */ -#line 308 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {HPUTNODE;(yyval.u)= (uint32_t)(hpos++-hstart);} -#line 2248 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 6: /* integer: UNSIGNED */ -#line 311 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {RNG("number",(yyvsp[0].u),0,INT32_MAX);} -#line 2254 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 7: /* glyph: CHARCODE REFERENCE */ -#line 314 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.c).c= (yyvsp[-1].u);REF(font_kind,(yyvsp[0].u));(yyval.c).f= (yyvsp[0].u);} -#line 2260 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 9: /* string: CHARCODE */ -#line 317 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {static char s[2]; -RNG("String element",(yyvsp[0].u),0x20,0x7E); -s[0]= (yyvsp[0].u);s[1]= 0;(yyval.s)= s;} -#line 2268 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 10: /* number: UNSIGNED */ -#line 322 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.f)= (float64_t)(yyvsp[0].u);} -#line 2274 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 11: /* number: SIGNED */ -#line 322 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.f)= (float64_t)(yyvsp[0].i);} -#line 2280 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 13: /* dimension: number "pt" */ -#line 325 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.d)= ROUND((yyvsp[-1].f)*ONE);RNG("Dimension",(yyval.d),-MAX_DIMEN,MAX_DIMEN);} -#line 2286 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 14: /* dimension: number "in" */ -#line 326 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.d)= ROUND((yyvsp[-1].f)*ONE*72.27);RNG("Dimension",(yyval.d),-MAX_DIMEN,MAX_DIMEN);} -#line 2292 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 15: /* dimension: number "mm" */ -#line 327 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.d)= ROUND((yyvsp[-1].f)*ONE*(72.27/25.4));RNG("Dimension",(yyval.d),-MAX_DIMEN,MAX_DIMEN);} -#line 2298 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 16: /* xdimen: dimension number "h" number "v" */ -#line 330 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.xd).w= (yyvsp[-4].d);(yyval.xd).h= (yyvsp[-3].f);(yyval.xd).v= (yyvsp[-1].f);} -#line 2304 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 17: /* xdimen: dimension number "h" */ -#line 331 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.xd).w= (yyvsp[-2].d);(yyval.xd).h= (yyvsp[-1].f);(yyval.xd).v= 0.0;} -#line 2310 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 18: /* xdimen: dimension number "v" */ -#line 332 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.xd).w= (yyvsp[-2].d);(yyval.xd).h= 0.0;(yyval.xd).v= (yyvsp[-1].f);} -#line 2316 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 19: /* xdimen: dimension */ -#line 333 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.xd).w= (yyvsp[0].d);(yyval.xd).h= 0.0;(yyval.xd).v= 0.0;} -#line 2322 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 20: /* xdimen_node: start "xdimen" xdimen ">" */ -#line 337 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_tags((yyvsp[-3].u),hput_xdimen(&((yyvsp[-1].xd))));} -#line 2328 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 21: /* order: "pt" */ -#line 341 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.o)= normal_o;} -#line 2334 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 22: /* order: "fil" */ -#line 341 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.o)= fil_o;} -#line 2340 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 23: /* order: "fill" */ -#line 341 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.o)= fill_o;} -#line 2346 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 24: /* order: "filll" */ -#line 341 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.o)= filll_o;} -#line 2352 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 25: /* stretch: number order */ -#line 343 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.st).f= (yyvsp[-1].f);(yyval.st).o= (yyvsp[0].o);} -#line 2358 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 26: /* penalty: integer */ -#line 346 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {RNG("Penalty",(yyvsp[0].i),-20000,+20000);(yyval.i)= (yyvsp[0].i);} -#line 2364 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 27: /* content_node: start "penalty" penalty ">" */ -#line 347 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_tags((yyvsp[-3].u),hput_int((yyvsp[-1].i)));} -#line 2370 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 29: /* rule_dimension: "|" */ -#line 350 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.d)= RUNNING_DIMEN;} -#line 2376 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 30: /* rule: rule_dimension rule_dimension rule_dimension */ -#line 352 "../../../texk/web2c/hitexdir/hishrink-parser.y" -{(yyval.r).h= (yyvsp[-2].d);(yyval.r).d= (yyvsp[-1].d);(yyval.r).w= (yyvsp[0].d); -if((yyvsp[0].d)==RUNNING_DIMEN&&((yyvsp[-2].d)==RUNNING_DIMEN||(yyvsp[-1].d)==RUNNING_DIMEN)) -QUIT("Incompatible running dimensions 0x%x 0x%x 0x%x",(yyvsp[-2].d),(yyvsp[-1].d),(yyvsp[0].d));} -#line 2384 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 31: /* rule_node: start "rule" rule ">" */ -#line 355 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_tags((yyvsp[-3].u),hput_rule(&((yyvsp[-1].r))));} -#line 2390 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 33: /* explicit: %empty */ -#line 359 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.b)= false;} -#line 2396 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 34: /* explicit: "!" */ -#line 359 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.b)= true;} -#line 2402 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 35: /* kern: explicit xdimen */ -#line 360 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.kt).x= (yyvsp[-1].b);(yyval.kt).d= (yyvsp[0].xd);} -#line 2408 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 36: /* content_node: start "kern" kern ">" */ -#line 361 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_tags((yyvsp[-3].u),hput_kern(&((yyvsp[-1].kt))));} -#line 2414 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 37: /* plus: %empty */ -#line 364 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.st).f= 0.0;(yyval.st).o= 0;} -#line 2420 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 38: /* plus: "plus" stretch */ -#line 364 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.st)= (yyvsp[0].st);} -#line 2426 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 39: /* minus: %empty */ -#line 365 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.st).f= 0.0;(yyval.st).o= 0;} -#line 2432 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 40: /* minus: "minus" stretch */ -#line 365 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.st)= (yyvsp[0].st);} -#line 2438 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 41: /* glue: xdimen plus minus */ -#line 366 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.g).w= (yyvsp[-2].xd);(yyval.g).p= (yyvsp[-1].st);(yyval.g).m= (yyvsp[0].st);} -#line 2444 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 42: /* content_node: start "glue" glue ">" */ -#line 367 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {if(ZERO_GLUE((yyvsp[-1].g))){HPUT8(zero_skip_no); -hput_tags((yyvsp[-3].u),TAG(glue_kind,0));}else hput_tags((yyvsp[-3].u),hput_glue(&((yyvsp[-1].g))));} -#line 2451 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 43: /* glue_node: start "glue" glue ">" */ -#line 370 "../../../texk/web2c/hitexdir/hishrink-parser.y" -{if(ZERO_GLUE((yyvsp[-1].g))){hpos--;(yyval.b)= false;} -else{hput_tags((yyvsp[-3].u),hput_glue(&((yyvsp[-1].g))));(yyval.b)= true;}} -#line 2458 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 44: /* position: %empty */ -#line 374 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.u)= hpos-hstart;} -#line 2464 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 47: /* estimate: %empty */ -#line 377 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hpos+= 2;} -#line 2470 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 48: /* estimate: UNSIGNED */ -#line 378 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hpos+= hsize_bytes((yyvsp[0].u))+1;} -#line 2476 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 49: /* list: start estimate content_list ">" */ -#line 380 "../../../texk/web2c/hitexdir/hishrink-parser.y" -{(yyval.l).k= list_kind;(yyval.l).p= (yyvsp[-1].u);(yyval.l).s= (hpos-hstart)-(yyvsp[-1].u); -hput_tags((yyvsp[-3].u),hput_list((yyvsp[-3].u)+1,&((yyval.l))));} -#line 2483 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 50: /* $@1: %empty */ -#line 385 "../../../texk/web2c/hitexdir/hishrink-parser.y" -{hpos+= 4;} -#line 2489 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 51: /* list: TXT_START position $@1 text TXT_END */ -#line 387 "../../../texk/web2c/hitexdir/hishrink-parser.y" -{(yyval.l).k= text_kind;(yyval.l).p= (yyvsp[-1].u);(yyval.l).s= (hpos-hstart)-(yyvsp[-1].u); -hput_tags((yyvsp[-3].u),hput_list((yyvsp[-3].u)+1,&((yyval.l))));} -#line 2496 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 54: /* txt: TXT_CC */ -#line 391 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_txt_cc((yyvsp[0].u));} -#line 2502 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 55: /* txt: TXT_FONT */ -#line 392 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {REF(font_kind,(yyvsp[0].u));hput_txt_font((yyvsp[0].u));} -#line 2508 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 56: /* txt: TXT_GLOBAL */ -#line 393 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {REF((yyvsp[0].rf).k,(yyvsp[0].rf).n);hput_txt_global(&((yyvsp[0].rf)));} -#line 2514 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 57: /* txt: TXT_LOCAL */ -#line 394 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {RNG("Font parameter",(yyvsp[0].u),0,11);hput_txt_local((yyvsp[0].u));} -#line 2520 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 58: /* txt: TXT_FONT_GLUE */ -#line 395 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {HPUTX(1);HPUT8(txt_glue);} -#line 2526 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 59: /* txt: TXT_FONT_HYPHEN */ -#line 396 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {HPUTX(1);HPUT8(txt_hyphen);} -#line 2532 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 60: /* txt: TXT_IGNORE */ -#line 397 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {HPUTX(1);HPUT8(txt_ignore);} -#line 2538 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 61: /* $@2: %empty */ -#line 398 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {HPUTX(1);HPUT8(txt_node);} -#line 2544 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 63: /* box_dimen: dimension dimension dimension */ -#line 403 "../../../texk/web2c/hitexdir/hishrink-parser.y" -{(yyval.info)= hput_box_dimen((yyvsp[-2].d),(yyvsp[-1].d),(yyvsp[0].d));} -#line 2550 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 64: /* box_shift: %empty */ -#line 404 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= b000;} -#line 2556 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 65: /* box_shift: "shifted" dimension */ -#line 405 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= hput_box_shift((yyvsp[0].d));} -#line 2562 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 66: /* box_glue_set: %empty */ -#line 407 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= b000;} -#line 2568 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 67: /* box_glue_set: "plus" stretch */ -#line 408 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= hput_box_glue_set(+1,(yyvsp[0].st).f,(yyvsp[0].st).o);} -#line 2574 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 68: /* box_glue_set: "minus" stretch */ -#line 409 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= hput_box_glue_set(-1,(yyvsp[0].st).f,(yyvsp[0].st).o);} -#line 2580 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 69: /* box: box_dimen box_shift box_glue_set list */ -#line 412 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= (yyvsp[-3].info)|(yyvsp[-2].info)|(yyvsp[-1].info);} -#line 2586 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 70: /* hbox_node: start "hbox" box ">" */ -#line 414 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_tags((yyvsp[-3].u),TAG(hbox_kind,(yyvsp[-1].info)));} -#line 2592 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 71: /* vbox_node: start "vbox" box ">" */ -#line 415 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_tags((yyvsp[-3].u),TAG(vbox_kind,(yyvsp[-1].info)));} -#line 2598 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 74: /* box_flex: plus minus */ -#line 419 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_stretch(&((yyvsp[-1].st)));hput_stretch(&((yyvsp[0].st)));} -#line 2604 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 75: /* xbox: box_dimen box_shift box_flex xdimen_ref list */ -#line 420 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= (yyvsp[-4].info)|(yyvsp[-3].info);} -#line 2610 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 76: /* xbox: box_dimen box_shift box_flex xdimen_node list */ -#line 421 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= (yyvsp[-4].info)|(yyvsp[-3].info)|b100;} -#line 2616 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 77: /* box_goal: "to" xdimen_ref */ -#line 423 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= b000;} -#line 2622 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 78: /* box_goal: "add" xdimen_ref */ -#line 424 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= b001;} -#line 2628 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 79: /* box_goal: "to" xdimen_node */ -#line 425 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= b100;} -#line 2634 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 80: /* box_goal: "add" xdimen_node */ -#line 426 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= b101;} -#line 2640 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 81: /* hpack: box_shift box_goal list */ -#line 428 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= (yyvsp[-1].info);} -#line 2646 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 82: /* $@3: %empty */ -#line 429 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {HPUT32((yyvsp[0].d));} -#line 2652 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 83: /* vpack: box_shift "max" "depth" dimension $@3 box_goal list */ -#line 429 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= (yyvsp[-6].info)|(yyvsp[-1].info);} -#line 2658 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 84: /* vxbox_node: start "vset" xbox ">" */ -#line 431 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_tags((yyvsp[-3].u),TAG(vset_kind,(yyvsp[-1].info)));} -#line 2664 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 85: /* vxbox_node: start "vpack" vpack ">" */ -#line 432 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_tags((yyvsp[-3].u),TAG(vpack_kind,(yyvsp[-1].info)));} -#line 2670 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 86: /* hxbox_node: start "hset" xbox ">" */ -#line 435 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_tags((yyvsp[-3].u),TAG(hset_kind,(yyvsp[-1].info)));} -#line 2676 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 87: /* hxbox_node: start "hpack" hpack ">" */ -#line 436 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_tags((yyvsp[-3].u),TAG(hpack_kind,(yyvsp[-1].info)));} -#line 2682 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 90: /* ltype: %empty */ -#line 441 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= 1;} -#line 2688 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 91: /* ltype: "align" */ -#line 441 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= 1;} -#line 2694 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 92: /* ltype: "center" */ -#line 441 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= 2;} -#line 2700 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 93: /* ltype: "expand" */ -#line 441 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= 3;} -#line 2706 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 94: /* leaders: glue_node ltype rule_node */ -#line 442 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {if((yyvsp[-2].b))(yyval.info)= (yyvsp[-1].info)|b100;else (yyval.info)= (yyvsp[-1].info);} -#line 2712 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 95: /* leaders: glue_node ltype hbox_node */ -#line 443 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {if((yyvsp[-2].b))(yyval.info)= (yyvsp[-1].info)|b100;else (yyval.info)= (yyvsp[-1].info);} -#line 2718 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 96: /* leaders: glue_node ltype vbox_node */ -#line 444 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {if((yyvsp[-2].b))(yyval.info)= (yyvsp[-1].info)|b100;else (yyval.info)= (yyvsp[-1].info);} -#line 2724 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 97: /* content_node: start "leaders" leaders ">" */ -#line 445 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_tags((yyvsp[-3].u),TAG(leaders_kind,(yyvsp[-1].info)));} -#line 2730 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 98: /* $@4: %empty */ -#line 448 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {if((yyvsp[0].d)!=0)HPUT32((yyvsp[0].d));} -#line 2736 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 99: /* baseline: dimension $@4 glue_node glue_node */ -#line 449 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= b000;if((yyvsp[-3].d)!=0)(yyval.info)|= b001; -if((yyvsp[-1].b))(yyval.info)|= b100; -if((yyvsp[0].b))(yyval.info)|= b010; -} -#line 2745 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 100: /* content_node: start "baseline" baseline ">" */ -#line 454 "../../../texk/web2c/hitexdir/hishrink-parser.y" -{if((yyvsp[-1].info)==b000)HPUT8(0);hput_tags((yyvsp[-3].u),TAG(baseline_kind,(yyvsp[-1].info)));} -#line 2751 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 102: /* cc_list: cc_list TXT_CC */ -#line 457 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_utf8((yyvsp[0].u));} -#line 2757 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 103: /* lig_cc: UNSIGNED */ -#line 458 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {RNG("UTF-8 code",(yyvsp[0].u),0,0x1FFFFF);(yyval.u)= hpos-hstart;hput_utf8((yyvsp[0].u));} -#line 2763 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 104: /* lig_cc: CHARCODE */ -#line 459 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.u)= hpos-hstart;hput_utf8((yyvsp[0].u));} -#line 2769 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 105: /* ref: REFERENCE */ -#line 460 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {HPUT8((yyvsp[0].u));(yyval.u)= (yyvsp[0].u);} -#line 2775 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 106: /* $@5: %empty */ -#line 461 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {REF(font_kind,(yyvsp[0].u));} -#line 2781 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 107: /* ligature: ref $@5 lig_cc TXT_START cc_list TXT_END */ -#line 462 "../../../texk/web2c/hitexdir/hishrink-parser.y" -{(yyval.lg).f= (yyvsp[-5].u);(yyval.lg).l.p= (yyvsp[-3].u);(yyval.lg).l.s= (hpos-hstart)-(yyvsp[-3].u); -RNG("Ligature size",(yyval.lg).l.s,0,255);} -#line 2788 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 108: /* content_node: start "ligature" ligature ">" */ -#line 464 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_tags((yyvsp[-3].u),hput_ligature(&((yyvsp[-1].lg))));} -#line 2794 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 109: /* replace_count: explicit */ -#line 467 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {if((yyvsp[0].b)){(yyval.u)= 0x80;HPUT8(0x80);}else (yyval.u)= 0x00;} -#line 2800 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 110: /* replace_count: explicit UNSIGNED */ -#line 468 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {RNG("Replace count",(yyvsp[0].u),0,31); -(yyval.u)= ((yyvsp[0].u))|(((yyvsp[-1].b))?0x80:0x00);if((yyval.u)!=0)HPUT8((yyval.u));} -#line 2807 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 111: /* disc: replace_count list list */ -#line 470 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.dc).r= (yyvsp[-2].u);(yyval.dc).p= (yyvsp[-1].l);(yyval.dc).q= (yyvsp[0].l); -if((yyvsp[0].l).s==0){hpos= hpos-2;if((yyvsp[-1].l).s==0)hpos= hpos-2;}} -#line 2814 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 112: /* disc: replace_count list */ -#line 472 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.dc).r= (yyvsp[-1].u);(yyval.dc).p= (yyvsp[0].l);if((yyvsp[0].l).s==0)hpos= hpos-2;(yyval.dc).q.s= 0;} -#line 2820 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 113: /* disc: replace_count */ -#line 473 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.dc).r= (yyvsp[0].u);(yyval.dc).p.s= 0;(yyval.dc).q.s= 0;} -#line 2826 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 114: /* disc_node: start "disc" disc ">" */ -#line 477 "../../../texk/web2c/hitexdir/hishrink-parser.y" -{hput_tags((yyvsp[-3].u),hput_disc(&((yyvsp[-1].dc))));} -#line 2832 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 116: /* par_dimen: xdimen */ -#line 482 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_xdimen_node(&((yyvsp[0].xd)));} -#line 2838 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 117: /* par: xdimen_ref param_ref list */ -#line 483 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= b000;} -#line 2844 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 118: /* par: xdimen_ref empty_param_list non_empty_param_list list */ -#line 484 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= b010;} -#line 2850 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 119: /* par: xdimen_ref empty_param_list list */ -#line 485 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= b010;} -#line 2856 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 120: /* $@6: %empty */ -#line 486 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_xdimen_node(&((yyvsp[-1].xd)));} -#line 2862 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 121: /* par: xdimen param_ref $@6 list */ -#line 486 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= b100;} -#line 2868 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 122: /* par: par_dimen empty_param_list non_empty_param_list list */ -#line 487 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= b110;} -#line 2874 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 123: /* par: par_dimen empty_param_list list */ -#line 488 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= b110;} -#line 2880 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 124: /* content_node: start "par" par ">" */ -#line 490 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_tags((yyvsp[-3].u),TAG(par_kind,(yyvsp[-1].info)));} -#line 2886 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 125: /* math: param_ref list */ -#line 493 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= b000;} -#line 2892 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 126: /* math: param_ref list hbox_node */ -#line 494 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= b001;} -#line 2898 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 127: /* math: param_ref hbox_node list */ -#line 495 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= b010;} -#line 2904 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 128: /* math: empty_param_list list */ -#line 496 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= b100;} -#line 2910 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 129: /* math: empty_param_list list hbox_node */ -#line 497 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= b101;} -#line 2916 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 130: /* math: empty_param_list hbox_node list */ -#line 498 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= b110;} -#line 2922 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 131: /* math: empty_param_list non_empty_param_list list */ -#line 499 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= b100;} -#line 2928 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 132: /* math: empty_param_list non_empty_param_list list hbox_node */ -#line 500 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= b101;} -#line 2934 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 133: /* math: empty_param_list non_empty_param_list hbox_node list */ -#line 501 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= b110;} -#line 2940 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 134: /* content_node: start "math" math ">" */ -#line 503 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_tags((yyvsp[-3].u),TAG(math_kind,(yyvsp[-1].info)));} -#line 2946 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 135: /* on_off: "on" */ -#line 506 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.i)= 1;} -#line 2952 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 136: /* on_off: "off" */ -#line 506 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.i)= 0;} -#line 2958 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 137: /* math: on_off */ -#line 507 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= b011|((yyvsp[0].i)<<2);} -#line 2964 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 138: /* content_node: start "adjust" list ">" */ -#line 510 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_tags((yyvsp[-3].u),TAG(adjust_kind,1));} -#line 2970 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 139: /* span_count: UNSIGNED */ -#line 513 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= hput_span_count((yyvsp[0].u));} -#line 2976 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 140: /* content_node: start "item" content_node ">" */ -#line 514 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_tags((yyvsp[-3].u),TAG(item_kind,1));} -#line 2982 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 141: /* content_node: start "item" span_count content_node ">" */ -#line 515 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_tags((yyvsp[-4].u),TAG(item_kind,(yyvsp[-2].info)));} -#line 2988 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 142: /* content_node: start "item" list ">" */ -#line 516 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_tags((yyvsp[-3].u),TAG(item_kind,b000));} -#line 2994 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 143: /* table: "h" box_goal list list */ -#line 518 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= (yyvsp[-2].info);} -#line 3000 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 144: /* table: "v" box_goal list list */ -#line 519 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= (yyvsp[-2].info)|b010;} -#line 3006 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 145: /* content_node: start "table" table ">" */ -#line 521 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_tags((yyvsp[-3].u),TAG(table_kind,(yyvsp[-1].info)));} -#line 3012 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 146: /* image_dimen: dimension dimension */ -#line 524 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.x).w= (yyvsp[-1].d);(yyval.x).h= (yyvsp[0].d);} -#line 3018 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 147: /* image_dimen: %empty */ -#line 524 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.x).w= (yyval.x).h= 0;} -#line 3024 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 148: /* image: UNSIGNED image_dimen plus minus */ -#line 525 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.x).w= (yyvsp[-2].x).w;(yyval.x).h= (yyvsp[-2].x).h;(yyval.x).p= (yyvsp[-1].st);(yyval.x).m= (yyvsp[0].st);RNG("Section number",(yyvsp[-3].u),3,max_section_no);(yyval.x).n= (yyvsp[-3].u);} -#line 3030 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 149: /* content_node: start "image" image ">" */ -#line 526 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_tags((yyvsp[-3].u),hput_image(&((yyvsp[-1].x))));} -#line 3036 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 150: /* max_value: "outline" UNSIGNED */ -#line 529 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {max_outline= (yyvsp[0].u); -RNG("max outline",max_outline,0,0xFFFF); -DBG(DBGDEF|DBGLABEL,"Setting max outline to %d\n",max_outline); -} -#line 3045 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 151: /* placement: "top" */ -#line 535 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.i)= LABEL_TOP;} -#line 3051 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 152: /* placement: "bot" */ -#line 535 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.i)= LABEL_BOT;} -#line 3057 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 153: /* placement: "mid" */ -#line 535 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.i)= LABEL_MID;} -#line 3063 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 154: /* placement: %empty */ -#line 535 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.i)= LABEL_MID;} -#line 3069 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 155: /* content_node: "<" "label" REFERENCE placement ">" */ -#line 537 "../../../texk/web2c/hitexdir/hishrink-parser.y" -{hset_label((yyvsp[-2].u),(yyvsp[-1].i));} -#line 3075 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 156: /* content_node: start "link" REFERENCE on_off ">" */ -#line 541 "../../../texk/web2c/hitexdir/hishrink-parser.y" -{hput_tags((yyvsp[-4].u),hput_link((yyvsp[-2].u),(yyvsp[-1].i)));} -#line 3081 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 157: /* def_node: "<" "outline" REFERENCE integer position list ">" */ -#line 544 "../../../texk/web2c/hitexdir/hishrink-parser.y" - { -static int outline_no= -1; -(yyval.rf).k= outline_kind;(yyval.rf).n= (yyvsp[-4].u); -if((yyvsp[-1].l).s==0)QUIT("Outline with empty title in line %d",yylineno); -outline_no++; -hset_outline(outline_no,(yyvsp[-4].u),(yyvsp[-3].i),(yyvsp[-2].u)); -} -#line 3093 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 158: /* stream_link: ref */ -#line 553 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {REF_RNG(stream_kind,(yyvsp[0].u));} -#line 3099 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 159: /* stream_link: "*" */ -#line 553 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {HPUT8(255);} -#line 3105 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 160: /* stream_split: stream_link stream_link UNSIGNED */ -#line 554 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {RNG("split ratio",(yyvsp[0].u),0,1000);HPUT16((yyvsp[0].u));} -#line 3111 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 161: /* $@7: %empty */ -#line 555 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {RNG("magnification factor",(yyvsp[0].u),0,1000);HPUT16((yyvsp[0].u));} -#line 3117 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 163: /* stream_type: stream_info */ -#line 557 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= 0;} -#line 3123 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 164: /* stream_type: "first" */ -#line 557 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= 1;} -#line 3129 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 165: /* stream_type: "last" */ -#line 557 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= 2;} -#line 3135 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 166: /* stream_type: "top" */ -#line 557 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= 3;} -#line 3141 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 167: /* stream_def_node: start "stream (definition)" ref stream_type list xdimen_node glue_node list glue_node ">" */ -#line 561 "../../../texk/web2c/hitexdir/hishrink-parser.y" -{DEF((yyval.rf),stream_kind,(yyvsp[-7].u));hput_tags((yyvsp[-9].u),TAG(stream_kind,(yyvsp[-6].info)|b100));} -#line 3147 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 168: /* stream_ins_node: start "stream (definition)" ref ">" */ -#line 564 "../../../texk/web2c/hitexdir/hishrink-parser.y" -{RNG("Stream insertion",(yyvsp[-1].u),0,max_ref[stream_kind]);hput_tags((yyvsp[-3].u),TAG(stream_kind,b100));} -#line 3153 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 171: /* stream: empty_param_list list */ -#line 569 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= b010;} -#line 3159 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 172: /* stream: empty_param_list non_empty_param_list list */ -#line 570 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= b010;} -#line 3165 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 173: /* stream: param_ref list */ -#line 571 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.info)= b000;} -#line 3171 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 174: /* content_node: start "stream" stream_ref stream ">" */ -#line 573 "../../../texk/web2c/hitexdir/hishrink-parser.y" -{hput_tags((yyvsp[-4].u),TAG(stream_kind,(yyvsp[-1].info)));} -#line 3177 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 175: /* page_priority: %empty */ -#line 576 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {HPUT8(1);} -#line 3183 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 176: /* page_priority: UNSIGNED */ -#line 577 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {RNG("page priority",(yyvsp[0].u),0,255);HPUT8((yyvsp[0].u));} -#line 3189 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 179: /* $@8: %empty */ -#line 581 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_string((yyvsp[0].s));} -#line 3195 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 180: /* $@9: %empty */ -#line 581 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {HPUT32((yyvsp[0].d));} -#line 3201 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 182: /* content_node: "<" "range" REFERENCE "on" ">" */ -#line 587 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {REF(page_kind,(yyvsp[-2].u));hput_range((yyvsp[-2].u),true);} -#line 3207 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 183: /* content_node: "<" "range" REFERENCE "off" ">" */ -#line 588 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {REF(page_kind,(yyvsp[-2].u));hput_range((yyvsp[-2].u),false);} -#line 3213 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 185: /* $@10: %empty */ -#line 594 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {new_directory((yyvsp[0].u)+1);new_output_buffers();} -#line 3219 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 189: /* entry: "<" "entry" UNSIGNED string ">" */ -#line 597 "../../../texk/web2c/hitexdir/hishrink-parser.y" -{RNG("Section number",(yyvsp[-2].u),3,max_section_no);hset_entry(&(dir[(yyvsp[-2].u)]),(yyvsp[-2].u),0,0,(yyvsp[-1].s));} -#line 3225 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 190: /* $@11: %empty */ -#line 600 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_definitions_start();} -#line 3231 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 191: /* definition_section: "<" "definitions" $@11 max_definitions definition_list ">" */ -#line 602 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_definitions_end();} -#line 3237 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 194: /* max_definitions: "<" "max" max_list ">" */ -#line 607 "../../../texk/web2c/hitexdir/hishrink-parser.y" -{/*245:*/ - -if(max_ref[label_kind]>=0) -ALLOCATE(labels,max_ref[label_kind]+1,label_t); -/*:245*//*266:*/ - -if(max_outline>=0) -ALLOCATE(outlines,max_outline+1,outline_t); -/*:266*//*293:*/ - -ALLOCATE(page_on,max_ref[page_kind]+1,int); -ALLOCATE(range_pos,2*(max_ref[range_kind]+1),range_pos_t); -/*:293*//*357:*/ - -definition_bits[0][int_kind]= (1<<(MAX_INT_DEFAULT+1))-1; -definition_bits[0][dimen_kind]= (1<<(MAX_DIMEN_DEFAULT+1))-1; -definition_bits[0][xdimen_kind]= (1<<(MAX_XDIMEN_DEFAULT+1))-1; -definition_bits[0][glue_kind]= (1<<(MAX_GLUE_DEFAULT+1))-1; -definition_bits[0][baseline_kind]= (1<<(MAX_BASELINE_DEFAULT+1))-1; -definition_bits[0][page_kind]= (1<<(MAX_PAGE_DEFAULT+1))-1; -definition_bits[0][stream_kind]= (1<<(MAX_STREAM_DEFAULT+1))-1; -definition_bits[0][range_kind]= (1<<(MAX_RANGE_DEFAULT+1))-1; -/*:357*//*372:*/ - -ALLOCATE(hfont_name,max_ref[font_kind]+1,char*); -/*:372*/ -hput_max_definitions();} -#line 3269 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 197: /* max_value: "font" UNSIGNED */ -#line 637 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hset_max(font_kind,(yyvsp[0].u));} -#line 3275 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 198: /* max_value: "int" UNSIGNED */ -#line 638 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hset_max(int_kind,(yyvsp[0].u));} -#line 3281 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 199: /* max_value: "dimen" UNSIGNED */ -#line 639 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hset_max(dimen_kind,(yyvsp[0].u));} -#line 3287 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 200: /* max_value: "ligature" UNSIGNED */ -#line 640 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hset_max(ligature_kind,(yyvsp[0].u));} -#line 3293 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 201: /* max_value: "disc" UNSIGNED */ -#line 641 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hset_max(disc_kind,(yyvsp[0].u));} -#line 3299 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 202: /* max_value: "glue" UNSIGNED */ -#line 642 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hset_max(glue_kind,(yyvsp[0].u));} -#line 3305 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 203: /* max_value: "language" UNSIGNED */ -#line 643 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hset_max(language_kind,(yyvsp[0].u));} -#line 3311 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 204: /* max_value: "rule" UNSIGNED */ -#line 644 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hset_max(rule_kind,(yyvsp[0].u));} -#line 3317 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 205: /* max_value: "image" UNSIGNED */ -#line 645 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hset_max(image_kind,(yyvsp[0].u));} -#line 3323 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 206: /* max_value: "leaders" UNSIGNED */ -#line 646 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hset_max(leaders_kind,(yyvsp[0].u));} -#line 3329 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 207: /* max_value: "baseline" UNSIGNED */ -#line 647 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hset_max(baseline_kind,(yyvsp[0].u));} -#line 3335 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 208: /* max_value: "xdimen" UNSIGNED */ -#line 648 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hset_max(xdimen_kind,(yyvsp[0].u));} -#line 3341 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 209: /* max_value: "param" UNSIGNED */ -#line 649 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hset_max(param_kind,(yyvsp[0].u));} -#line 3347 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 210: /* max_value: "stream (definition)" UNSIGNED */ -#line 650 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hset_max(stream_kind,(yyvsp[0].u));} -#line 3353 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 211: /* max_value: "page" UNSIGNED */ -#line 651 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hset_max(page_kind,(yyvsp[0].u));} -#line 3359 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 212: /* max_value: "range" UNSIGNED */ -#line 652 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hset_max(range_kind,(yyvsp[0].u));} -#line 3365 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 213: /* max_value: "label" UNSIGNED */ -#line 653 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hset_max(label_kind,(yyvsp[0].u));} -#line 3371 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 214: /* def_node: start "font" ref font ">" */ -#line 658 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {DEF((yyval.rf),font_kind,(yyvsp[-2].u));hput_tags((yyvsp[-4].u),(yyvsp[-1].info));} -#line 3377 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 215: /* def_node: start "int" ref integer ">" */ -#line 659 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {DEF((yyval.rf),int_kind,(yyvsp[-2].u));hput_tags((yyvsp[-4].u),hput_int((yyvsp[-1].i)));} -#line 3383 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 216: /* def_node: start "dimen" ref dimension ">" */ -#line 660 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {DEF((yyval.rf),dimen_kind,(yyvsp[-2].u));hput_tags((yyvsp[-4].u),hput_dimen((yyvsp[-1].d)));} -#line 3389 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 217: /* def_node: start "language" ref string ">" */ -#line 661 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {DEF((yyval.rf),language_kind,(yyvsp[-2].u));hput_string((yyvsp[-1].s));hput_tags((yyvsp[-4].u),TAG(language_kind,0));} -#line 3395 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 218: /* def_node: start "glue" ref glue ">" */ -#line 662 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {DEF((yyval.rf),glue_kind,(yyvsp[-2].u));hput_tags((yyvsp[-4].u),hput_glue(&((yyvsp[-1].g))));} -#line 3401 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 219: /* def_node: start "xdimen" ref xdimen ">" */ -#line 663 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {DEF((yyval.rf),xdimen_kind,(yyvsp[-2].u));hput_tags((yyvsp[-4].u),hput_xdimen(&((yyvsp[-1].xd))));} -#line 3407 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 220: /* def_node: start "rule" ref rule ">" */ -#line 664 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {DEF((yyval.rf),rule_kind,(yyvsp[-2].u));hput_tags((yyvsp[-4].u),hput_rule(&((yyvsp[-1].r))));} -#line 3413 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 221: /* def_node: start "leaders" ref leaders ">" */ -#line 665 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {DEF((yyval.rf),leaders_kind,(yyvsp[-2].u));hput_tags((yyvsp[-4].u),TAG(leaders_kind,(yyvsp[-1].info)));} -#line 3419 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 222: /* def_node: start "baseline" ref baseline ">" */ -#line 666 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {DEF((yyval.rf),baseline_kind,(yyvsp[-2].u));hput_tags((yyvsp[-4].u),TAG(baseline_kind,(yyvsp[-1].info)));} -#line 3425 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 223: /* def_node: start "ligature" ref ligature ">" */ -#line 667 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {DEF((yyval.rf),ligature_kind,(yyvsp[-2].u));hput_tags((yyvsp[-4].u),hput_ligature(&((yyvsp[-1].lg))));} -#line 3431 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 224: /* def_node: start "disc" ref disc ">" */ -#line 668 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {DEF((yyval.rf),disc_kind,(yyvsp[-2].u));hput_tags((yyvsp[-4].u),hput_disc(&((yyvsp[-1].dc))));} -#line 3437 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 225: /* def_node: start "image" ref image ">" */ -#line 669 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {DEF((yyval.rf),image_kind,(yyvsp[-2].u));hput_tags((yyvsp[-4].u),hput_image(&((yyvsp[-1].x))));} -#line 3443 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 226: /* def_node: start "param" ref parameters ">" */ -#line 670 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {DEF((yyval.rf),param_kind,(yyvsp[-2].u));hput_tags((yyvsp[-4].u),hput_list((yyvsp[-4].u)+2,&((yyvsp[-1].l))));} -#line 3449 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 227: /* def_node: start "page" ref page ">" */ -#line 671 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {DEF((yyval.rf),page_kind,(yyvsp[-2].u));hput_tags((yyvsp[-4].u),TAG(page_kind,0));} -#line 3455 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 228: /* def_node: start "int" ref ref ">" */ -#line 675 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {DEF_REF((yyval.rf),int_kind,(yyvsp[-2].u),(yyvsp[-1].u));hput_tags((yyvsp[-4].u),TAG(int_kind,0));} -#line 3461 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 229: /* def_node: start "dimen" ref ref ">" */ -#line 676 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {DEF_REF((yyval.rf),dimen_kind,(yyvsp[-2].u),(yyvsp[-1].u));hput_tags((yyvsp[-4].u),TAG(dimen_kind,0));} -#line 3467 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 230: /* def_node: start "glue" ref ref ">" */ -#line 677 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {DEF_REF((yyval.rf),glue_kind,(yyvsp[-2].u),(yyvsp[-1].u));hput_tags((yyvsp[-4].u),TAG(glue_kind,0));} -#line 3473 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 232: /* def_list: def_list def_node */ -#line 681 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {check_param_def(&((yyvsp[0].rf)));} -#line 3479 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 233: /* parameters: estimate def_list */ -#line 682 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {(yyval.l).p= (yyvsp[0].u);(yyval.l).k= param_kind;(yyval.l).s= (hpos-hstart)-(yyvsp[0].u);} -#line 3485 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 234: /* empty_param_list: position */ -#line 685 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {HPUTX(2);hpos++;hput_tags((yyvsp[0].u),TAG(param_kind,1));} -#line 3491 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 235: /* $@12: %empty */ -#line 686 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hpos= hpos-2;} -#line 3497 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 236: /* non_empty_param_list: start "param" $@12 parameters ">" */ -#line 687 "../../../texk/web2c/hitexdir/hishrink-parser.y" -{hput_tags((yyvsp[-4].u)-2,hput_list((yyvsp[-4].u)-1,&((yyvsp[-1].l))));} -#line 3503 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 238: /* font_head: string dimension UNSIGNED UNSIGNED */ -#line 694 "../../../texk/web2c/hitexdir/hishrink-parser.y" -{uint8_t f= (yyvsp[-4].u);SET_DBIT(f,font_kind);hfont_name[f]= strdup((yyvsp[-3].s));(yyval.info)= hput_font_head(f,hfont_name[f],(yyvsp[-2].d),(yyvsp[-1].u),(yyvsp[0].u));} -#line 3509 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 241: /* font_param: start "penalty" fref penalty ">" */ -#line 699 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_tags((yyvsp[-4].u),hput_int((yyvsp[-1].i)));} -#line 3515 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 242: /* font_param: start "kern" fref kern ">" */ -#line 700 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_tags((yyvsp[-4].u),hput_kern(&((yyvsp[-1].kt))));} -#line 3521 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 243: /* font_param: start "ligature" fref ligature ">" */ -#line 701 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_tags((yyvsp[-4].u),hput_ligature(&((yyvsp[-1].lg))));} -#line 3527 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 244: /* font_param: start "disc" fref disc ">" */ -#line 702 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_tags((yyvsp[-4].u),hput_disc(&((yyvsp[-1].dc))));} -#line 3533 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 245: /* font_param: start "glue" fref glue ">" */ -#line 703 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_tags((yyvsp[-4].u),hput_glue(&((yyvsp[-1].g))));} -#line 3539 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 246: /* font_param: start "language" fref string ">" */ -#line 704 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_string((yyvsp[-1].s));hput_tags((yyvsp[-4].u),TAG(language_kind,0));} -#line 3545 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 247: /* font_param: start "rule" fref rule ">" */ -#line 705 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_tags((yyvsp[-4].u),hput_rule(&((yyvsp[-1].r))));} -#line 3551 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 248: /* font_param: start "image" fref image ">" */ -#line 706 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_tags((yyvsp[-4].u),hput_image(&((yyvsp[-1].x))));} -#line 3557 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 249: /* fref: ref */ -#line 708 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {RNG("Font parameter",(yyvsp[0].u),0,MAX_FONT_PARAMS);} -#line 3563 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 250: /* xdimen_ref: ref */ -#line 711 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {REF(xdimen_kind,(yyvsp[0].u));} -#line 3569 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 251: /* param_ref: ref */ -#line 712 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {REF(param_kind,(yyvsp[0].u));} -#line 3575 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 252: /* stream_ref: ref */ -#line 713 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {REF_RNG(stream_kind,(yyvsp[0].u));} -#line 3581 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 253: /* content_node: start "penalty" ref ">" */ -#line 717 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {REF(penalty_kind,(yyvsp[-1].u));hput_tags((yyvsp[-3].u),TAG(penalty_kind,0));} -#line 3587 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 254: /* content_node: start "kern" explicit ref ">" */ -#line 719 "../../../texk/web2c/hitexdir/hishrink-parser.y" -{REF(dimen_kind,(yyvsp[-1].u));hput_tags((yyvsp[-4].u),TAG(kern_kind,((yyvsp[-2].b))?b100:b000));} -#line 3593 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 255: /* content_node: start "kern" explicit "xdimen" ref ">" */ -#line 721 "../../../texk/web2c/hitexdir/hishrink-parser.y" -{REF(xdimen_kind,(yyvsp[-1].u));hput_tags((yyvsp[-5].u),TAG(kern_kind,((yyvsp[-3].b))?b101:b001));} -#line 3599 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 256: /* content_node: start "glue" ref ">" */ -#line 722 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {REF(glue_kind,(yyvsp[-1].u));hput_tags((yyvsp[-3].u),TAG(glue_kind,0));} -#line 3605 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 257: /* content_node: start "ligature" ref ">" */ -#line 723 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {REF(ligature_kind,(yyvsp[-1].u));hput_tags((yyvsp[-3].u),TAG(ligature_kind,0));} -#line 3611 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 258: /* content_node: start "disc" ref ">" */ -#line 724 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {REF(disc_kind,(yyvsp[-1].u));hput_tags((yyvsp[-3].u),TAG(disc_kind,0));} -#line 3617 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 259: /* content_node: start "rule" ref ">" */ -#line 725 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {REF(rule_kind,(yyvsp[-1].u));hput_tags((yyvsp[-3].u),TAG(rule_kind,0));} -#line 3623 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 260: /* content_node: start "image" ref ">" */ -#line 726 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {REF(image_kind,(yyvsp[-1].u));hput_tags((yyvsp[-3].u),TAG(image_kind,0));} -#line 3629 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 261: /* content_node: start "leaders" ref ">" */ -#line 727 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {REF(leaders_kind,(yyvsp[-1].u));hput_tags((yyvsp[-3].u),TAG(leaders_kind,0));} -#line 3635 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 262: /* content_node: start "baseline" ref ">" */ -#line 728 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {REF(baseline_kind,(yyvsp[-1].u));hput_tags((yyvsp[-3].u),TAG(baseline_kind,0));} -#line 3641 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 263: /* content_node: start "language" REFERENCE ">" */ -#line 729 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {REF(language_kind,(yyvsp[-1].u));hput_tags((yyvsp[-3].u),hput_language((yyvsp[-1].u)));} -#line 3647 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 264: /* glue_node: start "glue" ref ">" */ -#line 731 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {REF(glue_kind,(yyvsp[-1].u)); -if((yyvsp[-1].u)==zero_skip_no){hpos= hpos-2;(yyval.b)= false;} -else{hput_tags((yyvsp[-3].u),TAG(glue_kind,0));(yyval.b)= true;}} -#line 3655 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 265: /* $@13: %empty */ -#line 737 "../../../texk/web2c/hitexdir/hishrink-parser.y" - {hput_content_start();} -#line 3661 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - case 266: /* content_section: "<" "content" $@13 content_list ">" */ -#line 738 "../../../texk/web2c/hitexdir/hishrink-parser.y" -{hput_content_end();hput_range_defs();hput_label_defs();} -#line 3667 "../../../texk/web2c/hitexdir/hishrink-parser.c" - break; - - -#line 3671 "../../../texk/web2c/hitexdir/hishrink-parser.c" - - default: break; - } - /* User semantic actions sometimes alter yychar, and that requires - that yytoken be updated with the new translation. We take the - approach of translating immediately before every use of yytoken. - One alternative is translating here after every semantic action, - but that translation would be missed if the semantic action invokes - YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or - if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an - incorrect destructor might then be invoked immediately. In the - case of YYERROR or YYBACKUP, subsequent parser actions might lead - to an incorrect destructor call or verbose syntax error message - before the lookahead is translated. */ - YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc); - - YYPOPSTACK (yylen); - yylen = 0; - - *++yyvsp = yyval; - - /* Now 'shift' the result of the reduction. Determine what state - that goes to, based on the state we popped back to and the rule - number reduced by. */ - { - const int yylhs = yyr1[yyn] - YYNTOKENS; - const int yyi = yypgoto[yylhs] + *yyssp; - yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp - ? yytable[yyi] - : yydefgoto[yylhs]); - } - - goto yynewstate; - - -/*--------------------------------------. -| yyerrlab -- here on detecting error. | -`--------------------------------------*/ -yyerrlab: - /* Make sure we have latest lookahead translation. See comments at - user semantic actions for why this is necessary. */ - yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); - /* If not already recovering from an error, report this error. */ - if (!yyerrstatus) - { - ++yynerrs; - { - yypcontext_t yyctx - = {yyssp, yytoken}; - char const *yymsgp = YY_("syntax error"); - int yysyntax_error_status; - yysyntax_error_status = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx); - if (yysyntax_error_status == 0) - yymsgp = yymsg; - else if (yysyntax_error_status == -1) - { - if (yymsg != yymsgbuf) - YYSTACK_FREE (yymsg); - yymsg = YY_CAST (char *, - YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc))); - if (yymsg) - { - yysyntax_error_status - = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx); - yymsgp = yymsg; - } - else - { - yymsg = yymsgbuf; - yymsg_alloc = sizeof yymsgbuf; - yysyntax_error_status = YYENOMEM; - } - } - yyerror (yymsgp); - if (yysyntax_error_status == YYENOMEM) - YYNOMEM; - } - } - - if (yyerrstatus == 3) - { - /* If just tried and failed to reuse lookahead token after an - error, discard it. */ - - if (yychar <= YYEOF) - { - /* Return failure if at end of input. */ - if (yychar == YYEOF) - YYABORT; - } - else - { - yydestruct ("Error: discarding", - yytoken, &yylval); - yychar = YYEMPTY; - } - } - - /* Else will try to reuse lookahead token after shifting the error - token. */ - goto yyerrlab1; - - -/*---------------------------------------------------. -| yyerrorlab -- error raised explicitly by YYERROR. | -`---------------------------------------------------*/ -yyerrorlab: - /* Pacify compilers when the user code never invokes YYERROR and the - label yyerrorlab therefore never appears in user code. */ - if (0) - YYERROR; - ++yynerrs; - - /* Do not reclaim the symbols of the rule whose action triggered - this YYERROR. */ - YYPOPSTACK (yylen); - yylen = 0; - YY_STACK_PRINT (yyss, yyssp); - yystate = *yyssp; - goto yyerrlab1; - - -/*-------------------------------------------------------------. -| yyerrlab1 -- common code for both syntax error and YYERROR. | -`-------------------------------------------------------------*/ -yyerrlab1: - yyerrstatus = 3; /* Each real token shifted decrements this. */ - - /* Pop stack until we find a state that shifts the error token. */ - for (;;) - { - yyn = yypact[yystate]; - if (!yypact_value_is_default (yyn)) - { - yyn += YYSYMBOL_YYerror; - if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror) - { - yyn = yytable[yyn]; - if (0 < yyn) - break; - } - } - - /* Pop the current state because it cannot handle the error token. */ - if (yyssp == yyss) - YYABORT; - - - yydestruct ("Error: popping", - YY_ACCESSING_SYMBOL (yystate), yyvsp); - YYPOPSTACK (1); - yystate = *yyssp; - YY_STACK_PRINT (yyss, yyssp); - } - - YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN - *++yyvsp = yylval; - YY_IGNORE_MAYBE_UNINITIALIZED_END - - - /* Shift the error token. */ - YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp); - - yystate = yyn; - goto yynewstate; - - -/*-------------------------------------. -| yyacceptlab -- YYACCEPT comes here. | -`-------------------------------------*/ -yyacceptlab: - yyresult = 0; - goto yyreturnlab; - - -/*-----------------------------------. -| yyabortlab -- YYABORT comes here. | -`-----------------------------------*/ -yyabortlab: - yyresult = 1; - goto yyreturnlab; - - -/*-----------------------------------------------------------. -| yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. | -`-----------------------------------------------------------*/ -yyexhaustedlab: - yyerror (YY_("memory exhausted")); - yyresult = 2; - goto yyreturnlab; - - -/*----------------------------------------------------------. -| yyreturnlab -- parsing is finished, clean up and return. | -`----------------------------------------------------------*/ -yyreturnlab: - if (yychar != YYEMPTY) - { - /* Make sure we have latest lookahead translation. See comments at - user semantic actions for why this is necessary. */ - yytoken = YYTRANSLATE (yychar); - yydestruct ("Cleanup: discarding lookahead", - yytoken, &yylval); - } - /* Do not reclaim the symbols of the rule whose action triggered - this YYABORT or YYACCEPT. */ - YYPOPSTACK (yylen); - YY_STACK_PRINT (yyss, yyssp); - while (yyssp != yyss) - { - yydestruct ("Cleanup: popping", - YY_ACCESSING_SYMBOL (+*yyssp), yyvsp); - YYPOPSTACK (1); - } -#ifndef yyoverflow - if (yyss != yyssa) - YYSTACK_FREE (yyss); -#endif - if (yymsg != yymsgbuf) - YYSTACK_FREE (yymsg); - return yyresult; -} - -#line 741 "../../../texk/web2c/hitexdir/hishrink-parser.y" - -/*:510*/ diff --git a/Build/source/texk/web2c/hitexdir/hishrink-parser.h b/Build/source/texk/web2c/hitexdir/hishrink-parser.h deleted file mode 100644 index c6b0ea3d8e2..00000000000 --- a/Build/source/texk/web2c/hitexdir/hishrink-parser.h +++ /dev/null @@ -1,258 +0,0 @@ -/* A Bison parser, made by GNU Bison 3.8.2. */ - -/* Bison interface for Yacc-like parsers in C - - Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation, - Inc. - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see . */ - -/* As a special exception, you may create a larger work that contains - part or all of the Bison parser skeleton and distribute that work - under terms of your choice, so long as that work isn't itself a - parser generator using the skeleton or a modified version thereof - as a parser skeleton. Alternatively, if you modify or redistribute - the parser skeleton itself, you may (at your option) remove this - special exception, which will cause the skeleton and the resulting - Bison output files to be licensed under the GNU General Public - License without this special exception. - - This special exception was added by the Free Software Foundation in - version 2.2 of Bison. */ - -/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, - especially those whose name start with YY_ or yy_. They are - private implementation details that can be changed or removed. */ - -#ifndef YY_YY__TEXK_WEB_C_HITEXDIR_HISHRINK_PARSER_H_INCLUDED -# define YY_YY__TEXK_WEB_C_HITEXDIR_HISHRINK_PARSER_H_INCLUDED -/* Debug traces. */ -#ifndef YYDEBUG -# define YYDEBUG 0 -#endif -#if YYDEBUG -extern int yydebug; -#endif - -/* Token kinds. */ -#ifndef YYTOKENTYPE -# define YYTOKENTYPE - enum yytokentype - { - YYEMPTY = -2, - YYEOF = 0, /* "end of file" */ - YYerror = 256, /* error */ - YYUNDEF = 257, /* "invalid token" */ - START = 258, /* "<" */ - END = 259, /* ">" */ - GLYPH = 260, /* "glyph" */ - UNSIGNED = 261, /* UNSIGNED */ - REFERENCE = 262, /* REFERENCE */ - SIGNED = 263, /* SIGNED */ - STRING = 264, /* STRING */ - CHARCODE = 265, /* CHARCODE */ - FPNUM = 266, /* FPNUM */ - DIMEN = 267, /* "dimen" */ - PT = 268, /* "pt" */ - MM = 269, /* "mm" */ - INCH = 270, /* "in" */ - XDIMEN = 271, /* "xdimen" */ - H = 272, /* "h" */ - V = 273, /* "v" */ - FIL = 274, /* "fil" */ - FILL = 275, /* "fill" */ - FILLL = 276, /* "filll" */ - PENALTY = 277, /* "penalty" */ - INTEGER = 278, /* "int" */ - LANGUAGE = 279, /* "language" */ - RULE = 280, /* "rule" */ - RUNNING = 281, /* "|" */ - KERN = 282, /* "kern" */ - EXPLICIT = 283, /* "!" */ - GLUE = 284, /* "glue" */ - PLUS = 285, /* "plus" */ - MINUS = 286, /* "minus" */ - TXT_START = 287, /* TXT_START */ - TXT_END = 288, /* TXT_END */ - TXT_IGNORE = 289, /* TXT_IGNORE */ - TXT_FONT_GLUE = 290, /* TXT_FONT_GLUE */ - TXT_FONT_HYPHEN = 291, /* TXT_FONT_HYPHEN */ - TXT_FONT = 292, /* TXT_FONT */ - TXT_LOCAL = 293, /* TXT_LOCAL */ - TXT_GLOBAL = 294, /* TXT_GLOBAL */ - TXT_CC = 295, /* TXT_CC */ - HBOX = 296, /* "hbox" */ - VBOX = 297, /* "vbox" */ - SHIFTED = 298, /* "shifted" */ - HPACK = 299, /* "hpack" */ - HSET = 300, /* "hset" */ - VPACK = 301, /* "vpack" */ - VSET = 302, /* "vset" */ - DEPTH = 303, /* "depth" */ - ADD = 304, /* "add" */ - TO = 305, /* "to" */ - LEADERS = 306, /* "leaders" */ - ALIGN = 307, /* "align" */ - CENTER = 308, /* "center" */ - EXPAND = 309, /* "expand" */ - BASELINE = 310, /* "baseline" */ - LIGATURE = 311, /* "ligature" */ - DISC = 312, /* "disc" */ - PAR = 313, /* "par" */ - MATH = 314, /* "math" */ - ON = 315, /* "on" */ - OFF = 316, /* "off" */ - ADJUST = 317, /* "adjust" */ - TABLE = 318, /* "table" */ - ITEM = 319, /* "item" */ - IMAGE = 320, /* "image" */ - LABEL = 321, /* "label" */ - BOT = 322, /* "bot" */ - MID = 323, /* "mid" */ - LINK = 324, /* "link" */ - OUTLINE = 325, /* "outline" */ - STREAM = 326, /* "stream" */ - STREAMDEF = 327, /* "stream (definition)" */ - FIRST = 328, /* "first" */ - LAST = 329, /* "last" */ - TOP = 330, /* "top" */ - NOREFERENCE = 331, /* "*" */ - PAGE = 332, /* "page" */ - RANGE = 333, /* "range" */ - DIRECTORY = 334, /* "directory" */ - SECTION = 335, /* "entry" */ - DEFINITIONS = 336, /* "definitions" */ - MAX = 337, /* "max" */ - PARAM = 338, /* "param" */ - FONT = 339, /* "font" */ - CONTENT = 340 /* "content" */ - }; - typedef enum yytokentype yytoken_kind_t; -#endif -/* Token kinds. */ -#define YYEMPTY -2 -#define YYEOF 0 -#define YYerror 256 -#define YYUNDEF 257 -#define START 258 -#define END 259 -#define GLYPH 260 -#define UNSIGNED 261 -#define REFERENCE 262 -#define SIGNED 263 -#define STRING 264 -#define CHARCODE 265 -#define FPNUM 266 -#define DIMEN 267 -#define PT 268 -#define MM 269 -#define INCH 270 -#define XDIMEN 271 -#define H 272 -#define V 273 -#define FIL 274 -#define FILL 275 -#define FILLL 276 -#define PENALTY 277 -#define INTEGER 278 -#define LANGUAGE 279 -#define RULE 280 -#define RUNNING 281 -#define KERN 282 -#define EXPLICIT 283 -#define GLUE 284 -#define PLUS 285 -#define MINUS 286 -#define TXT_START 287 -#define TXT_END 288 -#define TXT_IGNORE 289 -#define TXT_FONT_GLUE 290 -#define TXT_FONT_HYPHEN 291 -#define TXT_FONT 292 -#define TXT_LOCAL 293 -#define TXT_GLOBAL 294 -#define TXT_CC 295 -#define HBOX 296 -#define VBOX 297 -#define SHIFTED 298 -#define HPACK 299 -#define HSET 300 -#define VPACK 301 -#define VSET 302 -#define DEPTH 303 -#define ADD 304 -#define TO 305 -#define LEADERS 306 -#define ALIGN 307 -#define CENTER 308 -#define EXPAND 309 -#define BASELINE 310 -#define LIGATURE 311 -#define DISC 312 -#define PAR 313 -#define MATH 314 -#define ON 315 -#define OFF 316 -#define ADJUST 317 -#define TABLE 318 -#define ITEM 319 -#define IMAGE 320 -#define LABEL 321 -#define BOT 322 -#define MID 323 -#define LINK 324 -#define OUTLINE 325 -#define STREAM 326 -#define STREAMDEF 327 -#define FIRST 328 -#define LAST 329 -#define TOP 330 -#define NOREFERENCE 331 -#define PAGE 332 -#define RANGE 333 -#define DIRECTORY 334 -#define SECTION 335 -#define DEFINITIONS 336 -#define MAX 337 -#define PARAM 338 -#define FONT 339 -#define CONTENT 340 - -/* Value type. */ -#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED -union YYSTYPE -{ -#line 78 "../../../texk/web2c/hitexdir/hishrink-parser.y" -uint32_t u;int32_t i;char*s;float64_t f;glyph_t c; -dimen_t d;stretch_t st;xdimen_t xd;kern_t kt; -rule_t r;glue_t g;image_t x; -list_t l;box_t h;disc_t dc;lig_t lg; -ref_t rf;info_t info;order_t o;bool b; - -#line 244 "../../../texk/web2c/hitexdir/hishrink-parser.h" - -}; -typedef union YYSTYPE YYSTYPE; -# define YYSTYPE_IS_TRIVIAL 1 -# define YYSTYPE_IS_DECLARED 1 -#endif - - -extern YYSTYPE yylval; - - -int yyparse (void); - - -#endif /* !YY_YY__TEXK_WEB_C_HITEXDIR_HISHRINK_PARSER_H_INCLUDED */ diff --git a/Build/source/texk/web2c/hitexdir/hitex.w b/Build/source/texk/web2c/hitexdir/hitex.w index 5e5e6cccb0f..f99e40077a4 100644 --- a/Build/source/texk/web2c/hitexdir/hitex.w +++ b/Build/source/texk/web2c/hitexdir/hitex.w @@ -24,207 +24,29924 @@ % dealings in this Software without prior written authorization from the % copyright holders. -\input ../hint.sty -\input ../changefile.sty +% The HINT program is derived from Donald E. Knuth's TeX and the +% subsequent e-TeX extension of TeX. + +% Prote is copyright (C) 2021 by Thierry Laronde and put under +% the kerTeX Public License version 1.0 (a BSD type license with a +% simplified advertising clause). +% +% As TeX and e-TeX are reserved names for the unchanged (except for the +% necessary implementation of system dependencies) instances of, resp., +% Donald E. Knuth's program and the NTS team's e-TeX implementation, the +% name Prote is reserved for this kerTeX implementation. +% +% Hence, this is neither TeX (even if it is compatible at start) nor +% e-TeX (even if is compatible when entering the first set of +% extensions). + +% Version 0 was released in September 1982 after it passed a variety of tests. +% Version 1 was released in November 1983 after thorough testing. +% Version 1.1 fixed ``disappearing font identifiers'' et alia (July 1984). +% Version 1.2 allowed `0' in response to an error, et alia (October 1984). +% Version 1.3 made memory allocation more flexible and local (November 1984). +% Version 1.4 fixed accents right after line breaks, et alia (April 1985). +% Version 1.5 fixed \the\toks after other expansion in \edefs (August 1985). +% Version 2.0 (almost identical to 1.5) corresponds to "Volume B" (April 1986). +% Version 2.1 corrected anomalies in discretionary breaks (January 1987). +% Version 2.2 corrected "(Please type...)" with null \endlinechar (April 1987). +% Version 2.3 avoided incomplete page in premature termination (August 1987). +% Version 2.4 fixed \noaligned rules in indented displays (August 1987). +% Version 2.5 saved cur_order when expanding tokens (September 1987). +% Version 2.6 added 10sp slop when shipping leaders (November 1987). +% Version 2.7 improved rounding of negative-width characters (November 1987). +% Version 2.8 fixed weird bug if no \patterns are used (December 1987). +% Version 2.9 made \csname\endcsname's "relax" local (December 1987). +% Version 2.91 fixed \outer\def\a0{}\a\a bug (April 1988). +% Version 2.92 fixed \patterns, also file names with complex macros (May 1988). +% Version 2.93 fixed negative halving in allocator when mem_min<0 (June 1988). +% Version 2.94 kept open_log_file from calling fatal_error (November 1988). +% Version 2.95 solved that problem a better way (December 1988). +% Version 2.96 corrected bug in "Infinite shrinkage" recovery (January 1989). +% Version 2.97 corrected blunder in creating 2.95 (February 1989). +% Version 2.98 omitted save_for_after at outer level (March 1989). +% Version 2.99 caught $$\begingroup\halign..$$ (June 1989). +% Version 2.991 caught .5\ifdim.6... (June 1989). +% Version 2.992 introduced major changes for 8-bit extensions (September 1989). +% Version 2.993 fixed a save_stack synchronization bug et alia (December 1989). +% Version 3.0 fixed unusual displays; was more \output robust (March 1990). +% Version 3.1 fixed nullfont, disabled \write{\the\prevgraf} (September 1990). +% Version 3.14 fixed unprintable font names and corrected typos (March 1991). +% Version 3.141 more of same; reconstituted ligatures better (March 1992). +% Version 3.1415 preserved nonexplicit kerns, tidied up (February 1993). +% Version 3.14159 allowed fontmemsize to change; bulletproofing (March 1995). +% Version 3.141592 fixed \xleaders, glueset, weird alignments (December 2002). +% Version 3.1415926 was a general cleanup with minor fixes (February 2008). +% Version 3.14159265 was similar (January 2014). +% Version 3.141592653 was similar but more extensive (January 2021). + +% A reward of $327.68 will be paid to the first finder of any remaining bug. + +% This is a beta version of 1.0 of Prote, developed during August 2021, +% and corrected during september/october 2021. +% +% 1.0: adds primitives needed by LaTeX as listed in ltnews31. +% History towards 1.0 release: +% 0.99.4: +% - typos and style corrections provided by Martin Ruckert for +% clean translation in Pascal (forward declarations and underscores +% omitted); +% - adjustements against e-TeX 2.6 instead of 2.1 (T. Laronde). +% 0.99.7: +% - \expanded was using an e-TeX procedure not doing def handling +% => using scan_toks() now. Reported by Martin Ruckert and +% test code narrowed down by Phelype Oleinik. +% 0.99.8: +% - \expanded again: scan_toks() sets def_ref. But back_list() +% has to take not the refernce count, but the first token. +% Passing def_ref, a next invocation of scan_toks() was inserting +% a missing left brace and then reading pass the end of the token +% list to find a matching right one. def_ref => link(def_ref). +% Test code narrowed down by Phelype Oleinik (a great help!). +% - The API for file related primitives has been changed: no error +% is reported on failure to find/open and nothing is returned +% (matches current other implementations). +% +% This work was done by Thierry Laronde and is under the kerTeX +% Public License version 1.0. There is absolutely no warranty of any +% kind! Use it at your own risks! +% +% + +% Here is TeX material that gets inserted after \input webmac +\def\hang{\hangindent 3em\noindent\ignorespaces} +\def\hangg#1 {\hang\hbox{#1 }} +\def\textindent#1{\hangindent2.5em\noindent\hbox to2.5em{\hss#1 }\ignorespaces} +\font\ninerm=cmr9 +\let\mc=\ninerm % medium caps for names like SAIL +\def\Prote{{\tenrm P\kern-0.1em R\kern-0.15em\raise.11ex\hbox{o}% + \kern-0.22em T\kern-0.05em E}} +\ifacro +\sanitizecommand{\eTeX}{eTeX} +\sanitizecommand{\Prote}{PRoTE} +\fi +\font\tenlogo=logo10 +\def\MP{{\tenlogo META}\-{\tenlogo POST}} +\def\eTeX{$\varepsilon$-\TeX} +\font\sf=cmss10 % used for the HINT name +\def\HINT{\leavevmode\hbox{\sf HINT\spacefactor1000}} +\ifacro\sanitizecommand{\HINT}{HINT}\fi +\font\revrm=xbmc10 % for right-to-left text +% to generate xbmc10 (i.e., reflected cmbx10) use a file +% xbmc10.mf containing: +%+++++++++++++++++++++++++++++++++++++++++++++++++ +% if unknown cmbase: input cmbase fi +% extra_endchar := extra_endchar & +% "currentpicture:=currentpicture " & +% "reflectedabout((.5[l,r],0),(.5[l,r],1));"; +% input cmbx10 +%+++++++++++++++++++++++++++++++++++++++++++++++++ +\ifx\beginL\undefined % this is TeX + \def\XeT{X\kern-.125em\lower.5ex\hbox{E}\kern-.1667emT} + \def\TeXeT{\TeX-\hbox{\revrm \XeT}} % for TeX-XeT + \def\TeXXeT{\TeX-\hbox{\revrm -\XeT}} % for TeX--XeT +\else + \ifx\eTeXversion\undefined % this is \TeXeT + \def\TeXeT{\TeX-{\revrm\beginR\TeX\endR}} % for TeX-XeT + \def\TeXXeT{\TeX-{\revrm\beginR\TeX-\endR}} % for TeX--XeT + \else % this is \eTeX + \def\TeXeT{\TeX-{\TeXXeTstate=1\revrm\beginR\TeX\endR}} % for TeX-XeT + \def\TeXXeT{\TeX-{\TeXXeTstate=1\revrm\beginR\TeX-\endR}} % for TeX--XeT + \fi +\fi +\def\PASCAL{Pascal} +\def\ph{\hbox{Pascal-H}} +\def\pct!{{\char`\%}} % percent sign in ordinary text +\def\grp{\.{\char'173...\char'175}} +\font\logo=logo10 % font used for the METAFONT logo +\def\MF{{\logo META}\-{\logo FONT}} +\def\<#1>{$\langle#1\rangle$} +\def\section{\mathhexbox278} + +\def\(#1){} % this is used to make section names sort themselves better +\def\9#1{} % this is used for sort keys in the index via @@:sort key}{entry@@> + +\let\@@=\relax % we want to be able to \write a \? + +\def\title{Hi\TeX} +\def\LaTeX{L\kern-.36em\raise.3ex\hbox{\sc A}\kern-.15em\TeX}% +% system dependent redefinitions of \title should come later +% and should use: +% \toks0=\expandafter{\title} +% \edef\title{...\the\toks0...} +%\let\maybe=\iffalse % print only changed modules +\def\topofcontents{\hsize 5.5in + \vglue 0pt plus 1fil minus 1.5in + \def\@@##1]{\hbox to 1in{\hfil##1.\ }} + } +\def\botofcontents{\vskip 0pt plus 1fil minus 1.5in} +\pageno=3 +\def\glob{13} % this should be the section number of "" +\def\gglob{20, 26} % this should be the next two sections of "" + +\def\.#1{\leavevmode\hbox{\tentex % typewriter type for strings + \let\\=\BS % backslash in a string + \let\'=\RQ % right quote in a string + \let\`=\LQ % left quote in a string + \let\{=\LB % left brace in a string + \let\}=\RB % right brace in a string + \let\~=\TL % tilde in a string + \let\ =\SP % space in a string + \let\_=\UL % underline in a string + \let\&=\AM % ampersand in a string + #1\kern.05em}} +\def\^{\ifmmode\mathchar"222 \else\char`^ \fi} % pointer or hat +\def\LQ{{\tt\char'22}} % left quote in a string +\def\RQ{{\tt\char'23}} % right quote in a string +\def\dotdot{\mathrel{.\,.}} % double dot, used only in math mode +@s dotdot TeX +@* Introduction. +This is Hi\TeX, a program derived from and extending the capabilities +of \TeX\ plus \eTeX\ plus \Prote\ plus k\TeX, +a document compiler intended to produce typesetting of high +quality. +The \PASCAL\ program that follows is the definition of \TeX82, a standard +@:PASCAL}{\PASCAL@> +@!@:TeX82}{\TeX82@> +version of \TeX\ that is designed to be highly portable so that identical output +will be obtainable on a great variety of computers. + +The main purpose of the following program is to explain the algorithms of \TeX\ +as clearly as possible. As a result, the program will not necessarily be very +efficient when a particular \PASCAL\ compiler has translated it into a +particular machine language. However, the program has been written so that it +can be tuned to run efficiently in a wide variety of operating environments +by making comparatively few changes. Such flexibility is possible because +the documentation that follows is written in the \.{WEB} language, which is +at a higher level than \PASCAL; the preprocessing step that converts \.{WEB} +to \PASCAL\ is able to introduce most of the necessary refinements. +Semi-automatic translation to other languages is also feasible, because the +program below does not make extensive use of features that are peculiar to +\PASCAL. + +A large piece of software like \TeX\ has inherent complexity that cannot +be reduced below a certain level of difficulty, although each individual +part is fairly simple by itself. The \.{WEB} language is intended to make +the algorithms as readable as possible, by reflecting the way the +individual program pieces fit together and by providing the +cross-references that connect different parts. Detailed comments about +what is going on, and about why things were done in certain ways, have +been liberally sprinkled throughout the program. These comments explain +features of the implementation, but they rarely attempt to explain the +\TeX\ language itself, since the reader is supposed to be familiar with +{\sl The \TeX book}. +@.WEB@> +@:TeXbook}{\sl The \TeX book@> + +@ The present implementation has a long ancestry, beginning in the summer +of~1977, when Michael~F. Plass and Frank~M. Liang designed and coded +a prototype +@^Plass, Michael Frederick@> +@^Liang, Franklin Mark@> +@^Knuth, Donald Ervin@> +based on some specifications that the author (in the following, unless +specified, ``the author'' refers to D.E.~Knuth) had made in May of that year. +This original proto\TeX\ included macro definitions and elementary +manipulations on boxes and glue, but it did not have line-breaking, +page-breaking, mathematical formulas, alignment routines, error recovery, +or the present semantic nest; furthermore, +it used character lists instead of token lists, so that a control sequence +like \.{\\halign} was represented by a list of seven characters. A +complete version of \TeX\ was designed and coded by the author in late +1977 and early 1978; that program, like its prototype, was written in the +{\mc SAIL} language, for which an excellent debugging system was +available. Preliminary plans to convert the {\mc SAIL} code into a form +somewhat like the present ``web'' were developed by Luis Trabb~Pardo and +@^Trabb Pardo, Luis Isidoro@> +the author at the beginning of 1979, and a complete implementation was +created by Ignacio~A. Zabala in 1979 and 1980. The \TeX82 program, which +@^Zabala Salelles, Ignacio Andr\'es@> +was written by the author during the latter part of 1981 and the early +part of 1982, also incorporates ideas from the 1979 implementation of +@^Guibas, Leonidas Ioannis@> +@^Sedgewick, Robert@> +@^Wyatt, Douglas Kirk@> +\TeX\ in {\mc MESA} that was written by Leonidas Guibas, Robert Sedgewick, +and Douglas Wyatt at the Xerox Palo Alto Research Center. Several hundred +refinements were introduced into \TeX82 based on the experiences gained with +the original implementations, so that essentially every part of the system +has been substantially improved. After the appearance of ``Version 0'' in +September 1982, this program benefited greatly from the comments of +many other people, notably David~R. Fuchs and Howard~W. Trickey. +A final revision in September 1989 extended the input character set to +eight-bit codes and introduced the ability to hyphenate words from +different languages, based on some ideas of Michael~J. Ferguson. +@^Fuchs, David Raymond@> +@^Trickey, Howard Wellington@> +@^Ferguson, Michael John@> + +No doubt there still is plenty of room for improvement, but the author +is firmly committed to keeping \TeX82 ``frozen'' from now on; stability +and reliability are to be its main virtues. + +On the other hand, the \.{WEB} description can be extended without changing +the core of \TeX82 itself, and the program has been designed so that such +extensions are not extremely difficult to make. +The |banner| string defined here should be changed whenever \TeX\ +undergoes any modifications, so that it will be clear which version of +\TeX\ might be the guilty party when a problem arises. +@^extensions to \TeX@> +@^system dependencies@> + +This program contains code for various features extending \TeX, +therefore this program is called `\Prote' and not +`\TeX'; the official name `\TeX' by itself is reserved +for software systems that are fully compatible with each other. +A special test suite called the ``\.{TRIP} test'' is available for +helping to determine whether a particular implementation deserves to be +known as `\TeX' [cf.~Stanford Computer Science report CS1027, +November 1984]. + +A similar test suite called the ``\.{SELLETTE} test'' is available for +helping to determine whether a particular implementation deserves to be +known as `\Prote'. + +@d eTeX_version 2 /* \.{\\eTeXversion} */ +@d eTeX_revision ".6" /* \.{\\eTeXrevision} */ +@d eTeX_version_string "-2.6" /*current \eTeX\ version*/ +@# +@d TeX_banner "This is TeX, Version 3.141592653" /*printed when \TeX\ starts*/ +@# +@# +@d TEX ETEX /*change program name into |ETEX|*/ +@# +@d eTeX_states 1 /*number of \eTeX\ state variables in |eqtb|*/ +@# +@d Prote_version_string "3.141592653-2.6-0.99.8" /*current \Prote\ version*/ +@d Prote_version 0 /* \.{\\Proteversion} */ +@d Prote_revision ".99.8" /* \.{\\Proterevision} */ +@# +@d Prote_banner "This is Prote, Version " Prote_version_string + /*printed when \Prote\ starts*/ +@# +@d HiTeX_version_string Prote_version_string "-1.0" +@# +@d banner "This is HiTeX, Version 3.141592653" HiTeX_version_string /*printed when \TeX\ starts*/ + +@ Different \PASCAL s have slightly different conventions, and the present +@!@:PASCAL H}{\ph@> +program expresses \TeX\ in terms of the \PASCAL\ that was +available to the author in 1982. Constructions that apply to +this particular compiler, which we shall call \ph, should help the +reader see how to make an appropriate interface for other systems +if necessary. (\ph\ is Charles Hedrick's modification of a compiler +@^Hedrick, Charles Locke@> +for the DECsystem-10 that was originally developed at the University of +Hamburg; cf.\ {\sl Software---Practice and Experience \bf6} (1976), +29--42. The \TeX\ program below is intended to be adaptable, without +extensive changes, to most other versions of \PASCAL, so it does not fully +use the admirable features of \ph. Indeed, a conscious effort has been +made here to avoid using several idiosyncratic features of standard +\PASCAL\ itself, so that most of the code can be translated mechanically +into other high-level languages. For example, the `\&{with}' and `\\{new}' +features are not used, nor are pointer types, set types, or enumerated +scalar types; there are no `\&{var}' parameters, except in the case of files +--- \eTeX, however, does use `\&{var}' parameters for the |reverse| function; +there are no tag fields on variant records; there are no assignments +|double=int|; no procedures are declared local to other procedures.) + +The portions of this program that involve system-dependent code, where +changes might be necessary because of differences between \PASCAL\ compilers +and/or differences between +operating systems, can be identified by looking at the sections whose +numbers are listed under `system dependencies' in the index. Furthermore, +the index entries for `dirty \PASCAL' list all places where the restrictions +of \PASCAL\ have not been followed perfectly, for one reason or another. +@!@^system dependencies@> +@!@^dirty \PASCAL@> + +Incidentally, \PASCAL's standard |round| function can be problematical, +because it disagrees with the IEEE floating-point standard. +Many implementors have +therefore chosen to substitute their own home-grown rounding procedure. + +@ The following is an outline of the program, whose +components will be filled in later, using the conventions of \.{WEB}. +@.WEB@> +For example, the portion of the program called `\X\glob:Global +variables\X' below will be replaced by a sequence of variable declarations +that starts in $\section\glob$ of this documentation. In this way, we are able +to define each individual global variable when we are prepared to +understand what it means; we do not have to define all of the globals at +once. Cross references in $\section\glob$, where it says ``See also +sections \gglob, \dots,'' also make it possible to look at the set of +all global variables, if desired. Similar remarks apply to the other +portions of the program. + +@p @
@; +@h +enum {@+@@+}; +@@; +@@; +@@; +@# +static void initialize(void) /*this procedure gets things started properly*/ + {@+@@; + @; + } @# +@@; +@@; + +@ The overall \TeX\ program begins with the heading just shown, after which +comes a bunch of procedure declarations and function declarations. +Finally we will get to the main program, which begins with the +comment `|start_here|'. If you want to skip down to the +main program now, you can look up `|start_here|' in the index. +But the author suggests that the best way to understand this program +is to follow pretty much the order of \TeX's components as they appear in the +\.{WEB} description you are now reading, since the present ordering is +intended to combine the advantages of the ``bottom up'' and ``top down'' +approaches to the problem of understanding a somewhat complicated system. + +@ There is no need to declare labels in \CEE/, but occasionally +it is necessary to insert header files and declare functions +very early in the program. For example, the function |s_no| +which uses |make_string| to convert a \CEE/ string into +a string number is used in |initialize| and needs a forward +declaration. + +@
= +static int s_no(const char *str); + +@ Some of the code below is intended to be used only when diagnosing the +strange behavior that sometimes occurs when \TeX\ is being installed or +when system wizards are fooling around with \TeX\ without quite knowing +what they are doing. Such code will not normally be compiled; it is +delimited by the codewords `$|debug|\ldots|debug|$', with apologies +to people who wish to preserve the purity of English. + +Similarly, there is some conditional code delimited by +`$|stat|\ldots|tats|$' that is intended for use when statistics are to be +kept about \TeX's memory usage. The |stat| $\ldots$ |tats| code also +implements diagnostic information for \.{\\tracingparagraphs}, +\.{\\tracingpages}, and \.{\\tracingrestores}. +@^debugging@> + +@ This program has two important variations: (1) There is a long and slow +version called \.{INITEX}, which does the extra calculations needed to +@.INITEX@> +initialize \TeX's internal tables; and (2)~there is a shorter and faster +production version, which cuts the initialization to a bare minimum. +Parts of the program that are needed in (1) but not in (2) are delimited by +|#ifdef| |INIT|\dots\ |#endif|. + +\TeX\ Live has established the common practice +to select the initialization code at runtime +using the |iniversion| variable. + +@= +@@/ +#ifdef @!INIT +if (iniversion) {@+@@;@+} +#endif + +@ The declaration of all basic type definitions needed by Hi\TeX\ are +contained in a system dependent header file. -%% defining how to display certain C identifiers @s uint8_t int -@s uint16_t int -@s uint32_t int -@s uint64_t int -@s int8_t int @s int16_t int +@s uint16_t int @s int32_t int -@s float64_t int -@s float32_t int -@s scaled int +@s uint32_t int +@s halfword int +@s in TeX +@s line normal +@s to do + +@
= +#include "hibasetypes.h" +#include +#include + +@ Further it is necessary to define some build in primitives of +\PASCAL\ that are otherwise not available in \CEE/. +@:PASCAL H}{\ph@> + +@d odd(X) ((X)&1) +@d chr(X) ((unsigned char)(X)) +@d ord(X) ((unsigned int)(X)) +@d abs(X) ((X)>-(X)?(X):-(X)) +@d round(X) ((int)((X)>=0.0?floor((X)+0.5):ceil((X)-0.5))) + +@ The following parameters can be changed at compile time to extend or +reduce \TeX's capacity. They may have different values in \.{INITEX} and +in production versions of \TeX. +@.INITEX@> +@^system dependencies@> + +@= +@!mem_max=5000000, /*greatest index in \TeX's internal |mem| array; + must be strictly less than |max_halfword|; + must be equal to |mem_top| in \.{INITEX}, otherwise | >= mem_top|*/ +@!mem_min=0, /*smallest index in \TeX's internal |mem| array; + must be |min_halfword| or more; + must be equal to |mem_bot| in \.{INITEX}, otherwise | <= mem_bot|*/ +@!buf_size=2000000, /*maximum number of characters simultaneously present in + current lines of open files and in control sequences between + \.{\\csname} and \.{\\endcsname}; must not exceed |max_halfword|*/ +@!error_line=79, /*width of context lines on terminal error messages*/ +@!half_error_line=50, /*width of first lines of contexts in terminal + error messages; should be between 30 and |error_line-15|*/ +@!max_print_line=79, /*width of longest text lines output; should be at least 60*/ +@!stack_size=5000, /*maximum number of simultaneous input sources*/ +@!max_in_open=15, /*maximum number of input files and error insertions that + can be going on simultaneously*/ +@!font_max=255, /*maximum internal font number; must not exceed |max_quarterword| + and must be at most |font_base+256|*/ +@!font_mem_size=8000000, /*number of words of |font_info| for all fonts*/ +@!param_size=10000, /*maximum number of simultaneous macro parameters*/ +@!nest_size=500, /*maximum number of semantic levels simultaneously active*/ +@!max_strings=500000, /*maximum number of strings; must not exceed |max_halfword|*/ +@!string_vacancies=90000, /*the minimum number of characters that should be + available for the user's control sequences and font names, + after \TeX's own error messages are stored*/ +@!pool_size=6250000, /*maximum number of characters in strings, including all + error messages and help texts, and the names of all fonts and + control sequences; must exceed |string_vacancies| by the total + length of \TeX's own strings, which is currently about 23000*/ +@!save_size=100000, /*space for saving values outside of current group; must be + at most |max_halfword|*/ +@!trie_size=1000000, /*space for hyphenation patterns; should be larger for + \.{INITEX} than it is in production versions of \TeX*/ +@!trie_op_size=35111, /*space for ``opcodes'' in the hyphenation patterns*/ +@!dvi_buf_size=16384, /*size of the output buffer; must be a multiple of 8*/ +@!file_name_size=1024, /*file names shouldn't be longer than this*/ +@!xchg_buffer_size=64, /*must be at least 64*/ + /*size of |eight_bits| buffer for exchange with system routines*/ +@!empty_string=256 /*the empty string follows after 256 characters*/ + +@ Like the preceding parameters, the following quantities can be changed +at compile time to extend or reduce \TeX's capacity. But if they are changed, +it is necessary to rerun the initialization program \.{INITEX} +@.INITEX@> +to generate new tables for the production \TeX\ program. +One can't simply make helter-skelter changes to the following constants, +since certain rather complex initialization +numbers are computed from them. They are defined here using +\.{WEB} macros, instead of being put into \PASCAL's |const| list, in order to +emphasize this distinction. + +@d mem_bot 0 /*smallest index in the |mem| array dumped by \.{INITEX}; + must not be less than |mem_min|*/ +@d mem_top 5000000 /*largest index in the |mem| array dumped by \.{INITEX}; + must be substantially larger than |mem_bot| + and not greater than |mem_max|*/ +@d font_base 0 /*smallest internal font number; must not be less + than |min_quarterword|*/ +@d hash_size 45000 /*maximum number of control sequences; it should be at most + about |(mem_max-mem_min)/(double)10|*/ +@d hash_prime 35999 /*a prime number equal to about 85\pct! of |hash_size|*/ +@d hyph_size 8191 /*another prime; the number of \.{\\hyphenation} exceptions*/ +@^system dependencies@> + +@ In case somebody has inadvertently made bad settings of the ``constants,'' +\TeX\ checks them using a global variable called |bad|. + +This is the first of many sections of \TeX\ where global variables are +defined. + +@= +static int @!bad; /*is some ``constant'' wrong?*/ + +@ Later on we will say `\ignorespaces|if (mem_max >= max_halfword) bad=14|', +or something similar. (We can't do that until |max_halfword| has been defined.) + +@= +bad=0; +if ((half_error_line < 30)||(half_error_line > error_line-15)) bad=1; +if (max_print_line < 60) bad=2; +if (dvi_buf_size%8!=0) bad=3; +if (mem_bot+1100 > mem_top) bad=4; +if (hash_prime > hash_size) bad=5; +if (max_in_open >= 128) bad=6; +if (mem_top < 256+11) bad=7; /*we will want |null_list > 255|*/ + +@ Labels are given symbolic names by the following definitions, so that +occasional |goto| statements will be meaningful. We insert the label +`|end|' just before the `\ignorespaces|} |\unskip' of a procedure in +which we have used the `|goto end|' statement defined below; the label +`|restart|' is occasionally used at the very beginning of a procedure; and +the label `|reswitch|' is occasionally used just prior to a |case| +statement in which some cases change the conditions and we wish to branch +to the newly applicable case. Loops that are set up with the |loop| +construction defined below are commonly exited by going to `|done|' or to +`|found|' or to `|not_found|', and they are sometimes repeated by going to +`|resume|'. If two or more parts of a subroutine start differently but +end up the same, the shared code may be gathered together at +`|common_ending|'. + +Incidentally, this program never declares a label that isn't actually used, +because some fussy \PASCAL\ compilers will complain about redundant labels. + +@ Here are some macros for common programming idioms. + +@d incr(A) A=A+1 /*increase a variable by unity*/ +@d decr(A) A=A-1 /*decrease a variable by unity*/ +@d negate(A) A=-A /*change the sign of a variable*/ +@d loop @+while (true) @+ /*repeat over and over until a |goto| happens*/ +@f loop else + /*\.{WEB}'s |else| acts like `\ignorespaces|while true do|\unskip'*/ +@d do_nothing /*empty statement*/ +@d empty 0 /*symbolic name for a null constant*/ + +@* The character set. +In order to make \TeX\ readily portable to a wide variety of +computers, all of its input text is converted to an internal eight-bit +code that includes standard ASCII, the ``American Standard Code for +Information Interchange.'' This conversion is done immediately when each +character is read in. Conversely, characters are converted from ASCII to +the user's external representation just before they are output to a +text file. + +Such an internal code is relevant to users of \TeX\ primarily because it +governs the positions of characters in the fonts. For example, the +character `\.A' has ASCII code $65=0101$, and when \TeX\ typesets +this letter it specifies character number 65 in the current font. +If that font actually has `\.A' in a different position, \TeX\ doesn't +know what the real position is; the program that does the actual printing from +\TeX's device-independent files is responsible for converting from ASCII to +a particular font encoding. +@^ASCII code@> + +\TeX's internal code also defines the value of constants +that begin with a reverse apostrophe; and it provides an index to the +\.{\\catcode}, \.{\\mathcode}, \.{\\uccode}, \.{\\lccode}, and \.{\\delcode} +tables. + +@ Characters of text that have been converted to \TeX's internal form +are said to be of type |ASCII_code|, which is a subrange of the integers. + +@= +typedef uint8_t ASCII_code; /*eight-bit numbers*/ + +@ The original \PASCAL\ compiler was designed in the late 60s, when six-bit +character sets were common, so it did not make provision for lowercase +letters. Nowadays, of course, we need to deal with both capital and small +letters in a convenient way, especially in a program for typesetting; +so the present specification of \TeX\ has been written under the assumption +that the \PASCAL\ compiler and run-time system permit the use of text files +with more than 64 distinguishable characters. More precisely, we assume that +the character set contains at least the letters and symbols associated +with ASCII codes 040 through 0176; all of these characters are now +available on most computer terminals. + +Since we are dealing with more characters than were present in the first +\PASCAL\ compilers, we have to decide what to call the associated data +type. Some \PASCAL s use the original name |unsigned char| for the +characters in text files, even though there now are more than 64 such +characters, while other \PASCAL s consider |unsigned char| to be a 64-element +subrange of a larger data type that has some other name. + +In order to accommodate this difference, we shall use the name |text_char| +to stand for the data type of the characters that are converted to and +from |ASCII_code| when they are input and output. We shall also assume +that |text_char| consists of the elements |chr(first_text_char)| through +|chr(last_text_char)|, inclusive. The following definitions should be +adjusted if necessary. +@^system dependencies@> + +@s text_char char +@d text_char unsigned char /*the data type of characters in text files*/ +@d first_text_char 0 /*ordinal number of the smallest element of |text_char|*/ +@d last_text_char 255 /*ordinal number of the largest element of |text_char|*/ + +@= +int @!i; + +@ The \TeX\ processor converts between ASCII code and +the user's external character set by means of arrays |xord| and |xchr| +that are analogous to \PASCAL's |ord| and |chr| functions. + +@= +static ASCII_code @!xord[256]; + /*specifies conversion of input characters*/ +static text_char @!xchr[256]; + /*specifies conversion of output characters*/ + +@ Since we are assuming that our \PASCAL\ system is able to read and +write the visible characters of standard ASCII (although not +necessarily using the ASCII codes to represent them), the following +assignment statements initialize the standard part of the |xchr| array +properly, without needing any system-dependent changes. On the other +hand, it is possible to implement \TeX\ with less complete character +sets, and in such cases it will be necessary to change something here. +@^system dependencies@> + +@= +xchr[040]=' '; +xchr[041]='!'; +xchr[042]='"'; +xchr[043]='#'; +xchr[044]='$'; +xchr[045]='%'; +xchr[046]='&'; +xchr[047]='\'';@/ +xchr[050]='('; +xchr[051]=')'; +xchr[052]='*'; +xchr[053]='+'; +xchr[054]=','; +xchr[055]='-'; +xchr[056]='.'; +xchr[057]='/';@/ +xchr[060]='0'; +xchr[061]='1'; +xchr[062]='2'; +xchr[063]='3'; +xchr[064]='4'; +xchr[065]='5'; +xchr[066]='6'; +xchr[067]='7';@/ +xchr[070]='8'; +xchr[071]='9'; +xchr[072]=':'; +xchr[073]=';'; +xchr[074]='<'; +xchr[075]='='; +xchr[076]='>'; +xchr[077]='?';@/ +xchr[0100]='@@'; +xchr[0101]='A'; +xchr[0102]='B'; +xchr[0103]='C'; +xchr[0104]='D'; +xchr[0105]='E'; +xchr[0106]='F'; +xchr[0107]='G';@/ +xchr[0110]='H'; +xchr[0111]='I'; +xchr[0112]='J'; +xchr[0113]='K'; +xchr[0114]='L'; +xchr[0115]='M'; +xchr[0116]='N'; +xchr[0117]='O';@/ +xchr[0120]='P'; +xchr[0121]='Q'; +xchr[0122]='R'; +xchr[0123]='S'; +xchr[0124]='T'; +xchr[0125]='U'; +xchr[0126]='V'; +xchr[0127]='W';@/ +xchr[0130]='X'; +xchr[0131]='Y'; +xchr[0132]='Z'; +xchr[0133]='['; +xchr[0134]='\\'; +xchr[0135]=']'; +xchr[0136]='^'; +xchr[0137]='_';@/ +xchr[0140]='`'; +xchr[0141]='a'; +xchr[0142]='b'; +xchr[0143]='c'; +xchr[0144]='d'; +xchr[0145]='e'; +xchr[0146]='f'; +xchr[0147]='g';@/ +xchr[0150]='h'; +xchr[0151]='i'; +xchr[0152]='j'; +xchr[0153]='k'; +xchr[0154]='l'; +xchr[0155]='m'; +xchr[0156]='n'; +xchr[0157]='o';@/ +xchr[0160]='p'; +xchr[0161]='q'; +xchr[0162]='r'; +xchr[0163]='s'; +xchr[0164]='t'; +xchr[0165]='u'; +xchr[0166]='v'; +xchr[0167]='w';@/ +xchr[0170]='x'; +xchr[0171]='y'; +xchr[0172]='z'; +xchr[0173]='{'; +xchr[0174]='|'; +xchr[0175]='}'; +xchr[0176]='~';@/ + +@ Some of the ASCII codes without visible characters have been given symbolic +names in this program because they are used with a special meaning. + +@d null_code 00 /*ASCII code that might disappear*/ +@d carriage_return 015 /*ASCII code used at end of line*/ +@d invalid_code 0177 /*ASCII code that many systems prohibit in text files*/ + +@ The ASCII code is ``standard'' only to a certain extent, since many +computer installations have found it advantageous to have ready access +to more than 94 printing characters. Appendix~C of {\sl The \TeX book\/} +gives a complete specification of the intended correspondence between +characters and \TeX's internal representation. +@:TeXbook}{\sl The \TeX book@> + +If \TeX\ is being used +on a garden-variety \PASCAL\ for which only standard ASCII +codes will appear in the input and output files, it doesn't really matter +what codes are specified in |xchr[0 dotdot 037]|, but the safest policy is to +blank everything out by using the code shown below. + +However, other settings of |xchr| will make \TeX\ more friendly on +computers that have an extended character set, so that users can type things +like `\.^^Z' instead of `\.{\\ne}'. People with extended character sets can +assign codes arbitrarily, giving an |xchr| equivalent to whatever +characters the users of \TeX\ are allowed to have in their input files. +It is best to make the codes correspond to the intended interpretations as +shown in Appendix~C whenever possible; but this is not necessary. For +example, in countries with an alphabet of more than 26 letters, it is +usually best to map the additional letters into codes less than~040. +To get the most ``permissive'' character set, change |' '| on the +right of these assignment statements to |chr(i)|. +@^character set dependencies@> +@^system dependencies@> + +@= +for (i=0; i<=037; i++) xchr[i]=chr(i); /* k\TeX\ */ +for (i=0177; i<=0377; i++) xchr[i]=chr(i); /* k\TeX\ */ + +@ The following system-independent code makes the |xord| array contain a +suitable inverse to the information in |xchr|. Note that if |xchr[i]==xchr[j]| +where |i < j < 0177|, the value of |xord[xchr[i]]| will turn out to be +|j| or more; hence, standard ASCII code numbers will be used instead of +codes below 040 in case there is a coincidence. + +@= +for (i=first_text_char; i<=last_text_char; i++) xord[chr(i)]=invalid_code; +for (i=0200; i<=0377; i++) xord[xchr[i]]=i; +for (i=0; i<=0176; i++) xord[xchr[i]]=i; + +@* Input and output. +The bane of portability is the fact that different operating systems treat +input and output quite differently, perhaps because computer scientists +have not given sufficient attention to this problem. People have felt somehow +that input and output are not part of ``real'' programming. Well, it is true +that some kinds of programming are more fun than others. With existing +input/output conventions being so diverse and so messy, the only sources of +joy in such parts of the code are the rare occasions when one can find a +way to make the program a little less bad than it might have been. We have +two choices, either to attack I/O now and get it over with, or to postpone +I/O until near the end. Neither prospect is very attractive, so let's +get it over with. + +The basic operations we need to do are (1)~inputting and outputting of +text, to or from a file or the user's terminal; (2)~inputting and +outputting of eight-bit bytes, to or from a file; (3)~instructing the +operating system to initiate (``open'') or to terminate (``close'') input or +output from a specified file; (4)~testing whether the end of an input +file has been reached. + +\TeX\ needs to deal with two kinds of files. +We shall use the term |alpha_file| for a file that contains textual data, +and the term |byte_file| for a file that contains eight-bit binary information. +These two types turn out to be the same on many computers, but +sometimes there is a significant distinction, so we shall be careful to +distinguish between them. Standard protocols for transferring +such files from computer to computer, via high-speed networks, are +now becoming available to more and more communities of users. + +The program actually makes use also of a third kind of file, called a +|word_file|, when dumping and reloading base information for its own +initialization. We shall define a word file later; but it will be possible +for us to specify simple operations on word files before they are defined. + +@= +typedef uint8_t eight_bits; /*unsigned one-byte quantity*/ +typedef struct {@+FILE *f;@+text_char@,d;@+} alpha_file; /*files that contain textual data*/ +typedef struct {@+FILE *f;@+eight_bits@,d;@+} byte_file; /*files that contain binary data*/ + +@ Most of what we need to do with respect to input and output can be handled +by the I/O facilities that are standard in \PASCAL, i.e., the routines +called |get|, |put|, |eof|, and so on. But +standard \PASCAL\ does not allow file variables to be associated with file +names that are determined at run time, so it cannot be used to implement +\TeX; some sort of extension to \PASCAL's ordinary |reset| and |rewrite| +is crucial for our purposes. We shall assume that |name_of_file| is a variable +of an appropriate type such that the \PASCAL\ run-time system being used to +implement \TeX\ can open a file whose external name is specified by +|name_of_file|. +@^system dependencies@> + +@= +static unsigned char @!name_of_file0[file_name_size+1]={0}, *const @!name_of_file = @!name_of_file0-1;@;@/ + /*on some systems this may be a \&{record} variable*/ +static int @!name_length;@/ /*this many characters are actually + relevant in |name_of_file| (the rest are blank)*/ + +@ k\TeX\ uses the {\tt kpathsearch} library to implement access to files. +So most of the code to find and open files is contained in two functions, +|open_in| and |open_out| defined later. +\TeX's file-opening functions do not to issue their own +error messages if something goes wrong. If a file identified by +|name_of_file| cannot be found, +or if such a file cannot be opened for some other reason +(e.g., someone may already be trying to write the same file) +\TeX's file-opening functions return |false|. +This allows \TeX\ to undertake appropriate corrective action. +@^system dependencies@> + +@p +static FILE*open_in(char*filename,kpse_file_format_type t,const char*rwb); +static bool a_open_in(alpha_file *f) /*open a text file for input*/ +{@+f->f= open_in((char *)name_of_file+1,kpse_tex_format,"r"); + if (f->f!=NULL) get(*f); + return f->f!=NULL && ferror(f->f)==0; +} + +static bool b_open_in(byte_file *f) /*open a binary file for input*/ +{@+f->f= kpse_open_file((char *)name_of_file+1,kpse_tfm_format); + if (f->f!=NULL) get(*f); + return f->f!=NULL && ferror(f->f)==0; +} + +static bool w_open_in(word_file *f) /*open a word file for input*/ +{@+ + f->f=NULL; + if (name_of_file[1]!=0) + f->f= open_in((char*)name_of_file+1,kpse_fmt_format,"rb"); + if (f->f!=NULL) get(*f); + return f->f!=NULL && ferror(f->f)==0; +} + +static FILE *open_out(const char *file_name, const char *file_mode); +static bool a_open_out(alpha_file *f) /*open a text file for output*/ +{@+f->f=open_out((char*)name_of_file+1,"w"); + return f->f!=NULL && ferror(f->f)==0;@+ +} + +static bool b_open_out(byte_file *f) /*open a binary file for output*/ +{@+f->f=open_out((char *)name_of_file+1,"wb"); +return f->f!=NULL && ferror(f->f)==0;@+ +} + +#ifdef @!INIT +static bool w_open_out(word_file *f) /*open a word file for output*/ +{@+f->f=open_out((char *)name_of_file+1,"wb"); + return f->f!=NULL && ferror(f->f)==0;@+ +} +#endif + +@ Files can be closed with the \ph\ routine `|pascal_close(f)|', which +@:PASCAL H}{\ph@> +@^system dependencies@> +should be used when all input or output with respect to |f| has been completed. +This makes |f| available to be opened again, if desired; and if |f| was used for +output, the |pascal_close| operation makes the corresponding external file appear +on the user's area, ready to be read. + +These procedures should not generate error messages if a file is +being closed before it has been successfully opened. + +@p static void a_close(alpha_file *f) /*close a text file*/ +{@+pascal_close((*f)); +} +@# +static void b_close(byte_file *f) /*close a binary file*/ +{@+pascal_close((*f)); +} +@# +static void w_close(word_file *f) /*close a word file*/ +{@+pascal_close((*f)); +} + +@ Binary input and output are done with \PASCAL's ordinary |get| and |put| +procedures, so we don't have to make any other special arrangements for +binary~I/O. Text output is also easy to do with standard \PASCAL\ routines. +The treatment of text input is more difficult, however, because +of the necessary translation to |ASCII_code| values. +\TeX's conventions should be efficient, and they should +blend nicely with the user's operating environment. + +@ Input from text files is read one line at a time, using a routine called +|input_ln|. This function is defined in terms of global variables called +|buffer|, |first|, and |last| that will be described in detail later; for +now, it suffices for us to know that |buffer| is an array of |ASCII_code| +values, and that |first| and |last| are indices into this array +representing the beginning and ending of a line of text. + +@= +static ASCII_code @!buffer[buf_size+1]; /*lines of characters being read*/ +static int @!first; /*the first unused position in |buffer|*/ +static int @!last; /*end of the line just input to |buffer|*/ +static int @!max_buf_stack; /*largest index used in |buffer|*/ + +@ The |input_ln| function brings the next line of input from the specified +file into available positions of the buffer array and returns the value +|true|, unless the file has already been entirely read, in which case it +returns |false| and sets |last=first|. In general, the |ASCII_code| +numbers that represent the next line of the file are input into +|buffer[first]|, |buffer[first+1]|, \dots, |buffer[last-1]|; and the +global variable |last| is set equal to |first| plus the length of the +line. Trailing blanks are removed from the line; thus, either |last==first| +(in which case the line was entirely blank) or |buffer[last-1]!=' '|. + +An overflow error is given, however, if the normal actions of |input_ln| +would make |last >= buf_size|; this is done so that other parts of \TeX\ +can safely look at the contents of |buffer[last+1]| without overstepping +the bounds of the |buffer| array. Upon entry to |input_ln|, the condition +|first < buf_size| will always hold, so that there is always room for an +``empty'' line. + +The variable |max_buf_stack|, which is used to keep track of how large +the |buf_size| parameter must be to accommodate the present job, is +also kept up to date by |input_ln|. + +If the |bypass_eoln| parameter is |true|, |input_ln| will do a |get| +before looking at the first character of the line; this skips over +an |eoln| that was in |f.d|. The procedure does not do a |get| when it +reaches the end of the line; therefore it can be used to acquire input +from the user's terminal as well as from ordinary text files. + +Standard \PASCAL\ says that a file should have |eoln| immediately +before |eof|, but \TeX\ needs only a weaker restriction: If |eof| +occurs in the middle of a line, the system function |eoln| should return +a |true| result (even though |f.d| will be undefined). + +Since the inner loop of |input_ln| is part of \TeX's ``inner loop''---each +character of input comes in at this place---it is wise to reduce system +overhead by making use of special routines that read in an entire array +of characters at once, if such routines are available. The following +code uses standard \PASCAL\ to illustrate what needs to be done, but +finer tuning is often possible at well-developed \PASCAL\ sites. +@^inner loop@> + +@p static bool input_ln(alpha_file *f, bool @!bypass_eoln) + /*inputs the next line or returns |false|*/ +{@+int last_nonblank; /*|last| with trailing blanks removed*/ +if (bypass_eoln) if (!eof((*f))) get((*f)); + /*input the first character of the line into |f.d|*/ +last=first; /*cf.\ Matthew 19\thinspace:\thinspace30*/ +if (eof((*f))) return false; +else{@+last_nonblank=first; + while (!eoln((*f))) + {@+if (last >= max_buf_stack) + {@+max_buf_stack=last+1; + if (max_buf_stack==buf_size) + @; + } + buffer[last]=xord[(*f).d];get((*f));incr(last); + if (buffer[last-1]!=' ') last_nonblank=last; + } + last=last_nonblank;return true; + } +} + +@ The user's terminal acts essentially like other files of text, except +that it is used both for input and for output. When the terminal is +considered an input file, the file variable is called |term_in|, and when it +is considered an output file the file variable is |term_out|. +@^system dependencies@> + +@= +static alpha_file @!term_in; /*the terminal as an input file*/ +static alpha_file @!term_out; /*the terminal as an output file*/ + +@ Here is how to open the terminal files +in \ph. The `\.{/I}' switch suppresses the first |get|. +@:PASCAL H}{\ph@> +@^system dependencies@> + +@d t_open_in term_in.f=stdin /*open the terminal for text input*/ +@d t_open_out term_out.f=stdout /*open the terminal for text output*/ + +@ Sometimes it is necessary to synchronize the input/output mixture that +happens on the user's terminal, and three system-dependent +procedures are used for this +purpose. The first of these, |update_terminal|, is called when we want +to make sure that everything we have output to the terminal so far has +actually left the computer's internal buffers and been sent. +The second, |clear_terminal|, is called when we wish to cancel any +input that the user may have typed ahead (since we are about to +issue an unexpected error message). The third, |wake_up_terminal|, +is supposed to revive the terminal if the user has disabled it by +some instruction to the operating system. The following macros show how +these operations can be specified in \ph: +@:PASCAL H}{\ph@> +@^system dependencies@> + +@d update_terminal fflush(term_out.f) /*empty the terminal output buffer*/ +@d clear_terminal fflush(term_in.f) /*clear the terminal input buffer*/ +@d wake_up_terminal do_nothing /*cancel the user's cancellation of output*/ + +@ We need a special routine to read the first line of \TeX\ input from +the user's terminal. This line is different because it is read before we +have opened the transcript file; there is sort of a ``chicken and +egg'' problem here. If the user types `\.{\\input paper}' on the first +line, or if some macro invoked by that line does such an \.{\\input}, +the transcript file will be named `\.{paper.log}'; but if no \.{\\input} +commands are performed during the first line of terminal input, the transcript +file will acquire its default name `\.{texput.log}'. (The transcript file +will not contain error messages generated by the first line before the +first \.{\\input} command.) +@.texput@> + +The first line is even more special if we are lucky enough to have an operating +system that treats \TeX\ differently from a run-of-the-mill \PASCAL\ object +program. It's nice to let the user start running a \TeX\ job by typing +a command line like `\.{tex paper}'; in such a case, \TeX\ will operate +as if the first line of input were `\.{paper}', i.e., the first line will +consist of the remainder of the command line, after the part that invoked +\TeX. + +The first line is special also because it may be read before \TeX\ has +input a format file. In such cases, normal error messages cannot yet +be given. The following code uses concepts that will be explained later. +(If the \PASCAL\ compiler does not support non-local |@!goto|\unskip, the +@^system dependencies@> +statement `|goto exit(0)|' should be replaced by something that +quietly terminates the program.) + +@= +if (format_ident==0) + {@+write_ln(term_out,"Buffer size exceeded!");exit(0); +@.Buffer size exceeded@> + } +else{@+cur_input.loc_field=first;cur_input.limit_field=last-1; + overflow("buffer size", buf_size); +@:TeX capacity exceeded buffer size}{\quad buffer size@> + } + +@ Different systems have different ways to get started. But regardless of +what conventions are adopted, the routine that initializes the terminal +should satisfy the following specifications: + +\yskip\textindent{1)}It should open file |term_in| for input from the + terminal. (The file |term_out| will already be open for output to the + terminal.) + +\textindent{2)}If the user has given a command line, this line should be + considered the first line of terminal input. Otherwise the + user should be prompted with `\.{**}', and the first line of input + should be whatever is typed in response. + +\textindent{3)}The first line of input, which might or might not be a + command line, should appear in locations |first| to |last-1| of the + |buffer| array. + +\textindent{4)}The global variable |loc| should be set so that the + character to be read next by \TeX\ is in |buffer[loc]|. This + character should not be blank, and we should have |loc < last|. + +\yskip\noindent(It may be necessary to prompt the user several times +before a non-blank line comes in. The prompt is `\.{**}' instead of the +later `\.*' because the meaning is slightly different: `\.{\\input}' need +not be typed immediately after~`\.{**}'.) + +@d loc cur_input.loc_field /*location of first unread character in |buffer|*/ + +@ The following program calls |input_command_line| +to retrieve a possible command line. +@^system dependencies@> + +@p static bool init_terminal(void) /*gets the terminal input started*/ +{@+ +t_open_in; +if (input_command_line()) return true; /* k\TeX\ */ +loop@+{@+wake_up_terminal;pascal_write(term_out,"**");update_terminal; +@.**@> + if (!input_ln(&term_in, true)) /*this shouldn't happen*/ + {@+write_ln(term_out); + pascal_write(term_out,"! End of file on the terminal... why?"); +@.End of file on the terminal@> + return false; + } + loc=first; + while ((loc < last)&&(buffer[loc]==' ')) incr(loc); + if (loc < last) + {@+return true; + /*return unless the line was all blank*/ + } + write_ln(term_out,"Please type the name of your input file."); + } +} + +@* String handling. +Control sequence names and diagnostic messages are variable-length strings +of eight-bit characters. Since \PASCAL\ does not have a well-developed string +mechanism, \TeX\ does all of its string processing by homegrown methods. + +Elaborate facilities for dynamic strings are not needed, so all of the +necessary operations can be handled with a simple data structure. +The array |str_pool| contains all of the (eight-bit) ASCII codes in all +of the strings, and the array |str_start| contains indices of the starting +points of each string. Strings are referred to by integer numbers, so that +string number |s| comprises the characters |str_pool[j]| for +|str_start[s] <= j < str_start[s+1]|. Additional integer variables +|pool_ptr| and |str_ptr| indicate the number of entries used so far +in |str_pool| and |str_start|, respectively; locations +|str_pool[pool_ptr]| and |str_start[str_ptr]| are +ready for the next string to be allocated. + +String numbers 0 to 255 are reserved for strings that correspond to single +ASCII characters. This is in accordance with the conventions of \.{WEB}, +@.WEB@> +which converts single-character strings into the ASCII code number of the +single character involved, while it converts other strings into integers +and builds a string pool file. Thus, when the string constant \.{"."} appears +in the program below, \.{WEB} converts it into the integer 46, which is the +ASCII code for a period, while \.{WEB} will convert a string like \.{"hello"} +into some integer greater than~255. String number 46 will presumably be the +single character `\..'; but some ASCII codes have no standard visible +representation, and \TeX\ sometimes needs to be able to print an arbitrary +ASCII character, so the first 256 strings are used to specify exactly what +should be printed for each of the 256 possibilities. + +Elements of the |str_pool| array must be ASCII codes that can actually +be printed; i.e., they must have an |xchr| equivalent in the local +character set. (This restriction applies only to preloaded strings, +not to those generated dynamically by the user.) + +Some \PASCAL\ compilers won't pack integers into a single byte unless the +integers lie in the range |-128 dotdot 127|. To accommodate such systems +we access the string pool only via macros that can easily be redefined. +@^system dependencies@> + +@d si(A) A /*convert from |ASCII_code| to |packed_ASCII_code|*/ +@d so(A) A /*convert from |packed_ASCII_code| to |ASCII_code|*/ + +@= +typedef int32_t pool_pointer; /*for variables that point into |str_pool|*/ +typedef int32_t str_number; /*for variables that point into |str_start|*/ +typedef uint8_t packed_ASCII_code; /*elements of |str_pool| array*/ + +@ @= +static packed_ASCII_code @!str_pool[pool_size+1]; /*the characters*/ +static pool_pointer @!str_start[max_strings+1]; /*the starting pointers*/ +static pool_pointer @!pool_ptr; /*first unused position in |str_pool|*/ +static str_number @!str_ptr; /*number of the current string being created*/ +static pool_pointer @!init_pool_ptr; /*the starting value of |pool_ptr|*/ +static str_number @!init_str_ptr; /*the starting value of |str_ptr|*/ + +@ Several of the elementary string operations are performed using \.{WEB} +macros instead of \PASCAL\ procedures, because many of the +operations are done quite frequently and we want to avoid the +overhead of procedure calls. For example, here is +a simple macro that computes the length of a string. +@.WEB@> + +@d length(A) (str_start[A+1]-str_start[A]) /*the number of characters + in string number \#*/ + +@ The length of the current string is called |cur_length|: + +@d cur_length (pool_ptr-str_start[str_ptr]) + +@ Strings are created by appending character codes to |str_pool|. +The |append_char| macro, defined here, does not check to see if the +value of |pool_ptr| has gotten too high; this test is supposed to be +made before |append_char| is used. There is also a |flush_char| +macro, which erases the last character appended. + +To test if there is room to append |l| more characters to |str_pool|, +we shall write |str_room(l)|, which aborts \TeX\ and gives an +apologetic error message if there isn't enough room. + +@d append_char(A) /*put |ASCII_code| \# at the end of |str_pool|*/ +{@+str_pool[pool_ptr]=si(A);incr(pool_ptr); +} +@d flush_char decr(pool_ptr) /*forget the last character in the pool*/ +@d str_room(A) /*make sure that the pool hasn't overflowed*/ + {@+if (pool_ptr+A > pool_size) + overflow("pool size", pool_size-init_pool_ptr); +@:TeX capacity exceeded pool size}{\quad pool size@> + } + +@ Once a sequence of characters has been appended to |str_pool|, it +officially becomes a string when the function |make_string| is called. +This function returns the identification number of the new string as its +value. + +@p static str_number make_string(void) /*current string enters the pool*/ +{@+if (str_ptr==max_strings) + overflow("number of strings", max_strings-init_str_ptr); +@:TeX capacity exceeded number of strings}{\quad number of strings@> +incr(str_ptr);str_start[str_ptr]=pool_ptr; +return str_ptr-1; +} + +@ To destroy the most recently made string, we say |flush_string|. + +@d flush_string {@+decr(str_ptr);pool_ptr=str_start[str_ptr]; + } + +@ The following subroutine compares string |s| with another string of the +same length that appears in |buffer| starting at position |k|; +the result is |true| if and only if the strings are equal. +Empirical tests indicate that |str_eq_buf| is used in such a way that +it tends to return |true| about 80 percent of the time. + +@p static bool str_eq_buf(str_number @!s, int @!k) + /*test equality of strings*/ +{@+ /*loop exit*/ +pool_pointer j; /*running index*/ +bool @!result; /*result of comparison*/ +j=str_start[s]; +while (j < str_start[s+1]) + {@+if (so(str_pool[j])!=buffer[k]) + {@+result=false;goto not_found; + } + incr(j);incr(k); + } +result=true; +not_found: return result; +} + +@ Here is a similar routine, but it compares two strings in the string pool, +and it does not assume that they have the same length. + +@p static bool strn_eq_str(str_number @!s, str_number @!t) + /*test equality of strings*/ +{@+ /*loop exit*/ +pool_pointer j, @!k; /*running indices*/ +bool @!result; /*result of comparison*/ +result=false; +if (length(s)!=length(t)) goto not_found; +j=str_start[s];k=str_start[t]; +while (j < str_start[s+1]) + {@+if (str_pool[j]!=str_pool[k]) goto not_found; + incr(j);incr(k); + } +result=true; +not_found: return result; +} +@t\4@>@@; + +static bool str_eq_str(str_number @!s, char *@!t) + /*test equality of strings*/ +{@+int j, @!k; /*running indices*/ +if (length(s)!=(int)strlen(t)) return false; +j=str_start[s];k=0; +while (j < str_start[s+1]) + if (str_pool[j++]!=t[k++]) return false; +return true; +} + +@ The initial values of |str_pool|, |str_start|, |pool_ptr|, +and |str_ptr| are computed by the \.{INITEX} program, based in part +on the information that \.{WEB} has output while processing \TeX. +@.INITEX@> +@^string pool@> + +@p +static void get_strings_started(void) /*initializes the string pool*/ +{@+ +int k, @!l; /*small indices or counters*/ +pool_ptr=0;str_ptr=0;str_start[0]=0; +@; +@; +} + +@ @d app_lc_hex(A) l=A; + if (l < 10) append_char(l+'0')@;@+else append_char(l-10+'a') + +@= +for (k=0; k<=255; k++) + {@+if ((@)) + {@+append_char('^');append_char('^'); + if (k < 0100) append_char(k+0100)@; + else if (k < 0200) append_char(k-0100)@; + else{@+app_lc_hex(k/16);app_lc_hex(k%16); + } + } + else append_char(k); + make_string(); + } + +@ The first 128 strings will contain 95 standard ASCII characters, and the +other 33 characters will be printed in three-symbol form like `\.{\^\^A}' +unless a system-dependent change is made here. Installations that have +an extended character set, where for example |xchr[032]==@t\.{\'^^Z\'}@>|, +would like string 032 to be the single character 032 instead of the +three characters 0136, 0136, 0132 (\.{\^\^Z}). On the other hand, +even people with an extended character set will want to represent string +015 by \.{\^\^M}, since 015 is |carriage_return|; the idea is to +produce visible strings instead of tabs or line-feeds or carriage-returns +or bell-rings or characters that are treated anomalously in text files. + +Unprintable characters of codes 128--255 are, similarly, rendered +\.{\^\^80}--\.{\^\^ff}. + +The boolean expression defined here should be |true| unless \TeX\ +internal code number~|k| corresponds to a non-troublesome visible +symbol in the local character set. An appropriate formula for the +extended character set recommended in {\sl The \TeX book\/} would, for +example, be `|k in[0, 010 dotdot 012, 014, 015, 033, 0177 dotdot 0377]|'. +If character |k| cannot be printed, and |k < 0200|, then character |k+0100| or +|k-0100| must be printable; moreover, ASCII codes |[041 dotdot 046, +060 dotdot 071, 0136, 0141 dotdot 0146, 0160 dotdot 0171]| must be printable. +Thus, at least 80 printable characters are needed. +@:TeXbook}{\sl The \TeX book@> +@^character set dependencies@> +@^system dependencies@> + +@= + (k < ' ')||(k > '~') + +@ The |pool_file| variable is no longer needed and has been removed. + +@ Instead of reading the other strings from the \.{TEX.POOL} file, +it is sufficient here to add the empty string. +@= +make_string(); + +@ Without a string pool file there is no need for a pool check sum either. +But this is a convenient place to define the function |s_no| that will +add literal strings to the string pool at runtime, thereby obtaining their +string number. + +@p static int s_no(const char *str) +{@+ + if (str[0]==0) return empty_string; + if (str[1]==0) return str[0]; + str_room(strlen(str)); + while (*str!=0) append_char(*str++); + return make_string(); +} + +@* On-line and off-line printing. +Messages that are sent to a user's terminal and to the transcript-log file +are produced by several `|print|' procedures. These procedures will +direct their output to a variety of places, based on the setting of +the global variable |selector|, which has the following possible +values: + +\yskip +\hang |term_and_log|, the normal setting, prints on the terminal and on the + transcript file. + +\hang |log_only|, prints only on the transcript file. + +\hang |term_only|, prints only on the terminal. + +\hang |no_print|, doesn't print at all. This is used only in rare cases + before the transcript file is open. + +\hang |pseudo|, puts output into a cyclic buffer that is used + by the |show_context| routine; when we get to that routine we shall discuss + the reasoning behind this curious mode. + +\hang |new_string|, appends the output to the current string in the + string pool. + +\hang 0 to 15, prints on one of the sixteen files for \.{\\write} output. + +\yskip +\noindent The symbolic names `|term_and_log|', etc., have been assigned +numeric codes that satisfy the convenient relations |no_print+1==term_only|, +|no_print+2==log_only|, |term_only+2==log_only+1==term_and_log|. + +Three additional global variables, |tally| and |term_offset| and +|file_offset|, record the number of characters that have been printed +since they were most recently cleared to zero. We use |tally| to record +the length of (possibly very long) stretches of printing; |term_offset| +and |file_offset|, on the other hand, keep track of how many characters +have appeared so far on the current line that has been output to the +terminal or to the transcript file, respectively. + +@d no_print 16 /*|selector| setting that makes data disappear*/ +@d term_only 17 /*printing is destined for the terminal only*/ +@d log_only 18 /*printing is destined for the transcript file only*/ +@d term_and_log 19 /*normal |selector| setting*/ +@d pseudo 20 /*special |selector| setting for |show_context|*/ +@d new_string 21 /*printing is deflected to the string pool*/ +@d max_selector 21 /*highest selector setting*/ + +@= +static alpha_file @!log_file; /*transcript of \TeX\ session*/ +static int @!selector; /*where to print a message*/ +static int8_t @!dig[23]; /*digits in a number being output*/ +static int @!tally; /*the number of characters recently printed*/ +static int @!term_offset; + /*the number of characters on the current terminal line*/ +static int @!file_offset; + /*the number of characters on the current file line*/ +static ASCII_code @!trick_buf[error_line+1]; /*circular buffer for + pseudoprinting*/ +static int @!trick_count; /*threshold for pseudoprinting, explained later*/ +static int @!first_count; /*another variable for pseudoprinting*/ + +@ @= +selector=term_only;tally=0;term_offset=0;file_offset=0; + +@ Macro abbreviations for output to the terminal and to the log file are +defined here for convenience. Some systems need special conventions +for terminal output, and it is possible to adhere to those conventions +by changing |wterm|, |wterm_ln|, and |wterm_cr| in this section. +@^system dependencies@> + +@= +#define put(F) @[fwrite(&((F).d),sizeof((F).d),1,(F).f)@] +#define get(F) @[fread(&((F).d),sizeof((F).d),1,(F).f)@] + +#define pascal_close(F) @[fclose((F).f)@] +#define eof(F) @[feof((F).f)@] +#define eoln(F) @[((F).d=='\n'||eof(F))@] +#define erstat(F) @[((F).f==NULL?-1:ferror((F).f))@] + +#define pascal_read(F,X) @[((X)=(F).d,get(F))@] +#define read_ln(F) @[do get(F); while (!eoln(F))@] + +#define pascal_write(F, FMT,...) @[fprintf(F.f,FMT,## __VA_ARGS__)@] +#define write_ln(F,...) @[pascal_write(F,__VA_ARGS__"\n")@] + +#define wterm(FMT,...) @[pascal_write(term_out,FMT, ## __VA_ARGS__)@] +#define wterm_ln(FMT,...) @[wterm(FMT "\n", ## __VA_ARGS__)@] +#define wterm_cr @[pascal_write(term_out,"\n")@] +#define wlog(FMT, ...) @[pascal_write(log_file,FMT, ## __VA_ARGS__)@] +#define wlog_ln(FMT, ...) @[wlog(FMT "\n", ## __VA_ARGS__)@] +#define wlog_cr @[pascal_write(log_file,"\n")@] + +@ To end a line of text output, we call |print_ln|. + +@= +static void print_ln(void) /*prints an end-of-line*/ +{@+switch (selector) { +case term_and_log: {@+wterm_cr;wlog_cr; + term_offset=0;file_offset=0; + } @+break; +case log_only: {@+wlog_cr;file_offset=0; + } @+break; +case term_only: {@+wterm_cr;term_offset=0; + } @+break; +case no_print: case pseudo: case new_string: do_nothing;@+break; +default:write_ln(write_file[selector]); +} @/ +} /*|tally| is not affected*/ + +@ The |print_char| procedure sends one character to the desired destination, +using the |xchr| array to map it into an external character compatible with +|input_ln|. All printing comes through |print_ln| or |print_char|. + +@= +static void print_char(ASCII_code @!s) /*prints a single character*/ +{@+ +if (@) + if (selector < pseudo) + {@+print_ln();return; + } +switch (selector) { +case term_and_log: {@+wterm("%c",xchr[s]);wlog("%c",xchr[s]); + incr(term_offset);incr(file_offset); + if (term_offset==max_print_line) + {@+wterm_cr;term_offset=0; + } + if (file_offset==max_print_line) + {@+wlog_cr;file_offset=0; + } + } @+break; +case log_only: {@+wlog("%c",xchr[s]);incr(file_offset); + if (file_offset==max_print_line) print_ln(); + } @+break; +case term_only: {@+wterm("%c",xchr[s]);incr(term_offset); + if (term_offset==max_print_line) print_ln(); + } @+break; +case no_print: do_nothing;@+break; +case pseudo: if (tally < trick_count) trick_buf[tally%error_line]=s;@+break; +case new_string: {@+if (pool_ptr < pool_size) append_char(s); + } @+break; /*we drop characters if the string space is full*/ +default:pascal_write(write_file[selector],"%c", xchr[s]); +} @/ +incr(tally); +} + +@ An entire string is output by calling |print|. Note that if we are outputting +the single standard ASCII character \.c, we could call |print('c')|, since +|'c'==99| is the number of a single-character string, as explained above. But +|print_char('c')| is quicker, so \TeX\ goes directly to the |print_char| +routine when it knows that this is safe. (The present implementation +assumes that it is always safe to print a visible ASCII character.) +@^system dependencies@> + +@= +static void print(char *s) /* the simple version */ +{ while (*s!=0) print_char(*s++);@+ +} + +static void printn(int @!s) /*prints string |s|*/ +{@+ +pool_pointer j; /*current character code position*/ +int @!nl; /*new-line character to restore*/ +if (s >= str_ptr) {print("???"); return;}/*this can't happen*/ +@.???@> +else if (s < 256) + if (s < 0) { print("???");return; } /*can't happen*/ + else{@+if (selector > pseudo) + {@+print_char(s);return; /*internal strings are not expanded*/ + } + if ((@)) + if (selector < pseudo) + {@+print_ln();return; + } + nl=new_line_char;new_line_char=-1; + /*temporarily disable new-line character*/ + j=str_start[s]; + while (j < str_start[s+1]) + {@+print_char(so(str_pool[j]));incr(j); + } + new_line_char=nl;return; + } +j=str_start[s]; +while (j < str_start[s+1]) + {@+print_char(so(str_pool[j]));incr(j); + } +} + +@ Control sequence names, file names, and strings constructed with +\.{\\string} might contain |ASCII_code| values that can't +be printed using |print_char|. Therefore we use |slow_print| for them: + +@= +static void slow_print(int @!s) /*prints string |s|*/ +{@+pool_pointer j; /*current character code position*/ +if ((s >= str_ptr)||(s < 256)) printn(s); +else{@+j=str_start[s]; + while (j < str_start[s+1]) + {@+printn(so(str_pool[j]));incr(j); + } + } +} + +@ Here is the very first thing that \TeX\ prints: a headline that identifies +the version number and format package. The |term_offset| variable is temporarily +incorrect, but the discrepancy is not serious since we assume that this +part of the program is system dependent. +@^system dependencies@> + +k\TeX, according to the conventions of \TeX\ Live, + prints the |dump_name| if no format identifier is known. +@= +wterm("%s",banner); +if (format_ident==0) wterm_ln(" (preloaded format=%s)", dump_name); +else{@+slow_print(format_ident);print_ln(); + } +update_terminal; + +@ The procedure |print_nl| is like |print|, but it makes sure that the +string appears at the beginning of a new line. + +@= +static void print_nl(char *@!s) /*prints string |s| at beginning of line*/ +{@+if (((term_offset > 0)&&(odd(selector)))||@| + ((file_offset > 0)&&(selector >= log_only))) print_ln(); +print(s); +} + +@ The procedure |print_esc| prints a string that is preceded by +the user's escape character (which is usually a backslash). + +@= +static void printn_esc(str_number @!s) /*prints escape character, then |s|*/ +{@+int c; /*the escape character code*/ +@; +if (c >= 0) if (c < 256) printn(c); +slow_print(s); +} + +static void print_esc(char *@!s) /*the fast way*/ +{@+int c; /*the escape character code*/ +@; +if (c >= 0) if (c < 256) printn(c); +print(s); +} + +@ An array of digits in the range |0 dotdot 15| is printed by |print_the_digs|. + +@= +static void print_the_digs(eight_bits @!k) + /*prints |dig[k-1]|$\,\ldots\,$|dig[0]|*/ +{@+while (k > 0) + {@+decr(k); + if (dig[k] < 10) print_char('0'+dig[k]); + else print_char('A'-10+dig[k]); + } +} + +@ The following procedure, which prints out the decimal representation of a +given integer |n|, has been written carefully so that it works properly +if |n==0| or if |(-n)| would cause overflow. It does not apply |%| or |/| +to negative arguments, since such operations are not implemented consistently +by all \PASCAL\ compilers. + +@= +static void print_int(int @!n) /*prints an integer in decimal form*/ +{@+int k; /*index to current digit; we assume that $\vert n\vert<10^{23}$*/ +int @!m; /*used to negate |n| in possibly dangerous cases*/ +k=0; +if (n < 0) + {@+print_char('-'); + if (n > -100000000) negate(n); + else{@+m=-1-n;n=m/10;m=(m%10)+1;k=1; + if (m < 10) dig[0]=m; + else{@+dig[0]=0;incr(n); + } + } + } +@/do@+{dig[k]=n%10;n=n/10;incr(k); +}@+ while (!(n==0)); +print_the_digs(k); +} + +@ Here is a trivial procedure to print two digits; it is usually called with +a parameter in the range |0 <= n <= 99|. + +@p static void print_two(int @!n) /*prints two least significant digits*/ +{@+n=abs(n)%100;print_char('0'+(n/10)); +print_char('0'+(n%10)); +} + +@ Hexadecimal printing of nonnegative integers is accomplished by |print_hex|. + +@p static void print_hex(int @!n) + /*prints a positive integer in hexadecimal form*/ +{@+int k; /*index to current digit; we assume that $0\le n<16^{22}$*/ +k=0;print_char('"'); +@/do@+{dig[k]=n%16;n=n/16;incr(k); +}@+ while (!(n==0)); +print_the_digs(k); +} + +@ Old versions of \TeX\ needed a procedure called |print_ASCII| whose function +is now subsumed by |print|. We retain the old name here as a possible aid to +future software arch\ae ologists. + +@d print_ASCII printn + +@ Roman numerals are produced by the |print_roman_int| routine. Readers +who like puzzles might enjoy trying to figure out how this tricky code +works; therefore no explanation will be given. Notice that 1990 yields +\.{mcmxc}, not \.{mxm}. + +@p static void print_roman_int(int @!n) +{@+ +pool_pointer j, @!k; /*mysterious indices into |mystery|*/ +nonnegative_integer @!u, @!v; /*mysterious numbers*/ +const char mystery[] ="m2d5c2l5x2v5i"; +j=0;v=1000; +loop@+{@+while (n >= v) + {@+print_char(so(mystery[j]));n=n-v; + } + if (n <= 0) return; /*nonpositive input produces no output*/ + k=j+2;u=v/(so(mystery[k-1])-'0'); + if (mystery[k-1]==si('2')) + {@+k=k+2;u=u/(so(mystery[k-1])-'0'); + } + if (n+u >= v) + {@+print_char(so(mystery[k]));n=n+u; + } + else{@+j=j+2;v=v/(so(mystery[j-1])-'0'); + } + } +} + +@ The |print| subroutine will not print a string that is still being +created. The following procedure will. + +@p static void print_current_string(void) /*prints a yet-unmade string*/ +{@+pool_pointer j; /*points to current character code*/ +j=str_start[str_ptr]; +while (j < pool_ptr) + {@+print_char(so(str_pool[j]));incr(j); + } +} + +@ Here is a procedure that asks the user to type a line of input, +assuming that the |selector| setting is either |term_only| or |term_and_log|. +The input is placed into locations |first| through |last-1| of the +|buffer| array, and echoed on the transcript file if appropriate. + +This procedure is never called when |interaction < scroll_mode|. + +@d prompt_input(A) {@+wake_up_terminal;print(A);term_input(); + } /*prints a string and gets a line of input*/ + +@p static void term_input(void) /*gets a line from the terminal*/ +{@+int k; /*index into |buffer|*/ +update_terminal; /*now the user sees the prompt for sure*/ +if (!input_ln(&term_in, true)) fatal_error("End of file on the terminal!"); +@.End of file on the terminal@> +term_offset=0; /*the user's line ended with \<\rm return>*/ +decr(selector); /*prepare to echo the input*/ +if (last!=first) for (k=first; k<=last-1; k++) printn(buffer[k]); +print_ln();incr(selector); /*restore previous status*/ +} + +@* Reporting errors. +When something anomalous is detected, \TeX\ typically does something like this: +$$\vbox{\halign{#\hfil\cr +|print_err("Something anomalous has been detected");|\cr +|help3("This is the first line of my offer to help.")|\cr +|("This is the second line. I'm trying to")|\cr +|("explain the best way for you to proceed.");|\cr +|error;|\cr}}$$ +A two-line help message would be given using |help2|, etc.; these informal +helps should use simple vocabulary that complements the words used in the +official error message that was printed. (Outside the U.S.A., the help +messages should preferably be translated into the local vernacular. Each +line of help is at most 60 characters long, in the present implementation, +so that |max_print_line| will not be exceeded.) + +The |print_err| procedure supplies a `\.!' before the official message, +and makes sure that the terminal is awake if a stop is going to occur. +The |error| procedure supplies a `\..' after the official message, then it +shows the location of the error; and if |interaction==error_stop_mode|, +it also enters into a dialog with the user, during which time the help +message may be printed. +@^system dependencies@> + +@= +void print_err(char *s) +{@+if (interaction==error_stop_mode) wake_up_terminal; + if (filelineerrorstylep) print_file_line(); /* k\TeX\ */ + else print_nl("! "); + print(s); +} + +@ The global variable |interaction| has four settings, representing increasing +amounts of user interaction: + +@d batch_mode 0 /*omits all stops and omits terminal output*/ +@d nonstop_mode 1 /*omits all stops*/ +@d scroll_mode 2 /*omits error stops*/ +@d error_stop_mode 3 /*stops at every opportunity to interact*/ + +@= +static int @!interaction; /*current level of interaction*/ + +@ @=interaction=error_stop_mode; + +@ \TeX\ is careful not to call |error| when the print |selector| setting +might be unusual. The only possible values of |selector| at the time of +error messages are + +\yskip\hang|no_print| (when |interaction==batch_mode| + and |log_file| not yet open); + +\hang|term_only| (when |interaction > batch_mode| and |log_file| not yet open); + +\hang|log_only| (when |interaction==batch_mode| and |log_file| is open); + +\hang|term_and_log| (when |interaction > batch_mode| and |log_file| is open). + +@= +if (interaction==batch_mode) selector=no_print;@+else selector=term_only + +@ A global variable |deletions_allowed| is set |false| if the |get_next| +routine is active when |error| is called; this ensures that |get_next| +and related routines like |get_token| will never be called recursively. +A similar interlock is provided by |set_box_allowed|. +@^recursion@> + +The global variable |history| records the worst level of error that +has been detected. It has four possible values: |spotless|, |warning_issued|, +|error_message_issued|, and |fatal_error_stop|. + +Another global variable, |error_count|, is increased by one when an +|error| occurs without an interactive dialog, and it is reset to zero at +the end of every paragraph. If |error_count| reaches 100, \TeX\ decides +that there is no point in continuing further. + +@d spotless 0 /*|history| value when nothing has been amiss yet*/ +@d warning_issued 1 /*|history| value when |begin_diagnostic| has been called*/ +@d error_message_issued 2 /*|history| value when |error| has been called*/ +@d fatal_error_stop 3 /*|history| value when termination was premature*/ + +@= +static bool @!deletions_allowed; /*is it safe for |error| to call |get_token|?*/ +static bool @!set_box_allowed; /*is it safe to do a \.{\\setbox} assignment?*/ +static int @!history; /*has the source input been clean so far?*/ +static int @!error_count; /*the number of scrolled errors since the + last paragraph ended*/ + +@ The value of |history| is initially |fatal_error_stop|, but it will +be changed to |spotless| if \TeX\ survives the initialization process. + +@= +deletions_allowed=true;set_box_allowed=true; +error_count=0; /*|history| is initialized elsewhere*/ + +@ Since errors can be detected almost anywhere in \TeX, we want to declare the +error procedures near the beginning of the program. But the error procedures +in turn use some other procedures, which need to be declared |forward| +before we get to |error| itself. + +It is possible for |error| to be called recursively if some error arises +when |get_token| is being used to delete a token, and/or if some fatal error +occurs while \TeX\ is trying to fix a non-fatal one. But such recursion +@^recursion@> +is never more than two levels deep. + +@= +static void normalize_selector(void);@/ +static void get_token(void);@/ +static void term_input(void);@/ +static void show_context(void);@/ +static void begin_file_reading(void);@/ +static void open_log_file(void);@/ +static void close_files_and_terminate(void);@/ +static void clear_for_error_prompt(void);@/ +static void give_err_help(void);@/ +#ifdef @!DEBUG +static void debug_help(void); +#else +#define debug_help() do_nothing +#endif + +@ Individual lines of help are recorded in the array |help_line|, which +contains entries in positions |0 dotdot(help_ptr-1)|. They should be printed +in reverse order, i.e., with |help_line[0]| appearing last. + +@d hlp1(A) help_line[0]=A;@+} +@d hlp2(A, B) help_line[1]=A;help_line[0]=B;@+} +@d hlp3(A, B, C) help_line[2]=A;help_line[1]=B;help_line[0]=C;@+} +@d hlp4(A, B, C, D) help_line[3]=A;help_line[2]=B;help_line[1]=C;help_line[0]=D;@+} +@d hlp5(A, B, C, D, E) help_line[4]=A;help_line[3]=B;help_line[2]=C;help_line[1]=D;help_line[0]=E;@+} +@d hlp6(A, B, C, D, E, F) help_line[5]=A;help_line[4]=B;help_line[3]=C;help_line[2]=D;help_line[1]=E;help_line[0]=F;@+} +@d help0 help_ptr=0 /*sometimes there might be no help*/ +@d help1(A) @+{@+help_ptr=1;hlp1(A) /*use this with one help line*/ +@d help2(A, B) @+{@+help_ptr=2;hlp2(A, B) /*use this with two help lines*/ +@d help3(A, B, C) @+{@+help_ptr=3;hlp3(A, B, C) /*use this with three help lines*/ +@d help4(A, B, C, D) @+{@+help_ptr=4;hlp4(A, B, C, D) /*use this with four help lines*/ +@d help5(A, B, C, D, E) @+{@+help_ptr=5;hlp5(A, B, C, D, E) /*use this with five help lines*/ +@d help6(A, B, C, D, E, F) @+{@+help_ptr=6;hlp6(A, B, C, D, E, F) /*use this with six help lines*/ + +@= +static char *@!help_line[6]; /*helps for the next |error|*/ +static int @!help_ptr; /*the number of help lines present*/ +static bool @!use_err_help; /*should the |err_help| list be shown?*/ + +@ @= +help_ptr=0;use_err_help=false; + +@ The |jump_out| procedure just cuts across all active procedure levels and +goes to |end_of_TEX|. This is the only nontrivial |@!goto| statement in the +whole program. It is used when there is no recovery from a particular error. + +Some \PASCAL\ compilers do not implement non-local |goto| statements. +@^system dependencies@> +In such cases the body of |jump_out| should simply be +`|close_files_and_terminate|;\thinspace' followed by a call on some system +procedure that quietly terminates the program. + +@= +static void jump_out(void) +{@+ close_files_and_terminate(); exit(0); +} + +@ Here now is the general |error| routine. + +@= +static void error(void) /*completes the job of error reporting*/ +{@+ +ASCII_code c; /*what the user types*/ +int @!s1, @!s2, @!s3, @!s4; + /*used to save global variables when deleting tokens*/ +if (history < error_message_issued) history=error_message_issued; +print_char('.');show_context(); +if (interaction==error_stop_mode) + @; +incr(error_count); +if (error_count==100) + {@+print_nl("(That makes 100 errors; please try again.)"); +@.That makes 100 errors...@> + history=fatal_error_stop;jump_out(); + } +@; +} + +@ @= +loop@+{@+resume: if (interaction!=error_stop_mode) return; + clear_for_error_prompt();prompt_input("? "); +@.?\relax@> + if (last==first) return; + c=buffer[first]; + if (c >= 'a') c=c+'A'-'a'; /*convert to uppercase*/ + @; + } + +@ It is desirable to provide an `\.E' option here that gives the user +an easy way to return from \TeX\ to the system editor, with the offending +line ready to be edited. But such an extension requires some system +wizardry, so the present implementation simply types out the name of the +file that should be +edited and the relevant line number. +@^system dependencies@> + +There is a secret `\.D' option available when the debugging routines haven't +been commented~out. +@^debugging@> + +@= +switch (c) { +case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': if (deletions_allowed) + @@;@+break; +@t\4\4@>@; +#ifdef @!DEBUG +case 'D': {@+debug_help();goto resume;@+} +#endif +case 'E': if (base_ptr > 0) if (input_stack[base_ptr].name_field >= 256) + {@+print_nl("You want to edit file "); +@.You want to edit file x@> + slow_print(input_stack[base_ptr].name_field); + print(" at line ");print_int(line); + interaction=scroll_mode;jump_out(); + } @+break; +case 'H': @@; +case 'I': @@; +case 'Q': case 'R': case 'S': @@; +case 'X': {@+interaction=scroll_mode;jump_out(); + } @+break; +default:do_nothing; +} @/ +@@; + +@ @= +{@+print("Type to proceed, S to scroll future error messages,");@/ +@.Type to proceed...@> +print_nl("R to run without stopping, Q to run quietly,");@/ +print_nl("I to insert something, "); +if (base_ptr > 0) if (input_stack[base_ptr].name_field >= 256) + print("E to edit your file,"); +if (deletions_allowed) + print_nl("1 or ... or 9 to ignore the next 1 to 9 tokens of input,"); +print_nl("H for help, X to quit."); +} + +@ Here the author of \TeX\ apologizes for making use of the numerical +relation between |'Q'|, |'R'|, |'S'|, and the desired interaction settings +|batch_mode|, |nonstop_mode|, |scroll_mode|. +@^Knuth, Donald Ervin@> + +@= +{@+error_count=0;interaction=batch_mode+c-'Q'; +print("OK, entering "); +switch (c) { +case 'Q': {@+print_esc("batchmode");decr(selector); + } @+break; +case 'R': print_esc("nonstopmode");@+break; +case 'S': print_esc("scrollmode"); +} /*there are no other cases*/ +print("...");print_ln();update_terminal;return; +} + +@ When the following code is executed, |buffer[(first+1)dotdot(last-1)]| may +contain the material inserted by the user; otherwise another prompt will +be given. In order to understand this part of the program fully, you need +to be familiar with \TeX's input stacks. + +@= +{@+begin_file_reading(); /*enter a new syntactic level for terminal input*/ + /*now |state==mid_line|, so an initial blank space will count as a blank*/ +if (last > first+1) + {@+loc=first+1;buffer[first]=' '; + } +else{@+prompt_input("insert>");loc=first; +@.insert>@> + } +first=last; +cur_input.limit_field=last-1; /*no |end_line_char| ends this line*/ +return; +} + +@ We allow deletion of up to 99 tokens at a time. + +@= +{@+s1=cur_tok;s2=cur_cmd;s3=cur_chr;s4=align_state; +align_state=1000000;OK_to_interrupt=false; +if ((last > first+1)&&(buffer[first+1] >= '0')&&(buffer[first+1] <= '9')) + c=c*10+buffer[first+1]-'0'*11; +else c=c-'0'; +while (c > 0) + {@+get_token(); /*one-level recursive call of |error| is possible*/ + decr(c); + } +cur_tok=s1;cur_cmd=s2;cur_chr=s3;align_state=s4;OK_to_interrupt=true; +help2("I have just deleted some text, as you asked.",@/ +"You can now delete more, or insert, or whatever."); +show_context();goto resume; +} + +@ @= +{@+if (use_err_help) + {@+give_err_help();use_err_help=false; + } +else{@+if (help_ptr==0) + help2("Sorry, I don't know how to help in this situation.",@/ + @t\kern1em@>"Maybe you should try asking a human?"); + @/do@+{decr(help_ptr);print(help_line[help_ptr]);print_ln(); + }@+ while (!(help_ptr==0)); + } +help4("Sorry, I already gave what help I could...",@/ + "Maybe you should try asking a human?",@/ + "An error might have occurred before I noticed any problems.",@/ + "``If all else fails, read the instructions.'");@/ +goto resume; +} + +@ @= +if (interaction > batch_mode) decr(selector); /*avoid terminal output*/ +if (use_err_help) + {@+print_ln();give_err_help(); + } +else while (help_ptr > 0) + {@+decr(help_ptr);print_nl(help_line[help_ptr]); + } +print_ln(); +if (interaction > batch_mode) incr(selector); /*re-enable terminal output*/ +print_ln() + +@ A dozen or so error messages end with a parenthesized integer, so we +save a teeny bit of program space by declaring the following procedure: + +@p static void int_error(int @!n) +{@+print(" (");print_int(n);print_char(')');error(); +} + +@ In anomalous cases, the print selector might be in an unknown state; +the following subroutine is called to fix things just enough to keep +running a bit longer. + +@p static void normalize_selector(void) +{@+if (log_opened) selector=term_and_log; +else selector=term_only; +if (job_name==0) open_log_file(); +if (interaction==batch_mode) decr(selector); +} + +@ The following procedure prints \TeX's last words before dying. + +@d succumb {@+if (interaction==error_stop_mode) + interaction=scroll_mode; /*no more interaction*/ + if (log_opened) error(); + if (interaction > batch_mode) debug_help(); + history=fatal_error_stop;jump_out(); /*irrecoverable error*/ + } + +@= +static void fatal_error(char *@!s) /*prints |s|, and that's it*/ +{@+normalize_selector();@/ +print_err("Emergency stop");help1(s);succumb; +@.Emergency stop@> +} + +@ Here is the most dreaded error message. + +@= +static void overflow(char *@!s, int @!n) /*stop due to finiteness*/ +{@+normalize_selector(); +print_err("TeX capacity exceeded, sorry ["); +@.TeX capacity exceeded ...@> +print(s);print_char('=');print_int(n);print_char(']'); +help2("If you really absolutely need more capacity,",@/ + "you can ask a wizard to enlarge me."); +succumb; +} + +@ The program might sometime run completely amok, at which point there is +no choice but to stop. If no previous error has been detected, that's bad +news; a message is printed that is really intended for the \TeX\ +maintenance person instead of the user (unless the user has been +particularly diabolical). The index entries for `this can't happen' may +help to pinpoint the problem. +@^dry rot@> + +@= +static void confusion(char *@!s) + /*consistency check violated; |s| tells where*/ +{@+normalize_selector(); +if (history < error_message_issued) + {@+print_err("This can't happen (");print(s);print_char(')'); +@.This can't happen@> + help1("I'm broken. Please show this to someone who can fix can fix"); + } +else{@+print_err("I can't go on meeting you like this"); +@.I can't go on...@> + help2("One of your faux pas seems to have wounded me deeply...",@/ + "in fact, I'm barely conscious. Please fix it and try again."); + } +succumb; +} + +@ Users occasionally want to interrupt \TeX\ while it's running. +If the \PASCAL\ runtime system allows this, one can implement +a routine that sets the global variable |interrupt| to some nonzero value +when such an interrupt is signalled. Otherwise there is probably at least +a way to make |interrupt| nonzero using the \PASCAL\ debugger. +@^system dependencies@> +@^debugging@> + +@d check_interrupt {@+if (interrupt!=0) pause_for_instructions(); + } + +@= +static int @!interrupt; /*should \TeX\ pause for instructions?*/ +static bool @!OK_to_interrupt; /*should interrupts be observed?*/ + +@ @= +interrupt=0;OK_to_interrupt=true; + +@ When an interrupt has been detected, the program goes into its +highest interaction level and lets the user have nearly the full flexibility of +the |error| routine. \TeX\ checks for interrupts only at times when it is +safe to do this. + +@p static void pause_for_instructions(void) +{@+if (OK_to_interrupt) + {@+interaction=error_stop_mode; + if ((selector==log_only)||(selector==no_print)) + incr(selector); + print_err("Interruption"); +@.Interruption@> + help3("You rang?",@/ + "Try to insert an instruction for me (e.g., `I\\showlists'),",@/ + "unless you just want to quit by typing `X'."); + deletions_allowed=false;error();deletions_allowed=true; + interrupt=0; + } +} + +@* Arithmetic with scaled dimensions. +The principal computations performed by \TeX\ are done entirely in terms of +integers less than $2^{31}$ in magnitude; and divisions are done only when both +dividend and divisor are nonnegative. Thus, the arithmetic specified in this +program can be carried out in exactly the same way on a wide variety of +computers, including some small ones. Why? Because the arithmetic +calculations need to be spelled out precisely in order to guarantee that +\TeX\ will produce identical output on different machines. If some +quantities were rounded differently in different implementations, we would +find that line breaks and even page breaks might occur in different places. +Hence the arithmetic of \TeX\ has been designed with care, and systems that +claim to be implementations of \TeX82 should follow precisely the +@:TeX82}{\TeX82@> +calculations as they appear in the present program. + +(Actually there are three places where \TeX\ uses |/| with a possibly negative +numerator. These are harmless; see |/| in the index. Also if the user +sets the \.{\\time} or the \.{\\year} to a negative value, some diagnostic +information will involve negative-numerator division. The same remarks +apply for |%| as well as for |/|.) + +@ Here is a routine that calculates half of an integer, using an +unambiguous convention with respect to signed odd numbers. + +@p static int half(int @!x) +{@+if (odd(x)) return(x+1)/2; +else return x/2; +} + +@ Fixed-point arithmetic is done on {\sl scaled integers\/} that are multiples +of $2^{-16}$. In other words, a binary point is assumed to be sixteen bit +positions from the right end of a binary computer word. + +@d unity 0200000 /*$2^{16}$, represents 1.00000*/ +@d two 0400000 /*$2^{17}$, represents 2.00000*/ + +@= +typedef int scaled; /*this type is used for scaled integers*/ +typedef int32_t nonnegative_integer; /*$0\le x<2^{31}$*/ +typedef int8_t small_number; /*this type is self-explanatory*/ + +@ The following function is used to create a scaled integer from a given decimal +fraction $(.d_0d_1\ldots d_{k-1})$, where |0 <= k <= 17|. The digit $d_i$ is +given in |dig[i]|, and the calculation produces a correctly rounded result. + +@p static scaled round_decimals(small_number @!k) + /*converts a decimal fraction*/ +{@+int a; /*the accumulator*/ +a=0; +while (k > 0) + {@+decr(k);a=(a+dig[k]*two)/10; + } +return(a+1)/2; +} + +@ Conversely, here is a procedure analogous to |print_int|. If the output +of this procedure is subsequently read by \TeX\ and converted by the +|round_decimals| routine above, it turns out that the original value will +be reproduced exactly; the ``simplest'' such decimal number is output, +but there is always at least one digit following the decimal point. + +The invariant relation in the \&{repeat} loop is that a sequence of +decimal digits yet to be printed will yield the original number if and only if +they form a fraction~$f$ in the range $s-\delta\le 10\cdot2^{16}f unity) s=s+0100000-50000; /*round the last digit*/ +print_char('0'+(s/unity));s=10*(s%unity);delta=delta*10; +}@+ while (!(s <= delta)); +} + +@ Physical sizes that a \TeX\ user specifies for portions of documents are +represented internally as scaled points. Thus, if we define an `sp' (scaled +@^sp@> +point) as a unit equal to $2^{-16}$ printer's points, every dimension +inside of \TeX\ is an integer number of sp. There are exactly +4,736,286.72 sp per inch. Users are not allowed to specify dimensions +larger than $2^{30}-1$ sp, which is a distance of about 18.892 feet (5.7583 +meters); two such quantities can be added without overflow on a 32-bit +computer. + +The present implementation of \TeX\ does not check for overflow when +@^overflow in arithmetic@> +dimensions are added or subtracted. This could be done by inserting a +few dozen tests of the form `\ignorespaces|if (x >= 010000000000)| +\\{report\_overflow}', but the chance of overflow is so remote that +such tests do not seem worthwhile. + +\TeX\ needs to do only a few arithmetic operations on scaled quantities, +other than addition and subtraction, and the following subroutines do most of +the work. A single computation might use several subroutine calls, and it is +desirable to avoid producing multiple error messages in case of arithmetic +overflow; so the routines set the global variable |arith_error| to |true| +instead of reporting errors directly to the user. Another global variable, +|rem|, holds the remainder after a division. + +@= +static bool @!arith_error; /*has arithmetic overflow occurred recently?*/ +static scaled @!rem; /*amount subtracted to get an exact division*/ + +@ The first arithmetical subroutine we need computes $nx+y$, where |x| +and~|y| are |scaled| and |n| is an integer. We will also use it to +multiply integers. + +@d nx_plus_y(A, B, C) mult_and_add(A, B, C, 07777777777) +@d mult_integers(A, B) mult_and_add(A, B, 0, 017777777777) + +@p static scaled mult_and_add(int @!n, scaled @!x, scaled @!y, scaled @!max_answer) +{@+if (n < 0) + {@+negate(x);negate(n); + } +if (n==0) return y; +else if (((x <= (max_answer-y)/n)&&(-x <= (max_answer+y)/n))) + return n*x+y; +else{@+arith_error=true;return 0; + } +} + +@ We also need to divide scaled dimensions by integers. + +@p static scaled x_over_n(scaled @!x, int @!n) +{@+bool negative; /*should |rem| be negated?*/ +scaled x_over_n; +negative=false; +if (n==0) + {@+arith_error=true;x_over_n=0;rem=x; + } +else{@+if (n < 0) + {@+negate(x);negate(n);negative=true; + } + if (x >= 0) + {@+x_over_n=x/n;rem=x%n; + } + else{@+x_over_n=-((-x)/n);rem=-((-x)%n); + } + } +if (negative) negate(rem); +return x_over_n;} + +@ Then comes the multiplication of a scaled number by a fraction |n/(double)d|, +where |n| and |d| are nonnegative integers | <= @t$2^{16}$@>| and |d| is +positive. It would be too dangerous to multiply by~|n| and then divide +by~|d|, in separate operations, since overflow might well occur; and it +would be too inaccurate to divide by |d| and then multiply by |n|. Hence +this subroutine simulates 1.5-precision arithmetic. + +@p static scaled xn_over_d(scaled @!x, int @!n, int @!d) +{@+bool positive; /*was |x >= 0|?*/ +nonnegative_integer @!t, @!u, @!v; /*intermediate quantities*/ +scaled xn_over_d; +if (x >= 0) positive=true; +else{@+negate(x);positive=false; + } +t=(x%0100000)*n; +u=(x/0100000)*n+(t/0100000); +v=(u%d)*0100000+(t%0100000); +if (u/d >= 0100000) arith_error=true; +else u=0100000*(u/d)+(v/d); +if (positive) + {@+xn_over_d=u;rem=v%d; + } +else{@+xn_over_d=-u;rem=-(v%d); + } +return xn_over_d;} + +@ The next subroutine is used to compute the ``badness'' of glue, when a +total~|t| is supposed to be made from amounts that sum to~|s|. According +to {\sl The \TeX book}, the badness of this situation is $100(t/s)^3$; +however, badness is simply a heuristic, so we need not squeeze out the +last drop of accuracy when computing it. All we really want is an +approximation that has similar properties. +@:TeXbook}{\sl The \TeX book@> + +The actual method used to compute the badness is easier to read from the +program than to describe in words. It produces an integer value that is a +reasonably close approximation to $100(t/s)^3$, and all implementations +of \TeX\ should use precisely this method. Any badness of $2^{13}$ or more is +treated as infinitely bad, and represented by 10000. + +It is not difficult to prove that $$\hbox{|badness(t+1, s) >= badness(t, s) + >= badness(t, s+1)|}.$$ The badness function defined here is capable of +computing at most 1095 distinct values, but that is plenty. + +@d inf_bad 10000 /*infinitely bad value*/ + +@p @@/ +static halfword badness(scaled @!t, scaled @!s) /*compute badness, given |t >= 0|*/ +{@+int r; /*approximation to $\alpha t/s$, where $\alpha^3\approx + 100\cdot2^{18}$*/ +if (t==0) return 0; +else if (s <= 0) return inf_bad; +else{@+if (t <= 7230584) r=(t*297)/s; /*$297^3=99.94\times2^{18}$*/ + else if (s >= 1663497) r=t/(s/297); + else r=t; + if (r > 1290) return inf_bad; /*$1290^3<2^{31}<1291^3$*/ + else return(r*r*r+0400000)/01000000; + } /*that was $r^3/2^{18}$, rounded to the nearest integer*/ +} + +@ When \TeX\ ``packages'' a list into a box, it needs to calculate the +proportionality ratio by which the glue inside the box should stretch +or shrink. This calculation does not affect \TeX's decision making, +so the precise details of rounding, etc., in the glue calculation are not +of critical importance for the consistency of results on different computers. + +We shall use the type |glue_ratio| for such proportionality ratios. +A glue ratio should take the same amount of memory as an +|int| (usually 32 bits) if it is to blend smoothly with \TeX's +other data structures. Thus |glue_ratio| should be equivalent to +|short_real| in some implementations of \PASCAL. Alternatively, +it is possible to deal with glue ratios using nothing but fixed-point +arithmetic; see {\sl TUGboat \bf3},1 (March 1982), 10--27. (But the +routines cited there must be modified to allow negative glue ratios.) +@^system dependencies@> + +@d set_glue_ratio_zero(A) A=0.0 /*store the representation of zero ratio*/ +@d set_glue_ratio_one(A) A=1.0 /*store the representation of unit ratio*/ +@d float(A) ((double)(A)) /*convert from |glue_ratio| to type |double|*/ +@d unfloat(A) ((glue_ratio)(A)) /*convert from |double| to type |glue_ratio|*/ +@d float_constant(A) ((double)(A)) /*convert |int| constant to |double|*/ + +@= +#if __SIZEOF_FLOAT__==4 +typedef float float32_t; +#else +#error float type must have size 4 +#endif +typedef float @!glue_ratio; /*one-word representation of a glue expansion factor*/ + +@* Packed data. +In order to make efficient use of storage space, \TeX\ bases its major data +structures on a |memory_word|, which contains either a (signed) integer, +possibly scaled, or a (signed) |glue_ratio|, or a small number of +fields that are one half or one quarter of the size used for storing +integers. + +If |x| is a variable of type |memory_word|, it contains up to four +fields that can be referred to as follows: +$$\vbox{\halign{\hfil#&#\hfil&#\hfil\cr +|x|&.|i|&(an |int|)\cr +|x|&.|sc|\qquad&(a |scaled| integer)\cr +|x|&.|gr|&(a |glue_ratio|)\cr +|x.hh.lh|, |x.hh|&.|rh|&(two halfword fields)\cr +|x.hh.b0|, |x.hh.b1|, |x.hh|&.|rh|&(two quarterword fields, one halfword + field)\cr +|x.qqqq.b0|, |x.qqqq.b1|, |x.qqqq|&.|b2|, |x.qqqq.b3|\hskip-100pt + &\qquad\qquad\qquad(four quarterword fields)\cr}}$$ +This is somewhat cumbersome to write, and not very readable either, but +macros will be used to make the notation shorter and more transparent. +The \PASCAL\ code below gives a formal definition of |memory_word| and +its subsidiary types, using packed variant records. \TeX\ makes no +assumptions about the relative positions of the fields within a word. + +Since we are assuming 32-bit integers, a halfword must contain at least +16 bits, and a quarterword must contain at least 8 bits. +@^system dependencies@> +But it doesn't hurt to have more bits; for example, with enough 36-bit +words you might be able to have |mem_max| as large as 262142, which is +eight times as much memory as anybody had during the first four years of +\TeX's existence. + +N.B.: Valuable memory space will be dreadfully wasted unless \TeX\ is compiled +by a \PASCAL\ that packs all of the |memory_word| variants into +the space of a single integer. This means, for example, that |glue_ratio| +words should be |short_real| instead of |double| on some computers. Some +\PASCAL\ compilers will pack an integer whose subrange is `|0 dotdot 255|' into +an eight-bit field, but others insist on allocating space for an additional +sign bit; on such systems you can get 256 values into a quarterword only +if the subrange is `|-128 dotdot 127|'. + +The present implementation tries to accommodate as many variations as possible, +so it makes few assumptions. If integers having the subrange +`|min_quarterword dotdot max_quarterword|' can be packed into a quarterword, +and if integers having the subrange `|min_halfword dotdot max_halfword|' +can be packed into a halfword, everything should work satisfactorily. + +It is usually most efficient to have |min_quarterword==min_halfword==0|, +so one should try to achieve this unless it causes a severe problem. +The values defined here are recommended for most 32-bit computers. + +@d min_quarterword 0 /*smallest allowable value in a |quarterword|*/ +@d max_quarterword 65535 /*largest allowable value in a |quarterword|*/ +@d min_halfword 0 /*smallest allowable value in a |halfword|*/ +@d max_halfword 0x3FFFFFFF /*largest allowable value in a |halfword|*/ + +@ Here are the inequalities that the quarterword and halfword values +must satisfy (or rather, the inequalities that they mustn't satisfy): + +@= +#ifdef @!INIT +if ((mem_min!=mem_bot)||(mem_max!=mem_top)) bad=10; +#endif +@;@/ +if ((mem_min > mem_bot)||(mem_max < mem_top)) bad=10; +if ((min_quarterword > 0)||(max_quarterword < 127)) bad=11; +if ((min_halfword > 0)||(max_halfword < 32767)) bad=12; +if ((min_quarterword < min_halfword)||@| + (max_quarterword > max_halfword)) bad=13; +if ((mem_min < min_halfword)||(mem_max >= max_halfword)||@| + (mem_bot-mem_min > max_halfword+1)) bad=14; +if ((font_base < min_quarterword)||(font_max > max_quarterword)) bad=15; +if (font_max > font_base+256) bad=16; +if ((save_size > max_halfword)||(max_strings > max_halfword)) bad=17; +if (buf_size > max_halfword) bad=18; +if (max_quarterword-min_quarterword < 255) bad=19; + +@ The operation of adding or subtracting |min_quarterword| occurs quite +frequently in \TeX, so it is convenient to abbreviate this operation +by using the macros |qi| and |qo| for input and output to and from +quarterword format. + +The inner loop of \TeX\ will run faster with respect to compilers +that don't optimize expressions like `|x+0|' and `|x-0|', if these +macros are simplified in the obvious way when |min_quarterword==0|. +@^inner loop@>@^system dependencies@> + +@d qi(A) A+min_quarterword + /*to put an |eight_bits| item into a quarterword*/ +@d qo(A) A-min_quarterword + /*to take an |eight_bits| item out of a quarterword*/ +@d hi(A) A+min_halfword + /*to put a sixteen-bit item into a halfword*/ +@d ho(A) A-min_halfword + /*to take a sixteen-bit item from a halfword*/ + +@ The reader should study the following definitions closely: +@^system dependencies@> + +@d sc i /*|scaled| data is equivalent to |int|*/ + +@= +typedef uint16_t quarterword; /*1/4 of a word*/ +typedef int32_t halfword; /*1/2 of a word*/ +typedef int8_t two_choices; /*used when there are two variants in a record*/ +typedef int8_t four_choices; /*used when there are four variants in a record*/ +typedef struct { @;@/ + halfword @!rh; + union { + halfword @!lh; + struct { quarterword @!b0;quarterword @!b1;} ; + };} two_halves; +typedef struct { @;@/ + quarterword @!b0; + quarterword @!b1; + quarterword @!b2; + quarterword @!b3; + } four_quarters; +typedef struct { @;@/ + union { + int @!i; + glue_ratio @!gr; + two_halves @!hh; + four_quarters @!qqqq; + };} memory_word; +typedef struct {@+FILE *f;@+memory_word@,d;@+} word_file; + +@ When debugging, we may want to print a |memory_word| without knowing +what type it is; so we print it in all modes. +@^dirty \PASCAL@>@^debugging@> + +@p +#ifdef @!DEBUG +static void print_word(memory_word @!w) + /*prints |w| in all ways*/ +{@+print_int(w.i);print_char(' ');@/ +print_scaled(w.sc);print_char(' ');@/ +print_scaled(round(unity*float(w.gr)));print_ln();@/ +@^real multiplication@> +print_int(w.hh.lh);print_char('=');print_int(w.hh.b0);print_char(':'); +print_int(w.hh.b1);print_char(';');print_int(w.hh.rh);print_char(' ');@/ +print_int(w.qqqq.b0);print_char(':');print_int(w.qqqq.b1);print_char(':'); +print_int(w.qqqq.b2);print_char(':');print_int(w.qqqq.b3); +} +#endif + +@* Dynamic memory allocation. +The \TeX\ system does nearly all of its own memory allocation, so that it +can readily be transported into environments that do not have automatic +facilities for strings, garbage collection, etc., and so that it can be in +control of what error messages the user receives. The dynamic storage +requirements of \TeX\ are handled by providing a large array |mem| in +which consecutive blocks of words are used as nodes by the \TeX\ routines. + +Pointer variables are indices into this array, or into another array +called |eqtb| that will be explained later. A pointer variable might +also be a special flag that lies outside the bounds of |mem|, so we +allow pointers to assume any |halfword| value. The minimum halfword +value represents a null pointer. \TeX\ does not assume that |mem[null]| exists. + @s pointer int -@s memory_word int -@s ASCII_code int -@s small_number int -@s info_t int -@s lig_t int -@s disc_t int -@s math_t int -@s glyph_t int -@s glue_t int -@s rule_t int -@s list_t int -@s kind_t int -@s image_t int -@s glue_ord int -@s four_quarters int -@s eight_bits int -@s internal_font_number int -@s explicit normal -@s str_number int -@s dimen_t int -@s loop else -@s kpse_file_format_type int -@s font_t int - - -\makeindex -\maketoc - -%\makefigindex -\titletrue - -\def\lastrevision{${}$Revision: 2515 ${}$} -\def\lastdate{${}$Date: 2021-09-23 17:59:58 +0200 (Thu, 23 Sep 2021) ${}$} -\eject -\input titlepage.tex - - -\frontmatter +@d pointer halfword /*a flag or a location in |mem| or |eqtb|*/ +@d null min_halfword /*the null pointer*/ + +@= +static pointer @!temp_ptr; /*a pointer variable for occasional emergency use*/ + +@ The |mem| array is divided into two regions that are allocated separately, +but the dividing line between these two regions is not fixed; they grow +together until finding their ``natural'' size in a particular job. +Locations less than or equal to |lo_mem_max| are used for storing +variable-length records consisting of two or more words each. This region +is maintained using an algorithm similar to the one described in exercise +2.5--19 of {\sl The Art of Computer Programming}. However, no size field +appears in the allocated nodes; the program is responsible for knowing the +relevant size when a node is freed. Locations greater than or equal to +|hi_mem_min| are used for storing one-word records; a conventional +\.{AVAIL} stack is used for allocation in this region. + +Locations of |mem| between |mem_bot| and |mem_top| may be dumped as part +of preloaded format files, by the \.{INITEX} preprocessor. +@.INITEX@> +Production versions of \TeX\ may extend the memory at both ends in order to +provide more space; locations between |mem_min| and |mem_bot| are always +used for variable-size nodes, and locations between |mem_top| and |mem_max| +are always used for single-word nodes. + +The key pointers that govern |mem| allocation have a prescribed order: +$$\advance\thickmuskip-2mu +\hbox{|null <= mem_min <= mem_bot < lo_mem_max < + hi_mem_min < mem_top <= mem_end <= mem_max|.}$$ + +Empirical tests show that the present implementation of \TeX\ tends to +spend about 9\pct! of its running time allocating nodes, and about 6\pct! +deallocating them after their use. + +@= +static memory_word @!mem0[mem_max-mem_min+1], *const @!mem = @!mem0-mem_min; /*the big dynamic storage area*/ +static pointer @!lo_mem_max; /*the largest location of variable-size memory in use*/ +static pointer @!hi_mem_min; /*the smallest location of one-word memory in use*/ + +@ In order to study the memory requirements of particular applications, it +is possible to prepare a version of \TeX\ that keeps track of current and +maximum memory usage. When code between the delimiters | +#ifdef @!STAT +| $\ldots$ +|tats| is not ``commented out,'' \TeX\ will run a bit slower but it will +report these statistics when |tracing_stats| is sufficiently large. + +@= +static int @!var_used, @!dyn_used; /*how much memory is in use*/ +#ifdef @!STAT +#define incr_dyn_used @[incr(dyn_used)@] +#define decr_dyn_used @[decr(dyn_used)@] +#else +#define incr_dyn_used +#define decr_dyn_used +#endif + +@ Let's consider the one-word memory region first, since it's the +simplest. The pointer variable |mem_end| holds the highest-numbered location +of |mem| that has ever been used. The free locations of |mem| that +occur between |hi_mem_min| and |mem_end|, inclusive, are of type +|two_halves|, and we write |info(p)| and |link(p)| for the |lh| +and |rh| fields of |mem[p]| when it is of this type. The single-word +free locations form a linked list +$$|avail|,\;\hbox{|link(avail)|},\;\hbox{|link(link(avail))|},\;\ldots$$ +terminated by |null|. + +@d link(A) mem[A].hh.rh /*the |link| field of a memory word*/ +@d info(A) mem[A].hh.lh /*the |info| field of a memory word*/ + +@= +static pointer @!avail; /*head of the list of available one-word nodes*/ +static pointer @!mem_end; /*the last one-word node used in |mem|*/ + +@ If memory is exhausted, it might mean that the user has forgotten +a right brace. We will define some procedures later that try to help +pinpoint the trouble. + +@p @@/ +@@; + +@ The function |get_avail| returns a pointer to a new one-word node whose +|link| field is null. However, \TeX\ will halt if there is no more room left. +@^inner loop@> + +If the available-space list is empty, i.e., if |avail==null|, +we try first to increase |mem_end|. If that cannot be done, i.e., if +|mem_end==mem_max|, we try to decrease |hi_mem_min|. If that cannot be +done, i.e., if |hi_mem_min==lo_mem_max+1|, we have to quit. + +@p static pointer get_avail(void) /*single-word node allocation*/ +{@+pointer p; /*the new node being got*/ +p=avail; /*get top location in the |avail| stack*/ +if (p!=null) avail=link(avail); /*and pop it off*/ +else if (mem_end < mem_max) /*or go into virgin territory*/ + {@+incr(mem_end);p=mem_end; + } +else{@+decr(hi_mem_min);p=hi_mem_min; + if (hi_mem_min <= lo_mem_max) + {@+runaway(); /*if memory is exhausted, display possible runaway text*/ + overflow("main memory size", mem_max+1-mem_min); + /*quit; all one-word nodes are busy*/ +@:TeX capacity exceeded main memory size}{\quad main memory size@> + } + } +link(p)=null; /*provide an oft-desired initialization of the new node*/ +#ifdef @!STAT +incr(dyn_used); +#endif +@; /*maintain statistics*/ +return p; +} + +@ Conversely, a one-word node is recycled by calling |free_avail|. +This routine is part of \TeX's ``inner loop,'' so we want it to be fast. +@^inner loop@> + +@d free_avail(A) /*single-word node liberation*/ + {@+link(A)=avail;avail=A; + decr_dyn_used; + } + +@ There's also a |fast_get_avail| routine, which saves the procedure-call +overhead at the expense of extra programming. This routine is used in +the places that would otherwise account for the most calls of |get_avail|. +@^inner loop@> + +@d fast_get_avail(A) @t@>@;@/ + {@+A=avail; /*avoid |get_avail| if possible, to save time*/ + if (A==null) A=get_avail(); + else{@+avail=link(A);link(A)=null; + incr_dyn_used; + } + } + +@ The procedure |flush_list(p)| frees an entire linked list of +one-word nodes that starts at position |p|. +@^inner loop@> + +@p static void flush_list(pointer @!p) /*makes list of single-word nodes + available*/ +{@+pointer @!q, @!r; /*list traversers*/ +if (p!=null) + {@+r=p; + @/do@+{q=r;r=link(r); +#ifdef @!STAT +decr(dyn_used); +#endif + }@+ while (!(r==null)); /*now |q| is the last node on the list*/ + link(q)=avail;avail=p; + } +} + +@ The available-space list that keeps track of the variable-size portion +of |mem| is a nonempty, doubly-linked circular list of empty nodes, +pointed to by the roving pointer |rover|. + +Each empty node has size 2 or more; the first word contains the special +value |max_halfword| in its |link| field and the size in its |info| field; +the second word contains the two pointers for double linking. + +Each nonempty node also has size 2 or more. Its first word is of type +|two_halves|\kern-1pt, and its |link| field is never equal to |max_halfword|. +Otherwise there is complete flexibility with respect to the contents +of its other fields and its other words. + +(We require |mem_max < max_halfword| because terrible things can happen +when |max_halfword| appears in the |link| field of a nonempty node.) + +@d empty_flag max_halfword /*the |link| of an empty variable-size node*/ +@d is_empty(A) (link(A)==empty_flag) /*tests for empty node*/ +@d node_size(A) info(A) /*the size field in empty variable-size nodes*/ +@d llink(A) info(A+1) /*left link in doubly-linked list of empty nodes*/ +@d rlink(A) link(A+1) /*right link in doubly-linked list of empty nodes*/ + +@= +static pointer @!rover; /*points to some node in the list of empties*/ + +@ A call to |get_node| with argument |s| returns a pointer to a new node +of size~|s|, which must be 2~or more. The |link| field of the first word +of this new node is set to null. An overflow stop occurs if no suitable +space exists. + +If |get_node| is called with $s=2^{30}$, it simply merges adjacent free +areas and returns the value |max_halfword|. + +@p static pointer get_node(int @!s) /*variable-size node allocation*/ +{@+ +pointer p; /*the node currently under inspection*/ +pointer @!q; /*the node physically after node |p|*/ +int @!r; /*the newly allocated node, or a candidate for this honor*/ +int @!t; /*temporary register*/ +restart: p=rover; /*start at some free node in the ring*/ +@/do@+{@; +@^inner loop@> +p=rlink(p); /*move to the next node in the ring*/ +}@+ while (!(p==rover)); /*repeat until the whole list has been traversed*/ +if (s==010000000000) + {@+return max_halfword; + } +if (lo_mem_max+2 < hi_mem_min) if (lo_mem_max+2 <= mem_bot+max_halfword) + @; +overflow("main memory size", mem_max+1-mem_min); + /*sorry, nothing satisfactory is left*/ +@:TeX capacity exceeded main memory size}{\quad main memory size@> +found: link(r)=null; /*this node is now nonempty*/ +#ifdef @!STAT +var_used=var_used+s; /*maintain usage statistics*/ +#endif +@;@/ +return r; +} + +@ The lower part of |mem| grows by 1000 words at a time, unless +we are very close to going under. When it grows, we simply link +a new node into the available-space list. This method of controlled +growth helps to keep the |mem| usage consecutive when \TeX\ is +implemented on ``virtual memory'' systems. +@^virtual memory@> + +@= +{@+if (hi_mem_min-lo_mem_max >= 1998) t=lo_mem_max+1000; +else t=lo_mem_max+1+(hi_mem_min-lo_mem_max)/2; + /*|lo_mem_max+2 <= t < hi_mem_min|*/ +p=llink(rover);q=lo_mem_max;rlink(p)=q;llink(rover)=q;@/ +if (t > mem_bot+max_halfword) t=mem_bot+max_halfword; +rlink(q)=rover;llink(q)=p;link(q)=empty_flag;node_size(q)=t-lo_mem_max;@/ +lo_mem_max=t;link(lo_mem_max)=null;info(lo_mem_max)=null; +rover=q;goto restart; +} + +@ Empirical tests show that the routine in this section performs a +node-merging operation about 0.75 times per allocation, on the average, +after which it finds that |r > p+1| about 95\pct! of the time. + +@= +q=p+node_size(p); /*find the physical successor*/ +@^inner loop@> +while (is_empty(q)) /*merge node |p| with node |q|*/ + {@+t=rlink(q); + if (q==rover) rover=t; + llink(t)=llink(q);rlink(llink(q))=t;@/ + q=q+node_size(q); + } +r=q-s; +if (r > p+1) @; +if (r==p) if (rlink(p)!=p) + @; +node_size(p)=q-p /*reset the size in case it grew*/ + +@ @= +{@+node_size(p)=r-p; /*store the remaining size*/ +@^inner loop@> +rover=p; /*start searching here next time*/ +goto found; +} + +@ Here we delete node |p| from the ring, and let |rover| rove around. + +@= +{@+rover=rlink(p);t=llink(p); +llink(rover)=t;rlink(t)=rover; +goto found; +} + +@ Conversely, when some variable-size node |p| of size |s| is no longer needed, +the operation |free_node(p, s)| will make its words available, by inserting +|p| as a new empty node just before where |rover| now points. +@^inner loop@> + +@p static void free_node(pointer @!p, halfword @!s) /*variable-size node + liberation*/ +{@+pointer q; /*|llink(rover)|*/ +node_size(p)=s;link(p)=empty_flag; +q=llink(rover);llink(p)=q;rlink(p)=rover; /*set both links*/ +llink(rover)=p;rlink(q)=p; /*insert |p| into the ring*/ +#ifdef @!STAT +var_used=var_used-s; +#endif +@; /*maintain statistics*/ +} + +@ Just before \.{INITEX} writes out the memory, it sorts the doubly linked +available space list. The list is probably very short at such times, so a +simple insertion sort is used. The smallest available location will be +pointed to by |rover|, the next-smallest by |rlink(rover)|, etc. + +@p +#ifdef @!INIT +static void sort_avail(void) /*sorts the available variable-size nodes + by location*/ +{@+pointer p, @!q, @!r; /*indices into |mem|*/ +pointer @!old_rover; /*initial |rover| setting*/ +p=get_node(010000000000); /*merge adjacent free areas*/ +p=rlink(rover);rlink(rover)=max_halfword;old_rover=rover; +while (p!=old_rover) @; +p=rover; +while (rlink(p)!=max_halfword) + {@+llink(rlink(p))=p;p=rlink(p); + } +rlink(p)=rover;llink(rover)=p; +} +#endif + +@ The following |while | loop is guaranteed to +terminate, since the list that starts at +|rover| ends with |max_halfword| during the sorting procedure. + +@= +if (p < rover) + {@+q=p;p=rlink(q);rlink(q)=rover;rover=q; + } +else{@+q=rover; + while (rlink(q) < p) q=rlink(q); + r=rlink(p);rlink(p)=rlink(q);rlink(q)=p;p=r; + } + +@* Data structures for boxes and their friends. +From the computer's standpoint, \TeX's chief mission is to create +horizontal and vertical lists. We shall now investigate how the elements +of these lists are represented internally as nodes in the dynamic memory. + +A horizontal or vertical list is linked together by |link| fields in +the first word of each node. Individual nodes represent boxes, glue, +penalties, or special things like discretionary hyphens; because of this +variety, some nodes are longer than others, and we must distinguish different +kinds of nodes. We do this by putting a `|type|' field in the first word, +together with the link and an optional `|subtype|'. + +@d type(A) mem[A].hh.b0 /*identifies what kind of node this is*/ +@d subtype(A) mem[A].hh.b1 /*secondary identification in some cases*/ + +@ A |@!char_node|, which represents a single character, is the most important +kind of node because it accounts for the vast majority of all boxes. +Special precautions are therefore taken to ensure that a |char_node| does +not take up much memory space. Every such node is one word long, and in fact +it is identifiable by this property, since other kinds of nodes have at least +two words, and they appear in |mem| locations less than |hi_mem_min|. +This makes it possible to omit the |type| field in a |char_node|, leaving +us room for two bytes that identify a |font| and a |character| within +that font. + +Note that the format of a |char_node| allows for up to 256 different +fonts and up to 256 characters per font; but most implementations will +probably limit the total number of fonts to fewer than 75 per job, +and most fonts will stick to characters whose codes are +less than 128 (since higher codes +are more difficult to access on most keyboards). + +Extensions of \TeX\ intended for oriental languages will need even more +than $256\times256$ possible characters, when we consider different sizes +@^oriental characters@>@^Chinese characters@>@^Japanese characters@> +and styles of type. It is suggested that Chinese and Japanese fonts be +handled by representing such characters in two consecutive |char_node| +entries: The first of these has |font==font_base|, and its |link| points +to the second; +the second identifies the font and the character dimensions. +The saving feature about oriental characters is that most of them have +the same box dimensions. The |character| field of the first |char_node| +is a ``\\{charext}'' that distinguishes between graphic symbols whose +dimensions are identical for typesetting purposes. (See the \MF\ manual.) +Such an extension of \TeX\ would not be difficult; further details are +left to the reader. + +In order to make sure that the |character| code fits in a quarterword, +\TeX\ adds the quantity |min_quarterword| to the actual code. + +Character nodes appear only in horizontal lists, never in vertical lists. + +@d is_char_node(A) (A >= hi_mem_min) + /*does the argument point to a |char_node|?*/ +@d font(A) type(A) /*the font code in a |char_node|*/ +@d character(A) subtype(A) /*the character code in a |char_node|*/ + +@ An |hlist_node| stands for a box that was made from a horizontal list. +Each |hlist_node| is seven words long, and contains the following fields +(in addition to the mandatory |type| and |link|, which we shall not +mention explicitly when discussing the other node types): The |height| and +|width| and |depth| are scaled integers denoting the dimensions of the +box. There is also a |shift_amount| field, a scaled integer indicating +how much this box should be lowered (if it appears in a horizontal list), +or how much it should be moved to the right (if it appears in a vertical +list). There is a |list_ptr| field, which points to the beginning of the +list from which this box was fabricated; if |list_ptr| is |null|, the box +is empty. Finally, there are three fields that represent the setting of +the glue: |glue_set(p)| is a word of type |glue_ratio| that represents +the proportionality constant for glue setting; |glue_sign(p)| is +|stretching| or |shrinking| or |normal| depending on whether or not the +glue should stretch or shrink or remain rigid; and |glue_order(p)| +specifies the order of infinity to which glue setting applies (|normal|, +|fil|, |fill|, or |filll|). The |subtype| field is not used. + +@d hlist_node 0 /*|type| of hlist nodes*/ +@d box_node_size 9 /*number of words to allocate for a box, set, or pack node*/ +@d width_offset 1 /*position of |width| field in a box node*/ +@d depth_offset 2 /*position of |depth| field in a box node*/ +@d height_offset 3 /*position of |height| field in a box node*/ +@d width(A) mem[A+width_offset].sc /*width of the box, in sp*/ +@d depth(A) mem[A+depth_offset].sc /*depth of the box, in sp*/ +@d height(A) mem[A+height_offset].sc /*height of the box, in sp*/ +@d shift_amount(A) mem[A+4].sc /*repositioning distance, in sp*/ +@d list_offset 5 /*position of |list_ptr| field in a box node*/ +@d list_ptr(A) link(A+list_offset) /*beginning of the list inside the box*/ +@d glue_order(A) subtype(A+list_offset) /*applicable order of infinity*/ +@d glue_sign(A) type(A+list_offset) /*stretching or shrinking*/ +@d normal 0 /*the most common case when several cases are named*/ +@d stretching 1 /*glue setting applies to the stretch components*/ +@d shrinking 2 /*glue setting applies to the shrink components*/ +@d glue_offset 6 /*position of |glue_set| in a box node*/ +@d glue_set(A) mem[A+glue_offset].gr + /*a word of type |glue_ratio| for glue setting*/ + +@ The |new_null_box| function returns a pointer to an |hlist_node| in +which all subfields have the values corresponding to `\.{\\hbox\{\}}'. +(The |subtype| field is set to |min_quarterword|, for historic reasons +that are no longer relevant.) + +@p static pointer new_null_box(void) /*creates a new box node*/ +{@+pointer p; /*the new node*/ +p=get_node(box_node_size);type(p)=hlist_node; +subtype(p)=min_quarterword; +width(p)=0;depth(p)=0;height(p)=0;shift_amount(p)=0;list_ptr(p)=null; +glue_sign(p)=normal;glue_order(p)=normal;set_glue_ratio_zero(glue_set(p)); +return p; +} + +@ A |vlist_node| is like an |hlist_node| in all respects except that it +contains a vertical list. + +@d vlist_node 1 /*|type| of vlist nodes*/ + +@ A |rule_node| stands for a solid black rectangle; it has |width|, +|depth|, and |height| fields just as in an |hlist_node|. However, if +any of these dimensions is $-2^{30}$, the actual value will be determined +by running the rule up to the boundary of the innermost enclosing box. +This is called a ``running dimension.'' The |width| is never running in +an hlist; the |height| and |depth| are never running in a~vlist. + +@d rule_node 2 /*|type| of rule nodes*/ +@d rule_node_size 4 /*number of words to allocate for a rule node*/ +@d null_flag -010000000000 /*$-2^{30}$, signifies a missing item*/ +@d is_running(A) (A==null_flag) /*tests for a running dimension*/ + +@ A new rule node is delivered by the |new_rule| function. It +makes all the dimensions ``running,'' so you have to change the +ones that are not allowed to run. + +@p static pointer new_rule(void) +{@+pointer p; /*the new node*/ +p=get_node(rule_node_size);type(p)=rule_node; +subtype(p)=0; /*the |subtype| is not used*/ +width(p)=null_flag;depth(p)=null_flag;height(p)=null_flag; +return p; +} + +@ Insertions are represented by |ins_node| records, where the |subtype| +indicates the corresponding box number. For example, `\.{\\insert 250}' +leads to an |ins_node| whose |subtype| is |250+min_quarterword|. +The |height| field of an |ins_node| is slightly misnamed; it actually holds +the natural height plus depth of the vertical list being inserted. +The |depth| field holds the |split_max_depth| to be used in case this +insertion is split, and the |split_top_ptr| points to the corresponding +|split_top_skip|. The |float_cost| field holds the |floating_penalty| that +will be used if this insertion floats to a subsequent page after a +split insertion of the same class. There is one more field, the +|ins_ptr|, which points to the beginning of the vlist for the insertion. + +@d ins_node 3 /*|type| of insertion nodes*/ +@d ins_node_size 5 /*number of words to allocate for an insertion*/ +@d float_cost(A) mem[A+1].i /*the |floating_penalty| to be used*/ +@d ins_ptr(A) info(A+4) /*the vertical list to be inserted*/ +@d split_top_ptr(A) link(A+4) /*the |split_top_skip| to be used*/ + +@ A |mark_node| has a |mark_ptr| field that points to the reference count +of a token list that contains the user's \.{\\mark} text. +This field occupies a full word instead of a halfword, because +there's nothing to put in the other halfword; it is easier in \PASCAL\ to +use the full word than to risk leaving garbage in the unused half. + +@d mark_node 4 /*|type| of a mark node*/ +@d small_node_size 2 /*number of words to allocate for most node types*/ +@d mark_ptr(A) mem[A+1].i /*head of the token list for a mark*/ + +@ An |adjust_node|, which occurs only in horizontal lists, +specifies material that will be moved out into the surrounding +vertical list; i.e., it is used to implement \TeX's `\.{\\vadjust}' +operation. The |adjust_ptr| field points to the vlist containing this +material. + +@d adjust_node 5 /*|type| of an adjust node*/ +@d adjust_ptr(A) mark_ptr(A) /*vertical list to be moved out of horizontal list*/ + +@ A |ligature_node|, which occurs only in horizontal lists, specifies +a character that was fabricated from the interaction of two or more +actual characters. The second word of the node, which is called the +|lig_char| word, contains |font| and |character| fields just as in a +|char_node|. The characters that generated the ligature have not been +forgotten, since they are needed for diagnostic messages and for +hyphenation; the |lig_ptr| field points to a linked list of character +nodes for all original characters that have been deleted. (This list +might be empty if the characters that generated the ligature were +retained in other nodes.) + +The |subtype| field is 0, plus 2 and/or 1 if the original source of the +ligature included implicit left and/or right boundaries. + +@d ligature_node 6 /*|type| of a ligature node*/ +@d lig_char(A) A+1 /*the word where the ligature is to be found*/ +@d lig_ptr(A) link(lig_char(A)) /*the list of characters*/ + +@ The |new_ligature| function creates a ligature node having given +contents of the |font|, |character|, and |lig_ptr| fields. We also have +a |new_lig_item| function, which returns a two-word node having a given +|character| field. Such nodes are used for temporary processing as ligatures +are being created. + +@p static pointer new_ligature(quarterword @!f, quarterword @!c, pointer @!q) +{@+pointer p; /*the new node*/ +p=get_node(small_node_size);type(p)=ligature_node; +font(lig_char(p))=f;character(lig_char(p))=c;lig_ptr(p)=q; +subtype(p)=0;return p; +} +@# +static pointer new_lig_item(quarterword @!c) +{@+pointer p; /*the new node*/ +p=get_node(small_node_size);character(p)=c;lig_ptr(p)=null; +return p; +} + +@ A |disc_node|, which occurs only in horizontal lists, specifies a +``dis\-cretion\-ary'' line break. If such a break occurs at node |p|, the text +that starts at |pre_break(p)| will precede the break, the text that starts at +|post_break(p)| will follow the break, and text that appears in the next +|replace_count(p)| nodes will be ignored. For example, an ordinary +discretionary hyphen, indicated by `\.{\\-}', yields a |disc_node| with +|pre_break| pointing to a |char_node| containing a hyphen, |post_break==null|, +and |replace_count==0|. All three of the discretionary texts must be +lists that consist entirely of character, kern, box, rule, and ligature nodes. + +If |pre_break(p)==null|, the |ex_hyphen_penalty| will be charged for this +break. Otherwise the |hyphen_penalty| will be charged. The texts will +actually be substituted into the list by the line-breaking algorithm if it +decides to make the break, and the discretionary node will disappear at +that time; thus, the output routine sees only discretionaries that were +not chosen. + +@d disc_node 7 /*|type| of a discretionary node*/ +@d replace_count(A) (subtype(A)&0x7F) /*how many subsequent nodes to replace*/ +@d set_replace_count(A,B) (subtype(A)=(B)&0x7F) +@d set_auto_disc(A) (subtype(A)|=0x80) +@d is_auto_disc(A) (subtype(A)&0x80) +@d pre_break(A) llink(A) /*text that precedes a discretionary break*/ +@d post_break(A) rlink(A) /*text that follows a discretionary break*/ + +@p static pointer new_disc(void) /*creates an empty |disc_node|*/ +{@+pointer p; /*the new node*/ +p=get_node(small_node_size);type(p)=disc_node; +set_replace_count(p,0);pre_break(p)=null;post_break(p)=null; +return p; +} + +@ A |whatsit_node| is a wild card reserved for extensions to \TeX. The +|subtype| field in its first word says what `\\{whatsit}' it is, and +implicitly determines the node size (which must be 2 or more) and the +format of the remaining words. When a |whatsit_node| is encountered +in a list, special actions are invoked; knowledgeable people who are +careful not to mess up the rest of \TeX\ are able to make \TeX\ do new +things by adding code at the end of the program. For example, there +might be a `\TeX nicolor' extension to specify different colors of ink, +@^extensions to \TeX@> +and the whatsit node might contain the desired parameters. + +The present implementation of \TeX\ treats the features associated with +`\.{\\write}' and `\.{\\special}' as if they were extensions, in order to +illustrate how such routines might be coded. We shall defer further +discussion of extensions until the end of this program. + +@d whatsit_node 8 /*|type| of special extension nodes*/ + +@ A |math_node|, which occurs only in horizontal lists, appears before and +after mathematical formulas. The |subtype| field is |before| before the +formula and |after| after it. There is a |width| field, which represents +the amount of surrounding space inserted by \.{\\mathsurround}. + +@d math_node 9 /*|type| of a math node*/ +@d before 0 /*|subtype| for math node that introduces a formula*/ +@d after 1 /*|subtype| for math node that winds up a formula*/ + +@p static pointer new_math(scaled @!w, small_number @!s) +{@+pointer p; /*the new node*/ +p=get_node(small_node_size);type(p)=math_node; +subtype(p)=s;width(p)=w;return p; +} + +@ \TeX\ makes use of the fact that |hlist_node|, |vlist_node|, +|rule_node|, |ins_node|, |mark_node|, |adjust_node|, |ligature_node|, +|disc_node|, |whatsit_node|, and |math_node| are at the low end of the +type codes, by permitting a break at glue in a list if and only if the +|type| of the previous node is less than |math_node|. Furthermore, a +node is discarded after a break if its type is |math_node| or~more. + +@d precedes_break(A) (type(A) < math_node) +@d non_discardable(A) (type(A) < math_node) + +@ A |glue_node| represents glue in a list. However, it is really only +a pointer to a separate glue specification, since \TeX\ makes use of the +fact that many essentially identical nodes of glue are usually present. +If |p| points to a |glue_node|, |glue_ptr(p)| points to +another packet of words that specify the stretch and shrink components, etc. + +Glue nodes also serve to represent leaders; the |subtype| is used to +distinguish between ordinary glue (which is called |normal|) and the three +kinds of leaders (which are called |a_leaders|, |c_leaders|, and |x_leaders|). +The |leader_ptr| field points to a rule node or to a box node containing the +leaders; it is set to |null| in ordinary glue nodes. + +Many kinds of glue are computed from \TeX's ``skip'' parameters, and +it is helpful to know which parameter has led to a particular glue node. +Therefore the |subtype| is set to indicate the source of glue, whenever +it originated as a parameter. We will be defining symbolic names for the +parameter numbers later (e.g., |line_skip_code==0|, |baseline_skip_code==1|, +etc.); it suffices for now to say that the |subtype| of parametric glue +will be the same as the parameter number, plus~one. + +In math formulas there are two more possibilities for the |subtype| in a +glue node: |mu_glue| denotes an \.{\\mskip} (where the units are scaled \.{mu} +instead of scaled \.{pt}); and |cond_math_glue| denotes the `\.{\\nonscript}' +feature that cancels the glue node immediately following if it appears +in a subscript. + +@d glue_node 10 /*|type| of node that points to a glue specification*/ +@d cond_math_glue 98 /*special |subtype| to suppress glue in the next node*/ +@d mu_glue 99 /*|subtype| for math glue*/ +@d a_leaders 100 /*|subtype| for aligned leaders*/ +@d c_leaders 101 /*|subtype| for centered leaders*/ +@d x_leaders 102 /*|subtype| for expanded leaders*/ +@d glue_ptr(A) llink(A) /*pointer to a glue specification*/ +@d leader_ptr(A) rlink(A) /*pointer to box or rule node for leaders*/ + +@ A glue specification has a halfword reference count in its first word, +@^reference counts@> +representing |null| plus the number of glue nodes that point to it (less one). +Note that the reference count appears in the same position as +the |link| field in list nodes; this is the field that is initialized +to |null| when a node is allocated, and it is also the field that is flagged +by |empty_flag| in empty nodes. + +Glue specifications also contain three |scaled| fields, for the |width|, +|stretch|, and |shrink| dimensions. Finally, there are two one-byte +fields called |stretch_order| and |shrink_order|; these contain the +orders of infinity (|normal|, |fil|, |fill|, or |filll|) +corresponding to the stretch and shrink values. + +@d glue_spec_size 4 /*number of words to allocate for a glue specification*/ +@d glue_ref_count(A) link(A) /*reference count of a glue specification*/ +@d stretch(A) mem[A+2].sc /*the stretchability of this glob of glue*/ +@d shrink(A) mem[A+3].sc /*the shrinkability of this glob of glue*/ +@d stretch_order(A) type(A) /*order of infinity for stretching*/ +@d shrink_order(A) subtype(A) /*order of infinity for shrinking*/ +@d fil 1 /*first-order infinity*/ +@d fill 2 /*second-order infinity*/ +@d filll 3 /*third-order infinity*/ + +@= +typedef int8_t glue_ord; /*infinity to the 0, 1, 2, or 3 power*/ + +@ Here is a function that returns a pointer to a copy of a glue spec. +The reference count in the copy is |null|, because there is assumed +to be exactly one reference to the new specification. + +@p static pointer new_spec(pointer @!p) /*duplicates a glue specification*/ +{@+pointer q; /*the new spec*/ +q=get_node(glue_spec_size);@/ +mem[q]=mem[p];glue_ref_count(q)=null;@/ +width(q)=width(p);stretch(q)=stretch(p);shrink(q)=shrink(p); +return q; +} + +@ And here's a function that creates a glue node for a given parameter +identified by its code number; for example, +|new_param_glue(line_skip_code)| returns a pointer to a glue node for the +current \.{\\lineskip}. + +@p static pointer new_param_glue(small_number @!n) +{@+pointer p; /*the new node*/ +pointer @!q; /*the glue specification*/ +p=get_node(small_node_size);type(p)=glue_node;subtype(p)=n+1; +leader_ptr(p)=null;@/ +q=@@t@>; +glue_ptr(p)=q;incr(glue_ref_count(q)); +return p; +} + +@ Glue nodes that are more or less anonymous are created by |new_glue|, +whose argument points to a glue specification. + +@p static pointer new_glue(pointer @!q) +{@+pointer p; /*the new node*/ +p=get_node(small_node_size);type(p)=glue_node;subtype(p)=normal; +leader_ptr(p)=null;glue_ptr(p)=q;incr(glue_ref_count(q)); +return p; +} + +@ Still another subroutine is needed: This one is sort of a combination +of |new_param_glue| and |new_glue|. It creates a glue node for one of +the current glue parameters, but it makes a fresh copy of the glue +specification, since that specification will probably be subject to change, +while the parameter will stay put. The global variable |temp_ptr| is +set to the address of the new spec. + +@p static pointer new_skip_param(small_number @!n) +{@+pointer p; /*the new node*/ +temp_ptr=new_spec(@); +p=new_glue(temp_ptr);glue_ref_count(temp_ptr)=null;subtype(p)=n+1; +return p; +} + +@ A |kern_node| has a |width| field to specify a (normally negative) +amount of spacing. This spacing correction appears in horizontal lists +between letters like A and V when the font designer said that it looks +better to move them closer together or further apart. A kern node can +also appear in a vertical list, when its `|width|' denotes additional +spacing in the vertical direction. The |subtype| is either |normal| (for +kerns inserted from font information or math mode calculations) or |explicit| +(for kerns inserted from \.{\\kern} and \.{\\/} commands) or |acc_kern| +(for kerns inserted from non-math accents) or |mu_glue| (for kerns +inserted from \.{\\mkern} specifications in math formulas). + +@d kern_node 11 /*|type| of a kern node*/ +@d explicit 1 /*|subtype| of kern nodes from \.{\\kern} and \.{\\/}*/ +@d acc_kern 2 /*|subtype| of kern nodes from accents*/ + +@ The |new_kern| function creates a kern node having a given width. + +@p static pointer new_kern(scaled @!w) +{@+pointer p; /*the new node*/ +p=get_node(small_node_size);type(p)=kern_node; +subtype(p)=normal; +width(p)=w; +return p; +} + +@ A |penalty_node| specifies the penalty associated with line or page +breaking, in its |penalty| field. This field is a fullword integer, but +the full range of integer values is not used: Any penalty | >= 10000| is +treated as infinity, and no break will be allowed for such high values. +Similarly, any penalty | <= -10000| is treated as negative infinity, and a +break will be forced. + +@d penalty_node 12 /*|type| of a penalty node*/ +@d inf_penalty inf_bad /*``infinite'' penalty value*/ +@d eject_penalty (-inf_penalty) /*``negatively infinite'' penalty value*/ +@d penalty(A) mem[A+1].i /*the added cost of breaking a list here*/ + +@ Anyone who has been reading the last few sections of the program will +be able to guess what comes next. + +@p static pointer new_penalty(int @!m) +{@+pointer p; /*the new node*/ +p=get_node(small_node_size);type(p)=penalty_node; +subtype(p)=0; /*the |subtype| is not used*/ +penalty(p)=m;return p; +} + +@ You might think that we have introduced enough node types by now. Well, +almost, but there is one more: An |unset_node| has nearly the same format +as an |hlist_node| or |vlist_node|; it is used for entries in \.{\\halign} +or \.{\\valign} that are not yet in their final form, since the box +dimensions are their ``natural'' sizes before any glue adjustment has been +made. The |glue_set| word is not present; instead, we have a |glue_stretch| +field, which contains the total stretch of order |glue_order| that is +present in the hlist or vlist being boxed. +Similarly, the |shift_amount| field is replaced by a |glue_shrink| field, +containing the total shrink of order |glue_sign| that is present. +The |subtype| field is called |span_count|; an unset box typically +contains the data for |qo(span_count)+1| columns. +Unset nodes will be changed to box nodes when alignment is completed. + +@d unset_node 13 /*|type| for an unset node*/ +@d unset_set_node 32 /*|type| for an unset |set_node|*/ +@d unset_pack_node 33 /*|type| for an unset |pack_node|*/ +@d glue_stretch(A) mem[A+glue_offset].sc /*total stretch in an unset node*/ +@d glue_shrink(A) shift_amount(A) /*total shrink in an unset node*/ +@d span_count(A) subtype(A) /*indicates the number of spanned columns*/ + +@ In fact, there are still more types coming. When we get to math formula +processing we will see that a |style_node| has |type==14|; and a number +of larger type codes will also be defined, for use in math mode only. + +@ Warning: If any changes are made to these data structure layouts, such as +changing any of the node sizes or even reordering the words of nodes, +the |copy_node_list| procedure and the memory initialization code +below may have to be changed. Such potentially dangerous parts of the +program are listed in the index under `data structure assumptions'. +@!@^data structure assumptions@> +However, other references to the nodes are made symbolically in terms of +the \.{WEB} macro definitions above, so that format changes will leave +\TeX's other algorithms intact. +@^system dependencies@> + +@* Memory layout. +Some areas of |mem| are dedicated to fixed usage, since static allocation is +more efficient than dynamic allocation when we can get away with it. For +example, locations |mem_bot| to |mem_bot+3| are always used to store the +specification for glue that is `\.{0pt plus 0pt minus 0pt}'. The +following macro definitions accomplish the static allocation by giving +symbolic names to the fixed positions. Static variable-size nodes appear +in locations |mem_bot| through |lo_mem_stat_max|, and static single-word nodes +appear in locations |hi_mem_stat_min| through |mem_top|, inclusive. It is +harmless to let |lig_trick| and |garbage| share the same location of |mem|. + +@d zero_glue mem_bot /*specification for \.{0pt plus 0pt minus 0pt}*/ +@d fil_glue zero_glue+glue_spec_size /*\.{0pt plus 1fil minus 0pt}*/ +@d fill_glue fil_glue+glue_spec_size /*\.{0pt plus 1fill minus 0pt}*/ +@d ss_glue fill_glue+glue_spec_size /*\.{0pt plus 1fil minus 1fil}*/ +@d fil_neg_glue ss_glue+glue_spec_size /*\.{0pt plus -1fil minus 0pt}*/ +@d lo_mem_stat_max fil_neg_glue+glue_spec_size-1 /*largest statically + allocated word in the variable-size |mem|*/ +@# +@d page_ins_head mem_top /*list of insertion data for current page*/ +@d contrib_head mem_top-1 /*vlist of items not yet on current page*/ +@d page_head mem_top-2 /*vlist for current page*/ +@d temp_head mem_top-3 /*head of a temporary list of some kind*/ +@d hold_head mem_top-4 /*head of a temporary list of another kind*/ +@d adjust_head mem_top-5 /*head of adjustment list returned by |hpack|*/ +@d active mem_top-7 /*head of active list in |line_break|, needs two words*/ +@d align_head mem_top-8 /*head of preamble list for alignments*/ +@d end_span mem_top-9 /*tail of spanned-width lists*/ +@d omit_template mem_top-10 /*a constant token list*/ +@d null_list mem_top-11 /*permanently empty list*/ +@d lig_trick mem_top-12 /*a ligature masquerading as a |char_node|*/ +@d garbage mem_top-12 /*used for scrap information*/ +@d backup_head mem_top-13 /*head of token list built by |scan_keyword|*/ +@d setpage_head mem_top-14 /*head of page template list build by |new_setpage_node|*/ +@d max_page type(setpage_head) /* maximum page template number */ +@d max_stream subtype(setpage_head) /* maximum stream number */ +@d hi_mem_stat_min mem_top-14 /*smallest statically allocated word in + the one-word |mem|*/ +@d hi_mem_stat_usage 15 /*the number of one-word nodes always present*/ + +@ The following code gets |mem| off to a good start, when \TeX\ is +initializing itself the slow~way. + +@= +int @!k; /*index into |mem|, |eqtb|, etc.*/ + +@ @= +for (k=mem_bot+1; k<=lo_mem_stat_max; k++) mem[k].sc=0; + /*all glue dimensions are zeroed*/ +@^data structure assumptions@> +k=mem_bot;@+while (k <= lo_mem_stat_max) + /*set first words of glue specifications*/ + {@+glue_ref_count(k)=null+1; + stretch_order(k)=normal;shrink_order(k)=normal; + k=k+glue_spec_size; + } +stretch(fil_glue)=unity;stretch_order(fil_glue)=fil;@/ +stretch(fill_glue)=unity;stretch_order(fill_glue)=fill;@/ +stretch(ss_glue)=unity;stretch_order(ss_glue)=fil;@/ +shrink(ss_glue)=unity;shrink_order(ss_glue)=fil;@/ +stretch(fil_neg_glue)=-unity;stretch_order(fil_neg_glue)=fil;@/ +rover=lo_mem_stat_max+1; +link(rover)=empty_flag; /*now initialize the dynamic memory*/ +node_size(rover)=1000; /*which is a 1000-word available node*/ +llink(rover)=rover;rlink(rover)=rover;@/ +lo_mem_max=rover+1000;link(lo_mem_max)=null;info(lo_mem_max)=null;@/ +for (k=hi_mem_stat_min; k<=mem_top; k++) + mem[k]=mem[lo_mem_max]; /*clear list heads*/ +@; +avail=null;mem_end=mem_top; +hi_mem_min=hi_mem_stat_min; /*initialize the one-word memory*/ +var_used=lo_mem_stat_max+1-mem_bot;dyn_used=hi_mem_stat_usage; + /*initialize statistics*/ + +@ If \TeX\ is extended improperly, the |mem| array might get screwed up. +For example, some pointers might be wrong, or some ``dead'' nodes might not +have been freed when the last reference to them disappeared. Procedures +|check_mem| and |search_mem| are available to help diagnose such +problems. These procedures make use of two arrays called |is_free| and +|was_free| that are present only if \TeX's debugging routines have +been included. (You may want to decrease the size of |mem| while you +@^debugging@> +are debugging.) + +@= +#ifdef @!DEBUG +static bool @!is_free0[mem_max-mem_min+1], *const @!is_free = @!is_free0-mem_min; /*free cells*/ +@t\hskip10pt@>static bool @!was_free0[mem_max-mem_min+1], *const @!was_free = @!was_free0-mem_min; + /*previously free cells*/ +@t\hskip10pt@>static pointer @!was_mem_end, @!was_lo_max, @!was_hi_min; + /*previous |mem_end|, |lo_mem_max|, and |hi_mem_min|*/ +@t\hskip10pt@>static bool @!panicking; /*do we want to check memory constantly?*/ +#endif + +@ @= +#ifdef @!DEBUG +was_mem_end=mem_min; /*indicate that everything was previously free*/ +was_lo_max=mem_min;was_hi_min=mem_max; +panicking=false; +#endif + +@ Procedure |check_mem| makes sure that the available space lists of +|mem| are well formed, and it optionally prints out all locations +that are reserved now but were free the last time this procedure was called. + +@p +#ifdef @!DEBUG +static void check_mem(bool @!print_locs) +{@+ /*loop exits*/ +int p, @!q; /*current locations of interest in |mem|*/ +bool @!clobbered; /*is something amiss?*/ +for (p=mem_min; p<=lo_mem_max; p++) is_free[p]=false; /*you can probably + do this faster*/ +for (p=hi_mem_min; p<=mem_end; p++) is_free[p]=false; /*ditto*/ +@; +@; +@; +if (print_locs) @; +for (p=mem_min; p<=lo_mem_max; p++) was_free[p]=is_free[p]; +for (p=hi_mem_min; p<=mem_end; p++) was_free[p]=is_free[p]; + /*|was_free=is_free| might be faster*/ +was_mem_end=mem_end;was_lo_max=lo_mem_max;was_hi_min=hi_mem_min; +} +#endif + +@ @= +p=avail;q=null;clobbered=false; +while (p!=null) + {@+if ((p > mem_end)||(p < hi_mem_min)) clobbered=true; + else if (is_free[p]) clobbered=true; + if (clobbered) + {@+print_nl("AVAIL list clobbered at "); +@.AVAIL list clobbered...@> + print_int(q);goto done1; + } + is_free[p]=true;q=p;p=link(q); + } +done1: + +@ @= +p=rover;q=null;clobbered=false; +@/do@+{if ((p >= lo_mem_max)||(p < mem_min)) clobbered=true; + else if ((rlink(p) >= lo_mem_max)||(rlink(p) < mem_min)) clobbered=true; + else if (!(is_empty(p))||(node_size(p) < 2)||@| + (p+node_size(p) > lo_mem_max)||@|(llink(rlink(p))!=p)) clobbered=true; + if (clobbered) + {@+print_nl("Double-AVAIL list clobbered at "); + print_int(q);goto done2; + } +for (q=p; q<=p+node_size(p)-1; q++) /*mark all locations free*/ + {@+if (is_free[q]) + {@+print_nl("Doubly free location at "); +@.Doubly free location...@> + print_int(q);goto done2; + } + is_free[q]=true; + } +q=p;p=rlink(p); +}@+ while (!(p==rover)); +done2: + +@ @= +p=mem_min; +while (p <= lo_mem_max) /*node |p| should not be empty*/ + {@+if (is_empty(p)) + {@+print_nl("Bad flag at ");print_int(p); +@.Bad flag...@> + } + while ((p <= lo_mem_max)&&!is_free[p]) incr(p); + while ((p <= lo_mem_max)&&is_free[p]) incr(p); + } + +@ @= +{@+print_nl("New busy locs:"); +for (p=mem_min; p<=lo_mem_max; p++) + if (!is_free[p]&&((p > was_lo_max)||was_free[p])) + {@+print_char(' ');print_int(p); + } +for (p=hi_mem_min; p<=mem_end; p++) + if (!is_free[p]&& + ((p < was_hi_min)||(p > was_mem_end)||was_free[p])) + {@+print_char(' ');print_int(p); + } +} + +@ The |search_mem| procedure attempts to answer the question ``Who points +to node~|p|?'' In doing so, it fetches |link| and |info| fields of |mem| +that might not be of type |two_halves|. Strictly speaking, this is +@^dirty \PASCAL@> +undefined in \PASCAL, and it can lead to ``false drops'' (words that seem to +point to |p| purely by coincidence). But for debugging purposes, we want +to rule out the places that do {\sl not\/} point to |p|, so a few false +drops are tolerable. + +@p +#ifdef @!DEBUG +static void search_mem(pointer @!p) /*look for pointers to |p|*/ +{@+int q; /*current position being searched*/ +for (q=mem_min; q<=lo_mem_max; q++) + {@+if (link(q)==p) + {@+print_nl("LINK(");print_int(q);print_char(')'); + } + if (info(q)==p) + {@+print_nl("INFO(");print_int(q);print_char(')'); + } + } +for (q=hi_mem_min; q<=mem_end; q++) + {@+if (link(q)==p) + {@+print_nl("LINK(");print_int(q);print_char(')'); + } + if (info(q)==p) + {@+print_nl("INFO(");print_int(q);print_char(')'); + } + } +@; +@; +@; +} +#endif + +@* Displaying boxes. +We can reinforce our knowledge of the data structures just introduced +by considering two procedures that display a list in symbolic form. +The first of these, called |short_display|, is used in ``overfull box'' +messages to give the top-level description of a list. The other one, +called |show_node_list|, prints a detailed description of exactly what +is in the data structure. + +The philosophy of |short_display| is to ignore the fine points about exactly +what is inside boxes, except that ligatures and discretionary breaks are +expanded. As a result, |short_display| is a recursive procedure, but the +recursion is never more than one level deep. +@^recursion@> + +A global variable |font_in_short_display| keeps track of the font code that +is assumed to be present when |short_display| begins; deviations from this +font will be printed. + +@= +static int @!font_in_short_display; /*an internal font number*/ + +@ Boxes, rules, inserts, whatsits, marks, and things in general that are +sort of ``complicated'' are indicated only by printing `\.{[]}'. + +@p static void short_display(int @!p) /*prints highlights of list |p|*/ +{@+int n; /*for replacement counts*/ +while (p > mem_min) + {@+if (is_char_node(p)) + {@+if (p <= mem_end) + {@+if (font(p)!=font_in_short_display) + {@+if ((font(p) < font_base)||(font(p) > font_max)) + print_char('*'); +@.*\relax@> + else@; + print_char(' ');font_in_short_display=font(p); + } + print_ASCII(qo(character(p))); + } + } + else@; + p=link(p); + } +} + +@ @= +switch (type(p)) { +case hlist_node: case vlist_node: case ins_node: case whatsit_node: case mark_node: case adjust_node: + case unset_node: case unset_set_node: case unset_pack_node: print("[]");@+break; +case rule_node: print_char('|');@+break; +case glue_node: if (glue_ptr(p)!=zero_glue) print_char(' ');@+break; +case math_node: print_char('$');@+break; +case ligature_node: short_display(lig_ptr(p));@+break; +case disc_node: {@+short_display(pre_break(p)); + short_display(post_break(p));@/ + n=replace_count(p); + while (n > 0) + {@+if (link(p)!=null) p=link(p); + decr(n); + } + } @+break; +default:do_nothing; +} + +@ The |show_node_list| routine requires some auxiliary subroutines: one to +print a font-and-character combination, one to print a token list without +its reference count, and one to print a rule dimension. + +@p static void print_font_and_char(int @!p) /*prints |char_node| data*/ +{@+if (p > mem_end) print_esc("CLOBBERED."); +else{@+if ((font(p) < font_base)||(font(p) > font_max)) print_char('*'); +@.*\relax@> + else@; + print_char(' ');print_ASCII(qo(character(p))); + } +} +@# +static void print_mark(int @!p) /*prints token list data in braces*/ +{@+print_char('{'); +if ((p < hi_mem_min)||(p > mem_end)) print_esc("CLOBBERED."); +else show_token_list(link(p), null, max_print_line-10); +print_char('}'); +} +@# +static void print_rule_dimen(scaled @!d) /*prints dimension in rule node*/ +{@+if (is_running(d)) print_char('*');else print_scaled(d); +@.*\relax@> +} + +@ Then there is a subroutine that prints glue stretch and shrink, possibly +followed by the name of finite units: + +@p static void print_glue(scaled @!d, int @!order, char *@!s) + /*prints a glue component*/ +{@+print_scaled(d); +if ((order < normal)||(order > filll)) print("foul"); +else if (order > normal) + {@+print("fil"); + while (order > fil) + {@+print_char('l');decr(order); + } + } +else if (s!=0) print(s); +} + +@ The next subroutine prints a whole glue specification. + +@p static void print_spec(int @!p, char *@!s) + /*prints a glue specification*/ +{@+if ((p < mem_min)||(p >= lo_mem_max)) print_char('*'); +@.*\relax@> +else{@+print_scaled(width(p)); + if (s!=0) print(s); + if (stretch(p)!=0) + {@+print(" plus ");print_glue(stretch(p), stretch_order(p), s); + } + if (shrink(p)!=0) + {@+print(" minus ");print_glue(shrink(p), shrink_order(p), s); + } + } +} + +@ We also need to declare some procedures that appear later in this +documentation. + +@p @@; +@@; +static void print_xdimen(pointer p) +{ print_scaled(xdimen_width(p)); + if (xdimen_hfactor(p)!=0) + { print_char('+');print_scaled(xdimen_hfactor(p));print("*hsize");} + if (xdimen_vfactor(p)!=0) + { print_char('+');print_scaled(xdimen_vfactor(p));print("*vsize");} +} + +@ Since boxes can be inside of boxes, |show_node_list| is inherently recursive, +@^recursion@> +up to a given maximum number of levels. The history of nesting is indicated +by the current string, which will be printed at the beginning of each line; +the length of this string, namely |cur_length|, is the depth of nesting. + +Recursive calls on |show_node_list| therefore use the following pattern: + +@d node_list_display(A) + {@+append_char('.');show_node_list(A);flush_char; + } /*|str_room| need not be checked; see |show_box| below*/ + +@ A global variable called |depth_threshold| is used to record the maximum +depth of nesting for which |show_node_list| will show information. If we +have |depth_threshold==0|, for example, only the top level information will +be given and no sublists will be traversed. Another global variable, called +|breadth_max|, tells the maximum number of items to show at each level; +|breadth_max| had better be positive, or you won't see anything. + +@= +static int @!depth_threshold; /*maximum nesting depth in box displays*/ +static int @!breadth_max; /*maximum number of items shown at the same list level*/ + +@ Now we are ready for |show_node_list| itself. This procedure has been +written to be ``extra robust'' in the sense that it should not crash or get +into a loop even if the data structures have been messed up by bugs in +the rest of the program. You can safely call its parent routine +|show_box(p)| for arbitrary values of |p| when you are debugging \TeX. +However, in the presence of bad data, the procedure may +@^dirty \PASCAL@>@^debugging@> +fetch a |memory_word| whose variant is different from the way it was stored; +for example, it might try to read |mem[p].hh| when |mem[p]| +contains a scaled integer, if |p| is a pointer that has been +clobbered or chosen at random. + +@p static void show_node_list(int @!p) /*prints a node list symbolically*/ +{@+ +int n; /*the number of items already printed at this level*/ +double @!g; /*a glue ratio, as a floating point number*/ +if (cur_length > depth_threshold) + {@+if (p > null) print(" []"); + /*indicate that there's been some truncation*/ + return; + } +n=0; +while (p > mem_min) + {@+print_ln();print_current_string(); /*display the nesting history*/ + if (p > mem_end) /*pointer out of range*/ + {@+print("Bad link, display aborted.");return; +@.Bad link...@> + } + incr(n);if (n > breadth_max) /*time to stop*/ + {@+print("etc.");return; +@.etc@> + } + @; + p=link(p); + } + +} + +@ @= +if (is_char_node(p)) print_font_and_char(p); +else switch (type(p)) { + case hlist_node: case vlist_node: case unset_node: case unset_set_node: case unset_pack_node: @@;@+break; + case rule_node: @@;@+break; + case ins_node: @@;@+break; + case whatsit_node: @@;@+break; + case glue_node: @@;@+break; + case kern_node: @@;@+break; + case math_node: @@;@+break; + case ligature_node: @@;@+break; + case penalty_node: @@;@+break; + case disc_node: @@;@+break; + case mark_node: @@;@+break; + case adjust_node: @@;@+break; + @t\4@>@@; + default:print("Unknown node type!"); + } + +@ @= +{@+if (type(p)==hlist_node) print_esc("h"); +else if (type(p)==vlist_node) print_esc("v"); +else print_esc("unset"); +print("box(");print_scaled(height(p));print_char('+'); +print_scaled(depth(p));print(")x");print_scaled(width(p)); +if (type(p)==unset_set_node) print("set"); +else if (type(p)==unset_pack_node) print("pack"); +else if (type(p)==unset_node) + @@; +else{@+@; + if (shift_amount(p)!=0) + {@+print(", shifted ");print_scaled(shift_amount(p)); + } + } +node_list_display(list_ptr(p)); /*recursive call*/ +} + +@ @= +{@+if (span_count(p)!=min_quarterword) + {@+print(" (");print_int(qo(span_count(p))+1); + print(" columns)"); + } +if (glue_stretch(p)!=0) + {@+print(", stretch ");print_glue(glue_stretch(p), glue_order(p), 0); + } +if (glue_shrink(p)!=0) + {@+print(", shrink ");print_glue(glue_shrink(p), glue_sign(p), 0); + } +} + +@ The code will have to change in this place if |glue_ratio| is +a structured type instead of an ordinary |double|. Note that this routine +should avoid arithmetic errors even if the |glue_set| field holds an +arbitrary random value. The following code assumes that a properly +formed nonzero |double| number has absolute value $2^{20}$ or more when +it is regarded as an integer; this precaution was adequate to prevent +floating point underflow on the author's computer. +@^system dependencies@> +@^dirty \PASCAL@> + +@= +g=float(glue_set(p)); +if ((g!=float_constant(0))&&(glue_sign(p)!=normal)) + {@+print(", glue set "); + if (glue_sign(p)==shrinking) print("- "); + if (abs(mem[p+glue_offset].i) < 04000000) print("?.?"); + else if (abs(g) > float_constant(20000)) + {@+if (g > float_constant(0)) print_char('>'); + else print("< -"); + print_glue(20000*unity, glue_order(p), 0); + } + else print_glue(round(unity*g), glue_order(p), 0); +@^real multiplication@> + } + +@ @= +{@+print_esc("rule(");print_rule_dimen(height(p));print_char('+'); +print_rule_dimen(depth(p));print(")x");print_rule_dimen(width(p)); +} + +@ @= +{@+print_esc("insert");print_int(qo(subtype(p))); +print("; split(");print_spec(split_top_ptr(p), 0); +print_char(',');print_scaled(depth(p)); +print("); float cost ");print_int(float_cost(p)); +node_list_display(ins_ptr(p)); /*recursive call*/ +} + +@ @= +if (subtype(p) >= a_leaders) @@; +else{@+print_esc("glue"); + if (subtype(p)!=normal) + {@+print_char('('); + if (subtype(p) < cond_math_glue) + print_skip_param(subtype(p)-1); + else if (subtype(p)==cond_math_glue) print_esc("nonscript"); + else print_esc("mskip"); + print_char(')'); + } + if (subtype(p)!=cond_math_glue) + {@+print_char(' '); + if (subtype(p) < cond_math_glue) print_spec(glue_ptr(p), 0); + else print_spec(glue_ptr(p),"mu"); + } + } + +@ @= +{@+print_esc(""); +if (subtype(p)==c_leaders) print_char('c'); +else if (subtype(p)==x_leaders) print_char('x'); +print("leaders ");print_spec(glue_ptr(p), 0); +node_list_display(leader_ptr(p)); /*recursive call*/ +} + +@ An ``explicit'' kern value is indicated implicitly by an explicit space. + +@= +if (subtype(p)!=mu_glue) + {@+print_esc("kern"); + if (subtype(p)!=normal) print_char(' '); + print_scaled(width(p)); + if (subtype(p)==acc_kern) print(" (for accent)"); +@.for accent@> + } +else{@+print_esc("mkern");print_scaled(width(p));print("mu"); + } + +@ @= +{@+print_esc("math"); +if (subtype(p)==before) print("on"); +else print("off"); +if (width(p)!=0) + {@+print(", surrounded ");print_scaled(width(p)); + } +} + +@ @= +{@+print_font_and_char(lig_char(p));print(" (ligature "); +if (subtype(p) > 1) print_char('|'); +font_in_short_display=font(lig_char(p));short_display(lig_ptr(p)); +if (odd(subtype(p))) print_char('|'); +print_char(')'); +} + +@ @= +{@+print_esc("penalty ");print_int(penalty(p)); +} + +@ The |post_break| list of a discretionary node is indicated by a prefixed +`\.{\char'174}' instead of the `\..' before the |pre_break| list. + +@= +{@+print_esc("discretionary"); +if (replace_count(p) > 0) + {@+print(" replacing ");print_int(replace_count(p)); + } +node_list_display(pre_break(p)); /*recursive call*/ +append_char('|');show_node_list(post_break(p));flush_char; /*recursive call*/ +} + +@ @= +{@+print_esc("mark");print_mark(mark_ptr(p)); +} + +@ @= +{@+print_esc("vadjust");node_list_display(adjust_ptr(p)); /*recursive call*/ +} + +@ The recursive machinery is started by calling |show_box|. +@^recursion@> + +@p static void show_box(pointer @!p) +{@+@; +if (breadth_max <= 0) breadth_max=5; +if (pool_ptr+depth_threshold >= pool_size) + depth_threshold=pool_size-pool_ptr-1; + /*now there's enough room for prefix string*/ +show_node_list(p); /*the show starts at |p|*/ +print_ln(); +} + +@* Destroying boxes. +When we are done with a node list, we are obliged to return it to free +storage, including all of its sublists. The recursive procedure +|flush_node_list| does this for us. + +@ First, however, we shall consider two non-recursive procedures that do +simpler tasks. The first of these, |delete_token_ref|, is called when +a pointer to a token list's reference count is being removed. This means +that the token list should disappear if the reference count was |null|, +otherwise the count should be decreased by one. +@^reference counts@> + +@d token_ref_count(A) info(A) /*reference count preceding a token list*/ + +@p static void delete_token_ref(pointer @!p) /*|p| points to the reference count + of a token list that is losing one reference*/ +{@+if (token_ref_count(p)==null) flush_list(p); +else decr(token_ref_count(p)); +} + +@ Similarly, |delete_glue_ref| is called when a pointer to a glue +specification is being withdrawn. +@^reference counts@> +@d fast_delete_glue_ref(A) @t@>@;@/ + {@+if (glue_ref_count(A)==null) free_node(A, glue_spec_size); + else decr(glue_ref_count(A)); + } + +@p static void delete_glue_ref(pointer @!p) /*|p| points to a glue specification*/ +fast_delete_glue_ref(p) +static void delete_xdimen_ref(pointer @!p) /*|p| points to a xdimen specification*/ +{@+if (xdimen_ref_count(p)==null) free_node(p, xdimen_node_size); + else decr(xdimen_ref_count(p)); +} + +@ Now we are ready to delete any node list, recursively. +In practice, the nodes deleted are usually charnodes (about 2/3 of the time), +and they are glue nodes in about half of the remaining cases. +@^recursion@> + +@p static void flush_node_list(pointer @!p) /*erase list of nodes starting at |p|*/ +{@+ /*go here when node |p| has been freed*/ +pointer q; /*successor to node |p|*/ +while (p!=null) +@^inner loop@> + {@+q=link(p); + if (is_char_node(p)) free_avail(p)@; + else{@+switch (type(p)) { + case hlist_node: case vlist_node: case unset_node: case unset_set_node: case unset_pack_node: {@+flush_node_list(list_ptr(p)); + free_node(p, box_node_size);goto done; + } + case rule_node: {@+free_node(p, rule_node_size);goto done; + } + case ins_node: {@+flush_node_list(ins_ptr(p)); + delete_glue_ref(split_top_ptr(p)); + free_node(p, ins_node_size);goto done; + } + case whatsit_node: @@; + case glue_node: {@+fast_delete_glue_ref(glue_ptr(p)); + if (leader_ptr(p)!=null) flush_node_list(leader_ptr(p)); + } @+break; + case kern_node: case math_node: case penalty_node: do_nothing;@+break; + case ligature_node: flush_node_list(lig_ptr(p));@+break; + case mark_node: delete_token_ref(mark_ptr(p));@+break; + case disc_node: {@+flush_node_list(pre_break(p)); + flush_node_list(post_break(p)); + } @+break; + case adjust_node: flush_node_list(adjust_ptr(p));@+break; + @t\4@>@@; + default:confusion("flushing"); +@:this can't happen flushing}{\quad flushing@> + } @/ + free_node(p, small_node_size); + done: ;} + p=q; + } +} + +@* Copying boxes. +Another recursive operation that acts on boxes is sometimes needed: The +procedure |copy_node_list| returns a pointer to another node list that has +the same structure and meaning as the original. Note that since glue +specifications and token lists have reference counts, we need not make +copies of them. Reference counts can never get too large to fit in a +halfword, since each pointer to a node is in a different memory address, +and the total number of memory addresses fits in a halfword. +@^recursion@> +@^reference counts@> + +(Well, there actually are also references from outside |mem|; if the +|save_stack| is made arbitrarily large, it would theoretically be possible +to break \TeX\ by overflowing a reference count. But who would want to do that?) + +@d add_token_ref(A) incr(token_ref_count(A)) /*new reference to a token list*/ +@d add_glue_ref(A) incr(glue_ref_count(A)) /*new reference to a glue spec*/ +@d add_xdimen_ref(A) incr(xdimen_ref_count(A)) /*new reference to an xdimen*/ + +@ The copying procedure copies words en masse without bothering +to look at their individual fields. If the node format changes---for +example, if the size is altered, or if some link field is moved to another +relative position---then this code may need to be changed too. +@^data structure assumptions@> + +@p static pointer copy_node_list(pointer @!p) /*makes a duplicate of the + node list that starts at |p| and returns a pointer to the new list*/ +{@+pointer h; /*temporary head of copied list*/ +pointer @!q; /*previous position in new list*/ +pointer @!r; /*current node being fabricated for new list*/ +int @!words; /*number of words remaining to be copied*/ +h=get_avail();q=h; +while (p!=null) + {@+@; + link(q)=r;q=r;p=link(p); + } +link(q)=null;q=link(h);free_avail(h); +return q; +} + +@ @= +words=1; /*this setting occurs in more branches than any other*/ +if (is_char_node(p)) r=get_avail(); +else@; +while (words > 0) + {@+decr(words);mem[r+words]=mem[p+words]; + } + +@ @= +switch (type(p)) { +case hlist_node: case vlist_node: case unset_node: case unset_set_node: case unset_pack_node: {@+r=get_node(box_node_size); + mem[r+6]=mem[p+6];mem[r+5]=mem[p+5]; /*copy the last two words*/ + list_ptr(r)=copy_node_list(list_ptr(p)); /*this affects |mem[r+5]|*/ + words=5; + } @+break; +case rule_node: {@+r=get_node(rule_node_size);words=rule_node_size; + } @+break; +case ins_node: {@+r=get_node(ins_node_size);mem[r+4]=mem[p+4]; + add_glue_ref(split_top_ptr(p)); + ins_ptr(r)=copy_node_list(ins_ptr(p)); /*this affects |mem[r+4]|*/ + words=ins_node_size-1; + } @+break; +case whatsit_node: @@;@+break; +case glue_node: {@+r=get_node(small_node_size);add_glue_ref(glue_ptr(p)); + glue_ptr(r)=glue_ptr(p);leader_ptr(r)=copy_node_list(leader_ptr(p)); + } @+break; +case kern_node: case math_node: case penalty_node: {@+r=get_node(small_node_size); + words=small_node_size; + } @+break; +case ligature_node: {@+r=get_node(small_node_size); + mem[lig_char(r)]=mem[lig_char(p)]; /*copy |font| and |character|*/ + lig_ptr(r)=copy_node_list(lig_ptr(p)); + } @+break; +case disc_node: {@+r=get_node(small_node_size); + pre_break(r)=copy_node_list(pre_break(p)); + post_break(r)=copy_node_list(post_break(p)); + } @+break; +case mark_node: {@+r=get_node(small_node_size);add_token_ref(mark_ptr(p)); + words=small_node_size; + } @+break; +case adjust_node: {@+r=get_node(small_node_size); + adjust_ptr(r)=copy_node_list(adjust_ptr(p)); + } @+break; /*|words==1==small_node_size-1|*/ +default:confusion("copying"); +@:this can't happen copying}{\quad copying@> +} + +@* The command codes. +Before we can go any further, we need to define symbolic names for the internal +code numbers that represent the various commands obeyed by \TeX. These codes +are somewhat arbitrary, but not completely so. For example, the command +codes for character types are fixed by the language, since a user says, +e.g., `\.{\\catcode \`\\\${} = 3}' to make \.{\char'44} a math delimiter, +and the command code |math_shift| is equal to~3. Some other codes have +been made adjacent so that |case| statements in the program need not consider +cases that are widely spaced, or so that |case| statements can be replaced +by |if (| statements. + +At any rate, here is the list, for future reference. First come the +``catcode'' commands, several of which share their numeric codes with +ordinary commands when the catcode cannot emerge from \TeX's scanning routine. + +@d escape 0 /*escape delimiter (called \.\\ in {\sl The \TeX book\/})*/ +@:TeXbook}{\sl The \TeX book@> +@d relax 0 /*do nothing ( \.{\\relax} )*/ +@d left_brace 1 /*beginning of a group ( \.\{ )*/ +@d right_brace 2 /*ending of a group ( \.\} )*/ +@d math_shift 3 /*mathematics shift character ( \.\$ )*/ +@d tab_mark 4 /*alignment delimiter ( \.\&, \.{\\span} )*/ +@d car_ret 5 /*end of line ( |carriage_return|, \.{\\cr}, \.{\\crcr} )*/ +@d out_param 5 /*output a macro parameter*/ +@d mac_param 6 /*macro parameter symbol ( \.\# )*/ +@d sup_mark 7 /*superscript ( \.{\char'136} )*/ +@d sub_mark 8 /*subscript ( \.{\char'137} )*/ +@d ignore 9 /*characters to ignore ( \.{\^\^@@} )*/ +@d endv 9 /*end of \ list in alignment template*/ +@d spacer 10 /*characters equivalent to blank space ( \.{\ } )*/ +@d letter 11 /*characters regarded as letters ( \.{A..Z}, \.{a..z} )*/ +@d other_char 12 /*none of the special character types*/ +@d active_char 13 /*characters that invoke macros ( \.{\char`\~} )*/ +@d par_end 13 /*end of paragraph ( \.{\\par} )*/ +@d match 13 /*match a macro parameter*/ +@d comment 14 /*characters that introduce comments ( \.\% )*/ +@d end_match 14 /*end of parameters to macro*/ +@d stop 14 /*end of job ( \.{\\end}, \.{\\dump} )*/ +@d invalid_char 15 /*characters that shouldn't appear ( \.{\^\^?} )*/ +@d delim_num 15 /*specify delimiter numerically ( \.{\\delimiter} )*/ +@d max_char_code 15 /*largest catcode for individual characters*/ + +@ Next are the ordinary run-of-the-mill command codes. Codes that are +|min_internal| or more represent internal quantities that might be +expanded by `\.{\\the}'. + +@d char_num 16 /*character specified numerically ( \.{\\char} )*/ +@d math_char_num 17 /*explicit math code ( \.{\\mathchar} )*/ +@d mark 18 /*mark definition ( \.{\\mark} )*/ +@d xray 19 /*peek inside of \TeX\ ( \.{\\show}, \.{\\showbox}, etc.~)*/ +@d make_box 20 /*make a box ( \.{\\box}, \.{\\copy}, \.{\\hbox}, etc.~)*/ +@d hmove 21 /*horizontal motion ( \.{\\moveleft}, \.{\\moveright} )*/ +@d vmove 22 /*vertical motion ( \.{\\raise}, \.{\\lower} )*/ +@d un_hbox 23 /*unglue a box ( \.{\\unhbox}, \.{\\unhcopy} )*/ +@d un_vbox 24 /*unglue a box ( \.{\\unvbox}, \.{\\unvcopy} )*/ +@d remove_item 25 /*nullify last item ( \.{\\unpenalty}, + \.{\\unkern}, \.{\\unskip} )*/ +@d hskip 26 /*horizontal glue ( \.{\\hskip}, \.{\\hfil}, etc.~)*/ +@d vskip 27 /*vertical glue ( \.{\\vskip}, \.{\\vfil}, etc.~)*/ +@d mskip 28 /*math glue ( \.{\\mskip} )*/ +@d kern 29 /*fixed space ( \.{\\kern} )*/ +@d mkern 30 /*math kern ( \.{\\mkern} )*/ +@d leader_ship 31 /*use a box ( \.{\\shipout}, \.{\\leaders}, etc.~)*/ +@d halign 32 /*horizontal table alignment ( \.{\\halign} )*/ +@d valign 33 /*vertical table alignment ( \.{\\valign} )*/ +@d no_align 34 /*temporary escape from alignment ( \.{\\noalign} )*/ +@d vrule 35 /*vertical rule ( \.{\\vrule} )*/ +@d hrule 36 /*horizontal rule ( \.{\\hrule} )*/ +@d insert 37 /*vlist inserted in box ( \.{\\insert} )*/ +@d vadjust 38 /*vlist inserted in enclosing paragraph ( \.{\\vadjust} )*/ +@d ignore_spaces 39 /*gobble |spacer| tokens ( \.{\\ignorespaces} )*/ +@d after_assignment 40 /*save till assignment is done ( \.{\\afterassignment} )*/ +@d after_group 41 /*save till group is done ( \.{\\aftergroup} )*/ +@d break_penalty 42 /*additional badness ( \.{\\penalty} )*/ +@d start_par 43 /*begin paragraph ( \.{\\indent}, \.{\\noindent} )*/ +@d ital_corr 44 /*italic correction ( \.{\\/} )*/ +@d accent 45 /*attach accent in text ( \.{\\accent} )*/ +@d math_accent 46 /*attach accent in math ( \.{\\mathaccent} )*/ +@d discretionary 47 /*discretionary texts ( \.{\\-}, \.{\\discretionary} )*/ +@d eq_no 48 /*equation number ( \.{\\eqno}, \.{\\leqno} )*/ +@d left_right 49 /*variable delimiter ( \.{\\left}, \.{\\right} )*/ + /*( or \.{\\middle} )*/ +@d math_comp 50 /*component of formula ( \.{\\mathbin}, etc.~)*/ +@d limit_switch 51 /*diddle limit conventions ( \.{\\displaylimits}, etc.~)*/ +@d above 52 /*generalized fraction ( \.{\\above}, \.{\\atop}, etc.~)*/ +@d math_style 53 /*style specification ( \.{\\displaystyle}, etc.~)*/ +@d math_choice 54 /*choice specification ( \.{\\mathchoice} )*/ +@d non_script 55 /*conditional math glue ( \.{\\nonscript} )*/ +@d vcenter 56 /*vertically center a vbox ( \.{\\vcenter} )*/ +@d case_shift 57 /*force specific case ( \.{\\lowercase}, \.{\\uppercase}~)*/ +@d message 58 /*send to user ( \.{\\message}, \.{\\errmessage} )*/ +@d extension 59 /*extensions to \TeX\ ( \.{\\write}, \.{\\special}, etc.~)*/ +@d in_stream 60 /*files for reading ( \.{\\openin}, \.{\\closein} )*/ +@d begin_group 61 /*begin local grouping ( \.{\\begingroup} )*/ +@d end_group 62 /*end local grouping ( \.{\\endgroup} )*/ +@d omit 63 /*omit alignment template ( \.{\\omit} )*/ +@d ex_space 64 /*explicit space ( \.{\\\ } )*/ +@d no_boundary 65 /*suppress boundary ligatures ( \.{\\noboundary} )*/ +@d radical 66 /*square root and similar signs ( \.{\\radical} )*/ +@d end_cs_name 67 /*end control sequence ( \.{\\endcsname} )*/ +@d min_internal 68 /*the smallest code that can follow \.{\\the}*/ +@d char_given 68 /*character code defined by \.{\\chardef}*/ +@d math_given 69 /*math code defined by \.{\\mathchardef}*/ +@d last_item 70 /*most recent item ( \.{\\lastpenalty}, + \.{\\lastkern}, \.{\\lastskip} )*/ +@d max_non_prefixed_command 70 /*largest command code that can't be \.{\\global}*/ + +@ The next codes are special; they all relate to mode-independent +assignment of values to \TeX's internal registers or tables. +Codes that are |max_internal| or less represent internal quantities +that might be expanded by `\.{\\the}'. + +@d toks_register 71 /*token list register ( \.{\\toks} )*/ +@d assign_toks 72 /*special token list ( \.{\\output}, \.{\\everypar}, etc.~)*/ +@d assign_int 73 /*user-defined integer ( \.{\\tolerance}, \.{\\day}, etc.~)*/ +@d assign_dimen 74 /*user-defined length ( \.{\\hsize}, etc.~)*/ +@d assign_glue 75 /*user-defined glue ( \.{\\baselineskip}, etc.~)*/ +@d assign_mu_glue 76 /*user-defined muglue ( \.{\\thinmuskip}, etc.~)*/ +@d assign_font_dimen 77 /*user-defined font dimension ( \.{\\fontdimen} )*/ +@d assign_font_int 78 /*user-defined font integer ( \.{\\hyphenchar}, + \.{\\skewchar} )*/ +@d set_aux 79 /*specify state info ( \.{\\spacefactor}, \.{\\prevdepth} )*/ +@d set_prev_graf 80 /*specify state info ( \.{\\prevgraf} )*/ +@d set_page_dimen 81 /*specify state info ( \.{\\pagegoal}, etc.~)*/ +@d set_page_int 82 /*specify state info ( \.{\\deadcycles}, + \.{\\insertpenalties} )*/ + /*( or \.{\\interactionmode} )*/ +@d set_box_dimen 83 /*change dimension of box ( \.{\\wd}, \.{\\ht}, \.{\\dp} )*/ +@d set_shape 84 /*specify fancy paragraph shape ( \.{\\parshape} )*/ + /*(or \.{\\interlinepenalties}, etc.~)*/ +@d def_code 85 /*define a character code ( \.{\\catcode}, etc.~)*/ +@d def_family 86 /*declare math fonts ( \.{\\textfont}, etc.~)*/ +@d set_font 87 /*set current font ( font identifiers )*/ +@d def_font 88 /*define a font file ( \.{\\font} )*/ +@d internal_register 89 /*internal register ( \.{\\count}, \.{\\dimen}, etc.~)*/ +@d max_internal 89 /*the largest code that can follow \.{\\the}*/ +@d advance 90 /*advance a register or parameter ( \.{\\advance} )*/ +@d multiply 91 /*multiply a register or parameter ( \.{\\multiply} )*/ +@d divide 92 /*divide a register or parameter ( \.{\\divide} )*/ +@d prefix 93 /*qualify a definition ( \.{\\global}, \.{\\long}, \.{\\outer} )*/ + /*( or \.{\\protected} )*/ +@d let 94 /*assign a command code ( \.{\\let}, \.{\\futurelet} )*/ +@d shorthand_def 95 /*code definition ( \.{\\chardef}, \.{\\countdef}, etc.~)*/ +@d read_to_cs 96 /*read into a control sequence ( \.{\\read} )*/ + /*( or \.{\\readline} )*/ +@d def 97 /*macro definition ( \.{\\def}, \.{\\gdef}, \.{\\xdef}, \.{\\edef} )*/ +@d set_box 98 /*set a box ( \.{\\setbox} )*/ +@d hyph_data 99 /*hyphenation data ( \.{\\hyphenation}, \.{\\patterns} )*/ +@d set_interaction 100 /*define level of interaction ( \.{\\batchmode}, etc.~)*/ +@d max_command 100 /*the largest command code seen at |big_switch|*/ + +@ The remaining command codes are extra special, since they cannot get through +\TeX's scanner to the main control routine. They have been given values higher +than |max_command| so that their special nature is easily discernible. +The ``expandable'' commands come first. + +@d undefined_cs (max_command+1) /*initial state of most |eq_type| fields*/ +@d expand_after (max_command+2) /*special expansion ( \.{\\expandafter} )*/ +@d no_expand (max_command+3) /*special nonexpansion ( \.{\\noexpand} )*/ +@d input (max_command+4) /*input a source file ( \.{\\input}, \.{\\endinput} )*/ + /*( or \.{\\scantokens} )*/ +@d if_test (max_command+5) /*conditional text ( \.{\\if}, \.{\\ifcase}, etc.~)*/ +@d fi_or_else (max_command+6) /*delimiters for conditionals ( \.{\\else}, etc.~)*/ +@d cs_name (max_command+7) /*make a control sequence from tokens ( \.{\\csname} )*/ +@d convert (max_command+8) /*convert to text ( \.{\\number}, \.{\\string}, etc.~)*/ +@d the (max_command+9) /*expand an internal quantity ( \.{\\the} )*/ + /*( or \.{\\unexpanded}, \.{\\detokenize} )*/ +@d top_bot_mark (max_command+10) /*inserted mark ( \.{\\topmark}, etc.~)*/ +@d call (max_command+11) /*non-long, non-outer control sequence*/ +@d long_call (max_command+12) /*long, non-outer control sequence*/ +@d outer_call (max_command+13) /*non-long, outer control sequence*/ +@d long_outer_call (max_command+14) /*long, outer control sequence*/ +@d end_template (max_command+15) /*end of an alignment template*/ +@d dont_expand (max_command+16) /*the following token was marked by \.{\\noexpand}*/ +@d glue_ref (max_command+17) /*the equivalent points to a glue specification*/ +@d shape_ref (max_command+18) /*the equivalent points to a parshape specification*/ +@d box_ref (max_command+19) /*the equivalent points to a box node, or is |null|*/ +@d data (max_command+20) /*the equivalent is simply a halfword number*/ + +@* The semantic nest. +\TeX\ is typically in the midst of building many lists at once. For example, +when a math formula is being processed, \TeX\ is in math mode and +working on an mlist; this formula has temporarily interrupted \TeX\ from +being in horizontal mode and building the hlist of a paragraph; and this +paragraph has temporarily interrupted \TeX\ from being in vertical mode +and building the vlist for the next page of a document. Similarly, when a +\.{\\vbox} occurs inside of an \.{\\hbox}, \TeX\ is temporarily +interrupted from working in restricted horizontal mode, and it enters +internal vertical mode. The ``semantic nest'' is a stack that +keeps track of what lists and modes are currently suspended. + +At each level of processing we are in one of six modes: + +\yskip\hang|vmode| stands for vertical mode (the page builder); + +\hang|hmode| stands for horizontal mode (the paragraph builder); + +\hang|mmode| stands for displayed formula mode; + +\hang|-vmode| stands for internal vertical mode (e.g., in a \.{\\vbox}); + +\hang|-hmode| stands for restricted horizontal mode (e.g., in an \.{\\hbox}); + +\hang|-mmode| stands for math formula mode (not displayed). + +\yskip\noindent The mode is temporarily set to zero while processing \.{\\write} +texts. + +Numeric values are assigned to |vmode|, |hmode|, and |mmode| so that +\TeX's ``big semantic switch'' can select the appropriate thing to +do by computing the value |abs(mode)+cur_cmd|, where |mode| is the current +mode and |cur_cmd| is the current command code. + +@d vmode 1 /*vertical mode*/ +@d hmode (vmode+max_command+1) /*horizontal mode*/ +@d mmode (hmode+max_command+1) /*math mode*/ + +@p static void print_mode(int @!m) /*prints the mode represented by |m|*/ +{@+if (m > 0) + switch (m/(max_command+1)) { + case 0: print("vertical");@+break; + case 1: print("horizontal");@+break; + case 2: print("display math"); + } +else if (m==0) print("no"); +else switch ((-m)/(max_command+1)) { + case 0: print("internal vertical");@+break; + case 1: print("restricted horizontal");@+break; + case 2: print("math"); + } +print(" mode"); +} + +@ The state of affairs at any semantic level can be represented by +five values: + +\yskip\hang|mode| is the number representing the semantic mode, as +just explained. + +\yskip\hang|head| is a |pointer| to a list head for the list being built; +|link(head)| therefore points to the first element of the list, or +to |null| if the list is empty. + +\yskip\hang|tail| is a |pointer| to the final node of the list being +built; thus, |tail==head| if and only if the list is empty. + +\yskip\hang|prev_graf| is the number of lines of the current paragraph that +have already been put into the present vertical list. + +\yskip\hang|aux| is an auxiliary |memory_word| that gives further information +that is needed to characterize the situation. + +\yskip\noindent +In vertical mode, |aux| is also known as |prev_depth|; it is the scaled +value representing the depth of the previous box, for use in baseline +calculations, or it is | <= -1000|pt if the next box on the vertical list is to +be exempt from baseline calculations. In horizontal mode, |aux| is also +known as |space_factor| and |clang|; it holds the current space factor used in +spacing calculations, and the current language used for hyphenation. +(The value of |clang| is undefined in restricted horizontal mode.) +In math mode, |aux| is also known as |incompleat_noad|; if +not |null|, it points to a record that represents the numerator of a +generalized fraction for which the denominator is currently being formed +in the current list. + +There is also a sixth quantity, |mode_line|, which correlates +the semantic nest with the user's input; |mode_line| contains the source +line number at which the current level of nesting was entered. The negative +of this line number is the |mode_line| at the level of the +user's output routine. + +A seventh quantity, |eTeX_aux|, is used by the extended features \eTeX. +In vertical modes it is known as |LR_save| and holds the LR stack when a +paragraph is interrupted by a displayed formula. In display math mode +it is known as |LR_box| and holds a pointer to a prototype box for the +display. In math mode it is known as |delim_ptr| and points to the most +recent |left_noad| or |middle_noad| of a |math_left_group|. + +In horizontal mode, the |prev_graf| field is used for initial language data. + +The semantic nest is an array called |nest| that holds the |mode|, |head|, +|tail|, |prev_graf|, |aux|, and |mode_line| values for all semantic levels +below the currently active one. Information about the currently active +level is kept in the global quantities |mode|, |head|, |tail|, |prev_graf|, +|aux|, and |mode_line|, which live in a \PASCAL\ record that is ready to +be pushed onto |nest| if necessary. + +@d ignore_depth (-1000*unity) /*|prev_depth| value that is ignored*/ +@d unknown_depth (-2000*unity) /*|prev_depth| value that is unknown*/ + +@= +typedef struct { int16_t @!mode_field;@+ + pointer @!head_field, @!tail_field; + pointer @!eTeX_aux_field; + int @!pg_field, @!ml_field;@+ + memory_word @!aux_field; + } list_state_record; + +@ @d mode cur_list.mode_field /*current mode*/ +@d head cur_list.head_field /*header node of current list*/ +@d tail cur_list.tail_field /*final node on current list*/ +@d eTeX_aux cur_list.eTeX_aux_field /*auxiliary data for \eTeX*/ +@d LR_save eTeX_aux /*LR stack when a paragraph is interrupted*/ +@d LR_box eTeX_aux /*prototype box for display*/ +@d delim_ptr eTeX_aux /*most recent left or right noad of a math left group*/ +@d prev_graf cur_list.pg_field /*number of paragraph lines accumulated*/ +@d aux cur_list.aux_field /*auxiliary data about the current list*/ +@d prev_depth aux.sc /*the name of |aux| in vertical mode*/ +@d space_factor aux.hh.lh /*part of |aux| in horizontal mode*/ +@d clang aux.hh.rh /*the other part of |aux| in horizontal mode*/ +@d incompleat_noad aux.i /*the name of |aux| in math mode*/ +@d mode_line cur_list.ml_field /*source file line number at beginning of list*/ + +@= +static list_state_record @!nest[nest_size+1]; +static int @!nest_ptr; /*first unused location of |nest|*/ +static int @!max_nest_stack; /*maximum of |nest_ptr| when pushing*/ +static list_state_record @!cur_list; /*the ``top'' semantic state*/ +static int @!shown_mode; /*most recent mode shown by \.{\\tracingcommands}*/ + +@ Here is a common way to make the current list grow: + +@d tail_append(A) {@+link(tail)=A;tail=link(tail); + } + +@ We will see later that the vertical list at the bottom semantic level is split +into two parts; the ``current page'' runs from |page_head| to |page_tail|, +and the ``contribution list'' runs from |contrib_head| to |tail| of +semantic level zero. The idea is that contributions are first formed in +vertical mode, then ``contributed'' to the current page (during which time +the page-breaking decisions are made). For now, we don't need to know +any more details about the page-building process. + +@= +nest_ptr=0;max_nest_stack=0; +mode=vmode;head=contrib_head;tail=contrib_head; +eTeX_aux=null; +prev_depth=ignore_depth;mode_line=0; +prev_graf=0;shown_mode=0; +@; + +@ When \TeX's work on one level is interrupted, the state is saved by +calling |push_nest|. This routine changes |head| and |tail| so that +a new (empty) list is begun; it does not change |mode| or |aux|. + +@p static void push_nest(void) /*enter a new semantic level, save the old*/ +{@+if (nest_ptr > max_nest_stack) + {@+max_nest_stack=nest_ptr; + if (nest_ptr==nest_size) overflow("semantic nest size", nest_size); +@:TeX capacity exceeded semantic nest size}{\quad semantic nest size@> + } +nest[nest_ptr]=cur_list; /*stack the record*/ +incr(nest_ptr);head=get_avail();tail=head;prev_graf=0;mode_line=line; +eTeX_aux=null; +} + +@ Conversely, when \TeX\ is finished on the current level, the former +state is restored by calling |pop_nest|. This routine will never be +called at the lowest semantic level, nor will it be called unless |head| +is a node that should be returned to free memory. + +@p static void pop_nest(void) /*leave a semantic level, re-enter the old*/ +{@+free_avail(head);decr(nest_ptr);cur_list=nest[nest_ptr]; +} + +@ Here is a procedure that displays what \TeX\ is working on, at all levels. + +@p static void print_totals(void); +static void show_activities(void) +{@+int p; /*index into |nest|*/ +int @!m; /*mode*/ +memory_word @!a; /*auxiliary*/ +pointer @!q, @!r; /*for showing the current page*/ +int @!t; /*ditto*/ +nest[nest_ptr]=cur_list; /*put the top level into the array*/ +print_nl("");print_ln(); +for (p=nest_ptr; p>=0; p--) + {@+m=nest[p].mode_field;a=nest[p].aux_field; + print_nl("### ");print_mode(m); + print(" entered at line ");print_int(abs(nest[p].ml_field)); + if (m==hmode) if (nest[p].pg_field!=040600000) + {@+print(" (language");print_int(nest[p].pg_field%0200000); + print(":hyphenmin");print_int(nest[p].pg_field/020000000); + print_char(',');print_int((nest[p].pg_field/0200000)%0100); + print_char(')'); + } + if (nest[p].ml_field < 0) print(" (\\output routine)"); + if (p==0) + {@+@; + if (link(contrib_head)!=null) + print_nl("### recent contributions:"); + } + show_box(link(nest[p].head_field)); + @; + } +} + +@ @= +switch (abs(m)/(max_command+1)) { +case 0: {@+print_nl("prevdepth "); + if (a.sc <= ignore_depth) + { if (a.sc <= unknown_depth) print("unknown"); else print("ignored"); } + else print_scaled(a.sc); + if (nest[p].pg_field!=0) + {@+print(", prevgraf "); + print_int(nest[p].pg_field);print(" line"); + if (nest[p].pg_field!=1) print_char('s'); + } + } @+break; +case 1: {@+print_nl("spacefactor ");print_int(a.hh.lh); + if (m > 0) @+if (a.hh.rh > 0) + {@+print(", current language ");print_int(a.hh.rh);@+ + } + } @+break; +case 2: if (a.i!=null) + {@+print("this will begin denominator of:");show_box(a.i);@+ + } +} /*there are no other cases*/ + +@* The table of equivalents. +Now that we have studied the data structures for \TeX's semantic routines, +we ought to consider the data structures used by its syntactic routines. In +other words, our next concern will be +the tables that \TeX\ looks at when it is scanning +what the user has written. + +The biggest and most important such table is called |eqtb|. It holds the +current ``equivalents'' of things; i.e., it explains what things mean +or what their current values are, for all quantities that are subject to +the nesting structure provided by \TeX's grouping mechanism. There are six +parts to |eqtb|: + +\yskip\hangg 1) |eqtb[active_base dotdot(hash_base-1)]| holds the current +equivalents of single-character control sequences. + +\yskip\hangg 2) |eqtb[hash_base dotdot(glue_base-1)]| holds the current +equivalents of multiletter control sequences. + +\yskip\hangg 3) |eqtb[glue_base dotdot(local_base-1)]| holds the current +equivalents of glue parameters like the current baselineskip. + +\yskip\hangg 4) |eqtb[local_base dotdot(int_base-1)]| holds the current +equivalents of local halfword quantities like the current box registers, +the current ``catcodes,'' the current font, and a pointer to the current +paragraph shape. + +\yskip\hangg 5) |eqtb[int_base dotdot(dimen_base-1)]| holds the current +equivalents of fullword integer parameters like the current hyphenation +penalty. + +\yskip\hangg 6) |eqtb[dimen_base dotdot eqtb_size]| holds the current equivalents +of fullword dimension parameters like the current hsize or amount of +hanging indentation. + +\yskip\noindent Note that, for example, the current amount of +baselineskip glue is determined by the setting of a particular location +in region~3 of |eqtb|, while the current meaning of the control sequence +`\.{\\baselineskip}' (which might have been changed by \.{\\def} or +\.{\\let}) appears in region~2. + +@ Each entry in |eqtb| is a |memory_word|. Most of these words are of type +|two_halves|, and subdivided into three fields: + +\yskip\hangg 1) The |eq_level| (a quarterword) is the level of grouping at +which this equivalent was defined. If the level is |level_zero|, the +equivalent has never been defined; |level_one| refers to the outer level +(outside of all groups), and this level is also used for global +definitions that never go away. Higher levels are for equivalents that +will disappear at the end of their group. @^global definitions@> + +\yskip\hangg 2) The |eq_type| (another quarterword) specifies what kind of +entry this is. There are many types, since each \TeX\ primitive like +\.{\\hbox}, \.{\\def}, etc., has its own special code. The list of +command codes above includes all possible settings of the |eq_type| field. + +\yskip\hangg 3) The |equiv| (a halfword) is the current equivalent value. +This may be a font number, a pointer into |mem|, or a variety of other +things. + +@d eq_level_field(A) A.hh.b1 +@d eq_type_field(A) A.hh.b0 +@d equiv_field(A) A.hh.rh +@d eq_level(A) eq_level_field(eqtb[A]) /*level of definition*/ +@d eq_type(A) eq_type_field(eqtb[A]) /*command code for equivalent*/ +@d equiv(A) equiv_field(eqtb[A]) /*equivalent value*/ +@d level_zero min_quarterword /*level for undefined quantities*/ +@d level_one (level_zero+1) /*outermost level for defined quantities*/ + +@ Many locations in |eqtb| have symbolic names. The purpose of the next +paragraphs is to define these names, and to set up the initial values of the +equivalents. + +In the first region we have 256 equivalents for ``active characters'' that +act as control sequences, followed by 256 equivalents for single-character +control sequences. + +Then comes region~2, which corresponds to the hash table that we will +define later. The maximum address in this region is used for a dummy +control sequence that is perpetually undefined. There also are several +locations for control sequences that are perpetually defined +(since they are used in error recovery). + +@d active_base 1 /*beginning of region 1, for active character equivalents*/ +@d single_base (active_base+256) /*equivalents of one-character control sequences*/ +@d null_cs (single_base+256) /*equivalent of \.{\\csname\\endcsname}*/ +@d hash_base (null_cs+1) /*beginning of region 2, for the hash table*/ +@d frozen_control_sequence (hash_base+hash_size) /*for error recovery*/ +@d frozen_protection frozen_control_sequence /*inaccessible but definable*/ +@d frozen_cr (frozen_control_sequence+1) /*permanent `\.{\\cr}'*/ +@d frozen_end_group (frozen_control_sequence+2) /*permanent `\.{\\endgroup}'*/ +@d frozen_right (frozen_control_sequence+3) /*permanent `\.{\\right}'*/ +@d frozen_fi (frozen_control_sequence+4) /*permanent `\.{\\fi}'*/ +@d frozen_end_template (frozen_control_sequence+5) /*permanent `\.{\\endtemplate}'*/ +@d frozen_endv (frozen_control_sequence+6) /*second permanent `\.{\\endtemplate}'*/ +@d frozen_relax (frozen_control_sequence+7) /*permanent `\.{\\relax}'*/ +@d end_write (frozen_control_sequence+8) /*permanent `\.{\\endwrite}'*/ +@d frozen_dont_expand (frozen_control_sequence+9) + /*permanent `\.{\\notexpanded:}'*/ +@d frozen_primitive (frozen_control_sequence+10) + /*permanent `\.{\\primitive:}'*/ +@d frozen_null_font (frozen_control_sequence+11) + /*permanent `\.{\\nullfont}'*/ +@d font_id_base (frozen_null_font-font_base) + /*begins table of 257 permanent font identifiers*/ +@d undefined_control_sequence (frozen_null_font+257) /*dummy location*/ +@d glue_base (undefined_control_sequence+1) /*beginning of region 3*/ + +@= +eq_type(undefined_control_sequence)=undefined_cs; +equiv(undefined_control_sequence)=null; +eq_level(undefined_control_sequence)=level_zero; +for (k=active_base; k<=undefined_control_sequence-1; k++) + eqtb[k]=eqtb[undefined_control_sequence]; + +@ Here is a routine that displays the current meaning of an |eqtb| entry +in region 1 or~2. (Similar routines for the other regions will appear +below.) + +@= +{@+sprint_cs(n);print_char('=');print_cmd_chr(eq_type(n), equiv(n)); +if (eq_type(n) >= call) + {@+print_char(':');show_token_list(link(equiv(n)), null, 32); + } +} + +@ Region 3 of |eqtb| contains the 256 \.{\\skip} registers, as well as the +glue parameters defined here. It is important that the ``muskip'' +parameters have larger numbers than the others. + +@d line_skip_code 0 /*interline glue if |baseline_skip| is infeasible*/ +@d baseline_skip_code 1 /*desired glue between baselines*/ +@d par_skip_code 2 /*extra glue just above a paragraph*/ +@d above_display_skip_code 3 /*extra glue just above displayed math*/ +@d below_display_skip_code 4 /*extra glue just below displayed math*/ +@d above_display_short_skip_code 5 + /*glue above displayed math following short lines*/ +@d below_display_short_skip_code 6 + /*glue below displayed math following short lines*/ +@d left_skip_code 7 /*glue at left of justified lines*/ +@d right_skip_code 8 /*glue at right of justified lines*/ +@d top_skip_code 9 /*glue at top of main pages*/ +@d split_top_skip_code 10 /*glue at top of split pages*/ +@d tab_skip_code 11 /*glue between aligned entries*/ +@d space_skip_code 12 /*glue between words (if not |zero_glue|)*/ +@d xspace_skip_code 13 /*glue after sentences (if not |zero_glue|)*/ +@d par_fill_skip_code 14 /*glue on last line of paragraph*/ +@d thin_mu_skip_code 15 /*thin space in math formula*/ +@d med_mu_skip_code 16 /*medium space in math formula*/ +@d thick_mu_skip_code 17 /*thick space in math formula*/ +@d glue_pars 18 /*total number of glue parameters*/ +@d skip_base (glue_base+glue_pars) /*table of 256 ``skip'' registers*/ +@d mu_skip_base (skip_base+256) /*table of 256 ``muskip'' registers*/ +@d local_base (mu_skip_base+256) /*beginning of region 4*/ +@# +@d skip(A) equiv(skip_base+A) /*|mem| location of glue specification*/ +@d mu_skip(A) equiv(mu_skip_base+A) /*|mem| location of math glue spec*/ +@d glue_par(A) equiv(glue_base+A) /*|mem| location of glue specification*/ +@d line_skip glue_par(line_skip_code) +@d baseline_skip glue_par(baseline_skip_code) +@d par_skip glue_par(par_skip_code) +@d above_display_skip glue_par(above_display_skip_code) +@d below_display_skip glue_par(below_display_skip_code) +@d above_display_short_skip glue_par(above_display_short_skip_code) +@d below_display_short_skip glue_par(below_display_short_skip_code) +@d left_skip glue_par(left_skip_code) +@d right_skip glue_par(right_skip_code) +@d top_skip glue_par(top_skip_code) +@d split_top_skip glue_par(split_top_skip_code) +@d tab_skip glue_par(tab_skip_code) +@d space_skip glue_par(space_skip_code) +@d xspace_skip glue_par(xspace_skip_code) +@d par_fill_skip glue_par(par_fill_skip_code) +@d thin_mu_skip glue_par(thin_mu_skip_code) +@d med_mu_skip glue_par(med_mu_skip_code) +@d thick_mu_skip glue_par(thick_mu_skip_code) + +@=glue_par(n) + +@ Sometimes we need to convert \TeX's internal code numbers into symbolic +form. The |print_skip_param| routine gives the symbolic name of a glue +parameter. + +@= +static void print_skip_param(int @!n) +{@+switch (n) { +case line_skip_code: print_esc("lineskip");@+break; +case baseline_skip_code: print_esc("baselineskip");@+break; +case par_skip_code: print_esc("parskip");@+break; +case above_display_skip_code: print_esc("abovedisplayskip");@+break; +case below_display_skip_code: print_esc("belowdisplayskip");@+break; +case above_display_short_skip_code: print_esc("abovedisplayshortskip");@+break; +case below_display_short_skip_code: print_esc("belowdisplayshortskip");@+break; +case left_skip_code: print_esc("leftskip");@+break; +case right_skip_code: print_esc("rightskip");@+break; +case top_skip_code: print_esc("topskip");@+break; +case split_top_skip_code: print_esc("splittopskip");@+break; +case tab_skip_code: print_esc("tabskip");@+break; +case space_skip_code: print_esc("spaceskip");@+break; +case xspace_skip_code: print_esc("xspaceskip");@+break; +case par_fill_skip_code: print_esc("parfillskip");@+break; +case thin_mu_skip_code: print_esc("thinmuskip");@+break; +case med_mu_skip_code: print_esc("medmuskip");@+break; +case thick_mu_skip_code: print_esc("thickmuskip");@+break; +default:print("[unknown glue parameter!]"); +} +} + +@ The symbolic names for glue parameters are put into \TeX's hash table +by using the routine called |primitive|, defined below. Let us enter them +now, so that we don't have to list all those parameter names anywhere else. + +@= +primitive("lineskip", assign_glue, glue_base+line_skip_code);@/ +@!@:line\_skip\_}{\.{\\lineskip} primitive@> +primitive("baselineskip", assign_glue, glue_base+baseline_skip_code);@/ +@!@:baseline\_skip\_}{\.{\\baselineskip} primitive@> +primitive("parskip", assign_glue, glue_base+par_skip_code);@/ +@!@:par\_skip\_}{\.{\\parskip} primitive@> +primitive("abovedisplayskip", assign_glue, glue_base+above_display_skip_code);@/ +@!@:above\_display\_skip\_}{\.{\\abovedisplayskip} primitive@> +primitive("belowdisplayskip", assign_glue, glue_base+below_display_skip_code);@/ +@!@:below\_display\_skip\_}{\.{\\belowdisplayskip} primitive@> +primitive("abovedisplayshortskip", + assign_glue, glue_base+above_display_short_skip_code);@/ +@!@:above\_display\_short\_skip\_}{\.{\\abovedisplayshortskip} primitive@> +primitive("belowdisplayshortskip", + assign_glue, glue_base+below_display_short_skip_code);@/ +@!@:below\_display\_short\_skip\_}{\.{\\belowdisplayshortskip} primitive@> +primitive("leftskip", assign_glue, glue_base+left_skip_code);@/ +@!@:left\_skip\_}{\.{\\leftskip} primitive@> +primitive("rightskip", assign_glue, glue_base+right_skip_code);@/ +@!@:right\_skip\_}{\.{\\rightskip} primitive@> +primitive("topskip", assign_glue, glue_base+top_skip_code);@/ +@!@:top\_skip\_}{\.{\\topskip} primitive@> +primitive("splittopskip", assign_glue, glue_base+split_top_skip_code);@/ +@!@:split\_top\_skip\_}{\.{\\splittopskip} primitive@> +primitive("tabskip", assign_glue, glue_base+tab_skip_code);@/ +@!@:tab\_skip\_}{\.{\\tabskip} primitive@> +primitive("spaceskip", assign_glue, glue_base+space_skip_code);@/ +@!@:space\_skip\_}{\.{\\spaceskip} primitive@> +primitive("xspaceskip", assign_glue, glue_base+xspace_skip_code);@/ +@!@:xspace\_skip\_}{\.{\\xspaceskip} primitive@> +primitive("parfillskip", assign_glue, glue_base+par_fill_skip_code);@/ +@!@:par\_fill\_skip\_}{\.{\\parfillskip} primitive@> +primitive("thinmuskip", assign_mu_glue, glue_base+thin_mu_skip_code);@/ +@!@:thin\_mu\_skip\_}{\.{\\thinmuskip} primitive@> +primitive("medmuskip", assign_mu_glue, glue_base+med_mu_skip_code);@/ +@!@:med\_mu\_skip\_}{\.{\\medmuskip} primitive@> +primitive("thickmuskip", assign_mu_glue, glue_base+thick_mu_skip_code);@/ +@!@:thick\_mu\_skip\_}{\.{\\thickmuskip} primitive@> + +@ @= +case assign_glue: case assign_mu_glue: if (chr_code < skip_base) + print_skip_param(chr_code-glue_base); + else if (chr_code < mu_skip_base) + {@+print_esc("skip");print_int(chr_code-skip_base); + } + else{@+print_esc("muskip");print_int(chr_code-mu_skip_base); + } @+break; + +@ All glue parameters and registers are initially `\.{0pt plus0pt minus0pt}'. + +@= +equiv(glue_base)=zero_glue;eq_level(glue_base)=level_one; +eq_type(glue_base)=glue_ref; +for (k=glue_base+1; k<=local_base-1; k++) eqtb[k]=eqtb[glue_base]; +glue_ref_count(zero_glue)=glue_ref_count(zero_glue)+local_base-glue_base; + +@ @= +if (n < skip_base) + {@+print_skip_param(n-glue_base);print_char('='); + if (n < glue_base+thin_mu_skip_code) print_spec(equiv(n),"pt"); + else print_spec(equiv(n),"mu"); + } +else if (n < mu_skip_base) + {@+print_esc("skip");print_int(n-skip_base);print_char('='); + print_spec(equiv(n),"pt"); + } +else{@+print_esc("muskip");print_int(n-mu_skip_base);print_char('='); + print_spec(equiv(n),"mu"); + } + +@ Region 4 of |eqtb| contains the local quantities defined here. The +bulk of this region is taken up by five tables that are indexed by eight-bit +characters; these tables are important to both the syntactic and semantic +portions of \TeX. There are also a bunch of special things like font and +token parameters, as well as the tables of \.{\\toks} and \.{\\box} +registers. + +@d par_shape_loc local_base /*specifies paragraph shape*/ +@d output_routine_loc (local_base+1) /*points to token list for \.{\\output}*/ +@d every_par_loc (local_base+2) /*points to token list for \.{\\everypar}*/ +@d every_math_loc (local_base+3) /*points to token list for \.{\\everymath}*/ +@d every_display_loc (local_base+4) /*points to token list for \.{\\everydisplay}*/ +@d every_hbox_loc (local_base+5) /*points to token list for \.{\\everyhbox}*/ +@d every_vbox_loc (local_base+6) /*points to token list for \.{\\everyvbox}*/ +@d every_job_loc (local_base+7) /*points to token list for \.{\\everyjob}*/ +@d every_cr_loc (local_base+8) /*points to token list for \.{\\everycr}*/ +@d err_help_loc (local_base+9) /*points to token list for \.{\\errhelp}*/ +@d tex_toks (local_base+10) /*end of \TeX's token list parameters*/ +@# +@d etex_toks_base tex_toks /*base for \eTeX's token list parameters*/ +@d every_eof_loc etex_toks_base /*points to token list for \.{\\everyeof}*/ +@d etex_toks (etex_toks_base+1) /*end of \eTeX's token list parameters*/ +@# +@d toks_base etex_toks /*table of 256 token list registers*/ +@# +@d etex_pen_base (toks_base+256) /*start of table of \eTeX's penalties*/ +@d inter_line_penalties_loc etex_pen_base /*additional penalties between lines*/ +@d club_penalties_loc (etex_pen_base+1) /*penalties for creating club lines*/ +@d widow_penalties_loc (etex_pen_base+2) /*penalties for creating widow lines*/ +@d display_widow_penalties_loc (etex_pen_base+3) /*ditto, just before a display*/ +@d etex_pens (etex_pen_base+4) /*end of table of \eTeX's penalties*/ +@# +@d box_base etex_pens /*table of 256 box registers*/ +@d cur_font_loc (box_base+256) /*internal font number outside math mode*/ +@d math_font_base (cur_font_loc+1) /*table of 48 math font numbers*/ +@d cat_code_base (math_font_base+48) + /*table of 256 command codes (the ``catcodes'')*/ +@d lc_code_base (cat_code_base+256) /*table of 256 lowercase mappings*/ +@d uc_code_base (lc_code_base+256) /*table of 256 uppercase mappings*/ +@d sf_code_base (uc_code_base+256) /*table of 256 spacefactor mappings*/ +@d math_code_base (sf_code_base+256) /*table of 256 math mode mappings*/ +@d int_base (math_code_base+256) /*beginning of region 5*/ +@# +@d par_shape_ptr equiv(par_shape_loc) +@d output_routine equiv(output_routine_loc) +@d every_par equiv(every_par_loc) +@d every_math equiv(every_math_loc) +@d every_display equiv(every_display_loc) +@d every_hbox equiv(every_hbox_loc) +@d every_vbox equiv(every_vbox_loc) +@d every_job equiv(every_job_loc) +@d every_cr equiv(every_cr_loc) +@d err_help equiv(err_help_loc) +@d toks(X) equiv(toks_base+X) +@d box(A) equiv(box_base+A) +@d cur_font equiv(cur_font_loc) +@d fam_fnt(A) equiv(math_font_base+A) +@d cat_code(A) equiv(cat_code_base+A) +@d lc_code(A) equiv(lc_code_base+A) +@d uc_code(A) equiv(uc_code_base+A) +@d sf_code(A) equiv(sf_code_base+A) +@d math_code(A) equiv(math_code_base+A) + /*Note: |math_code(c)| is the true math code plus |min_halfword|*/ + +@= +primitive("output", assign_toks, output_routine_loc); +@!@:output\_}{\.{\\output} primitive@> +primitive("everypar", assign_toks, every_par_loc); +@!@:every\_par\_}{\.{\\everypar} primitive@> +primitive("everymath", assign_toks, every_math_loc); +@!@:every\_math\_}{\.{\\everymath} primitive@> +primitive("everydisplay", assign_toks, every_display_loc); +@!@:every\_display\_}{\.{\\everydisplay} primitive@> +primitive("everyhbox", assign_toks, every_hbox_loc); +@!@:every\_hbox\_}{\.{\\everyhbox} primitive@> +primitive("everyvbox", assign_toks, every_vbox_loc); +@!@:every\_vbox\_}{\.{\\everyvbox} primitive@> +primitive("everyjob", assign_toks, every_job_loc); +@!@:every\_job\_}{\.{\\everyjob} primitive@> +primitive("everycr", assign_toks, every_cr_loc); +@!@:every\_cr\_}{\.{\\everycr} primitive@> +primitive("errhelp", assign_toks, err_help_loc); +@!@:err\_help\_}{\.{\\errhelp} primitive@> + +@ @= +case assign_toks: if (chr_code >= toks_base) + {@+print_esc("toks");print_int(chr_code-toks_base); + } +else switch (chr_code) { + case output_routine_loc: print_esc("output");@+break; + case every_par_loc: print_esc("everypar");@+break; + case every_math_loc: print_esc("everymath");@+break; + case every_display_loc: print_esc("everydisplay");@+break; + case every_hbox_loc: print_esc("everyhbox");@+break; + case every_vbox_loc: print_esc("everyvbox");@+break; + case every_job_loc: print_esc("everyjob");@+break; + case every_cr_loc: print_esc("everycr");@+break; + @/@@/ + default:print_esc("errhelp"); + } @+break; + +@ We initialize most things to null or undefined values. An undefined font +is represented by the internal code |font_base|. + +However, the character code tables are given initial values based on the +conventional interpretation of ASCII code. These initial values should +not be changed when \TeX\ is adapted for use with non-English languages; +all changes to the initialization conventions should be made in format +packages, not in \TeX\ itself, so that global interchange of formats is +possible. + +@d null_font font_base +@d var_code 070000 /*math code meaning ``use the current family''*/ + +@= +par_shape_ptr=null;eq_type(par_shape_loc)=shape_ref; +eq_level(par_shape_loc)=level_one;@/ +for (k=etex_pen_base; k<=etex_pens-1; k++) + eqtb[k]=eqtb[par_shape_loc]; +for (k=output_routine_loc; k<=toks_base+255; k++) + eqtb[k]=eqtb[undefined_control_sequence]; +box(0)=null;eq_type(box_base)=box_ref;eq_level(box_base)=level_one; +for (k=box_base+1; k<=box_base+255; k++) eqtb[k]=eqtb[box_base]; +cur_font=null_font;eq_type(cur_font_loc)=data; +eq_level(cur_font_loc)=level_one;@/ +for (k=math_font_base; k<=math_font_base+47; k++) eqtb[k]=eqtb[cur_font_loc]; +equiv(cat_code_base)=0;eq_type(cat_code_base)=data; +eq_level(cat_code_base)=level_one;@/ +for (k=cat_code_base+1; k<=int_base-1; k++) eqtb[k]=eqtb[cat_code_base]; +for (k=0; k<=255; k++) + {@+cat_code(k)=other_char;math_code(k)=hi(k);sf_code(k)=1000; + } +cat_code(carriage_return)=car_ret;cat_code(' ')=spacer; +cat_code('\\')=escape;cat_code('%')=comment; +cat_code(invalid_code)=invalid_char;cat_code(null_code)=ignore; +for (k='0'; k<='9'; k++) math_code(k)=hi(k+var_code); +for (k='A'; k<='Z'; k++) + {@+cat_code(k)=letter;cat_code(k+'a'-'A')=letter;@/ + math_code(k)=hi(k+var_code+0x100); + math_code(k+'a'-'A')=hi(k+'a'-'A'+var_code+0x100);@/ + lc_code(k)=k+'a'-'A';lc_code(k+'a'-'A')=k+'a'-'A';@/ + uc_code(k)=k;uc_code(k+'a'-'A')=k;@/ + sf_code(k)=999; + } + +@ @= +if ((n==par_shape_loc)||((n >= etex_pen_base)&&(n < etex_pens))) + {@+print_cmd_chr(set_shape, n);print_char('='); + if (equiv(n)==null) print_char('0'); + else if (n > par_shape_loc) + {@+print_int(penalty(equiv(n)));print_char(' '); + print_int(penalty(equiv(n)+1)); + if (penalty(equiv(n)) > 1) print_esc("ETC."); + } + else print_int(info(par_shape_ptr)); + } +else if (n < toks_base) + {@+print_cmd_chr(assign_toks, n);print_char('='); + if (equiv(n)!=null) show_token_list(link(equiv(n)), null, 32); + } +else if (n < box_base) + {@+print_esc("toks");print_int(n-toks_base);print_char('='); + if (equiv(n)!=null) show_token_list(link(equiv(n)), null, 32); + } +else if (n < cur_font_loc) + {@+print_esc("box");print_int(n-box_base);print_char('='); + if (equiv(n)==null) print("void"); + else{@+depth_threshold=0;breadth_max=1;show_node_list(equiv(n)); + } + } +else if (n < cat_code_base) @@; +else@@; + +@ @= +{@+if (n==cur_font_loc) print("current font"); +else if (n < math_font_base+16) + {@+print_esc("textfont");print_int(n-math_font_base); + } +else if (n < math_font_base+32) + {@+print_esc("scriptfont");print_int(n-math_font_base-16); + } +else{@+print_esc("scriptscriptfont");print_int(n-math_font_base-32); + } +print_char('=');@/ +printn_esc(hash[font_id_base+equiv(n)].rh); + /*that's |font_id_text(equiv(n))|*/ +} + +@ @= +if (n < math_code_base) + {@+if (n < lc_code_base) + {@+print_esc("catcode");print_int(n-cat_code_base); + } + else if (n < uc_code_base) + {@+print_esc("lccode");print_int(n-lc_code_base); + } + else if (n < sf_code_base) + {@+print_esc("uccode");print_int(n-uc_code_base); + } + else{@+print_esc("sfcode");print_int(n-sf_code_base); + } + print_char('=');print_int(equiv(n)); + } +else{@+print_esc("mathcode");print_int(n-math_code_base); + print_char('=');print_int(ho(equiv(n))); + } + +@ Region 5 of |eqtb| contains the integer parameters and registers defined +here, as well as the |del_code| table. The latter table differs from the +|cat_code dotdot math_code| tables that precede it, since delimiter codes are +fullword integers while the other kinds of codes occupy at most a +halfword. This is what makes region~5 different from region~4. We will +store the |eq_level| information in an auxiliary array of quarterwords +that will be defined later. + +@d pretolerance_code 0 /*badness tolerance before hyphenation*/ +@d tolerance_code 1 /*badness tolerance after hyphenation*/ +@d line_penalty_code 2 /*added to the badness of every line*/ +@d hyphen_penalty_code 3 /*penalty for break after discretionary hyphen*/ +@d ex_hyphen_penalty_code 4 /*penalty for break after explicit hyphen*/ +@d club_penalty_code 5 /*penalty for creating a club line*/ +@d widow_penalty_code 6 /*penalty for creating a widow line*/ +@d display_widow_penalty_code 7 /*ditto, just before a display*/ +@d broken_penalty_code 8 /*penalty for breaking a page at a broken line*/ +@d bin_op_penalty_code 9 /*penalty for breaking after a binary operation*/ +@d rel_penalty_code 10 /*penalty for breaking after a relation*/ +@d pre_display_penalty_code 11 + /*penalty for breaking just before a displayed formula*/ +@d post_display_penalty_code 12 + /*penalty for breaking just after a displayed formula*/ +@d inter_line_penalty_code 13 /*additional penalty between lines*/ +@d double_hyphen_demerits_code 14 /*demerits for double hyphen break*/ +@d final_hyphen_demerits_code 15 /*demerits for final hyphen break*/ +@d adj_demerits_code 16 /*demerits for adjacent incompatible lines*/ +@d mag_code 17 /*magnification ratio*/ +@d delimiter_factor_code 18 /*ratio for variable-size delimiters*/ +@d looseness_code 19 /*change in number of lines for a paragraph*/ +@d time_code 20 /*current time of day*/ +@d day_code 21 /*current day of the month*/ +@d month_code 22 /*current month of the year*/ +@d year_code 23 /*current year of our Lord*/ +@d show_box_breadth_code 24 /*nodes per level in |show_box|*/ +@d show_box_depth_code 25 /*maximum level in |show_box|*/ +@d hbadness_code 26 /*hboxes exceeding this badness will be shown by |hpack|*/ +@d vbadness_code 27 /*vboxes exceeding this badness will be shown by |vpack|*/ +@d pausing_code 28 /*pause after each line is read from a file*/ +@d tracing_online_code 29 /*show diagnostic output on terminal*/ +@d tracing_macros_code 30 /*show macros as they are being expanded*/ +@d tracing_stats_code 31 /*show memory usage if \TeX\ knows it*/ +@d tracing_paragraphs_code 32 /*show line-break calculations*/ +@d tracing_pages_code 33 /*show page-break calculations*/ +@d tracing_output_code 34 /*show boxes when they are shipped out*/ +@d tracing_lost_chars_code 35 /*show characters that aren't in the font*/ +@d tracing_commands_code 36 /*show command codes at |big_switch|*/ +@d tracing_restores_code 37 /*show equivalents when they are restored*/ +@d uc_hyph_code 38 /*hyphenate words beginning with a capital letter*/ +@d output_penalty_code 39 /*penalty found at current page break*/ +@d max_dead_cycles_code 40 /*bound on consecutive dead cycles of output*/ +@d hang_after_code 41 /*hanging indentation changes after this many lines*/ +@d floating_penalty_code 42 /*penalty for insertions held over after a split*/ +@d global_defs_code 43 /*override \.{\\global} specifications*/ +@d cur_fam_code 44 /*current family*/ +@d escape_char_code 45 /*escape character for token output*/ +@d default_hyphen_char_code 46 /*value of \.{\\hyphenchar} when a font is loaded*/ +@d default_skew_char_code 47 /*value of \.{\\skewchar} when a font is loaded*/ +@d end_line_char_code 48 /*character placed at the right end of the buffer*/ +@d new_line_char_code 49 /*character that prints as |print_ln|*/ +@d language_code 50 /*current hyphenation table*/ +@d left_hyphen_min_code 51 /*minimum left hyphenation fragment size*/ +@d right_hyphen_min_code 52 /*minimum right hyphenation fragment size*/ +@d holding_inserts_code 53 /*do not remove insertion nodes from \.{\\box255}*/ +@d error_context_lines_code 54 /*maximum intermediate line pairs shown*/ +@d tex_int_pars 55 /*total number of \TeX's integer parameters*/ +@# +@d etex_int_base tex_int_pars /*base for \eTeX's integer parameters*/ +@d tracing_assigns_code etex_int_base /*show assignments*/ +@d tracing_groups_code (etex_int_base+1) /*show save/restore groups*/ +@d tracing_ifs_code (etex_int_base+2) /*show conditionals*/ +@d tracing_scan_tokens_code (etex_int_base+3) /*show pseudo file open and close*/ +@d tracing_nesting_code (etex_int_base+4) /*show incomplete groups and ifs within files*/ +@d saving_vdiscards_code (etex_int_base+5) /*save items discarded from vlists*/ +@d expand_depth_code (etex_int_base+6) /*maximum depth for expansion---\eTeX*/ +@d eTeX_state_code (etex_int_base+7) /*\eTeX\ state variables*/ +@d etex_int_pars (eTeX_state_code+eTeX_states) /*total number of \eTeX's integer parameters*/ +@# +@d int_pars etex_int_pars /*total number of integer parameters*/ +@d count_base (int_base+int_pars) /*256 user \.{\\count} registers*/ +@d del_code_base (count_base+256) /*256 delimiter code mappings*/ +@d dimen_base (del_code_base+256) /*beginning of region 6*/ +@# +@d del_code(A) eqtb[del_code_base+A].i +@d count(A) eqtb[count_base+A].i +@d int_par(A) eqtb[int_base+A].i /*an integer parameter*/ +@d pretolerance int_par(pretolerance_code) +@d tolerance int_par(tolerance_code) +@d line_penalty int_par(line_penalty_code) +@d hyphen_penalty int_par(hyphen_penalty_code) +@d ex_hyphen_penalty int_par(ex_hyphen_penalty_code) +@d club_penalty int_par(club_penalty_code) +@d widow_penalty int_par(widow_penalty_code) +@d display_widow_penalty int_par(display_widow_penalty_code) +@d broken_penalty int_par(broken_penalty_code) +@d bin_op_penalty int_par(bin_op_penalty_code) +@d rel_penalty int_par(rel_penalty_code) +@d pre_display_penalty int_par(pre_display_penalty_code) +@d post_display_penalty int_par(post_display_penalty_code) +@d inter_line_penalty int_par(inter_line_penalty_code) +@d double_hyphen_demerits int_par(double_hyphen_demerits_code) +@d final_hyphen_demerits int_par(final_hyphen_demerits_code) +@d adj_demerits int_par(adj_demerits_code) +@d mag int_par(mag_code) +@d delimiter_factor int_par(delimiter_factor_code) +@d looseness int_par(looseness_code) +@d time int_par(time_code) +@d day int_par(day_code) +@d month int_par(month_code) +@d year int_par(year_code) +@d show_box_breadth int_par(show_box_breadth_code) +@d show_box_depth int_par(show_box_depth_code) +@d hbadness int_par(hbadness_code) +@d vbadness int_par(vbadness_code) +@d pausing int_par(pausing_code) +@d tracing_online int_par(tracing_online_code) +@d tracing_macros int_par(tracing_macros_code) +@d tracing_stats int_par(tracing_stats_code) +@d tracing_paragraphs int_par(tracing_paragraphs_code) +@d tracing_pages int_par(tracing_pages_code) +@d tracing_output int_par(tracing_output_code) +@d tracing_lost_chars int_par(tracing_lost_chars_code) +@d tracing_commands int_par(tracing_commands_code) +@d tracing_restores int_par(tracing_restores_code) +@d uc_hyph int_par(uc_hyph_code) +@d output_penalty int_par(output_penalty_code) +@d max_dead_cycles int_par(max_dead_cycles_code) +@d hang_after int_par(hang_after_code) +@d floating_penalty int_par(floating_penalty_code) +@d global_defs int_par(global_defs_code) +@d cur_fam int_par(cur_fam_code) +@d escape_char int_par(escape_char_code) +@d default_hyphen_char int_par(default_hyphen_char_code) +@d default_skew_char int_par(default_skew_char_code) +@d end_line_char int_par(end_line_char_code) +@d new_line_char int_par(new_line_char_code) +@d language int_par(language_code) +@d left_hyphen_min int_par(left_hyphen_min_code) +@d right_hyphen_min int_par(right_hyphen_min_code) +@d holding_inserts int_par(holding_inserts_code) +@d error_context_lines int_par(error_context_lines_code) +@# +@d tracing_assigns int_par(tracing_assigns_code) +@d tracing_groups int_par(tracing_groups_code) +@d tracing_ifs int_par(tracing_ifs_code) +@d tracing_scan_tokens int_par(tracing_scan_tokens_code) +@d tracing_nesting int_par(tracing_nesting_code) +@d expand_depth int_par(expand_depth_code) +@d saving_vdiscards int_par(saving_vdiscards_code) + +@= +depth_threshold=show_box_depth; +breadth_max=show_box_breadth + +@ We can print the symbolic name of an integer parameter as follows. + +@p static void print_param(int @!n) +{@+switch (n) { +case pretolerance_code: print_esc("pretolerance");@+break; +case tolerance_code: print_esc("tolerance");@+break; +case line_penalty_code: print_esc("linepenalty");@+break; +case hyphen_penalty_code: print_esc("hyphenpenalty");@+break; +case ex_hyphen_penalty_code: print_esc("exhyphenpenalty");@+break; +case club_penalty_code: print_esc("clubpenalty");@+break; +case widow_penalty_code: print_esc("widowpenalty");@+break; +case display_widow_penalty_code: print_esc("displaywidowpenalty");@+break; +case broken_penalty_code: print_esc("brokenpenalty");@+break; +case bin_op_penalty_code: print_esc("binoppenalty");@+break; +case rel_penalty_code: print_esc("relpenalty");@+break; +case pre_display_penalty_code: print_esc("predisplaypenalty");@+break; +case post_display_penalty_code: print_esc("postdisplaypenalty");@+break; +case inter_line_penalty_code: print_esc("interlinepenalty");@+break; +case double_hyphen_demerits_code: print_esc("doublehyphendemerits");@+break; +case final_hyphen_demerits_code: print_esc("finalhyphendemerits");@+break; +case adj_demerits_code: print_esc("adjdemerits");@+break; +case mag_code: print_esc("mag");@+break; +case delimiter_factor_code: print_esc("delimiterfactor");@+break; +case looseness_code: print_esc("looseness");@+break; +case time_code: print_esc("time");@+break; +case day_code: print_esc("day");@+break; +case month_code: print_esc("month");@+break; +case year_code: print_esc("year");@+break; +case show_box_breadth_code: print_esc("showboxbreadth");@+break; +case show_box_depth_code: print_esc("showboxdepth");@+break; +case hbadness_code: print_esc("hbadness");@+break; +case vbadness_code: print_esc("vbadness");@+break; +case pausing_code: print_esc("pausing");@+break; +case tracing_online_code: print_esc("tracingonline");@+break; +case tracing_macros_code: print_esc("tracingmacros");@+break; +case tracing_stats_code: print_esc("tracingstats");@+break; +case tracing_paragraphs_code: print_esc("tracingparagraphs");@+break; +case tracing_pages_code: print_esc("tracingpages");@+break; +case tracing_output_code: print_esc("tracingoutput");@+break; +case tracing_lost_chars_code: print_esc("tracinglostchars");@+break; +case tracing_commands_code: print_esc("tracingcommands");@+break; +case tracing_restores_code: print_esc("tracingrestores");@+break; +case uc_hyph_code: print_esc("uchyph");@+break; +case output_penalty_code: print_esc("outputpenalty");@+break; +case max_dead_cycles_code: print_esc("maxdeadcycles");@+break; +case hang_after_code: print_esc("hangafter");@+break; +case floating_penalty_code: print_esc("floatingpenalty");@+break; +case global_defs_code: print_esc("globaldefs");@+break; +case cur_fam_code: print_esc("fam");@+break; +case escape_char_code: print_esc("escapechar");@+break; +case default_hyphen_char_code: print_esc("defaulthyphenchar");@+break; +case default_skew_char_code: print_esc("defaultskewchar");@+break; +case end_line_char_code: print_esc("endlinechar");@+break; +case new_line_char_code: print_esc("newlinechar");@+break; +case language_code: print_esc("language");@+break; +case left_hyphen_min_code: print_esc("lefthyphenmin");@+break; +case right_hyphen_min_code: print_esc("righthyphenmin");@+break; +case holding_inserts_code: print_esc("holdinginserts");@+break; +case error_context_lines_code: print_esc("errorcontextlines");@+break; +@/@@/ +default:print("[unknown integer parameter!]"); +} +} + +@ The integer parameter names must be entered into the hash table. + +@= +primitive("pretolerance", assign_int, int_base+pretolerance_code);@/ +@!@:pretolerance\_}{\.{\\pretolerance} primitive@> +primitive("tolerance", assign_int, int_base+tolerance_code);@/ +@!@:tolerance\_}{\.{\\tolerance} primitive@> +primitive("linepenalty", assign_int, int_base+line_penalty_code);@/ +@!@:line\_penalty\_}{\.{\\linepenalty} primitive@> +primitive("hyphenpenalty", assign_int, int_base+hyphen_penalty_code);@/ +@!@:hyphen\_penalty\_}{\.{\\hyphenpenalty} primitive@> +primitive("exhyphenpenalty", assign_int, int_base+ex_hyphen_penalty_code);@/ +@!@:ex\_hyphen\_penalty\_}{\.{\\exhyphenpenalty} primitive@> +primitive("clubpenalty", assign_int, int_base+club_penalty_code);@/ +@!@:club\_penalty\_}{\.{\\clubpenalty} primitive@> +primitive("widowpenalty", assign_int, int_base+widow_penalty_code);@/ +@!@:widow\_penalty\_}{\.{\\widowpenalty} primitive@> +primitive("displaywidowpenalty", + assign_int, int_base+display_widow_penalty_code);@/ +@!@:display\_widow\_penalty\_}{\.{\\displaywidowpenalty} primitive@> +primitive("brokenpenalty", assign_int, int_base+broken_penalty_code);@/ +@!@:broken\_penalty\_}{\.{\\brokenpenalty} primitive@> +primitive("binoppenalty", assign_int, int_base+bin_op_penalty_code);@/ +@!@:bin\_op\_penalty\_}{\.{\\binoppenalty} primitive@> +primitive("relpenalty", assign_int, int_base+rel_penalty_code);@/ +@!@:rel\_penalty\_}{\.{\\relpenalty} primitive@> +primitive("predisplaypenalty", assign_int, int_base+pre_display_penalty_code);@/ +@!@:pre\_display\_penalty\_}{\.{\\predisplaypenalty} primitive@> +primitive("postdisplaypenalty", assign_int, int_base+post_display_penalty_code);@/ +@!@:post\_display\_penalty\_}{\.{\\postdisplaypenalty} primitive@> +primitive("interlinepenalty", assign_int, int_base+inter_line_penalty_code);@/ +@!@:inter\_line\_penalty\_}{\.{\\interlinepenalty} primitive@> +primitive("doublehyphendemerits", + assign_int, int_base+double_hyphen_demerits_code);@/ +@!@:double\_hyphen\_demerits\_}{\.{\\doublehyphendemerits} primitive@> +primitive("finalhyphendemerits", + assign_int, int_base+final_hyphen_demerits_code);@/ +@!@:final\_hyphen\_demerits\_}{\.{\\finalhyphendemerits} primitive@> +primitive("adjdemerits", assign_int, int_base+adj_demerits_code);@/ +@!@:adj\_demerits\_}{\.{\\adjdemerits} primitive@> +primitive("mag", assign_int, int_base+mag_code);@/ +@!@:mag\_}{\.{\\mag} primitive@> +primitive("delimiterfactor", assign_int, int_base+delimiter_factor_code);@/ +@!@:delimiter\_factor\_}{\.{\\delimiterfactor} primitive@> +primitive("looseness", assign_int, int_base+looseness_code);@/ +@!@:looseness\_}{\.{\\looseness} primitive@> +primitive("time", assign_int, int_base+time_code);@/ +@!@:time\_}{\.{\\time} primitive@> +primitive("day", assign_int, int_base+day_code);@/ +@!@:day\_}{\.{\\day} primitive@> +primitive("month", assign_int, int_base+month_code);@/ +@!@:month\_}{\.{\\month} primitive@> +primitive("year", assign_int, int_base+year_code);@/ +@!@:year\_}{\.{\\year} primitive@> +primitive("showboxbreadth", assign_int, int_base+show_box_breadth_code);@/ +@!@:show\_box\_breadth\_}{\.{\\showboxbreadth} primitive@> +primitive("showboxdepth", assign_int, int_base+show_box_depth_code);@/ +@!@:show\_box\_depth\_}{\.{\\showboxdepth} primitive@> +primitive("hbadness", assign_int, int_base+hbadness_code);@/ +@!@:hbadness\_}{\.{\\hbadness} primitive@> +primitive("vbadness", assign_int, int_base+vbadness_code);@/ +@!@:vbadness\_}{\.{\\vbadness} primitive@> +primitive("pausing", assign_int, int_base+pausing_code);@/ +@!@:pausing\_}{\.{\\pausing} primitive@> +primitive("tracingonline", assign_int, int_base+tracing_online_code);@/ +@!@:tracing\_online\_}{\.{\\tracingonline} primitive@> +primitive("tracingmacros", assign_int, int_base+tracing_macros_code);@/ +@!@:tracing\_macros\_}{\.{\\tracingmacros} primitive@> +primitive("tracingstats", assign_int, int_base+tracing_stats_code);@/ +@!@:tracing\_stats\_}{\.{\\tracingstats} primitive@> +primitive("tracingparagraphs", assign_int, int_base+tracing_paragraphs_code);@/ +@!@:tracing\_paragraphs\_}{\.{\\tracingparagraphs} primitive@> +primitive("tracingpages", assign_int, int_base+tracing_pages_code);@/ +@!@:tracing\_pages\_}{\.{\\tracingpages} primitive@> +primitive("tracingoutput", assign_int, int_base+tracing_output_code);@/ +@!@:tracing\_output\_}{\.{\\tracingoutput} primitive@> +primitive("tracinglostchars", assign_int, int_base+tracing_lost_chars_code);@/ +@!@:tracing\_lost\_chars\_}{\.{\\tracinglostchars} primitive@> +primitive("tracingcommands", assign_int, int_base+tracing_commands_code);@/ +@!@:tracing\_commands\_}{\.{\\tracingcommands} primitive@> +primitive("tracingrestores", assign_int, int_base+tracing_restores_code);@/ +@!@:tracing\_restores\_}{\.{\\tracingrestores} primitive@> +primitive("uchyph", assign_int, int_base+uc_hyph_code);@/ +@!@:uc\_hyph\_}{\.{\\uchyph} primitive@> +primitive("outputpenalty", assign_int, int_base+output_penalty_code);@/ +@!@:output\_penalty\_}{\.{\\outputpenalty} primitive@> +primitive("maxdeadcycles", assign_int, int_base+max_dead_cycles_code);@/ +@!@:max\_dead\_cycles\_}{\.{\\maxdeadcycles} primitive@> +primitive("hangafter", assign_int, int_base+hang_after_code);@/ +@!@:hang\_after\_}{\.{\\hangafter} primitive@> +primitive("floatingpenalty", assign_int, int_base+floating_penalty_code);@/ +@!@:floating\_penalty\_}{\.{\\floatingpenalty} primitive@> +primitive("globaldefs", assign_int, int_base+global_defs_code);@/ +@!@:global\_defs\_}{\.{\\globaldefs} primitive@> +primitive("fam", assign_int, int_base+cur_fam_code);@/ +@!@:fam\_}{\.{\\fam} primitive@> +primitive("escapechar", assign_int, int_base+escape_char_code);@/ +@!@:escape\_char\_}{\.{\\escapechar} primitive@> +primitive("defaulthyphenchar", assign_int, int_base+default_hyphen_char_code);@/ +@!@:default\_hyphen\_char\_}{\.{\\defaulthyphenchar} primitive@> +primitive("defaultskewchar", assign_int, int_base+default_skew_char_code);@/ +@!@:default\_skew\_char\_}{\.{\\defaultskewchar} primitive@> +primitive("endlinechar", assign_int, int_base+end_line_char_code);@/ +@!@:end\_line\_char\_}{\.{\\endlinechar} primitive@> +primitive("newlinechar", assign_int, int_base+new_line_char_code);@/ +@!@:new\_line\_char\_}{\.{\\newlinechar} primitive@> +primitive("language", assign_int, int_base+language_code);@/ +@!@:language\_}{\.{\\language} primitive@> +primitive("lefthyphenmin", assign_int, int_base+left_hyphen_min_code);@/ +@!@:left\_hyphen\_min\_}{\.{\\lefthyphenmin} primitive@> +primitive("righthyphenmin", assign_int, int_base+right_hyphen_min_code);@/ +@!@:right\_hyphen\_min\_}{\.{\\righthyphenmin} primitive@> +primitive("holdinginserts", assign_int, int_base+holding_inserts_code);@/ +@!@:holding\_inserts\_}{\.{\\holdinginserts} primitive@> +primitive("errorcontextlines", assign_int, int_base+error_context_lines_code);@/ +@!@:error\_context\_lines\_}{\.{\\errorcontextlines} primitive@> + +@ @= +case assign_int: if (chr_code < count_base) print_param(chr_code-int_base); + else{@+print_esc("count");print_int(chr_code-count_base); + } @+break; + +@ The integer parameters should really be initialized by a macro package; +the following initialization does the minimum to keep \TeX\ from +complete failure. +@^null delimiter@> + +@= +for (k=int_base; k<=del_code_base-1; k++) eqtb[k].i=0; +mag=1000;tolerance=10000;hang_after=1;max_dead_cycles=25; +escape_char='\\';end_line_char=carriage_return; +for (k=0; k<=255; k++) del_code(k)=-1; +del_code('.')=0; /*this null delimiter is used in error recovery*/ + +@ The following procedure, which is called just before \TeX\ initializes its +input and output, establishes the initial values of the date and time. +This does include too, for system integrators, the creation date and +the reference moment for the timer---\Prote\ extensions. If the system +supports environment variables, if |FORCE_SOURCE_DATE| is set to $1$ and +|SOURCE_DATE_EPOCH| is set, the date related values: year, month, day +and time, including creation date, will be taken relative from the value +defined by |SOURCE_DATE_EPOCH|. +@^creation date@> +@^reference time@> +@^system dependencies@> +k\TeX\ calls |tl_now| to obtain the current time (UTC) as a |tm| structure. +@p static void fix_date_and_time(void) +{@+ struct tm *gmt=tl_now(); + time=sys_time= gmt->tm_hour*60+gmt->tm_min;/*minutes since midnight*/ + day=sys_day= gmt->tm_mday;/*day of the month*/ + month=sys_month=gmt->tm_mon+1;/*month of the year*/ + year=sys_year=gmt->tm_year+1900;/*Anno Domini*/ +} + +@ @= +{@+if (n < count_base) print_param(n-int_base); +else if (n < del_code_base) + {@+print_esc("count");print_int(n-count_base); + } +else{@+print_esc("delcode");print_int(n-del_code_base); + } +print_char('=');print_int(eqtb[n].i); +} + +@ @=c=escape_char + +@ @=s==new_line_char + +@ \TeX\ is occasionally supposed to print diagnostic information that +goes only into the transcript file, unless |tracing_online| is positive. +Here are two routines that adjust the destination of print commands: + +@p static void begin_diagnostic(void) /*prepare to do some tracing*/ +{@+old_setting=selector; +if ((tracing_online <= 0)&&(selector==term_and_log)) + {@+decr(selector); + if (history==spotless) history=warning_issued; + } +} +@# +static void end_diagnostic(bool @!blank_line) + /*restore proper conditions after tracing*/ +{@+print_nl(""); +if (blank_line) print_ln(); +selector=old_setting; +} + +@ Of course we had better declare a few more global variables, if the previous +routines are going to work. + +@= +static int @!old_setting; +static int @!sys_time, @!sys_day, @!sys_month, @!sys_year; + /*date and time supplied by external system*/ + +@ The final region of |eqtb| contains the dimension parameters defined +here, and the 256 \.{\\dimen} registers. + +@d par_indent_code 0 /*indentation of paragraphs*/ +@d math_surround_code 1 /*space around math in text*/ +@d line_skip_limit_code 2 /*threshold for |line_skip| instead of |baseline_skip|*/ +@d hsize_code 3 /*line width in horizontal mode*/ +@d vsize_code 4 /*page height in vertical mode*/ +@d max_depth_code 5 /*maximum depth of boxes on main pages*/ +@d split_max_depth_code 6 /*maximum depth of boxes on split pages*/ +@d box_max_depth_code 7 /*maximum depth of explicit vboxes*/ +@d hfuzz_code 8 /*tolerance for overfull hbox messages*/ +@d vfuzz_code 9 /*tolerance for overfull vbox messages*/ +@d delimiter_shortfall_code 10 /*maximum amount uncovered by variable delimiters*/ +@d null_delimiter_space_code 11 /*blank space in null delimiters*/ +@d script_space_code 12 /*extra space after subscript or superscript*/ +@d pre_display_size_code 13 /*length of text preceding a display*/ +@d display_width_code 14 /*length of line for displayed equation*/ +@d display_indent_code 15 /*indentation of line for displayed equation*/ +@d overfull_rule_code 16 /*width of rule that identifies overfull hboxes*/ +@d hang_indent_code 17 /*amount of hanging indentation*/ +@d h_offset_code 18 /*amount of horizontal offset when shipping pages out*/ +@d v_offset_code 19 /*amount of vertical offset when shipping pages out*/ +@d emergency_stretch_code 20 /*reduces badnesses on final pass of line-breaking*/ +@d page_width_code 21 /*current paper page width*/ +@d page_height_code 22 /*current paper page height*/ +@d dimen_pars 23 /*total number of dimension parameters*/ +@d scaled_base (dimen_base+dimen_pars) + /*table of 256 user-defined \.{\\dimen} registers*/ +@d eqtb_size (scaled_base+255) /*largest subscript of |eqtb|*/ +@# +@d dimen(A) eqtb[scaled_base+A].sc +@d dimen_par(A) eqtb[dimen_base+A].sc /*a scaled quantity*/ +@d dimen_hfactor(A) hfactor_eqtb[scaled_base+A].sc +@d dimen_vfactor(A) vfactor_eqtb[scaled_base+A].sc +@d dimen_par_hfactor(A) hfactor_eqtb[dimen_base+A].sc +@d dimen_par_vfactor(A) vfactor_eqtb[dimen_base+A].sc +@d par_indent dimen_par(par_indent_code) +@d math_surround dimen_par(math_surround_code) +@d line_skip_limit dimen_par(line_skip_limit_code) +@d hsize dimen_par(hsize_code) +@d vsize dimen_par(vsize_code) +@d max_depth dimen_par(max_depth_code) +@d split_max_depth dimen_par(split_max_depth_code) +@d box_max_depth dimen_par(box_max_depth_code) +@d hfuzz dimen_par(hfuzz_code) +@d vfuzz dimen_par(vfuzz_code) +@d delimiter_shortfall dimen_par(delimiter_shortfall_code) +@d null_delimiter_space dimen_par(null_delimiter_space_code) +@d script_space dimen_par(script_space_code) +@d pre_display_size dimen_par(pre_display_size_code) +@d display_width dimen_par(display_width_code) +@d display_indent dimen_par(display_indent_code) +@d overfull_rule dimen_par(overfull_rule_code) +@d hang_indent dimen_par(hang_indent_code) +@d h_offset dimen_par(h_offset_code) +@d v_offset dimen_par(v_offset_code) +@d emergency_stretch dimen_par(emergency_stretch_code) +@d page_height dimen_par(page_height_code) + +@p static void print_length_param(int @!n) +{@+switch (n) { +case par_indent_code: print_esc("parindent");@+break; +case math_surround_code: print_esc("mathsurround");@+break; +case line_skip_limit_code: print_esc("lineskiplimit");@+break; +case hsize_code: print_esc("hsize");@+break; +case vsize_code: print_esc("vsize");@+break; +case max_depth_code: print_esc("maxdepth");@+break; +case split_max_depth_code: print_esc("splitmaxdepth");@+break; +case box_max_depth_code: print_esc("boxmaxdepth");@+break; +case hfuzz_code: print_esc("hfuzz");@+break; +case vfuzz_code: print_esc("vfuzz");@+break; +case delimiter_shortfall_code: print_esc("delimitershortfall");@+break; +case null_delimiter_space_code: print_esc("nulldelimiterspace");@+break; +case script_space_code: print_esc("scriptspace");@+break; +case pre_display_size_code: print_esc("predisplaysize");@+break; +case display_width_code: print_esc("displaywidth");@+break; +case display_indent_code: print_esc("displayindent");@+break; +case overfull_rule_code: print_esc("overfullrule");@+break; +case hang_indent_code: print_esc("hangindent");@+break; +case h_offset_code: print_esc("hoffset");@+break; +case v_offset_code: print_esc("voffset");@+break; +case emergency_stretch_code: print_esc("emergencystretch");@+break; +case page_width_code: print_esc("pagewidth");@+break; +case page_height_code: print_esc("pageheight");@+break; +default:print("[unknown dimen parameter!]"); +} +} + +@ @= +primitive("parindent", assign_dimen, dimen_base+par_indent_code);@/ +@!@:par\_indent\_}{\.{\\parindent} primitive@> +primitive("mathsurround", assign_dimen, dimen_base+math_surround_code);@/ +@!@:math\_surround\_}{\.{\\mathsurround} primitive@> +primitive("lineskiplimit", assign_dimen, dimen_base+line_skip_limit_code);@/ +@!@:line\_skip\_limit\_}{\.{\\lineskiplimit} primitive@> +primitive("hsize", assign_dimen, dimen_base+hsize_code);@/ +@!@:hsize\_}{\.{\\hsize} primitive@> +primitive("vsize", assign_dimen, dimen_base+vsize_code);@/ +@!@:vsize\_}{\.{\\vsize} primitive@> +primitive("maxdepth", assign_dimen, dimen_base+max_depth_code);@/ +@!@:max\_depth\_}{\.{\\maxdepth} primitive@> +primitive("splitmaxdepth", assign_dimen, dimen_base+split_max_depth_code);@/ +@!@:split\_max\_depth\_}{\.{\\splitmaxdepth} primitive@> +primitive("boxmaxdepth", assign_dimen, dimen_base+box_max_depth_code);@/ +@!@:box\_max\_depth\_}{\.{\\boxmaxdepth} primitive@> +primitive("hfuzz", assign_dimen, dimen_base+hfuzz_code);@/ +@!@:hfuzz\_}{\.{\\hfuzz} primitive@> +primitive("vfuzz", assign_dimen, dimen_base+vfuzz_code);@/ +@!@:vfuzz\_}{\.{\\vfuzz} primitive@> +primitive("delimitershortfall", + assign_dimen, dimen_base+delimiter_shortfall_code);@/ +@!@:delimiter\_shortfall\_}{\.{\\delimitershortfall} primitive@> +primitive("nulldelimiterspace", + assign_dimen, dimen_base+null_delimiter_space_code);@/ +@!@:null\_delimiter\_space\_}{\.{\\nulldelimiterspace} primitive@> +primitive("scriptspace", assign_dimen, dimen_base+script_space_code);@/ +@!@:script\_space\_}{\.{\\scriptspace} primitive@> +primitive("predisplaysize", assign_dimen, dimen_base+pre_display_size_code);@/ +@!@:pre\_display\_size\_}{\.{\\predisplaysize} primitive@> +primitive("displaywidth", assign_dimen, dimen_base+display_width_code);@/ +@!@:display\_width\_}{\.{\\displaywidth} primitive@> +primitive("displayindent", assign_dimen, dimen_base+display_indent_code);@/ +@!@:display\_indent\_}{\.{\\displayindent} primitive@> +primitive("overfullrule", assign_dimen, dimen_base+overfull_rule_code);@/ +@!@:overfull\_rule\_}{\.{\\overfullrule} primitive@> +primitive("hangindent", assign_dimen, dimen_base+hang_indent_code);@/ +@!@:hang\_indent\_}{\.{\\hangindent} primitive@> +primitive("hoffset", assign_dimen, dimen_base+h_offset_code);@/ +@!@:h\_offset\_}{\.{\\hoffset} primitive@> +primitive("voffset", assign_dimen, dimen_base+v_offset_code);@/ +@!@:v\_offset\_}{\.{\\voffset} primitive@> +primitive("emergencystretch", assign_dimen, dimen_base+emergency_stretch_code);@/ +@!@:emergency\_stretch\_}{\.{\\emergencystretch} primitive@> + +@ @= +case assign_dimen: if (chr_code < scaled_base) + print_length_param(chr_code-dimen_base); + else{@+print_esc("dimen");print_int(chr_code-scaled_base); + } @+break; + +@ @= +for (k=dimen_base; k<=eqtb_size; k++) hfactor_eqtb[k].sc=vfactor_eqtb[k].sc=eqtb[k].sc=0; + +@ @= +{@+if (n < scaled_base) print_length_param(n-dimen_base); +else{@+print_esc("dimen");print_int(n-scaled_base); + } +print_char('=');print_scaled(eqtb[n].sc);print("pt"); +} + +@ Here is a procedure that displays the contents of |eqtb[n]| +symbolically. + +@p @t\4@>@@;@/ +#ifdef @!STAT +static void show_eqtb(pointer @!n) +{@+if (n < active_base) print_char('?'); /*this can't happen*/ +else if (n < glue_base) @@; +else if (n < local_base) @@; +else if (n < int_base) @@; +else if (n < dimen_base) @@; +else if (n <= eqtb_size) @@; +else print_char('?'); /*this can't happen either*/ +} +#endif + +@ The last two regions of |eqtb| have fullword values instead of the +three fields |eq_level|, |eq_type|, and |equiv|. An |eq_type| is unnecessary, +but \TeX\ needs to store the |eq_level| information in another array +called |xeq_level|. + +@= +static memory_word @!eqtb0[eqtb_size-active_base+1], *const @!eqtb = @!eqtb0-active_base; +static memory_word hfactor_eqtb0[dimen_pars+256]={{{0}}}, *const @!hfactor_eqtb = @!hfactor_eqtb0-dimen_base; +static memory_word vfactor_eqtb0[dimen_pars+256]={{{0}}}, *const @!vfactor_eqtb = @!vfactor_eqtb0-dimen_base; +static scaled par_shape_hfactor=0, par_shape_vfactor=0; +static scaled hhsize=0,hvsize=0; +static quarterword @!xeq_level0[eqtb_size-int_base+1], *const @!xeq_level = @!xeq_level0-int_base; + +@ @= +for (k=int_base; k<=eqtb_size; k++) xeq_level[k]=level_one; + +@ When the debugging routine |search_mem| is looking for pointers having a +given value, it is interested only in regions 1 to~3 of~|eqtb|, and in the +first part of region~4. + +@= +for (q=active_base; q<=box_base+255; q++) + {@+if (equiv(q)==p) + {@+print_nl("EQUIV(");print_int(q);print_char(')'); + } + } + +@* The hash table. +Control sequences are stored and retrieved by means of a fairly standard hash +table algorithm called the method of ``coalescing lists'' (cf.\ Algorithm 6.4C +in {\sl The Art of Computer Programming\/}). Once a control sequence enters the +table, it is never removed, because there are complicated situations +involving \.{\\gdef} where the removal of a control sequence at the end of +a group would be a mistake preventable only by the introduction of a +complicated reference-count mechanism. + +The actual sequence of letters forming a control sequence identifier is +stored in the |str_pool| array together with all the other strings. An +auxiliary array |hash| consists of items with two halfword fields per +word. The first of these, called |next(p)|, points to the next identifier +belonging to the same coalesced list as the identifier corresponding to~|p|; +and the other, called |text(p)|, points to the |str_start| entry for +|p|'s identifier. If position~|p| of the hash table is empty, we have +|text(p)==0|; if position |p| is either empty or the end of a coalesced +hash list, we have |next(p)==0|. An auxiliary pointer variable called +|hash_used| is maintained in such a way that all locations |p >= hash_used| +are nonempty. The global variable |cs_count| tells how many multiletter +control sequences have been defined, if statistics are being kept. + +A global boolean variable called |no_new_control_sequence| is set to +|true| during the time that new hash table entries are forbidden. + +@d next(A) hash[A].lh /*link for coalesced lists*/ +@d text(A) hash[A].rh /*string number for control sequence name*/ +@d hash_is_full (hash_used==hash_base) /*test if all positions are occupied*/ +@d font_id_text(A) text(font_id_base+A) /*a frozen font identifier's name*/ + +@= +static two_halves @!hash0[undefined_control_sequence-hash_base], *const @!hash = @!hash0-hash_base; + /*the hash table*/ +static pointer @!hash_used; /*allocation pointer for |hash|*/ +static bool @!no_new_control_sequence; /*are new identifiers legal?*/ +static int @!cs_count; /*total number of known identifiers*/ + +@ @= +no_new_control_sequence=true; /*new identifiers are usually forbidden*/ +next(hash_base)=0;text(hash_base)=0; +for (k=hash_base+1; k<=undefined_control_sequence-1; k++) hash[k]=hash[hash_base]; + +@ @= +hash_used=frozen_control_sequence; /*nothing is used*/ +cs_count=0; +eq_type(frozen_dont_expand)=dont_expand; +text(frozen_dont_expand)=s_no("notexpanded:"); +@.notexpanded:@> + +@ Here is the subroutine that searches the hash table for an identifier +that matches a given string of length |l > 1| appearing in |buffer[j dotdot +(j+l-1)]|. If the identifier is found, the corresponding hash table address +is returned. Otherwise, if the global variable |no_new_control_sequence| +is |true|, the dummy address |undefined_control_sequence| is returned. +Otherwise the identifier is inserted into the hash table and its location +is returned. + +@p static pointer id_lookup(int @!j, int @!l) /*search the hash table*/ +{@+ /*go here if you found it*/ +int h; /*hash code*/ +int @!d; /*number of characters in incomplete current string*/ +pointer @!p; /*index in |hash| array*/ +int @!k; /*index in |buffer| array*/ +@; +p=h+hash_base; /*we start searching here; note that |0 <= h < hash_prime|*/ +loop@+{@+if (text(p) > 0) if (length(text(p))==l) + if (str_eq_buf(text(p), j)) goto found; + if (next(p)==0) + {@+if (no_new_control_sequence) + p=undefined_control_sequence; + else@; + goto found; + } + p=next(p); + } +found: return p; +} + +@ @= +{@+if (text(p) > 0) + {@+@/do@+{if (hash_is_full) overflow("hash size", hash_size); +@:TeX capacity exceeded hash size}{\quad hash size@> + decr(hash_used); + }@+ while (!(text(hash_used)==0)); /*search for an empty location in |hash|*/ + next(p)=hash_used;p=hash_used; + } +str_room(l);d=cur_length; +while (pool_ptr > str_start[str_ptr]) + {@+decr(pool_ptr);str_pool[pool_ptr+l]=str_pool[pool_ptr]; + } /*move current string up to make room for another*/ +for (k=j; k<=j+l-1; k++) append_char(buffer[k]); +text(p)=make_string();pool_ptr=pool_ptr+d; +#ifdef @!STAT +incr(cs_count); +#endif +@;@/ +} + +@ The value of |hash_prime| should be roughly 85\pct! of |hash_size|, and it +should be a prime number. The theory of hashing tells us to expect fewer +than two table probes, on the average, when the search is successful. +[See J.~S. Vitter, {\sl Journal of the ACM\/ \bf30} (1983), 231--258.] +@^Vitter, Jeffrey Scott@> + +@= +h=buffer[j]; +for (k=j+1; k<=j+l-1; k++) + {@+h=h+h+buffer[k]; + while (h >= hash_prime) h=h-hash_prime; + } + +@ Single-character control sequences do not need to be looked up in a hash +table, since we can use the character code itself as a direct address. +The procedure |print_cs| prints the name of a control sequence, given +a pointer to its address in |eqtb|. A space is printed after the name +unless it is a single nonletter or an active character. This procedure +might be invoked with invalid data, so it is ``extra robust.'' The +individual characters must be printed one at a time using |print|, since +they may be unprintable. + +@= +static void print_cs(int @!p) /*prints a purported control sequence*/ +{@+if (p < hash_base) /*single character*/ + if (p >= single_base) + if (p==null_cs) + {@+print_esc("csname");print_esc("endcsname");print_char(' '); + } + else{@+printn_esc(p-single_base); + if (cat_code(p-single_base)==letter) print_char(' '); + } + else if (p < active_base) print_esc("IMPOSSIBLE."); +@.IMPOSSIBLE@> + else printn(p-active_base); +else if (p >= undefined_control_sequence) print_esc("IMPOSSIBLE."); +else if ((text(p) < 0)||(text(p) >= str_ptr)) print_esc("NONEXISTENT."); +@.NONEXISTENT@> +else{@+if (p==frozen_primitive) print_esc("primitive"); + printn_esc(text(p));print_char(' '); + } +} + +@ Here is a similar procedure; it avoids the error checks, and it never +prints a space after the control sequence. + +@= +static void sprint_cs(pointer @!p) /*prints a control sequence*/ +{@+if (p < hash_base) + if (p < single_base) printn(p-active_base); + else if (p < null_cs) printn_esc(p-single_base); + else{@+print_esc("csname");print_esc("endcsname"); + } +else printn_esc(text(p)); +} + +@ We need to put \TeX's ``primitive'' control sequences into the hash +table, together with their command code (which will be the |eq_type|) +and an operand (which will be the |equiv|). The |primitive| procedure +does this, in a way that no \TeX\ user can. The global value |cur_val| +contains the new |eqtb| pointer after |primitive| has acted. + +@p +#ifdef @!INIT +static void primitive(char *@!str, quarterword @!c, halfword @!o) +{@+str_number s=s_no(str); +int k; /*index into |str_pool|*/ +int @!j; /*index into |buffer|*/ +small_number @!l; /*length of the string*/ +pointer @!p; /*pointer in |ROM|*/ +if (s < 256) cur_val=s+single_base; +else{@+k=str_start[s];l=str_start[s+1]-k; + /*we will move |s| into the (possibly non-empty) |buffer|*/ + if (first+l > buf_size+1) + overflow("buffer size", buf_size); +@:TeX capacity exceeded buffer size}{\quad buffer size@> + for (j=0; j<=l-1; j++) buffer[first+j]=so(str_pool[k+j]); + cur_val=id_lookup(first, l); /*|no_new_control_sequence| is |false|*/ + flush_string;text(cur_val)=s; /*we don't want to have the string twice*/ + } +eq_level(cur_val)=level_one;eq_type(cur_val)=c;equiv(cur_val)=o; +@; +} +#endif + +@ Many of \TeX's primitives need no |equiv|, since they are identifiable +by their |eq_type| alone. These primitives are loaded into the hash table +as follows: + +@= +primitive(" ", ex_space, 0);@/ +@!@:Single-character primitives /}{\quad\.{\\\ }@> +primitive("/", ital_corr, 0);@/ +@!@:Single-character primitives /}{\quad\.{\\/}@> +primitive("accent", accent, 0);@/ +@!@:accent\_}{\.{\\accent} primitive@> +primitive("advance", advance, 0);@/ +@!@:advance\_}{\.{\\advance} primitive@> +primitive("afterassignment", after_assignment, 0);@/ +@!@:after\_assignment\_}{\.{\\afterassignment} primitive@> +primitive("aftergroup", after_group, 0);@/ +@!@:after\_group\_}{\.{\\aftergroup} primitive@> +primitive("begingroup", begin_group, 0);@/ +@!@:begin\_group\_}{\.{\\begingroup} primitive@> +primitive("char", char_num, 0);@/ +@!@:char\_}{\.{\\char} primitive@> +primitive("csname", cs_name, 0);@/ +@!@:cs\_name\_}{\.{\\csname} primitive@> +primitive("delimiter", delim_num, 0);@/ +@!@:delimiter\_}{\.{\\delimiter} primitive@> +primitive("divide", divide, 0);@/ +@!@:divide\_}{\.{\\divide} primitive@> +primitive("endcsname", end_cs_name, 0);@/ +@!@:end\_cs\_name\_}{\.{\\endcsname} primitive@> +primitive("endgroup", end_group, 0); +@!@:end\_group\_}{\.{\\endgroup} primitive@> +text(frozen_end_group)=text(cur_val);eqtb[frozen_end_group]=eqtb[cur_val];@/ +primitive("expandafter", expand_after, 0);@/ +@!@:expand\_after\_}{\.{\\expandafter} primitive@> +primitive("font", def_font, 0);@/ +@!@:font\_}{\.{\\font} primitive@> +primitive("fontdimen", assign_font_dimen, 0);@/ +@!@:font\_dimen\_}{\.{\\fontdimen} primitive@> +primitive("halign", halign, 0);@/ +@!@:halign\_}{\.{\\halign} primitive@> +primitive("hrule", hrule, 0);@/ +@!@:hrule\_}{\.{\\hrule} primitive@> +primitive("ignorespaces", ignore_spaces, 0);@/ +@!@:ignore\_spaces\_}{\.{\\ignorespaces} primitive@> +primitive("insert", insert, 0);@/ +@!@:insert\_}{\.{\\insert} primitive@> +primitive("mark", mark, 0);@/ +@!@:mark\_}{\.{\\mark} primitive@> +primitive("mathaccent", math_accent, 0);@/ +@!@:math\_accent\_}{\.{\\mathaccent} primitive@> +primitive("mathchar", math_char_num, 0);@/ +@!@:math\_char\_}{\.{\\mathchar} primitive@> +primitive("mathchoice", math_choice, 0);@/ +@!@:math\_choice\_}{\.{\\mathchoice} primitive@> +primitive("multiply", multiply, 0);@/ +@!@:multiply\_}{\.{\\multiply} primitive@> +primitive("noalign", no_align, 0);@/ +@!@:no\_align\_}{\.{\\noalign} primitive@> +primitive("noboundary", no_boundary, 0);@/ +@!@:no\_boundary\_}{\.{\\noboundary} primitive@> +primitive("noexpand", no_expand, 0);@/ +@!@:no\_expand\_}{\.{\\noexpand} primitive@> +primitive("nonscript", non_script, 0);@/ +@!@:non\_script\_}{\.{\\nonscript} primitive@> +primitive("omit", omit, 0);@/ +@!@:omit\_}{\.{\\omit} primitive@> +primitive("parshape", set_shape, par_shape_loc);@/ +@!@:par\_shape\_}{\.{\\parshape} primitive@> +primitive("penalty", break_penalty, 0);@/ +@!@:penalty\_}{\.{\\penalty} primitive@> +primitive("prevgraf", set_prev_graf, 0);@/ +@!@:prev\_graf\_}{\.{\\prevgraf} primitive@> +primitive("radical", radical, 0);@/ +@!@:radical\_}{\.{\\radical} primitive@> +primitive("read", read_to_cs, 0);@/ +@!@:read\_}{\.{\\read} primitive@> +primitive("relax", relax, 256); /*cf.\ |scan_file_name|*/ +@!@:relax\_}{\.{\\relax} primitive@> +text(frozen_relax)=text(cur_val);eqtb[frozen_relax]=eqtb[cur_val];@/ +primitive("setbox", set_box, 0);@/ +@!@:set\_box\_}{\.{\\setbox} primitive@> +primitive("the", the, 0);@/ +@!@:the\_}{\.{\\the} primitive@> +primitive("toks", toks_register, mem_bot);@/ +@!@:toks\_}{\.{\\toks} primitive@> +primitive("vadjust", vadjust, 0);@/ +@!@:vadjust\_}{\.{\\vadjust} primitive@> +primitive("valign", valign, 0);@/ +@!@:valign\_}{\.{\\valign} primitive@> +primitive("vcenter", vcenter, 0);@/ +@!@:vcenter\_}{\.{\\vcenter} primitive@> +primitive("vrule", vrule, 0);@/ +@!@:vrule\_}{\.{\\vrule} primitive@> + +@ Each primitive has a corresponding inverse, so that it is possible to +display the cryptic numeric contents of |eqtb| in symbolic form. +Every call of |primitive| in this program is therefore accompanied by some +straightforward code that forms part of the |print_cmd_chr| routine +below. + +@= +case accent: print_esc("accent");@+break; +case advance: print_esc("advance");@+break; +case after_assignment: print_esc("afterassignment");@+break; +case after_group: print_esc("aftergroup");@+break; +case assign_font_dimen: print_esc("fontdimen");@+break; +case begin_group: print_esc("begingroup");@+break; +case break_penalty: print_esc("penalty");@+break; +case char_num: print_esc("char");@+break; +case cs_name: print_esc("csname");@+break; +case def_font: print_esc("font");@+break; +case delim_num: print_esc("delimiter");@+break; +case divide: print_esc("divide");@+break; +case end_cs_name: print_esc("endcsname");@+break; +case end_group: print_esc("endgroup");@+break; +case ex_space: print_esc(" ");@+break; +case expand_after: switch (chr_code) { +case 0: print_esc("expandafter");@+break; +@/@@/ +} @+break; /*there are no other cases*/ +case halign: print_esc("halign");@+break; +case hrule: print_esc("hrule");@+break; +case ignore_spaces: print_esc("ignorespaces");@+break; +case insert: print_esc("insert");@+break; +case ital_corr: print_esc("/");@+break; +case mark: print_esc("mark");@+break; +case math_accent: print_esc("mathaccent");@+break; +case math_char_num: print_esc("mathchar");@+break; +case math_choice: print_esc("mathchoice");@+break; +case multiply: print_esc("multiply");@+break; +case no_align: print_esc("noalign");@+break; +case no_boundary: print_esc("noboundary");@+break; +case no_expand: print_esc("noexpand");@+break; +case non_script: print_esc("nonscript");@+break; +case omit: print_esc("omit");@+break; +case radical: print_esc("radical");@+break; +case read_to_cs: if (chr_code==0) print_esc("read") + @;@+break; +case relax: print_esc("relax");@+break; +case set_box: print_esc("setbox");@+break; +case set_prev_graf: print_esc("prevgraf");@+break; +case set_shape: switch (chr_code) { + case par_shape_loc: print_esc("parshape");@+break; + @@;@/ + } @+break; /*there are no other cases*/ +case the: if (chr_code==0) print_esc("the") + @;@+break; +case toks_register: @@;@+break; +case vadjust: print_esc("vadjust");@+break; +case valign: print_esc("valign");@+break; +case vcenter: print_esc("vcenter");@+break; +case vrule: print_esc("vrule");@+break; + +@ We will deal with the other primitives later, at some point in the program +where their |eq_type| and |equiv| values are more meaningful. For example, +the primitives for math mode will be loaded when we consider the routines +that deal with formulas. It is easy to find where each particular +primitive was treated by looking in the index at the end; for example, the +section where |"radical"| entered |eqtb| is listed under `\.{\\radical} +primitive'. (Primitives consisting of a single nonalphabetic character, +@!like `\.{\\/}', are listed under `Single-character primitives'.) +@!@^Single-character primitives@> + +Meanwhile, this is a convenient place to catch up on something we were unable +to do before the hash table was defined: + +@= +printn_esc(font_id_text(font(p))) + +@* Saving and restoring equivalents. +The nested structure provided by `$\.{\char'173}\ldots\.{\char'175}$' groups +in \TeX\ means that |eqtb| entries valid in outer groups should be saved +and restored later if they are overridden inside the braces. When a new |eqtb| +value is being assigned, the program therefore checks to see if the previous +entry belongs to an outer level. In such a case, the old value is placed +on the |save_stack| just before the new value enters |eqtb|. At the +end of a grouping level, i.e., when the right brace is sensed, the +|save_stack| is used to restore the outer values, and the inner ones are +destroyed. + +Entries on the |save_stack| are of type |memory_word|. The top item on +this stack is |save_stack[p]|, where |p==save_ptr-1|; it contains three +fields called |save_type|, |save_level|, and |save_index|, and it is +interpreted in one of five ways: + +\yskip\hangg 1) If |save_type(p)==restore_old_value|, then +|save_index(p)| is a location in |eqtb| whose current value should +be destroyed at the end of the current group and replaced by |save_stack[p-1]|. +Furthermore if |save_index(p) >= int_base|, then |save_level(p)| +should replace the corresponding entry in |xeq_level|. + +\yskip\hangg 2) If |save_type(p)==restore_zero|, then |save_index(p)| +is a location in |eqtb| whose current value should be destroyed at the end +of the current group, when it should be +replaced by the value of |eqtb[undefined_control_sequence]|. + +\yskip\hangg 3) If |save_type(p)==insert_token|, then |save_index(p)| +is a token that should be inserted into \TeX's input when the current +group ends. + +\yskip\hangg 4) If |save_type(p)==level_boundary|, then |save_level(p)| +is a code explaining what kind of group we were previously in, and +|save_index(p)| points to the level boundary word at the bottom of +the entries for that group. +Furthermore, in extended \eTeX\ mode, |save_stack[p-1]| contains the +source line number at which the current level of grouping was entered. + +\yskip\hang 5) If |save_type(p)==restore_sa|, then |sa_chain| points to a +chain of sparse array entries to be restored at the end of the current +group. Furthermore |save_index(p)| and |save_level(p)| should replace +the values of |sa_chain| and |sa_level| respectively. + +@d save_type(A) save_stack[A].hh.b0 /*classifies a |save_stack| entry*/ +@d save_level(A) save_stack[A].hh.b1 + /*saved level for regions 5 and 6, or group code*/ +@d save_index(A) save_stack[A].hh.rh + /*|eqtb| location or token or |save_stack| location*/ +@d restore_old_value 0 /*|save_type| when a value should be restored later*/ +@d restore_zero 1 /*|save_type| when an undefined entry should be restored*/ +@d insert_token 2 /*|save_type| when a token is being saved for later use*/ +@d level_boundary 3 /*|save_type| corresponding to beginning of group*/ +@d restore_sa 4 /*|save_type| when sparse array entries should be restored*/ + +@p @t\4@>@@; + +@ Here are the group codes that are used to discriminate between different +kinds of groups. They allow \TeX\ to decide what special actions, if any, +should be performed when a group ends. +\def\grp{\.{\char'173...\char'175}} + +Some groups are not supposed to be ended by right braces. For example, +the `\.\$' that begins a math formula causes a |math_shift_group| to +be started, and this should be terminated by a matching `\.\$'. Similarly, +a group that starts with \.{\\left} should end with \.{\\right}, and +one that starts with \.{\\begingroup} should end with \.{\\endgroup}. + +@d bottom_level 0 /*group code for the outside world*/ +@d simple_group 1 /*group code for local structure only*/ +@d hbox_group 2 /*code for `\.{\\hbox}\grp'*/ +@d adjusted_hbox_group 3 /*code for `\.{\\hbox}\grp' in vertical mode*/ +@d vbox_group 4 /*code for `\.{\\vbox}\grp'*/ +@d vtop_group 5 /*code for `\.{\\vtop}\grp'*/ +@d align_group 6 /*code for `\.{\\halign}\grp', `\.{\\valign}\grp'*/ +@d no_align_group 7 /*code for `\.{\\noalign}\grp'*/ +@d output_group 8 /*code for output routine*/ +@d math_group 9 /*code for, e.g., `\.{\char'136}\grp'*/ +@d disc_group 10 /*code for `\.{\\discretionary}\grp\grp\grp'*/ +@d insert_group 11 /*code for `\.{\\insert}\grp', `\.{\\vadjust}\grp'*/ +@d vcenter_group 12 /*code for `\.{\\vcenter}\grp'*/ +@d math_choice_group 13 /*code for `\.{\\mathchoice}\grp\grp\grp\grp'*/ +@d semi_simple_group 14 /*code for `\.{\\begingroup...\\endgroup}'*/ +@d math_shift_group 15 /*code for `\.{\$...\$}'*/ +@d math_left_group 16 /*code for `\.{\\left...\\right}'*/ +@d page_group 17 +@d stream_group 18 +@d stream_before_group 19 +@d stream_after_group 20 +@d outline_group 21 +@d max_group_code 21 + +@= +typedef int8_t group_code; /*|save_level| for a level boundary*/ + +@ The global variable |cur_group| keeps track of what sort of group we are +currently in. Another global variable, |cur_boundary|, points to the +topmost |level_boundary| word. And |cur_level| is the current depth of +nesting. The routines are designed to preserve the condition that no entry +in the |save_stack| or in |eqtb| ever has a level greater than |cur_level|. + +@ @= +static memory_word @!save_stack[save_size+1]; +static memory_word @!save_hfactor[save_size+1]; +static memory_word @!save_vfactor[save_size+1]; +static int @!save_ptr; /*first unused entry on |save_stack|*/ +static int @!max_save_stack; /*maximum usage of save stack*/ +static quarterword @!cur_level; /*current nesting level for groups*/ +static group_code @!cur_group; /*current group type*/ +static int @!cur_boundary; /*where the current level begins*/ + +@ At this time it might be a good idea for the reader to review the introduction +to |eqtb| that was given above just before the long lists of parameter names. +Recall that the ``outer level'' of the program is |level_one|, since +undefined control sequences are assumed to be ``defined'' at |level_zero|. + +@= +save_ptr=0;cur_level=level_one;cur_group=bottom_level;cur_boundary=0; +max_save_stack=0; + +@ The following macro is used to test if there is room for up to seven more +entries on |save_stack|. By making a conservative test like this, we can +get by with testing for overflow in only a few places. + +@d check_full_save_stack if (save_ptr > max_save_stack) + {@+max_save_stack=save_ptr; + if (max_save_stack > save_size-7) overflow("save size", save_size); +@:TeX capacity exceeded save size}{\quad save size@> + } + +@ Procedure |new_save_level| is called when a group begins. The +argument is a group identification code like `|hbox_group|'. After +calling this routine, it is safe to put five more entries on |save_stack|. + +In some cases integer-valued items are placed onto the +|save_stack| just below a |level_boundary| word, because this is a +convenient place to keep information that is supposed to ``pop up'' just +when the group has finished. +For example, when `\.{\\hbox to 100pt}\grp' is being treated, the 100pt +dimension is stored on |save_stack| just before |new_save_level| is +called. + +We use the notation |saved(k)| to stand for an integer item that +appears in location |save_ptr+k| of the save stack. + +@d saved(A) save_stack[save_ptr+A].i +@d saved_hfactor(A) save_hfactor[save_ptr+A].i +@d saved_vfactor(A) save_vfactor[save_ptr+A].i + +@p static void new_save_level(group_code @!c) /*begin a new level of grouping*/ +{@+check_full_save_stack; +if (eTeX_ex) + {@+saved(0)=line;incr(save_ptr); + } +save_type(save_ptr)=level_boundary;save_level(save_ptr)=cur_group; +save_index(save_ptr)=cur_boundary; +if (cur_level==max_quarterword) overflow("grouping levels", +@:TeX capacity exceeded grouping levels}{\quad grouping levels@> + max_quarterword-min_quarterword); + /*quit if |(cur_level+1)| is too big to be stored in |eqtb|*/ +cur_boundary=save_ptr;cur_group=c; +#ifdef @!STAT +if (tracing_groups > 0) group_trace(false); +#endif +@;@/ +incr(cur_level);incr(save_ptr); +} + +@ Just before an entry of |eqtb| is changed, the following procedure should +be called to update the other data structures properly. It is important +to keep in mind that reference counts in |mem| include references from +within |save_stack|, so these counts must be handled carefully. +@^reference counts@> + +@p static void eq_destroy(memory_word @!w) /*gets ready to forget |w|*/ +{@+pointer q; /*|equiv| field of |w|*/ +switch (eq_type_field(w)) { +case call: case long_call: case outer_call: case long_outer_call: delete_token_ref(equiv_field(w));@+break; +case glue_ref: delete_glue_ref(equiv_field(w));@+break; +case shape_ref: {@+q=equiv_field(w); /*we need to free a \.{\\parshape} block*/ + if (q!=null) free_node(q, info(q)+info(q)+1); + } @+break; /*such a block is |2 n+1| words long, where |n==info(q)|*/ +case box_ref: flush_node_list(equiv_field(w));@+break; +@/@@/ +default:do_nothing; +} +} + +@ To save a value of |eqtb[p]| that was established at level |l|, we +can use the following subroutine. + +@p static void eq_save(pointer @!p, quarterword @!l) /*saves |eqtb[p]|*/ +{@+check_full_save_stack; +if (l==level_zero) save_type(save_ptr)=restore_zero; +else{@+save_stack[save_ptr]=eqtb[p]; + if (p>=dimen_base) + { save_hfactor[save_ptr]=hfactor_eqtb[p]; + save_vfactor[save_ptr]=vfactor_eqtb[p]; + } + else if (p==par_shape_loc) + { save_hfactor[save_ptr].i=par_shape_hfactor; + save_vfactor[save_ptr].i=par_shape_vfactor; + } + incr(save_ptr); + save_type(save_ptr)=restore_old_value; + } +save_level(save_ptr)=l;save_index(save_ptr)=p;incr(save_ptr); +} + +@ The procedure |eq_define| defines an |eqtb| entry having specified +|eq_type| and |equiv| fields, and saves the former value if appropriate. +This procedure is used only for entries in the first four regions of |eqtb|, +i.e., only for entries that have |eq_type| and |equiv| fields. +After calling this routine, it is safe to put four more entries on +|save_stack|, provided that there was room for four more entries before +the call, since |eq_save| makes the necessary test. + +@p +#ifdef @!STAT +#define assign_trace(A, B) if (tracing_assigns > 0) restore_trace(A, B); +#else +#define assign_trace(A, B) +#endif + +static void eq_define(pointer @!p, quarterword @!t, halfword @!e) + /*new data for |eqtb|*/ +{@+ +if (eTeX_ex&&(eq_type(p)==t)&&(equiv(p)==e)) + {@+assign_trace(p,"reassigning")@;@/ + eq_destroy(eqtb[p]);return; + } +assign_trace(p,"changing")@;@/ +if (eq_level(p)==cur_level) eq_destroy(eqtb[p]); +else if (cur_level > level_one) eq_save(p, eq_level(p)); +eq_level(p)=cur_level;eq_type(p)=t;equiv(p)=e; +if (p==par_shape_loc) +{ par_shape_hfactor=cur_hfactor; + par_shape_vfactor=cur_vfactor; +} +assign_trace(p,"into")@;@/ +} + +@ The counterpart of |eq_define| for the remaining (fullword) positions in +|eqtb| is called |eq_word_define|. Since |xeq_level[p] >= level_one| for all +|p|, a `|restore_zero|' will never be used in this case. + +@p static void eq_word_define(pointer @!p, int @!w) +{@+ +if (eTeX_ex&&(eqtb[p].i==w)) + {@+assign_trace(p,"reassigning")@;@/ + return; + } +assign_trace(p,"changing")@;@/ +if (cur_level==level_one)@t\1@> + { if (p==dimen_base+hsize_code) + { hhsize=w+round(((double)cur_hfactor*hhsize +(double)cur_vfactor*hvsize)/unity); return; @+} + if (p==dimen_base+vsize_code) + { hvsize=w+round(((double)cur_hfactor*hhsize +(double)cur_vfactor*hvsize)/unity); return; @+} + } +if (xeq_level[p]!=cur_level) + {@+eq_save(p, xeq_level[p]);xeq_level[p]=cur_level; + } +eqtb[p].i=w; +if (p>=dimen_base) +{ hfactor_eqtb[p].i=cur_hfactor; + vfactor_eqtb[p].i=cur_vfactor; +} +assign_trace(p,"into")@;@/ +} + +@ The |eq_define| and |eq_word_define| routines take care of local definitions. +@^global definitions@> +Global definitions are done in almost the same way, but there is no need +to save old values, and the new value is associated with |level_one|. + +@p static void geq_define(pointer @!p, quarterword @!t, halfword @!e) + /*global |eq_define|*/ +{@+assign_trace(p,"globally changing")@;@/ +{@+eq_destroy(eqtb[p]); +eq_level(p)=level_one;eq_type(p)=t;equiv(p)=e; +} +assign_trace(p,"into");@/ +} +@# +static void geq_word_define(pointer @!p, int @!w) /*global |eq_word_define|*/ +{@+assign_trace(p,"globally changing")@;@/ +{@t\1@>xeq_level[p]=level_one; + if (p==dimen_base+hsize_code) + hhsize=w+round(((double)cur_hfactor*hhsize +(double)cur_vfactor*hvsize)/unity); + else if (p==dimen_base+vsize_code) + hvsize=w+round(((double)cur_hfactor*hhsize +(double)cur_vfactor*hvsize)/unity); + else + { eqtb[p].i=w; + if (p>=dimen_base) + { hfactor_eqtb[p].i=cur_hfactor; + vfactor_eqtb[p].i=cur_vfactor; + } +} +} +assign_trace(p,"into");@/ +} + +@ Subroutine |save_for_after| puts a token on the stack for save-keeping. + +@p static void save_for_after(halfword @!t) +{@+if (cur_level > level_one) + {@+check_full_save_stack; + save_type(save_ptr)=insert_token;save_level(save_ptr)=level_zero; + save_index(save_ptr)=t;incr(save_ptr); + } +} + +@ The |unsave| routine goes the other way, taking items off of |save_stack|. +This routine takes care of restoration when a level ends; everything +belonging to the topmost group is cleared off of the save stack. + +@p +static void back_input(void); +static void unsave(void) /*pops the top level off the save stack*/ +{@+ +pointer p; /*position to be restored*/ +quarterword @!l; /*saved level, if in fullword regions of |eqtb|*/ +halfword @!t; /*saved value of |cur_tok|*/ +bool @!a; /*have we already processed an \.{\\aftergroup} ?*/ +a=false; +if (cur_level > level_one) + {@+decr(cur_level); + @; + } +else confusion("curlevel"); /*|unsave| is not used when |cur_group==bottom_level|*/ +@:this can't happen curlevel}{\quad curlevel@> +} + +@ @= +loop@+{@+decr(save_ptr); + if (save_type(save_ptr)==level_boundary) goto done; + p=save_index(save_ptr); + if (save_type(save_ptr)==insert_token) + @@; + else if (save_type(save_ptr)==restore_sa) + {@+sa_restore();sa_chain=p;sa_level=save_level(save_ptr); + } + else{@+if (save_type(save_ptr)==restore_old_value) + {@+l=save_level(save_ptr);decr(save_ptr); + } + else save_stack[save_ptr]=eqtb[undefined_control_sequence]; + @; + } + } +done: +#ifdef @!STAT +if (tracing_groups > 0) group_trace(true); +#endif +@;@/ +if (grp_stack[in_open]==cur_boundary) group_warning(); + /*groups possibly not properly nested with files*/ +cur_group=save_level(save_ptr);cur_boundary=save_index(save_ptr); +if (eTeX_ex) decr(save_ptr) + +@ A global definition, which sets the level to |level_one|, +@^global definitions@> +will not be undone by |unsave|. If at least one global definition of +|eqtb[p]| has been carried out within the group that just ended, the +last such definition will therefore survive. + +@= +if (p < int_base) + if (eq_level(p)==level_one) + {@+eq_destroy(save_stack[save_ptr]); /*destroy the saved value*/ +#ifdef @!STAT + if (tracing_restores > 0) restore_trace(p,"retaining"); +#endif +@;@/ + } + else{@+eq_destroy(eqtb[p]); /*destroy the current value*/ + eqtb[p]=save_stack[save_ptr]; /*restore the saved value*/ + if (p==par_shape_loc) + { par_shape_hfactor=save_hfactor[save_ptr].i; + par_shape_vfactor=save_vfactor[save_ptr].i; + } +#ifdef @!STAT + if (tracing_restores > 0) restore_trace(p,"restoring"); +#endif +@;@/ + } +else if (xeq_level[p]!=level_one) + {@t\1@>@+eqtb[p]=save_stack[save_ptr]; + if (p>=dimen_base) + { hfactor_eqtb[p]=save_hfactor[save_ptr]; + vfactor_eqtb[p]=save_vfactor[save_ptr]; + } + xeq_level[p]=l; +#ifdef @!STAT + if (tracing_restores > 0) restore_trace(p,"restoring"); +#endif +@;@/ + } +else{ +#ifdef @!STAT + if (tracing_restores > 0) restore_trace(p,"retaining"); +#endif +@;@/ + } + +@ @= +#ifdef @!STAT +static void restore_trace(pointer @!p, char *@!s) + /*|eqtb[p]| has just been restored or retained*/ +{@+begin_diagnostic();print_char('{');print(s);print_char(' '); +show_eqtb(p);print_char('}'); +end_diagnostic(false); +} +#endif + +@ When looking for possible pointers to a memory location, it is helpful +to look for references from |eqtb| that might be waiting on the +save stack. Of course, we might find spurious pointers too; but this +routine is merely an aid when debugging, and at such times we are +grateful for any scraps of information, even if they prove to be irrelevant. +@^dirty \PASCAL@> + +@= +if (save_ptr > 0) for (q=0; q<=save_ptr-1; q++) + {@+if (equiv_field(save_stack[q])==p) + {@+print_nl("SAVE(");print_int(q);print_char(')'); + } + } + +@ Most of the parameters kept in |eqtb| can be changed freely, but there's +an exception: The magnification should not be used with two different +values during any \TeX\ job, since a single magnification is applied to an +entire run. The global variable |mag_set| is set to the current magnification +whenever it becomes necessary to ``freeze'' it at a particular value. + +@= +static int @!mag_set; /*if nonzero, this magnification should be used henceforth*/ + +@ @= +mag_set=0; + +@ The |prepare_mag| subroutine is called whenever \TeX\ wants to use |mag| +for magnification. + +@p static void prepare_mag(void) +{@+if ((mag_set > 0)&&(mag!=mag_set)) + {@+print_err("Incompatible magnification (");print_int(mag); +@.Incompatible magnification@> + print(");");print_nl(" the previous value will be retained"); + help2("I can handle only one magnification ratio per job. So I've",@/ + "reverted to the magnification you used earlier on this run.");@/ + int_error(mag_set); + geq_word_define(int_base+mag_code, mag_set); /*|mag=mag_set|*/ + } +if ((mag <= 0)||(mag > 32768)) + {@+print_err("Illegal magnification has been changed to 1000");@/ +@.Illegal magnification...@> + help1("The magnification ratio must be between 1 and 32768."); + int_error(mag);geq_word_define(int_base+mag_code, 1000); + } +mag_set=mag; +} + +@* Token lists. +A \TeX\ token is either a character or a control sequence, and it is +@^token@> +represented internally in one of two ways: (1)~A character whose ASCII +code number is |c| and whose command code is |m| is represented as the +number $2^8m+c$; the command code is in the range |1 <= m <= 14|. (2)~A control +sequence whose |eqtb| address is |p| is represented as the number +|cs_token_flag+p|. Here |cs_token_flag==@t$2^{12}-1$@>| is larger than +$2^8m+c$, yet it is small enough that |cs_token_flag+p < max_halfword|; +thus, a token fits comfortably in a halfword. + +A token |t| represents a |left_brace| command if and only if +|t < left_brace_limit|; it represents a |right_brace| command if and only if +we have |left_brace_limit <= t < right_brace_limit|; and it represents a |match| or +|end_match| command if and only if |match_token <= t <= end_match_token|. +The following definitions take care of these token-oriented constants +and a few others. + +@d cs_token_flag 07777 /*amount added to the |eqtb| location in a + token that stands for a control sequence; is a multiple of~256, less~1*/ +@d left_brace_token 00400 /*$2^8\cdot|left_brace|$*/ +@d left_brace_limit 01000 /*$2^8\cdot(|left_brace|+1)$*/ +@d right_brace_token 01000 /*$2^8\cdot|right_brace|$*/ +@d right_brace_limit 01400 /*$2^8\cdot(|right_brace|+1)$*/ +@d math_shift_token 01400 /*$2^8\cdot|math_shift|$*/ +@d tab_token 02000 /*$2^8\cdot|tab_mark|$*/ +@d out_param_token 02400 /*$2^8\cdot|out_param|$*/ +@d space_token 05040 /*$2^8\cdot|spacer|+|' '|$*/ +@d letter_token 05400 /*$2^8\cdot|letter|$*/ +@d other_token 06000 /*$2^8\cdot|other_char|$*/ +@d match_token 06400 /*$2^8\cdot|match|$*/ +@d end_match_token 07000 /*$2^8\cdot|end_match|$*/ +@d protected_token 07001 /*$2^8\cdot|end_match|+1$*/ + +@ @= +if (cs_token_flag+undefined_control_sequence > max_halfword) bad=21; + +@ A token list is a singly linked list of one-word nodes in |mem|, where +each word contains a token and a link. Macro definitions, output-routine +definitions, marks, \.{\\write} texts, and a few other things +are remembered by \TeX\ in the form +of token lists, usually preceded by a node with a reference count in its +|token_ref_count| field. The token stored in location |p| is called +|info(p)|. + +Three special commands appear in the token lists of macro definitions. +When |m==match|, it means that \TeX\ should scan a parameter +for the current macro; when |m==end_match|, it means that parameter +matching should end and \TeX\ should start reading the macro text; and +when |m==out_param|, it means that \TeX\ should insert parameter +number |c| into the text at this point. + +The enclosing \.{\char'173} and \.{\char'175} characters of a macro +definition are omitted, but an output routine +will be enclosed in braces. + +Here is an example macro definition that illustrates these conventions. +After \TeX\ processes the text +$$\.{\\def\\mac a\#1\#2 \\b \{\#1\\-a \#\#1\#2 \#2\}}$$ +the definition of \.{\\mac} is represented as a token list containing +$$\def\,{\hskip2pt} +\vbox{\halign{\hfil#\hfil\cr +(reference count), |letter|\,\.a, |match|\,\#, |match|\,\#, |spacer|\,\.\ , +\.{\\b}, |end_match|,\cr +|out_param|\,1, \.{\\-}, |letter|\,\.a, |spacer|\,\.\ , |mac_param|\,\#, +|other_char|\,\.1,\cr +|out_param|\,2, |spacer|\,\.\ , |out_param|\,2.\cr}}$$ +The procedure |scan_toks| builds such token lists, and |macro_call| +does the parameter matching. +@^reference counts@> + +Examples such as +$$\.{\\def\\m\{\\def\\m\{a\}\ b\}}$$ +explain why reference counts would be needed even if \TeX\ had no \.{\\let} +operation: When the token list for \.{\\m} is being read, the redefinition of +\.{\\m} changes the |eqtb| entry before the token list has been fully +consumed, so we dare not simply destroy a token list when its +control sequence is being redefined. + +If the parameter-matching part of a definition ends with `\.{\#\{}', +the corresponding token list will have `\.\{' just before the `|end_match|' +and also at the very end. The first `\.\{' is used to delimit the parameter; the +second one keeps the first from disappearing. + +@ The procedure |show_token_list|, which prints a symbolic form of +the token list that starts at a given node |p|, illustrates these +conventions. The token list being displayed should not begin with a reference +count. However, the procedure is intended to be robust, so that if the +memory links are awry or if |p| is not really a pointer to a token list, +nothing catastrophic will happen. + +An additional parameter |q| is also given; this parameter is either null +or it points to a node in the token list where a certain magic computation +takes place that will be explained later. (Basically, |q| is non-null when +we are printing the two-line context information at the time of an error +message; |q| marks the place corresponding to where the second line +should begin.) + +For example, if |p| points to the node containing the first \.a in the +token list above, then |show_token_list| will print the string +$$\hbox{`\.{a\#1\#2\ \\b\ ->\#1\\-a\ \#\#1\#2\ \#2}';}$$ +and if |q| points to the node containing the second \.a, +the magic computation will be performed just before the second \.a is printed. + +The generation will stop, and `\.{\\ETC.}' will be printed, if the length +of printing exceeds a given limit~|l|. Anomalous entries are printed in the +form of control sequences that are not followed by a blank space, e.g., +`\.{\\BAD.}'; this cannot be confused with actual control sequences because +a real control sequence named \.{BAD} would come out `\.{\\BAD\ }'. + +@= +static void show_token_list(int @!p, int @!q, int @!l) +{@+ +int m, @!c; /*pieces of a token*/ +ASCII_code @!match_chr; /*character used in a `|match|'*/ +ASCII_code @!n; /*the highest parameter number, as an ASCII digit*/ +match_chr='#';n='0';tally=0; +while ((p!=null)&&(tally < l)) + {@+if (p==q) @; + @; + p=link(p); + } +if (p!=null) print_esc("ETC."); +@.ETC@> + +} + +@ @= +if ((p < hi_mem_min)||(p > mem_end)) + {@+print_esc("CLOBBERED.");return; +@.CLOBBERED@> + } +if (info(p) >= cs_token_flag) print_cs(info(p)-cs_token_flag); +else{@+m=info(p)/0400;c=info(p)%0400; + if (info(p) < 0) print_esc("BAD."); +@.BAD@> + else@; + } + +@ The procedure usually ``learns'' the character code used for macro +parameters by seeing one in a |match| command before it runs into any +|out_param| commands. + +@= +switch (m) { +case left_brace: case right_brace: case math_shift: case tab_mark: case sup_mark: case sub_mark: case spacer: + case letter: case other_char: printn(c);@+break; +case mac_param: {@+printn(c);printn(c); + } @+break; +case out_param: {@+printn(match_chr); + if (c <= 9) print_char(c+'0'); + else{@+print_char('!');return; + } + } @+break; +case match: {@+match_chr=c;printn(c);incr(n);print_char(n); + if (n > '9') return; + } @+break; +case end_match: if (c==0) print("->");@+break; +@.->@> +default:print_esc("BAD."); +@.BAD@> +} + +@ Here's the way we sometimes want to display a token list, given a pointer +to its reference count; the pointer may be null. + +@p static void token_show(pointer @!p) +{@+if (p!=null) show_token_list(link(p), null, 10000000); +} + +@ The |print_meaning| subroutine displays |cur_cmd| and |cur_chr| in +symbolic form, including the expansion of a macro or mark. + +@p static void print_meaning(void) +{@+print_cmd_chr(cur_cmd, cur_chr); +if (cur_cmd >= call) + {@+print_char(':');print_ln();token_show(cur_chr); + } +else if (cur_cmd==top_bot_mark) + {@+print_char(':');print_ln(); + token_show(cur_mark[cur_chr]); + } +} + +@* Introduction to the syntactic routines. +Let's pause a moment now and try to look at the Big Picture. +The \TeX\ program consists of three main parts: syntactic routines, +semantic routines, and output routines. The chief purpose of the +syntactic routines is to deliver the user's input to the semantic routines, +one token at a time. The semantic routines act as an interpreter +responding to these tokens, which may be regarded as commands. And the +output routines are periodically called on to convert box-and-glue +lists into a compact set of instructions that will be sent +to a typesetter. We have discussed the basic data structures and utility +routines of \TeX, so we are good and ready to plunge into the real activity by +considering the syntactic routines. + +Our current goal is to come to grips with the |get_next| procedure, +which is the keystone of \TeX's input mechanism. Each call of |get_next| +sets the value of three variables |cur_cmd|, |cur_chr|, and |cur_cs|, +representing the next input token. +$$\vbox{\halign{#\hfil\cr + \hbox{|cur_cmd| denotes a command code from the long list of codes + given above;}\cr + \hbox{|cur_chr| denotes a character code or other modifier of the command + code;}\cr + \hbox{|cur_cs| is the |eqtb| location of the current control sequence,}\cr + \hbox{\qquad if the current token was a control sequence, + otherwise it's zero.}\cr}}$$ +Underlying this external behavior of |get_next| is all the machinery +necessary to convert from character files to tokens. At a given time we +may be only partially finished with the reading of several files (for +which \.{\\input} was specified), and partially finished with the expansion +of some user-defined macros and/or some macro parameters, and partially +finished with the generation of some text in a template for \.{\\halign}, +and so on. When reading a character file, special characters must be +classified as math delimiters, etc.; comments and extra blank spaces must +be removed, paragraphs must be recognized, and control sequences must be +found in the hash table. Furthermore there are occasions in which the +scanning routines have looked ahead for a word like `\.{plus}' but only +part of that word was found, hence a few characters must be put back +into the input and scanned again. + +To handle these situations, which might all be present simultaneously, +\TeX\ uses various stacks that hold information about the incomplete +activities, and there is a finite state control for each level of the +input mechanism. These stacks record the current state of an implicitly +recursive process, but the |get_next| procedure is not recursive. +Therefore it will not be difficult to translate these algorithms into +low-level languages that do not support recursion. + +@= +static eight_bits @!cur_cmd; /*current command set by |get_next|*/ +static halfword @!cur_chr; /*operand of current command*/ +static pointer @!cur_cs; /*control sequence found here, zero if none found*/ +static halfword @!cur_tok; /*packed representative of |cur_cmd| and |cur_chr|*/ + +@ The |print_cmd_chr| routine prints a symbolic interpretation of a +command code and its modifier. This is used in certain `\.{You can\'t}' +error messages, and in the implementation of diagnostic routines like +\.{\\show}. + +The body of |print_cmd_chr| is a rather tedious listing of print +commands, and most of it is essentially an inverse to the |primitive| +routine that enters a \TeX\ primitive into |eqtb|. Therefore much of +this procedure appears elsewhere in the program, +together with the corresponding |primitive| calls. + +@d chr_cmd(A) {@+print(A);print_ASCII(chr_code); + } + +@= +static void print_cmd_chr(quarterword @!cmd, halfword @!chr_code) +{@+int n; /*temp variable*/ +switch (cmd) { +case left_brace: chr_cmd("begin-group character ")@;@+break; +case right_brace: chr_cmd("end-group character ")@;@+break; +case math_shift: chr_cmd("math shift character ")@;@+break; +case mac_param: chr_cmd("macro parameter character ")@;@+break; +case sup_mark: chr_cmd("superscript character ")@;@+break; +case sub_mark: chr_cmd("subscript character ")@;@+break; +case endv: print("end of alignment template");@+break; +case spacer: chr_cmd("blank space ")@;@+break; +case letter: chr_cmd("the letter ")@;@+break; +case other_char: chr_cmd("the character ")@;@+break; +@t\4@>@@/ +default:print("[unknown command code!]"); +} +} + +@ Here is a procedure that displays the current command. + +@p static void show_cur_cmd_chr(void) +{@+int n; /*level of \.{\\if...\\fi} nesting*/ +int @!l; /*line where \.{\\if} started*/ +pointer @!p; +begin_diagnostic();print_nl("{"); +if (mode!=shown_mode) + {@+print_mode(mode);print(": ");shown_mode=mode; + } +print_cmd_chr(cur_cmd, cur_chr); +if (tracing_ifs > 0) + if (cur_cmd >= if_test) if (cur_cmd <= fi_or_else) + {@+print(": "); + if (cur_cmd==fi_or_else) + {@+print_cmd_chr(if_test, cur_if);print_char(' '); + n=0;l=if_line; + } + else{@+n=1;l=line; + } + p=cond_ptr; + while (p!=null) + {@+incr(n);p=link(p); + } + print("(level ");print_int(n);print_char(')');print_if_line(l); + } +print_char('}'); +end_diagnostic(false); +} + +@* Input stacks and states. +This implementation of +\TeX\ uses two different conventions for representing sequential stacks. +@^stack conventions@>@^conventions for representing stacks@> + +\yskip\hangg 1) If there is frequent access to the top entry, and if the +stack is essentially never empty, then the top entry is kept in a global +variable (even better would be a machine register), and the other entries +appear in the array $\\{stack}[0\to(\\{ptr}-1)]$. For example, the +semantic stack described above is handled this way, and so is the input +stack that we are about to study. + +\yskip\hangg 2) If there is infrequent top access, the entire stack contents +are in the array $\\{stack}[0\to(\\{ptr}-1)]$. For example, the |save_stack| +is treated this way, as we have seen. + +\yskip\noindent +The state of \TeX's input mechanism appears in the input stack, whose +entries are records with six fields, called |state|, |index|, |start|, |loc|, +|limit|, and |name|. This stack is maintained with +convention~(1), so it is declared in the following way: + +@= +typedef struct { + quarterword @!state_field, @!index_field; + halfword @!start_field, @!loc_field, @!limit_field, @!name_field; + } in_state_record; + +@ @= +static in_state_record @!input_stack[stack_size+1]; +static int @!input_ptr; /*first unused location of |input_stack|*/ +static int @!max_in_stack; /*largest value of |input_ptr| when pushing*/ +static in_state_record @!cur_input; + /*the ``top'' input state, according to convention (1)*/ + +@ We've already defined the special variable |loc====cur_input.loc_field| +in our discussion of basic input-output routines. The other components of +|cur_input| are defined in the same way: + +@d state cur_input.state_field /*current scanner state*/ +@d index cur_input.index_field /*reference for buffer information*/ +@d start cur_input.start_field /*starting position in |buffer|*/ +@d limit cur_input.limit_field /*end of current line in |buffer|*/ +@d name cur_input.name_field /*name of the current file*/ + +@ Let's look more closely now at the control variables +(|state|,~|index|,~|start|,~|loc|,~|limit|,~|name|), +assuming that \TeX\ is reading a line of characters that have been input +from some file or from the user's terminal. There is an array called +|buffer| that acts as a stack of all lines of characters that are +currently being read from files, including all lines on subsidiary +levels of the input stack that are not yet completed. \TeX\ will return to +the other lines when it is finished with the present input file. + +(Incidentally, on a machine with byte-oriented addressing, it might be +appropriate to combine |buffer| with the |str_pool| array, +letting the buffer entries grow downward from the top of the string pool +and checking that these two tables don't bump into each other.) + +The line we are currently working on begins in position |start| of the +buffer; the next character we are about to read is |buffer[loc]|; and +|limit| is the location of the last character present. If |loc > limit|, +the line has been completely read. Usually |buffer[limit]| is the +|end_line_char|, denoting the end of a line, but this is not +true if the current line is an insertion that was entered on the user's +terminal in response to an error message. + +The |name| variable is a string number that designates the name of +the current file, if we are reading a text file. It is zero if we +are reading from the terminal; it is |n+1| if we are reading from +input stream |n|, where |0 <= n <= 16|. (Input stream 16 stands for +an invalid stream number; in such cases the input is actually from +the terminal, under control of the procedure |read_toks|.) +Finally |18 <= name <= 19| indicates that we are reading a pseudo file +created by the \.{\\scantokens} command. + +The |state| variable has one of three values, when we are scanning such +files: +$$\baselineskip 15pt\vbox{\halign{#\hfil\cr +1) |state==mid_line| is the normal state.\cr +2) |state==skip_blanks| is like |mid_line|, but blanks are ignored.\cr +3) |state==new_line| is the state at the beginning of a line.\cr}}$$ +These state values are assigned numeric codes so that if we add the state +code to the next character's command code, we get distinct values. For +example, `|mid_line+spacer|' stands for the case that a blank +space character occurs in the middle of a line when it is not being +ignored; after this case is processed, the next value of |state| will +be |skip_blanks|. + +@d mid_line 1 /*|state| code when scanning a line of characters*/ +@d skip_blanks (2+max_char_code) /*|state| code when ignoring blanks*/ +@d new_line (3+max_char_code+max_char_code) /*|state| code at start of line*/ + +@ Additional information about the current line is available via the +|index| variable, which counts how many lines of characters are present +in the buffer below the current level. We have |index==0| when reading +from the terminal and prompting the user for each line; then if the user types, +e.g., `\.{\\input paper}', we will have |index==1| while reading +the file \.{paper.tex}. However, it does not follow that |index| is the +same as the input stack pointer, since many of the levels on the input +stack may come from token lists. For example, the instruction `\.{\\input +paper}' might occur in a token list. + +The global variable |in_open| is equal to the |index| +value of the highest non-token-list level. Thus, the number of partially read +lines in the buffer is |in_open+1|, and we have |in_open==index| +when we are not reading a token list. + +If we are not currently reading from the terminal, or from an input +stream, we are reading from the file variable |input_file[index]|. We use +the notation |terminal_input| as a convenient abbreviation for |name==0|, +and |cur_file| as an abbreviation for |input_file[index]|. + +The global variable |line| contains the line number in the topmost +open file, for use in error messages. If we are not reading from +the terminal, |line_stack[index]| holds the line number for the +enclosing level, so that |line| can be restored when the current +file has been read. Line numbers should never be negative, since the +negative of the current line number is used to identify the user's output +routine in the |mode_line| field of the semantic nest entries. + +If more information about the input state is needed, it can be +included in small arrays like those shown here. For example, +the current page or segment number in the input file might be +put into a variable |@!page|, maintained for enclosing levels in +`\ignorespaces|@!page_stack: array[1 dotdot max_in_open]int|\unskip' +by analogy with |line_stack|. +@^system dependencies@> + +@d terminal_input (name==0) /*are we reading from the terminal?*/ +@d cur_file input_file[index] /*the current |alpha_file| variable*/ + +@= +static int @!in_open; /*the number of lines in the buffer, less one*/ +static int @!open_parens; /*the number of open text files*/ +static alpha_file @!input_file0[max_in_open], *const @!input_file = @!input_file0-1; +static int @!line; /*current line number in the current source file*/ +static int @!line_stack0[max_in_open], *const @!line_stack = @!line_stack0-1; + +@ Users of \TeX\ sometimes forget to balance left and right braces properly, +and one of the ways \TeX\ tries to spot such errors is by considering an +input file as broken into subfiles by control sequences that +are declared to be \.{\\outer}. + +A variable called |scanner_status| tells \TeX\ whether or not to complain +when a subfile ends. This variable has six possible values: + +\yskip\hang|normal|, means that a subfile can safely end here without incident. + +\yskip\hang|skipping|, means that a subfile can safely end here, but not a file, +because we're reading past some conditional text that was not selected. + +\yskip\hang|defining|, means that a subfile shouldn't end now because a +macro is being defined. + +\yskip\hang|matching|, means that a subfile shouldn't end now because a +macro is being used and we are searching for the end of its arguments. + +\yskip\hang|aligning|, means that a subfile shouldn't end now because we are +not finished with the preamble of an \.{\\halign} or \.{\\valign}. + +\yskip\hang|absorbing|, means that a subfile shouldn't end now because we are +reading a balanced token list for \.{\\message}, \.{\\write}, etc. + +\yskip\noindent +If the |scanner_status| is not |normal|, the variable |warning_index| points +to the |eqtb| location for the relevant control sequence name to print +in an error message. + +@d skipping 1 /*|scanner_status| when passing conditional text*/ +@d defining 2 /*|scanner_status| when reading a macro definition*/ +@d matching 3 /*|scanner_status| when reading macro arguments*/ +@d aligning 4 /*|scanner_status| when reading an alignment preamble*/ +@d absorbing 5 /*|scanner_status| when reading a balanced text*/ + +@= +static int @!scanner_status; /*can a subfile end now?*/ +static pointer @!warning_index; /*identifier relevant to non-|normal| scanner status*/ +static pointer @!def_ref; /*reference count of token list being defined*/ + +@ Here is a procedure that uses |scanner_status| to print a warning message +when a subfile has ended, and at certain other crucial times: + +@= +static void runaway(void) +{@+pointer p; /*head of runaway list*/ +if (scanner_status > skipping) + {@+print_nl("Runaway "); +@.Runaway...@> + switch (scanner_status) { + case defining: {@+print("definition");p=def_ref; + } @+break; + case matching: {@+print("argument");p=temp_head; + } @+break; + case aligning: {@+print("preamble");p=hold_head; + } @+break; + case absorbing: {@+print("text");p=def_ref; + } + } /*there are no other cases*/ + print_char('?');print_ln();show_token_list(link(p), null, error_line-10); + } +} + +@ However, all this discussion about input state really applies only to the +case that we are inputting from a file. There is another important case, +namely when we are currently getting input from a token list. In this case +|state==token_list|, and the conventions about the other state variables +are different: + +\yskip\hang|loc| is a pointer to the current node in the token list, i.e., +the node that will be read next. If |loc==null|, the token list has been +fully read. + +\yskip\hang|start| points to the first node of the token list; this node +may or may not contain a reference count, depending on the type of token +list involved. + +\yskip\hang|token_type|, which takes the place of |index| in the +discussion above, is a code number that explains what kind of token list +is being scanned. + +\yskip\hang|name| points to the |eqtb| address of the control sequence +being expanded, if the current token list is a macro. + +\yskip\hang|param_start|, which takes the place of |limit|, tells where +the parameters of the current macro begin in the |param_stack|, if the +current token list is a macro. + +\yskip\noindent The |token_type| can take several values, depending on +where the current token list came from: + +\yskip\hang|parameter|, if a parameter is being scanned; + +\hang|u_template|, if the \ part of an alignment +template is being scanned; + +\hang|v_template|, if the \ part of an alignment +template is being scanned; + +\hang|backed_up|, if the token list being scanned has been inserted as +`to be read again'; + +\hang|inserted|, if the token list being scanned has been inserted as +the text expansion of a \.{\\count} or similar variable; + +\hang|macro|, if a user-defined control sequence is being scanned; + +\hang|output_text|, if an \.{\\output} routine is being scanned; + +\hang|every_par_text|, if the text of \.{\\everypar} is being scanned; + +\hang|every_math_text|, if the text of \.{\\everymath} is being scanned; + +\hang|every_display_text|, if the text of \.{\\everydisplay} is being scanned; + +\hang|every_hbox_text|, if the text of \.{\\everyhbox} is being scanned; + +\hang|every_vbox_text|, if the text of \.{\\everyvbox} is being scanned; + +\hang|every_job_text|, if the text of \.{\\everyjob} is being scanned; + +\hang|every_cr_text|, if the text of \.{\\everycr} is being scanned; + +\hang|mark_text|, if the text of a \.{\\mark} is being scanned; + +\hang|write_text|, if the text of a \.{\\write} is being scanned. + +\yskip\noindent +The codes for |output_text|, |every_par_text|, etc., are equal to a constant +plus the corresponding codes for token list parameters |output_routine_loc|, +|every_par_loc|, etc. The token list begins with a reference count if and +only if |token_type >= macro|. +@^reference counts@> + +Since \eTeX's additional token list parameters precede |toks_base|, the +corresponding token types must precede |write_text|. + +@d token_list 0 /*|state| code when scanning a token list*/ +@d token_type index /*type of current token list*/ +@d param_start limit /*base of macro parameters in |param_stack|*/ +@d parameter 0 /*|token_type| code for parameter*/ +@d u_template 1 /*|token_type| code for \ template*/ +@d v_template 2 /*|token_type| code for \ template*/ +@d backed_up 3 /*|token_type| code for text to be reread*/ +@d inserted 4 /*|token_type| code for inserted texts*/ +@d macro 5 /*|token_type| code for defined control sequences*/ +@d output_text 6 /*|token_type| code for output routines*/ +@d every_par_text 7 /*|token_type| code for \.{\\everypar}*/ +@d every_math_text 8 /*|token_type| code for \.{\\everymath}*/ +@d every_display_text 9 /*|token_type| code for \.{\\everydisplay}*/ +@d every_hbox_text 10 /*|token_type| code for \.{\\everyhbox}*/ +@d every_vbox_text 11 /*|token_type| code for \.{\\everyvbox}*/ +@d every_job_text 12 /*|token_type| code for \.{\\everyjob}*/ +@d every_cr_text 13 /*|token_type| code for \.{\\everycr}*/ +@d mark_text 14 /*|token_type| code for \.{\\topmark}, etc.*/ +@# +@d eTeX_text_offset (output_routine_loc-output_text) +@d every_eof_text (every_eof_loc-eTeX_text_offset) + /*|token_type| code for \.{\\everyeof}*/ +@# +@d write_text (toks_base-eTeX_text_offset) /*|token_type| code for \.{\\write}*/ + +@ The |param_stack| is an auxiliary array used to hold pointers to the token +lists for parameters at the current level and subsidiary levels of input. +This stack is maintained with convention (2), and it grows at a different +rate from the others. + +@= +static pointer @!param_stack[param_size+1]; + /*token list pointers for parameters*/ +static int @!param_ptr; /*first unused entry in |param_stack|*/ +static int @!max_param_stack; + /*largest value of |param_ptr|, will be | <= param_size+9|*/ + +@ The input routines must also interact with the processing of +\.{\\halign} and \.{\\valign}, since the appearance of tab marks and +\.{\\cr} in certain places is supposed to trigger the beginning of special +\ template text in the scanner. This magic is accomplished by an +|align_state| variable that is increased by~1 when a `\.{\char'173}' is +scanned and decreased by~1 when a `\.{\char'175}' is scanned. The |align_state| +is nonzero during the \ template, after which it is set to zero; the +\ template begins when a tab mark or \.{\\cr} occurs at a time that +|align_state==0|. + +The same principle applies when entering the definition of a +control sequence between \.{\\csname} and \.{\\endcsname}. + +@= +static int @!align_state; /*group level with respect to current alignment*/ +static int @!incsname_state; /*group level with respect to in csname state*/ + +@ Thus, the ``current input state'' can be very complicated indeed; there +can be many levels and each level can arise in a variety of ways. The +|show_context| procedure, which is used by \TeX's error-reporting routine to +print out the current input state on all levels down to the most recent +line of characters from an input file, illustrates most of these conventions. +The global variable |base_ptr| contains the lowest level that was +displayed by this procedure. + +@= +static int @!base_ptr; /*shallowest level shown by |show_context|*/ + +@ The status at each level is indicated by printing two lines, where the first +line indicates what was read so far and the second line shows what remains +to be read. The context is cropped, if necessary, so that the first line +contains at most |half_error_line| characters, and the second contains +at most |error_line|. Non-current input levels whose |token_type| is +`|backed_up|' are shown only if they have not been fully read. + +@p static void show_context(void) /*prints where the scanner is*/ +{@+ +int old_setting; /*saved |selector| setting*/ +int @!nn; /*number of contexts shown so far, less one*/ +bool @!bottom_line; /*have we reached the final context to be shown?*/ +@@/ +base_ptr=input_ptr;input_stack[base_ptr]=cur_input; + /*store current state*/ +nn=-1;bottom_line=false; +loop@+{@+cur_input=input_stack[base_ptr]; /*enter into the context*/ + if ((state!=token_list)) + if ((name > 19)||(base_ptr==0)) bottom_line=true; + if ((base_ptr==input_ptr)||bottom_line||(nn < error_context_lines)) + @@; + else if (nn==error_context_lines) + {@+print_nl("...");incr(nn); /*omitted if |error_context_lines < 0|*/ + } + if (bottom_line) goto done; + decr(base_ptr); + } +done: cur_input=input_stack[input_ptr]; /*restore original state*/ +} + +@ @= +{@+if ((base_ptr==input_ptr)||(state!=token_list)|| + (token_type!=backed_up)||(loc!=null)) + /*we omit backed-up token lists that have already been read*/ + {@+tally=0; /*get ready to count characters*/ + old_setting=selector; + if (state!=token_list) + {@+@; + @; + } + else{@+@; + @; + } + selector=old_setting; /*stop pseudoprinting*/ + @; + incr(nn); + } +} + +@ This routine should be changed, if necessary, to give the best possible +indication of where the current line resides in the input file. +For example, on some systems it is best to print both a page and line number. +@^system dependencies@> + +@= +if (name <= 17) + if (terminal_input) + if (base_ptr==0) print_nl("<*>");else print_nl(" "); + else{@+print_nl(" + print_char('>'); + } +else{@+print_nl("l."); + if (index==in_open) print_int(line); + else print_int(line_stack[index+1]); /*input from a pseudo file*/ + } +print_char(' ') + +@ @= +switch (token_type) { +case parameter: print_nl(" ");@+break; +case u_template: case v_template: print_nl("