home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 3 / Meeting_Pearls_III.iso / Pearls / texmf / source / TeX / tex / itex.c < prev    next >
C/C++ Source or Header  |  1993-10-12  |  36KB  |  1,456 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4.  
  5. void initialize ( void )
  6. { initialize_regmem 
  7.   register integer i ;
  8.   register integer k ;
  9.   register hyphpointer z ;
  10.  
  11. #ifndef TEXCONFIG        /* see init.c */
  12.  
  13. #if !defined(atarist) && !defined(AMIGA)
  14.   xchr [ 32 ] = ' ' ; 
  15.   xchr [ 33 ] = '!' ; 
  16.   xchr [ 34 ] = '"' ; 
  17.   xchr [ 35 ] = '#' ; 
  18.   xchr [ 36 ] = '$' ; 
  19.   xchr [ 37 ] = '%' ; 
  20.   xchr [ 38 ] = '&' ; 
  21.   xchr [ 39 ] = '\'' ; 
  22.   xchr [ 40 ] = '(' ; 
  23.   xchr [ 41 ] = ')' ; 
  24.   xchr [ 42 ] = '*' ; 
  25.   xchr [ 43 ] = '+' ; 
  26.   xchr [ 44 ] = ',' ; 
  27.   xchr [ 45 ] = '-' ; 
  28.   xchr [ 46 ] = '.' ; 
  29.   xchr [ 47 ] = '/' ; 
  30.   xchr [ 48 ] = '0' ; 
  31.   xchr [ 49 ] = '1' ; 
  32.   xchr [ 50 ] = '2' ; 
  33.   xchr [ 51 ] = '3' ; 
  34.   xchr [ 52 ] = '4' ; 
  35.   xchr [ 53 ] = '5' ; 
  36.   xchr [ 54 ] = '6' ; 
  37.   xchr [ 55 ] = '7' ; 
  38.   xchr [ 56 ] = '8' ; 
  39.   xchr [ 57 ] = '9' ; 
  40.   xchr [ 58 ] = ':' ; 
  41.   xchr [ 59 ] = ';' ; 
  42.   xchr [ 60 ] = '<' ; 
  43.   xchr [ 61 ] = '=' ; 
  44.   xchr [ 62 ] = '>' ; 
  45.   xchr [ 63 ] = '?' ; 
  46.   xchr [ 64 ] = '@' ; 
  47.   xchr [ 65 ] = 'A' ; 
  48.   xchr [ 66 ] = 'B' ; 
  49.   xchr [ 67 ] = 'C' ; 
  50.   xchr [ 68 ] = 'D' ; 
  51.   xchr [ 69 ] = 'E' ; 
  52.   xchr [ 70 ] = 'F' ; 
  53.   xchr [ 71 ] = 'G' ; 
  54.   xchr [ 72 ] = 'H' ; 
  55.   xchr [ 73 ] = 'I' ; 
  56.   xchr [ 74 ] = 'J' ; 
  57.   xchr [ 75 ] = 'K' ; 
  58.   xchr [ 76 ] = 'L' ; 
  59.   xchr [ 77 ] = 'M' ; 
  60.   xchr [ 78 ] = 'N' ; 
  61.   xchr [ 79 ] = 'O' ; 
  62.   xchr [ 80 ] = 'P' ; 
  63.   xchr [ 81 ] = 'Q' ; 
  64.   xchr [ 82 ] = 'R' ; 
  65.   xchr [ 83 ] = 'S' ; 
  66.   xchr [ 84 ] = 'T' ; 
  67.   xchr [ 85 ] = 'U' ; 
  68.   xchr [ 86 ] = 'V' ; 
  69.   xchr [ 87 ] = 'W' ; 
  70.   xchr [ 88 ] = 'X' ; 
  71.   xchr [ 89 ] = 'Y' ; 
  72.   xchr [ 90 ] = 'Z' ; 
  73.   xchr [ 91 ] = '[' ; 
  74.   xchr [ 92 ] = '\\' ; 
  75.   xchr [ 93 ] = ']' ; 
  76.   xchr [ 94 ] = '^' ; 
  77.   xchr [ 95 ] = '_' ; 
  78.   xchr [ 96 ] = '`' ; 
  79.   xchr [ 97 ] = 'a' ; 
  80.   xchr [ 98 ] = 'b' ; 
  81.   xchr [ 99 ] = 'c' ; 
  82.   xchr [ 100 ] = 'd' ; 
  83.   xchr [ 101 ] = 'e' ; 
  84.   xchr [ 102 ] = 'f' ; 
  85.   xchr [ 103 ] = 'g' ; 
  86.   xchr [ 104 ] = 'h' ; 
  87.   xchr [ 105 ] = 'i' ; 
  88.   xchr [ 106 ] = 'j' ; 
  89.   xchr [ 107 ] = 'k' ; 
  90.   xchr [ 108 ] = 'l' ; 
  91.   xchr [ 109 ] = 'm' ; 
  92.   xchr [ 110 ] = 'n' ; 
  93.   xchr [ 111 ] = 'o' ; 
  94.   xchr [ 112 ] = 'p' ; 
  95.   xchr [ 113 ] = 'q' ; 
  96.   xchr [ 114 ] = 'r' ; 
  97.   xchr [ 115 ] = 's' ; 
  98.   xchr [ 116 ] = 't' ; 
  99.   xchr [ 117 ] = 'u' ; 
  100.   xchr [ 118 ] = 'v' ; 
  101.   xchr [ 119 ] = 'w' ; 
  102.   xchr [ 120 ] = 'x' ; 
  103.   xchr [ 121 ] = 'y' ; 
  104.   xchr [ 122 ] = 'z' ; 
  105.   xchr [ 123 ] = '{' ; 
  106.   xchr [ 124 ] = '|' ; 
  107.   xchr [ 125 ] = '}' ; 
  108.   xchr [ 126 ] = '~' ; 
  109.   {register integer for_end; i = 0 ; for_end = 31 ; if ( i <= for_end) do 
  110.     xchr [ i ] = chr ( i ) ; 
  111.   while ( i++ < for_end ) ; } 
  112.   {register integer for_end; i = 127 ; for_end = 255 ; if ( i <= for_end) do 
  113.     xchr [ i ] = chr ( i ) ; 
  114.   while ( i++ < for_end ) ; } 
  115.   {register integer for_end; i = 0 ; for_end = 255 ; if ( i <= for_end) do 
  116.     xord [ chr ( i ) ] = 127 ; 
  117.   while ( i++ < for_end ) ; } 
  118.   {register integer for_end; i = 128 ; for_end = 255 ; if ( i <= for_end) do 
  119.     xord [ xchr [ i ] ] = i ; 
  120.   while ( i++ < for_end ) ; } 
  121.   {register integer for_end; i = 0 ; for_end = 126 ; if ( i <= for_end) do 
  122.     xord [ xchr [ i ] ] = i ; 
  123.   while ( i++ < for_end ) ; } 
  124. #else
  125.   /* ST and AMIGA use an ASCII encoding, so ... (save space) */
  126.   /* There should be a CodePage support here, which uses xchr[] & xord[] */
  127.   for( i = 0; i < 255; i++ ) {
  128.     xchr[i] = chr(i);
  129.     /* ... and the rest is just this: (only for this xchr[] !!) */
  130.     xord[i] = i;    /* xord[xchr[i]] = i;  xord[127] = 127; */
  131.   }
  132. #endif
  133.  
  134. #endif    /* TEXCONFIG */
  135.  
  136.   interaction = errorstopmode ;
  137.   deletionsallowed = true ;
  138.   setboxallowed = true ;
  139.   errorcount = 0 ;
  140. #if 0
  141.   helpptr = 0 ; 
  142. #else
  143.   help0 ;
  144. #endif
  145.   useerrhelp = false ; 
  146.   interrupt = 0 ; 
  147.   OKtointerrupt = true ; 
  148.  
  149. #ifdef DEBUG
  150.   wasmemend = memmin ; 
  151.   waslomax = memmin ; 
  152.   washimin = memmax ; 
  153.   panicking = false ; 
  154. #endif /* DEBUG */
  155.   nestptr = 0 ; 
  156.   maxneststack = 0 ; 
  157.   curlist .modefield = vmode ;
  158.   curlist .headfield = contribhead ; 
  159.   curlist .tailfield = contribhead ; 
  160.   curlist .auxfield .cint = ignoredepth ; 
  161.   curlist .mlfield = 0 ; 
  162. #if 0  /* 3.1415 */
  163.   curlist .lhmfield = 0 ; 
  164.   curlist .rhmfield = 0 ; 
  165. #endif
  166. #ifdef TEXXET
  167.   LR_save = 0 ;
  168. #endif
  169.   curlist .pgfield = 0 ; 
  170.   shownmode = 0 ; 
  171.   pagecontents = 0 ; 
  172.   pagetail = pagehead ; 
  173.   link ( pagehead ) = 0 ; 
  174.   lastglue = maxhalfword ; 
  175.   lastpenalty = 0 ; 
  176.   lastkern = 0 ; 
  177.   pagesofar [ 7 ] = 0 ; 
  178.   pagemaxdepth = 0 ;
  179.   for( k = intbase ; k <= eqtbsize ; k++ ) {
  180.     xeqlevel [ k ] = levelone ; 
  181.   }
  182.   nonewcontrolsequence = true ; 
  183.   next ( hashbase ) = 0 ; 
  184.   ztext ( hashbase ) = 0 ; 
  185.   for( k = hashbase + 1 ; k <= undefinedcontrolsequence - 1 ; k++ ) {
  186.     hash [ k ] = hash [ hashbase ] ; 
  187.   }
  188.   saveptr = 0 ; 
  189.   curlevel = levelone ; 
  190.   curgroup = bottomlevel ; 
  191.   curboundary = 0 ; 
  192.   maxsavestack = 0 ; 
  193.   /* magset = 0 ; */ /* local nach preparemag() */
  194.   topmark = 0 ; 
  195.   firstmark = 0 ; 
  196.   botmark = 0 ; 
  197.   splitfirstmark = 0 ; 
  198.   splitbotmark = 0 ; 
  199.   curval = 0 ; 
  200.   curvallevel = intval ; 
  201.   radix = 0 ; 
  202.   curorder = 0 ; 
  203.   for( k = 16 ; k >= 0 ; --k )
  204.     readopen [ k ] = closed;
  205.   condptr = 0 ; 
  206.   iflimit = normal ; 
  207.   curif = 0 ; 
  208.   ifline = 0 ; 
  209.   for( k = fontmax ; k >= 0 ; --k )
  210.     fontused(k) = false;
  211.   nullcharacter .b0 = 0 ; 
  212.   nullcharacter .b1 = 0 ; 
  213.   nullcharacter .b2 = 0 ; 
  214.   nullcharacter .b3 = 0 ; 
  215.   totalpages = 0 ; 
  216.   maxv = 0 ; 
  217.   maxh = 0 ; 
  218.   maxpush = 0 ; 
  219.   lastbop = -1 ; 
  220.   doingleaders = false ; 
  221.   deadcycles = 0 ; 
  222. /* curs = -1 ; */
  223.   halfbuf = dvibufsize / 2 ; 
  224.   dvilimit = dvibufsize ; 
  225.   dviptr = 0 ; 
  226.   dvioffset = 0 ; 
  227.   dvigone = 0 ; 
  228. /* downptr = 0 ; */
  229. /* rightptr = 0 ; */
  230.   adjusttail = 0 ; 
  231.   lastbadness = 0 ; 
  232.   packbeginline = 0 ; 
  233.   emptyfield .v.RH = 0 ; 
  234.   emptyfield .v.LH = 0 ; 
  235.   nulldelimiter .b0 = 0 ; 
  236.   nulldelimiter .b1 = 0 ; 
  237.   nulldelimiter .b2 = 0 ; 
  238.   nulldelimiter .b3 = 0 ; 
  239.   alignptr = 0 ; 
  240.   curalign = 0 ; 
  241.   curspan = 0 ; 
  242.   curloop = 0 ; 
  243.   curhead = 0 ; 
  244.   curtail = 0 ; 
  245.   {register integer for_end; z = 0 ; for_end = hyphsize ; if ( z <= for_end) 
  246.   do 
  247.     {
  248.       hyphword(z) = 0 ; 
  249.       hyphlist(z) = 0 ; 
  250.     } 
  251.   while ( z++ < for_end ) ; } 
  252.   hyphcount = 0 ; 
  253.   outputactive = false ; 
  254.   insertpenalties = 0 ; 
  255.   ligaturepresent = false ; 
  256.   /* cancelboundary = false ; */ /* (br) local in main_control() */
  257.   lfthit = false ; 
  258.   rthit = false ;
  259.   /* insdisc = false ; */ /* (br) local in main_control() */
  260.   aftertoken = 0 ; 
  261.   longhelpseen = false ; 
  262.   formatident = 0 ; 
  263.   for( k = 17 ; k >= 0 ; --k )
  264.     writeopen [ k ] = false;
  265.   editnamestart = 0 ; 
  266. #ifdef INITEX
  267.   {register integer for_end; k = membot + 1 ; for_end = lomemstatmax ; if ( k 
  268.   <= for_end) do 
  269.     mem [ k ] .cint = 0 ; 
  270.   while ( k++ < for_end ) ; } 
  271.   k = membot ; 
  272.   while ( k <= lomemstatmax ) {
  273.     gluerefcount ( k ) = 1 ; 
  274.     stretchorder ( k ) = normal ; 
  275.     shrinkorder ( k ) = normal ; 
  276.     k = k + gluespecsize ; 
  277.   } 
  278.   stretch ( filglue ) = unity ; 
  279.   stretchorder ( filglue ) = fil ; 
  280.   stretch ( fillglue ) = unity ; 
  281.   stretchorder ( fillglue ) = fill ; 
  282.   stretch ( ssglue ) = unity ; 
  283.   stretchorder ( ssglue ) = fil ; 
  284.   shrink ( ssglue ) = unity ; 
  285.   shrinkorder ( ssglue ) = fil ; 
  286.   stretch ( filnegglue ) = - (integer) unity ; 
  287.   stretchorder ( filnegglue ) = fil ; 
  288.   rover = lomemstatmax + 1 ; 
  289.   link ( rover ) = emptyflag ; 
  290.   nodesize ( rover ) = 1000 ; 
  291.   llink ( rover ) = rover ; 
  292.   rlink ( rover ) = rover ; 
  293.   lomemmax = rover + 1000 ; 
  294.   link ( lomemmax ) = 0 ; 
  295.   info ( lomemmax ) = 0 ; 
  296.   {register integer for_end; k = himemstatmin ; for_end = memtop ; if ( k <= 
  297.   for_end) do 
  298.     mem [ k ] = mem [ lomemmax ] ; 
  299.   while ( k++ < for_end ) ; } 
  300.   info ( omittemplate ) = endtemplatetoken ; 
  301.   link ( endspan ) = maxquarterword + 1 ; 
  302.   info ( endspan ) = 0 ; 
  303.   ztype ( lastactive ) = hyphenated ; 
  304.   zlinenumber ( lastactive ) = maxhalfword ; 
  305.   subtype ( lastactive ) = 0 ; 
  306.   subtype ( pageinshead ) = 255 ; 
  307.   ztype ( pageinshead ) = splitup ; 
  308.   link ( pageinshead ) = pageinshead ; 
  309.   ztype ( pagehead ) = gluenode ; 
  310.   subtype ( pagehead ) = normal ; 
  311.   avail = 0 ; 
  312.   memend = memtop ; 
  313.   himemmin = himemstatmin ; 
  314.   varused = lomemstatmax + 1 - membot ; 
  315.   dynused = himemstatusage ; 
  316.   eqtype ( undefinedcontrolsequence ) = undefinedcs ; 
  317.   equiv ( undefinedcontrolsequence ) = 0 ; 
  318.   eqlevel ( undefinedcontrolsequence ) = levelzero ; 
  319.   for( k = activebase ; k <= undefinedcontrolsequence - 1 ; k++ ) {
  320.     eqtb [ k ] = eqtb [ undefinedcontrolsequence ] ; 
  321.   }
  322.   equiv ( gluebase ) = zeroglue ; 
  323.   eqlevel ( gluebase ) = levelone ; 
  324.   eqtype ( gluebase ) = glueref ; 
  325.   for( k = gluebase + 1 ; k <= localbase - 1 ; k++ ) {
  326.     eqtb [ k ] = eqtb [ gluebase ] ; 
  327.   }
  328.   gluerefcount ( zeroglue ) = gluerefcount ( zeroglue ) + localbase - gluebase;
  329.   parshapeptr = 0 ; 
  330.   eqtype ( parshapeloc ) = shaperef ; 
  331.   eqlevel ( parshapeloc ) = levelone ; 
  332.   for( k = outputroutineloc ; k <= toksbase + 255 ; k++ ) {
  333.     eqtb [ k ] = eqtb [ undefinedcontrolsequence ] ; 
  334.   }
  335.   box ( 0 ) = 0 ; 
  336.   eqtype ( boxbase ) = boxref ; 
  337.   eqlevel ( boxbase ) = levelone ; 
  338.   for( k = boxbase + 1 ; k <= boxbase + 255 ; k++ ) {
  339.     eqtb [ k ] = eqtb [ boxbase ] ; 
  340.   }
  341.   curfont = nullfont ; 
  342.   eqtype ( curfontloc ) = data ; 
  343.   eqlevel ( curfontloc ) = levelone ; 
  344.   {register integer for_end; k = mathfontbase ; for_end = mathfontbase + 47 
  345.   ; if ( k <= for_end) do 
  346.     eqtb [ k ] = eqtb [ curfontloc ] ; 
  347.   while ( k++ < for_end ) ; } 
  348.   equiv ( catcodebase ) = 0 ; 
  349.   eqtype ( catcodebase ) = data ; 
  350.   eqlevel ( catcodebase ) = levelone ; 
  351.   {register integer for_end; k = catcodebase + 1 ; for_end = intbase - 1 
  352.   ; if ( k <= for_end) do 
  353.     eqtb [ k ] = eqtb [ catcodebase ] ; 
  354.   while ( k++ < for_end ) ; } 
  355.   for( k = 255 ; k >= 0 ; --k ) {
  356.       catcode ( k ) = 12 ; 
  357.       mathcode ( k ) = k ; 
  358.       sfcode ( k ) = 1000 ; 
  359.   }
  360.   catcode ( 13 ) = 5 ; 
  361.   catcode ( 32 ) = 10 ; 
  362.   catcode ( 92 ) = 0 ; 
  363.   catcode ( 37 ) = 14 ; 
  364.   catcode ( 127 ) = 15 ; 
  365.   catcode ( 0 ) = 9 ; 
  366.   {register integer for_end; k = 48 ; for_end = 57 ; if ( k <= for_end) do 
  367.     mathcode ( k ) = k + varcode ; 
  368.   while ( k++ < for_end ) ; } 
  369.   {register integer for_end; k = 65 ; for_end = 90 ; if ( k <= for_end) do 
  370.     {
  371.       catcode ( k ) = 11 ; 
  372.       catcode ( k + 32 ) = 11 ; 
  373.       mathcode ( k ) = k + varcode + 256 ; 
  374.       mathcode ( k + 32 ) = k + 32 + varcode + 256 ; 
  375.       lccode ( k ) = k + 32 ; 
  376.       lccode ( k + 32 ) = k + 32 ; 
  377.       uccode ( k ) = k ; 
  378.       uccode ( k + 32 ) = k ; 
  379.       sfcode ( k ) = 999 ; 
  380.     } 
  381.   while ( k++ < for_end ) ; } 
  382.   {register integer for_end; k = intbase ; for_end = delcodebase - 1 ; if ( k 
  383.   <= for_end) do 
  384.     eqtb [ k ] .cint = 0 ; 
  385.   while ( k++ < for_end ) ; } 
  386.   mag = 1000 ; 
  387.   tolerance = 10000 ; 
  388.   hangafter = 1 ; 
  389.   maxdeadcycles = 25 ;
  390. #ifdef MLTEX
  391.   char_sub_def_max = 0;
  392.   tracing_char_sub_def = 0;
  393. #endif
  394.   escapechar = 92 ; 
  395.   endlinechar = 13 ; 
  396. #ifdef ERW_INTERACTION
  397.   interaction = errorstopmode;
  398. #endif
  399.   for( k = 255 ; k >= 0 ; --k ) {
  400.     delcode ( k ) = -1 ;
  401.   }
  402.  
  403.   delcode ( 46 ) = 0 ; 
  404.   {register integer for_end; k = dimenbase ; for_end = eqtbsize ; if ( k <= 
  405.   for_end) do 
  406.     eqtb [ k ] .cint = 0 ; 
  407.   while ( k++ < for_end ) ; } 
  408.   hashused = frozencontrolsequence ; 
  409.   cscount = 0 ; 
  410.   eqtype ( frozendontexpand ) = dontexpand ; 
  411.   ztext ( frozendontexpand ) = 498 ; 
  412.   fontptr = nullfont ; 
  413.   fmemptr = 7 ; 
  414.   fontname(nullfont) = STR_NULLFONT;
  415.   fontarea(nullfont) = 335 ; 
  416.   hyphenchar(nullfont) = 45 ; 
  417.   skewchar(nullfont) = -1 ; 
  418.   bcharlabel(nullfont) = nonaddress ; 
  419.   fontbchar(nullfont) = nonchar ; 
  420.   fontfalsebchar(nullfont) = nonchar;
  421.   fontbc(nullfont) = 1 ; 
  422.   fontec(nullfont) = 0 ; 
  423.   fontsize(nullfont) = 0 ; 
  424.   fontdsize(nullfont) = 0 ;
  425. #ifdef FONTPTR
  426.   charbase(nullfont) = &fontinfo[0] ; 
  427.   widthbase(nullfont) = &fontinfo[0] ; 
  428.   heightbase(nullfont) = &fontinfo[0] ; 
  429.   depthbase(nullfont) = &fontinfo[0] ; 
  430.   italicbase(nullfont) = &fontinfo[0] ; 
  431.   ligkernbase(nullfont) = &fontinfo[0] ; 
  432.   kernbase(nullfont) = &fontinfo[0] ; 
  433. #else
  434.   charbase(nullfont) = 0 ; 
  435.   widthbase(nullfont) = 0 ; 
  436.   heightbase(nullfont) = 0 ; 
  437.   depthbase(nullfont) = 0 ; 
  438.   italicbase(nullfont) = 0 ; 
  439.   ligkernbase(nullfont) = 0 ; 
  440.   kernbase(nullfont) = 0 ; 
  441. #endif
  442.   extenbase(nullfont) = 0 ; 
  443.   fontglue(nullfont) = 0 ; 
  444.   fontparams(nullfont) = 7 ; 
  445.   parambase(nullfont) = -1 ; 
  446.   for( k = 6 ; k >= 0 ; --k ) {
  447.     fontinfo [ k ].cint = 0 ;
  448.   }
  449.  
  450.   {register integer for_end; k = - (integer) trieopsize ; for_end = 
  451.   trieopsize ; if ( k <= for_end) do 
  452.     trieophash [ k ] = 0 ; 
  453.   while ( k++ < for_end ) ; } 
  454.   for( k = 255 ; k >= 0 ; --k ) {
  455.     trieused [ k ] = mintrieop ;
  456.   }
  457.   maxopused = mintrieop ; 
  458.   trieopptr = 0;
  459.   trienotready = true;
  460.   triel[0] = 0;
  461.   triec[0] = 0;
  462.   trieptr = 0;
  463.  
  464.   ztext ( frozenprotection ) = STR_INACCESSIBLE;
  465.   formatident = STR_INITEX ;
  466.   ztext ( endwrite ) = STR_ENDWRITE; 
  467.   eqlevel ( endwrite ) = levelone ; 
  468.   eqtype ( endwrite ) = outercall ; 
  469.   equiv ( endwrite ) = 0 ; 
  470. #endif /* INITEX */
  471. }
  472.  
  473.  
  474. #ifdef INITEX
  475. #if defined(MLTEX) || defined(TEXXET) || defined(ERW_INTERACTION)
  476. static void insert_c_string(char *s, strnumber n)
  477. {
  478.   if( poolptr + strlen(s) + stringvacancies > poolsize ) {
  479.     wakeupterminal ();
  480.     (void) printf("! You have to increase POOLSIZE.\n");
  481.     exit(1);
  482.   }
  483.  
  484.   while( *s != '\0' ) {
  485.     appendchar( *s++ );   /* oder xord[*s], falls Umlaute, ... erlaubt */
  486.   }
  487.  
  488.   if( n != makestring() ) {
  489.     wakeupterminal ();
  490.     (void) printf("! tex.pool doesn't match; wrong tex.pool file.\n");
  491.     (void) printf("! number of strings in pool file is wrong.\n");
  492.     exit(1);
  493.   }
  494. }
  495. #endif
  496.  
  497.  
  498. boolean getstringsstarted ( void )
  499. { getstringsstarted_regmem
  500.   register signed short k, l;
  501.   register short m, n;        /* ASCIIcode */
  502.   register strnumber g;
  503.   register integer a;
  504.   alphafile poolfile;
  505.  
  506.   poolptr = 0;
  507.   strptr = 0;
  508.   strstart[0] = 0;
  509.  
  510.   /* 48. Make the first 256 strings */
  511.   for( k = 0 ; k <= 255 ; k++ ) {
  512. #ifdef ERW_CODEPAGE
  513.     appendchar ( k );
  514.     g = makestring ();
  515. #else
  516. #ifdef NONASCII
  517.     if ( printable[k] )
  518. #else
  519.     if ( k < 32 || k > 126 )
  520. #endif
  521.     {
  522.     appendchar ( 94 );  appendchar ( 94 );
  523.     if ( k < 64 )
  524.       appendchar ( k + 64 );
  525.     else if ( k < 128 )
  526.       appendchar ( k - 64 );
  527.     else {
  528.       l = k / 16;  appendchar ( l + ( (l < 10) ? 48 : 87 ) );
  529.       l = k % 16;  appendchar ( l + ( (l < 10) ? 48 : 87 ) );
  530.     }
  531.     } else
  532.     appendchar ( k );
  533.     g = makestring ();
  534. #endif
  535.   }
  536.  
  537.  
  538.   /* 51. Read the other strings from TEX.POOL file ... */
  539.   vstrcpy ( nameoffile + 1 , poolname );
  540.   nameoffile [ 0 ] = ' ';
  541.   nameoffile [ strlen ( poolname ) + 1 ] = ' ';
  542.   namelength = strlen(poolname);  /* added br */
  543.   if ( aopenin(poolfile, TEXPOOLPATH) == false ) {
  544.     wakeupterminal ();
  545.     (void) printf("! I can't read tex.pool.\n");
  546.     return(false);
  547.   }
  548.  
  549.   while(true) {
  550.     /* 52. Read one string, but return |false| ... */
  551.     if( (m = getc(poolfile)) == EOF  ||  (n = getc(poolfile)) == EOF ) {
  552.       wakeupterminal ();
  553.       (void) printf("! tex.pool has no check sum.\n");
  554.       aclose ( poolfile );
  555.       return(false);
  556.     }
  557.  
  558.     if ( m == '*' ) {    /* 53. Check the pool check sum */
  559.       a = 0;  k = 9;
  560.       do {
  561.     if ( xord[n] < 48 || xord[n] > 57 ) {
  562.       wakeupterminal ();
  563.       (void) printf("! tex.pool check sum doesn't have nine digits.\n"); 
  564.       aclose ( poolfile );
  565.       return(false);
  566.     }
  567.     a = 10 * a + xord[n] - 48;
  568.       } while( --k > 0  &&  (n = getc(poolfile)) != EOF );
  569.  
  570.       if ( a != 127541212L ) {
  571.     wakeupterminal ();
  572.     (void) printf("! tex.pool doesn't match; wrong tex.pool file.\n");
  573.     aclose ( poolfile );
  574.     return(false);
  575.       }
  576.       break;    /*  leave loop ---v  */
  577.  
  578.     } else {
  579.       if ( xord[m] < 48 || xord[m] > 57 || xord[n] < 48 || xord[n] > 57 ) {
  580.     wakeupterminal ();
  581.     (void) printf("! tex.pool line doesn't begin with two digits.\n");
  582.     aclose ( poolfile );
  583.     return(false);
  584.       }
  585.       l = xord[m] * 10 + xord[n] - 48 * 11;    /* ... - "0" * 10 - "0" */
  586.       if ( poolptr + l + stringvacancies > poolsize ) {
  587.     wakeupterminal ();
  588.     (void) printf("! You have to increase POOLSIZE.\n");
  589.     aclose ( poolfile );
  590.     return(false);
  591.       }
  592.       while( --l >= 0 ) {
  593.     if( (m = getc(poolfile)) == EOF  ||  m == '\n' )    /* eoln() */
  594.       m = ' ';
  595.     appendchar ( xord[m] );
  596.       }
  597.       while( (m = getc(poolfile)) != EOF  &&  m != '\n' )
  598.     ;            /* == readln ( poolfile ); */
  599.       g = makestring();
  600.     }
  601.   }
  602.  
  603.   aclose ( poolfile );
  604.  
  605. #ifdef MLTEX
  606.   /* Insert the new strings at the end by hand,
  607.    * so we can use the old tex.pool file
  608.    */
  609.   insert_c_string("charsubdefmax", STR_CHARSUBDEFMAX);
  610.   insert_c_string("tracingcharsubdef", STR_TRACING_CHARSUBDEF);
  611.   insert_c_string("charsubdef", STR_CHARSUBDEF);
  612. #endif
  613.  
  614. #ifdef ERW_INTERACTION
  615.   insert_c_string("interactionmode", STR_INTERACTION_MODE);
  616. #endif
  617.  
  618. #ifdef TEXXET
  619.   insert_c_string("beginL", STR_BEGINL);
  620.   insert_c_string("beginR", STR_BEGINR);
  621.   insert_c_string("endL", STR_ENDL);
  622.   insert_c_string("endR", STR_ENDR);
  623. #endif
  624.  
  625.   return(true);
  626. }
  627. #endif /* INITEX */
  628.  
  629. #ifdef INITEX
  630. void sortavail ( void )
  631. { sortavail_regmem 
  632.   register halfword p, q, r ;
  633.   halfword oldrover;
  634.  
  635.   /* p = */ (void) getnode ( 1073741824L );
  636.   p = rlink ( rover );
  637.   rlink ( rover ) = maxhalfword;
  638.   oldrover = rover;
  639.   while ( p != oldrover )
  640.     if ( p < rover ) {
  641.       q = p ; 
  642.       p = rlink ( q ) ; 
  643.       rlink ( q ) = rover ; 
  644.       rover = q ; 
  645.     } else {
  646.       q = rover ; 
  647.       while ( rlink ( q ) < p )
  648.     q = rlink ( q ) ; 
  649.       r = rlink ( p ) ; 
  650.       rlink ( p ) = rlink ( q ) ; 
  651.       rlink ( q ) = p ; 
  652.       p = r ; 
  653.     }
  654.   p = rover ; 
  655.   while ( rlink ( p ) != maxhalfword ) {
  656.     llink ( rlink ( p ) ) = p ; 
  657.     p = rlink ( p ) ; 
  658.   } 
  659.   rlink ( p ) = rover ; 
  660.   llink ( rover ) = p ; 
  661. } 
  662. #endif /* INITEX */
  663.  
  664. #if 0
  665.  
  666. #ifdef INITEX
  667. void zprimitive ( strnumber s, quarterword c, halfword o );
  668. #endif /* INITEX */
  669.  
  670. #endif
  671.  
  672. #ifdef INITEX
  673. trieopcode newtrieop ( smallnumber d, smallnumber n, trieopcode v )
  674. { newtrieop_regmem 
  675.   register integer h ;
  676.   trieopcode u ;
  677.   register integer l ;
  678.  
  679.   h = abs ( toint ( n ) + 313 * toint ( d ) + 361 * toint ( v ) + 1009 * toint 
  680.     ( curlang ) ) % ( trieopsize + trieopsize ) - trieopsize ; 
  681.   while ( true ) {
  682.     l = trieophash [ h ];
  683.     if ( l == 0 ) {
  684.       if ( trieopptr == trieopsize ) 
  685.         overflow(13, trieopsize);
  686.       u = trieused [ curlang ] ; 
  687.       if ( u == maxtrieop ) 
  688.         overflow(14, maxtrieop - mintrieop);
  689.       incr ( trieopptr ) ; 
  690.       incr ( u ) ; 
  691.       trieused [ curlang ] = u ; 
  692.       if ( u > maxopused ) 
  693.         maxopused = u ; 
  694.       hyfdistance(trieopptr) = d;
  695.       hyfnum(trieopptr) = n ; 
  696.       hyfnext(trieopptr) = v ; 
  697.       trieoplang [ trieopptr ] = curlang ; 
  698.       trieophash [ h ] = trieopptr ; 
  699.       trieopval [ trieopptr ] = u ; 
  700.       return(u) ; 
  701.     }
  702.     if ( ( hyfdistance(l) == d ) && ( hyfnum(l) == n )
  703.     && ( hyfnext(l) == v ) && ( trieoplang [ l ] == curlang ) ) {
  704.       return(trieopval [ l ]);
  705.     }
  706.     if ( h > - (integer) trieopsize ) 
  707.       decr ( h ) ; 
  708.     else h = trieopsize ; 
  709.   }
  710. }
  711.  
  712. triepointer trienode ( triepointer p )
  713. { trienode_regmem 
  714.   register triepointer h ;
  715.   register triepointer q ; 
  716.  
  717. #ifdef ORIGTRIE
  718.   h = abs ( toint ( triec [ p ] ) + 1009 * toint ( trieo [ p ] ) + 2718 * 
  719.     toint ( triel [ p ] ) + 3142 * toint ( trier [ p ] ) ) % triesize ; 
  720. #else
  721.   h = abs ( toint ( triec[p] ) + 1009 * toint ( ztrie[p].trieo ) +
  722.     2718 * toint ( triel[p] ) + 3142 * toint ( trier[p] ) ) % triesize;
  723. #endif
  724.   while ( true ) {
  725.     q = triehash [ h ] ; 
  726.     if ( q == 0 ) {
  727.       triehash [ h ] = p ; 
  728.       return(p) ; 
  729.     } 
  730.     if ( ( triec [ q ] == triec [ p ] ) && (
  731. #ifdef ORIGTRIE
  732.                         trieo [ q ] == trieo [ p ]
  733. #else
  734.                     ztrie[q].trieo == ztrie[p].trieo
  735. #endif
  736.                                     )
  737.     && ( triel [ q ] == triel [ p ] ) && ( trier [ q ] == trier [ p ] ) ) {
  738.       return(q) ; 
  739.     }
  740.     if ( h > 0 )
  741.       decr ( h ) ; 
  742.     else
  743.       h = triesize ; 
  744.   }
  745. }
  746.  
  747. triepointer compresstrie ( triepointer p )
  748. { compresstrie_regmem 
  749.  
  750.   if ( p == 0 ) 
  751.     return( (triepointer)0L );
  752.   else {
  753.     triel [ p ] = compresstrie ( triel [ p ] ) ; 
  754.     trier [ p ] = compresstrie ( trier [ p ] ) ; 
  755.     return( trienode ( p ) );
  756.   }
  757. }
  758.  
  759. void firstfit ( triepointer p )
  760. { firstfit_regmem
  761.   register triepointer q;
  762.   register triepointer h;
  763.  
  764.  {triepointer z;
  765.   ASCIIcode c;
  766.  
  767.   c = triec [ p ] ; 
  768.   z = triemin [ c ] ; 
  769.   while ( true ) {
  770.     h = z - c ; 
  771.     if ( triemax < h + 256 ) {
  772.       if ( triesize <= h + 256 ) 
  773.     overflow(15, triesize);
  774.       do {
  775.     incr ( triemax ) ;
  776. #ifdef ORIGTRIE
  777.     trietaken [ triemax ] = false ; 
  778. #else
  779.     ztrie[triemax].trietaken = false;
  780. #endif
  781.     trietrl [ triemax ] = triemax + 1 ; 
  782.     trietro [ triemax ] = triemax - 1 ; 
  783.       } while ( ! ( triemax == h + 256 ) ) ; 
  784.     }
  785. #ifdef ORIGTRIE
  786.     if ( trietaken [ h ] ) 
  787.     goto lab45 ; 
  788. #else
  789.     if ( ztrie[h].trietaken )
  790.     goto lab45 ; 
  791. #endif
  792.     q = trier [ p ] ; 
  793.     while ( q > 0 ) {
  794.       if ( trietrl [ h + triec [ q ] ] == 0 ) 
  795.       goto lab45 ; 
  796.       q = trier [ q ] ; 
  797.     } 
  798.     goto lab40 ; 
  799. lab45:
  800.     z = trietrl [ z ] ; 
  801.   }
  802.  
  803. lab40:
  804. #ifdef ORIGTRIE
  805.   trietaken [ h ] = true ; 
  806. #else
  807.   ztrie[h].trietaken = true;
  808. #endif
  809.   triehash [ p ] = h ; 
  810.  }
  811.  
  812.   q = p;
  813.   do {
  814.     register triepointer l, r;
  815.     triepointer z;
  816.  
  817.     z = h + triec [ q ] ; 
  818.     l = trietro [ z ] ; 
  819.     r = trietrl [ z ] ; 
  820.     trietro [ r ] = l ; 
  821.     trietrl [ l ] = r ; 
  822.     trietrl [ z ] = 0 ; 
  823.     if ( l < 256 ) {
  824.       register short ll;
  825.  
  826.       if ( z < 256 )
  827.         ll = z;
  828.       else
  829.     ll = 256;
  830.       do {
  831.     triemin [ l ] = r;
  832.     incr ( l );
  833.       } while( l != ll );
  834.     } 
  835.     q = trier [ q ];
  836.   } while ( q != 0 );
  837. }
  838.  
  839. void triepack ( triepointer p )
  840. { triepack_regmem 
  841.   register triepointer q;
  842.  
  843.   do {
  844.     q = triel [ p ] ; 
  845.     if ( ( q > 0 ) && ( triehash [ q ] == 0 ) ) {
  846.       firstfit ( q ) ; 
  847.       triepack ( q ) ; 
  848.     } 
  849.     p = trier [ p ] ; 
  850.   } while ( ! ( p == 0 ) ) ; 
  851. }
  852.  
  853. void triefix ( triepointer p )
  854. { triefix_regmem 
  855.   register triepointer q  ; 
  856.   register ASCIIcode c  ; 
  857.   register triepointer z  ; 
  858.  
  859.   z = triehash [ p ] ; 
  860.   do {
  861.     q = triel [ p ] ; 
  862.     c = triec [ p ] ; 
  863.     trietrl [ z + c ] = triehash [ q ] ; 
  864.     trietrc [ z + c ] = c ; 
  865. #ifdef ORIGTRIE
  866.     trietro [ z + c ] = trieo [ p ] ; 
  867. #else
  868.     trietro [ z + c ] = ztrie[p].trieo;
  869. #endif
  870.     if ( q > 0 )
  871.     triefix ( q ) ; 
  872.     p = trier [ p ] ; 
  873.   } while ( p != 0 );
  874. } 
  875.  
  876. void newpatterns ( void )
  877. { newpatterns_regmem
  878.   register short k, l;
  879.   boolean digitsensed;
  880.   trieopcode v;
  881.   register triepointer p, q;
  882.   boolean firstchild;
  883.   register ASCIIcode c;
  884.  
  885.   if ( ! trienotready ) {
  886.     print_err("Too late for ");
  887.     printesc( STR_PATTERNS );
  888.     zhelp1( STR_H_ALL_PATTERNS );
  889.     error();
  890.     link ( garbage ) = scantoks ( false , false ) ; 
  891.     flushlist ( defref ) ; 
  892.     return;
  893.   }
  894.  
  895.   if ( language <= 0 ) 
  896.     curlang = 0 ; 
  897.   else if ( language > 255 ) 
  898.     curlang = 0 ; 
  899.   else curlang = language ; 
  900.  
  901.   scanleftbrace () ; 
  902.  
  903.   k = 0 ; 
  904.   hyf [ 0 ] = 0 ; 
  905.   digitsensed = false ; 
  906.  
  907.   while ( true ) {
  908.     register /* eightbits */ long_halfword r_curcmd;
  909.  
  910.     r_curcmd = getxtoken () ; 
  911.     switch ( r_curcmd ) {
  912.     case letter : 
  913.     case otherchar :
  914.     { register halfword r_curchr = curchr;
  915.  
  916.     if ( digitsensed || ( r_curchr < 48 ) || ( r_curchr > 57 ) ) {
  917.       if ( r_curchr == 46 )
  918.         r_curchr = 0 ; 
  919.       else {
  920.         r_curchr = lccode ( r_curchr ) ; 
  921.         if ( r_curchr == 0 ) {
  922.           curchr = r_curchr;
  923.           print_err("Nonletter");
  924.           zhelp1( STR_H_SEE_APP_H );
  925.           error(); 
  926.           r_curchr = curchr; 
  927.         } 
  928.       } 
  929.       if ( k < 63 ) {
  930.         incr ( k ) ; 
  931.         hc [ k ] = r_curchr ; 
  932.         hyf [ k ] = 0 ; 
  933.         digitsensed = false ; 
  934.       } 
  935.     } else if ( k < 63 ) {
  936.       hyf [ k ] = r_curchr - 48 ; 
  937.       digitsensed = true ; 
  938.     }
  939.     }
  940.     break ; 
  941.     case spacer : 
  942.     case right_brace : 
  943.     {
  944.       if ( k > 0 ) {
  945.         if ( hc [ 1 ] == 0 ) 
  946.           hyf [ 0 ] = 0 ; 
  947.         if ( hc [ k ] == 0 ) 
  948.           hyf [ k ] = 0 ; 
  949.         l = k ; 
  950.         v = mintrieop ; 
  951.         while ( true ) {
  952.           if ( hyf [ l ] != 0 ) 
  953.         v = newtrieop ( k - l , hyf [ l ] , v ) ; 
  954.           if ( l > 0 ) 
  955.         decr ( l ) ; 
  956.           else goto lab31 ; 
  957.         }
  958. lab31: ; 
  959.         q = 0 ; 
  960.         hc [ 0 ] = curlang ; 
  961.         while ( l <= k ) {
  962.           c = hc [ l ] ; 
  963.           incr ( l ) ; 
  964.           p = triel [ q ] ; 
  965.           firstchild = true ; 
  966.           while ( ( p > 0 ) && ( c > triec [ p ] ) ) {
  967.         q = p ; 
  968.         p = trier [ q ] ; 
  969.         firstchild = false ; 
  970.           } 
  971.           if ( ( p == 0 ) || ( c < triec [ p ] ) ) {
  972.         if ( trieptr == triesize ) 
  973.           overflow(15, triesize);
  974.         incr ( trieptr ) ; 
  975.         trier [ trieptr ] = p ; 
  976.         p = trieptr ; 
  977.         triel [ p ] = 0 ; 
  978.         if ( firstchild ) 
  979.           triel [ q ] = p ; 
  980.         else trier [ q ] = p ; 
  981.           triec [ p ] = c ; 
  982. #ifdef ORIGTRIE
  983.         trieo [ p ] = mintrieop ; 
  984. #else
  985.         ztrie[p].trieo = mintrieop;
  986. #endif
  987.           } 
  988.           q = p ; 
  989.         } 
  990.         if (
  991. #ifdef ORIGTRIE
  992.         trieo [ q ] != mintrieop
  993. #else
  994.         ztrie[q].trieo != mintrieop
  995. #endif
  996.                         ) {
  997.           print_err("Duplicate pattern");
  998.           zhelp1( STR_H_SEE_APP_H );
  999.           error();
  1000.         } 
  1001. #ifdef ORIGTRIE
  1002.         trieo [ q ] = v ; 
  1003. #else
  1004.         ztrie[q].trieo = v;
  1005. #endif
  1006.       } 
  1007.       if ( curcmd == right_brace )
  1008.         goto lab30;
  1009.  
  1010.       k = 0 ; 
  1011.       hyf [ 0 ] = 0 ; 
  1012.       digitsensed = false ; 
  1013.     } 
  1014.     break ; 
  1015.     default: 
  1016.     print_err("Bad ");
  1017.     printesc( STR_PATTERNS );
  1018.     zhelp1( STR_H_SEE_APP_H );
  1019.     error();
  1020.     break;
  1021.       }
  1022.   }        /* while ( true ) */
  1023. lab30: ; 
  1024. }
  1025.  
  1026. void inittrie ( void )
  1027. { inittrie_regmem 
  1028.  
  1029.  {register integer j;
  1030.  
  1031.   opstart [ 0 ] = - (integer) mintrieop ; 
  1032.   for( j = 1 ; j <= 255 ; j++ ) {
  1033.     opstart [ j ] = opstart [ j - 1 ] + trieused [ j - 1 ] ; 
  1034.   }
  1035.   {register integer for_end; j = 1 ; for_end = trieopptr ; if ( j <= for_end) 
  1036.   do 
  1037.     trieophash [ j ] = opstart [ trieoplang [ j ] ] + trieopval [ j ] ; 
  1038.   while ( j++ < for_end ) ; } 
  1039.  
  1040.   for( j = 1 ; j <= trieopptr ; j++ ) {
  1041.     while ( trieophash [ j ] > j ) {
  1042.       register integer k, t;
  1043.  
  1044.       k = trieophash [ j ] ; 
  1045.       t = hyfdistance(k); hyfdistance(k) = hyfdistance(j); hyfdistance(j) = t;
  1046.       t = hyfnum(k); hyfnum(k) = hyfnum(j); hyfnum(j) = t;
  1047.       t = hyfnext(k); hyfnext(k) = hyfnext(j); hyfnext(j) = t;
  1048.       trieophash [ j ] = trieophash [ k ] ; 
  1049.       trieophash [ k ] = k ; 
  1050.     }
  1051.   }
  1052.  }
  1053.  
  1054.  {register triepointer p;
  1055.  
  1056.   {register integer for_end; p = 0 ; for_end = triesize ; if ( p <= for_end) 
  1057.   do 
  1058.     triehash [ p ] = 0 ; 
  1059.   while ( p++ < for_end ) ; } 
  1060.  
  1061.   triel [ 0 ] = compresstrie ( triel [ 0 ] ) ; 
  1062.  
  1063.   {register integer for_end; p = 0 ; for_end = trieptr ; if ( p <= for_end) 
  1064.   do 
  1065.     triehash [ p ] = 0 ; 
  1066.   while ( p++ < for_end ) ; } 
  1067.  
  1068.   for( p = 0 ; p <= 255 ; p++ ) {
  1069.     triemin [ p ] = p + 1 ; 
  1070.   }
  1071.  }
  1072.  
  1073.   trietrl [ 0 ] = 1 ; 
  1074.   triemax = 0 ; 
  1075.   if ( triel [ 0 ] != 0 ) {
  1076.     firstfit ( triel [ 0 ] ) ; 
  1077.     triepack ( triel [ 0 ] ) ; 
  1078.   } 
  1079.   if ( triel [ 0 ] == 0 ) {
  1080.     register triepointer r;
  1081.  
  1082.     for( r = 0 ; r <= 256 ; r++ ) {
  1083.     trietrc [ r ] = 0 ; 
  1084.     trietrl [ r ] = 0 ; 
  1085.     trietro [ r ] = mintrieop ; 
  1086.     }
  1087.     triemax = 256 ; 
  1088.   } else {
  1089.     triefix ( triel [ 0 ] ) ; 
  1090.     { register triepointer r = 0;
  1091.  
  1092.       do {
  1093.     register triepointer s;
  1094.  
  1095.     s = trietrl [ r ] ; 
  1096.     trietrl [ r ] = 0 ; 
  1097.     trietro [ r ] = mintrieop ; 
  1098.     trietrc [ r ] = 0 ; 
  1099.     r = s ; 
  1100.       } while ( r <= triemax );
  1101.     }
  1102.   }
  1103.   trietrc [ 0 ] = 63 ; 
  1104.   trienotready = false ; 
  1105. }
  1106. #endif /* INITEX */
  1107.  
  1108.  
  1109.     /*
  1110.      * prefixedcommand() wurde nach tex8.c verlegt und nur der
  1111.      * Teil, der in initex/virtex anders ist, hier als separate
  1112.      * Funktion realisiert.
  1113.      * returnvalue: initex=0, virtex!=0
  1114.      */
  1115. int call_new_patterns(void)
  1116. {
  1117. #ifdef INITEX
  1118.   newpatterns();
  1119.   return(0);
  1120. #else /* ! INITEX */
  1121.   call_new_patterns_regmem
  1122.  
  1123.   print_err("Patterns can be loaded only by INITEX");
  1124.   help0;
  1125.   error();
  1126.   { register eightbits r_curcmd;
  1127.  
  1128.     do {
  1129.       r_curcmd = gettoken();
  1130.     } while( r_curcmd != right_brace );
  1131.   }
  1132.   return(1);
  1133. #endif
  1134. }
  1135.  
  1136.  
  1137. #if 0
  1138.  
  1139. #ifdef INITEX
  1140. void storefmtfile ( ) 
  1141. #endif /* INITEX */
  1142.  
  1143. boolean loadfmtfile ( ) 
  1144.  
  1145. #endif
  1146.  
  1147.  
  1148. void finalcleanup ( void )
  1149. {/* 10 */ finalcleanup_regmem 
  1150.   register smallnumber c  ; 
  1151.  
  1152.   c = curchr ; 
  1153.   if ( jobname == 0 ) 
  1154.     openlogfile () ; 
  1155.   while ( openparens > 0 ) {
  1156.     c_print(" )");
  1157.     decr ( openparens ) ; 
  1158.   } 
  1159.   if ( curlevel > levelone ) {
  1160.     printnl ( 40 ) ; 
  1161.     c_printesc("end occurred ");
  1162.     c_print("inside a group at level ");
  1163.     printint ( curlevel - levelone ) ; 
  1164.     printchar ( 41 ) ; 
  1165.   } 
  1166.   while ( condptr != 0 ) {
  1167.     printnl ( 40 ) ; 
  1168.     c_printesc("end occurred ");
  1169.     c_print("when ");
  1170.     printcmdchr ( iftest , curif ) ; 
  1171.     if ( ifline != 0 ) {
  1172.       c_print(" on line ");
  1173.       printint ( ifline );
  1174.     } 
  1175.     c_print(" was incomplete)");
  1176.     ifline = iflinefield ( condptr ) ; 
  1177.     curif = subtype ( condptr ) ; 
  1178.     condptr = link ( condptr ) ; 
  1179.   } 
  1180.   if ( history != spotless ) 
  1181.   if ( ( ( history == warningissued ) || ( interaction < errorstopmode ) ) ) 
  1182.   if ( selector == termandlog ) 
  1183.   {
  1184.     selector = termonly ; 
  1185.     c_printnl("(see the transcript file for additional information)");
  1186.     selector = termandlog ; 
  1187.   } 
  1188.   if ( c == 1 ) {
  1189. #ifdef INITEX
  1190.     storefmtfile () ; 
  1191. #else  /* ! INITEX */
  1192.     c_printnl("(\\dump is performed only by INITEX)");
  1193. #endif /* ! INITEX */
  1194.     return ; 
  1195.   } 
  1196. } 
  1197.  
  1198. #if 0
  1199.  
  1200. #ifdef INITEX
  1201. void initprim ( ) 
  1202. #endif /* INITEX */
  1203.  
  1204. #endif
  1205.  
  1206.  
  1207.    static boolean
  1208. check_consistency(void)
  1209. { char bad = 0;
  1210.   char *extra_info = NULL;
  1211.  
  1212.   if ( halferrorline < 30 || halferrorline > errorline - 15 ) {
  1213.     bad = 1;
  1214.     extra_info = "`halferrorline' should be between 30 and (errorline-15)";
  1215.   }
  1216.   if ( maxprintline < 60 ) {
  1217.     bad = 2;
  1218.     extra_info = "`maxprintline' should be at least 60";
  1219.   }
  1220.   if ( (dvibufsize < 32) && (dvibufsize % 8 != 0) ) {
  1221.     bad = 3;
  1222.     extra_info = "`dvibufsize' must be >= 32 and a multiple of 8";
  1223.   }
  1224.   if ( membot + 1100 > memtop ) {
  1225.     bad = 4;
  1226.     extra_info = "`memtop' should be at least 1100";
  1227.   }
  1228.   if ( hashprime > hashsize )
  1229.     bad = 5;
  1230.   if ( maxinopen >= 128 ) {
  1231.     bad = 6;
  1232.     extra_info = "`maxinopen' must not exceed 127";
  1233.   }
  1234.   if ( memtop < 267 )
  1235.     bad = 7;
  1236.  
  1237. #ifdef INITEX
  1238.   if ( memmin != membot || memmax != memtop ) {
  1239.     bad = 10;
  1240.     extra_info = "`memmax' = `memtop' for IniTeX";
  1241.   }
  1242. #else
  1243.   if ( memmin > membot || memmax < memtop ) {
  1244.     bad = 10;
  1245.     extra_info = "`memmax' >= `memtop'";
  1246.   }
  1247. #endif /* INITEX */
  1248.   if ( 0 > 0 || maxquarterword < 127 )
  1249.     bad = 11;
  1250.   if ( 0 > 0 || maxhalfword < 32767 )
  1251.     bad = 12;
  1252.   if ( 0 < 0 || maxquarterword > maxhalfword )
  1253.     bad = 13;
  1254.   if ( memmin < 0 || memmax >= maxhalfword || (membot-memmin > maxhalfword+1)) {
  1255.     bad = 14;
  1256. #ifdef BIG
  1257.     /* fuer 524286 memwords benoetigt man 0.5M * 8 bytes = 4MB Speicher */
  1258. #ifdef INITEX
  1259.     extra_info = "`memtop' must not exceed 524286";
  1260. #else
  1261.     extra_info = "`memmax' must not exceed 524286";
  1262. #endif
  1263. #else
  1264. #ifdef INITEX
  1265.     extra_info = "`memtop' must not exceed 65534";
  1266. #else
  1267.     extra_info = "`memmax' must not exceed 65534";
  1268. #endif
  1269. #endif
  1270.   }
  1271.   if ( 0 < 0 || fontmax > maxquarterword ) {
  1272.     bad = 15;
  1273.     extra_info = "`fontmax' must not exceed 255";
  1274.   }
  1275.   if ( fontmax > 256 )
  1276.     bad = 16;
  1277.   if ( savesize > maxhalfword || maxstrings > maxhalfword ) {
  1278.     bad = 17;
  1279.     extra_info = "`savesize' and `maxstrings' must not exceed 65535";
  1280.   }
  1281.   if ( bufsize > maxhalfword ) {
  1282.     bad = 18;
  1283.     extra_info = "`bufsize' must not exceed 65535";
  1284.   }
  1285.   if ( maxquarterword - 0 < 255 ) 
  1286.     bad = 19;
  1287.   if ( cstokenflag + undefinedcontrolsequence > maxhalfword ) 
  1288.     bad = 21;
  1289.   if ( formatdefaultlength > FILENAMESIZE ) 
  1290.     bad = 31;
  1291.   if ( 2 * maxhalfword < memtop - memmin ) 
  1292.     bad = 41;
  1293.   if ( bad > 0 ) {
  1294.     (void) printf("\
  1295. Ouch---my internal constants have been clobbered!---case %ld\n" , (long)bad );
  1296.     if( extra_info != NULL )
  1297.       (void) printf("Check: %s!\n", extra_info);
  1298.     return(false);
  1299.   }
  1300.   return(true);
  1301. }
  1302.  
  1303.  
  1304. void texbody ( void )
  1305. { texbody_regmem 
  1306.  
  1307.   history = fatalerrorstop ; 
  1308.   setpaths ( TEXFORMATPATHBIT+TEXINPUTPATHBIT+TEXPOOLPATHBIT+TFMFILEPATHBIT );
  1309.   if ( readyalready == 314159L ) 
  1310.     goto lab1 ; 
  1311.  
  1312.   if( ! check_consistency() )
  1313.     goto lab9999;
  1314.  
  1315.   initialize () ;
  1316. #ifdef INITEX
  1317.   if ( ! getstringsstarted () ) 
  1318.     goto lab9999 ; 
  1319.   initprim () ; 
  1320.   initstrptr = strptr ; 
  1321.   initpoolptr = poolptr ; 
  1322.   dateandtime ( ztime , zday , zmonth , zyear ) ; 
  1323. #endif /* INITEX */
  1324.   readyalready = 314159L ; 
  1325.  
  1326. lab1:
  1327.   selector = termonly ; 
  1328.   tally = 0 ; 
  1329.   termoffset = 0 ; 
  1330.   fileoffset = 0 ; 
  1331. #if 0
  1332.   (void) Fputs( stdout ,  "This is TeX, C Version 3.14t2" ) ; 
  1333. #else
  1334.   (void) Fputs( stdout ,  banner );
  1335. #endif
  1336.  
  1337. #ifdef INITEX
  1338. #if defined(MLTEX) && defined(TEXXET)
  1339.   if( is_ML_TeX && is_TeX_XeT)
  1340.     (void) Fputs(stdout, "\nThis is TeX--XeT (1.0) with ML-TeX (V.3)");
  1341.   else if( is_ML_TeX )
  1342.     (void) Fputs(stdout, "\nThis is ML-TeX, Version 3");
  1343.   else if( is_TeX_XeT )
  1344.     (void) Fputs(stdout, "\nThis is TeX--XeT (1.0)");
  1345. #else
  1346. # ifdef MLTEX
  1347.   /* if user has given ML-TeX switch in IniTeX, output a second line */
  1348.   if( is_ML_TeX )
  1349.     (void) Fputs(stdout, "\nThis is ML-TeX, Version 3");
  1350. # endif
  1351. # ifdef TEXXET
  1352.   /* if user has given TeX-XeT switch in IniTeX, output a second line */
  1353.   if( is_TeX_XeT )
  1354.     (void) Fputs(stdout, "\nThis is TeX--XeT (1.0)");
  1355. # endif
  1356. #endif
  1357. #endif
  1358.  
  1359.   if ( formatident > 0 ) 
  1360. #if 0  /* TeX 3.141 */
  1361.     print( formatident );
  1362. #else
  1363.     slowprint( formatident );
  1364. #endif
  1365.   println ();
  1366.   flush ( stdout );
  1367.   jobname = 0;
  1368.   nameinprogress = false;
  1369.   logopened = false;
  1370.   outputfilename = 0;
  1371.  
  1372.   inputptr = 0;
  1373. #ifdef INP_PTR
  1374.   curinput_ptr = &inputstack[ /* inputptr */ 0 ];
  1375. #endif
  1376.   maxinstack = 0;
  1377.   inopen = 0 ; 
  1378.   openparens = 0 ; 
  1379.   maxbufstack = 0 ; 
  1380.   paramptr = 0 ; 
  1381.   maxparamstack = 0 ; 
  1382.   first = bufsize ; 
  1383.   do {
  1384.     buffer [ first ] = 0 ; 
  1385.     decr ( first ) ; 
  1386.   } while ( first != 0 ) ; 
  1387.   scannerstatus = normal ; 
  1388.   warningindex = 0 ; 
  1389.   first = 1 ; 
  1390.   curinput .statefield = 33 ; 
  1391.   curinput .startfield = 1 ; 
  1392.   curinput .indexfield = 0 ; 
  1393.   line = 0 ; 
  1394.   curinput .namefield = 0 ; 
  1395.   forceeof = false ; 
  1396.   alignstate = 1000000L ; 
  1397.   if ( ! initterminal () ) 
  1398.     goto lab9999 ; 
  1399.   curinput .limitfield = last ; 
  1400.   first = last + 1 ; 
  1401.  
  1402.   if ( ( formatident == 0 ) || ( buffer [ curinput .locfield ] == 38 ) ) {
  1403.     if ( formatident != 0 ) 
  1404.     initialize () ; 
  1405.     if ( ! openfmtfile () ) 
  1406.     goto lab9999 ; 
  1407.     if ( ! loadfmtfile () ) {
  1408.     wclose ( fmtfile ) ; 
  1409.     goto lab9999 ; 
  1410.     } 
  1411.     wclose ( fmtfile ) ; 
  1412.     while ( ( curinput .locfield < curinput .limitfield ) && ( buffer [ 
  1413.       curinput .locfield ] == 32 ) )
  1414.     incr ( curinput .locfield ) ; 
  1415.   }
  1416.   if ( endlinecharinactive () ) 
  1417.     decr ( curinput .limitfield ) ; 
  1418.   else
  1419.     buffer [ curinput .limitfield ] = endlinechar ; 
  1420.   dateandtime ( ztime , zday , zmonth , zyear ) ; 
  1421. #if 0    /* (br) nicht mehr benoetigt */
  1422.   magicoffset = strstart [ 885 ] - 9 * ordnoad ; 
  1423. #endif
  1424.  
  1425.   /* (br) added: Has User set a \language ? */
  1426.   if( user_language >= 0 )
  1427.     geqworddefine( intbase+languagecode, user_language );
  1428.  
  1429.   /* (br) added: Has User set another Interaction Level ? */
  1430.   if( user_interaction != -1 )
  1431.     interaction = user_interaction;
  1432.  
  1433.   if ( interaction <= batchmode )
  1434.     selector = noprint ; 
  1435.   else selector = termonly ; 
  1436.   if ( ( curinput .locfield < curinput .limitfield )
  1437.     && ( catcode ( buffer [ curinput .locfield ] ) != 0 ) ) 
  1438.     startinput();
  1439.  
  1440.   history = spotless ; 
  1441.   maincontrol () ; 
  1442.   finalcleanup () ; 
  1443.   closefilesandterminate () ; 
  1444.  
  1445. lab9999:
  1446.   {
  1447.     flush ( stdout ) ; 
  1448.     readyalready = 0 ; 
  1449.     if ( ( history != spotless ) && ( history != warningissued ) ) 
  1450.       uexit ( 1 ) ; 
  1451.     else uexit ( 0 ) ; 
  1452.   } 
  1453. }
  1454.  
  1455. /* -- end -- */
  1456.