src/texsourc/itex.c

   1 /* Copyright 1992 Karl Berry
   2    Copyright 2007 TeX Users Group
   3    Copyright 2014 Clerk Ma
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 2 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful, but
  11    WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software
  17    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  18    02110-1301 USA.  */
  19
  20 #ifdef _WINDOWS
  21   #define NOCOMM
  22   #define NOSOUND
  23   #define NODRIVERS
  24   #define STRICT
  25   #pragma warning(disable:4115) // kill rpcasync.h complaint
  26   #include <windows.h>
  27   #define MYLIBAPI __declspec(dllexport)
  28 #endif
  29
  30 #include "texwin.h"
  31
  32 #pragma warning(disable:4996)
  33 #pragma warning(disable:4131)   // old style declarator
  34 #pragma warning(disable:4135)   // conversion between different integral types
  35 #pragma warning(disable:4127)   // conditional expression is constant
  36
  37 #include <setjmp.h>
  38
  39 #define EXTERN extern
  40
  41 #include "texd.h"
  42
  43 #pragma warning(disable:4244)                           /* 96/Jan/10 */
  44
  45 #include <time.h>                                                       // needed for clock_t
  46
  47 /* #define CHECKPOOL */                                         /* debugging only */
  48
  49 #define BEGINFMTCHECKSUM 367403084L
  50 #define ENDFMTCHECKSUM   69069L
  51
  52 extern clock_t start_time, main_time, finish_time;      /* in local.c */
  53
  54 /* imported from pascal.h */
  55 /* localized here to avoid conflict with io.h in other code */
  56
  57 #define read(f, b)      ((b) = getc (f))
  58 #define readln(f)   { register int c; while ((c = getc (f)) != '\n' && c != EOF); }
  59 /* #define      readln(f)       { while (getc (f) >= ' '); } ? use fgets ? */
  60
  61 #ifdef INITEX
  62   void do_initex (void);                                        /* later in this file */
  63 #endif
  64
  65 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
  66
  67 void initialize (void)
  68 {
  69   integer i;
  70   integer k;
  71   integer flag;                                         /* bkph */
  72 #ifndef ALLOCATEHYPHEN
  73   hyph_pointer z;
  74 #endif
  75
  76 /* We already initialized xchr if we are using non_ascii setup */
  77
  78 if (!non_ascii) {
  79
  80 /*      Normally, there is no translation of character code numbers */
  81
  82   {
  83           register integer for_end;
  84           i = 0;
  85           for_end = 255;
  86           if(i <= for_end)
  87                   do
  88                           xchr[i]= (char) i;                                            /* 95/Jan/7 */
  89           while(i++ < for_end);
  90   }
  91
  92 /* This is a kind of joke, since the characters are given as numeric codes ! */
  93
  94 #ifdef JOKE
  95   xchr[32]= ' ';
  96   xchr[33]= '!';
  97   xchr[34]= '"';
  98   xchr[35]= '#';
  99   xchr[36]= '$';
 100   xchr[37]= '%';
 101   xchr[38]= '&';
 102   xchr[39]= '\'';
 103   xchr[40]= '(';
 104   xchr[41]= ')';
 105   xchr[42]= '*';
 106   xchr[43]= '+';
 107   xchr[44]= ',';
 108   xchr[45]= '-';
 109   xchr[46]= '.';
 110   xchr[47]= '/';
 111   xchr[48]= '0';
 112   xchr[49]= '1';
 113   xchr[50]= '2';
 114   xchr[51]= '3';
 115   xchr[52]= '4';
 116   xchr[53]= '5';
 117   xchr[54]= '6';
 118   xchr[55]= '7';
 119   xchr[56]= '8';
 120   xchr[57]= '9';
 121   xchr[58]= ':';
 122   xchr[59]= ';';
 123   xchr[60]= '<';
 124   xchr[61]= '=';
 125   xchr[62]= '>';
 126   xchr[63]= '?';
 127   xchr[64]= '@';
 128   xchr[65]= 'A';
 129   xchr[66]= 'B';
 130   xchr[67]= 'C';
 131   xchr[68]= 'D';
 132   xchr[69]= 'E';
 133   xchr[70]= 'F';
 134   xchr[71]= 'G';
 135   xchr[72]= 'H';
 136   xchr[73]= 'I';
 137   xchr[74]= 'J';
 138   xchr[75]= 'K';
 139   xchr[76]= 'L';
 140   xchr[77]= 'M';
 141   xchr[78]= 'N';
 142   xchr[79]= 'O';
 143   xchr[80]= 'P';
 144   xchr[81]= 'Q';
 145   xchr[82]= 'R';
 146   xchr[83]= 'S';
 147   xchr[84]= 'T';
 148   xchr[85]= 'U';
 149   xchr[86]= 'V';
 150   xchr[87]= 'W';
 151   xchr[88]= 'X';
 152   xchr[89]= 'Y';
 153   xchr[90]= 'Z';
 154   xchr[91]= '[';
 155   xchr[92]= '\\';
 156   xchr[93]= ']';
 157   xchr[94]= '^';
 158   xchr[95]= '_';
 159   xchr[96]= '`';
 160   xchr[97]= 'a';
 161   xchr[98]= 'b';
 162   xchr[99]= 'c';
 163   xchr[100]= 'd';
 164   xchr[101]= 'e';
 165   xchr[102]= 'f';
 166   xchr[103]= 'g';
 167   xchr[104]= 'h';
 168   xchr[105]= 'i';
 169   xchr[106]= 'j';
 170   xchr[107]= 'k';
 171   xchr[108]= 'l';
 172   xchr[109]= 'm';
 173   xchr[110]= 'n';
 174   xchr[111]= 'o';
 175   xchr[112]= 'p';
 176   xchr[113]= 'q';
 177   xchr[114]= 'r';
 178   xchr[115]= 's';
 179   xchr[116]= 't';
 180   xchr[117]= 'u';
 181   xchr[118]= 'v';
 182   xchr[119]= 'w';
 183   xchr[120]= 'x';
 184   xchr[121]= 'y';
 185   xchr[122]= 'z';
 186   xchr[123]= '{';
 187   xchr[124]= '|';
 188   xchr[125]= '}';
 189   xchr[126]= '~';
 190
 191   {
 192           register integer for_end;
 193           i = 0;
 194           for_end = 31;
 195           if(i <= for_end)
 196                   do  xchr[i]= chr(i);
 197           while(i++ < for_end);
 198   }
 199
 200   {
 201           register integer for_end;
 202           i = 127;
 203           for_end = 255;
 204           if(i <= for_end)
 205                   do xchr[i]= chr(i);
 206           while(i++ < for_end);
 207   }
 208   #endif /* end of JOKE */
 209 } /* end of plain ASCII case (otherwise have read in xchr vector before) */
 210
 211 /*      Fill in background of `delete' for inverse mapping */
 212
 213   {
 214           register integer for_end;
 215           i = 0;
 216           for_end = 255;
 217           if(i <= for_end)
 218                   do xord[chr(i)] = 127;
 219           while(i++ < for_end);
 220   }
 221
 222 #ifdef JOKE
 223   {
 224           register integer for_end;
 225           i = 128;
 226           for_end = 255;
 227           if(i <= for_end)
 228                   do xord[xchr[i]] = i;
 229           while(i++ < for_end);
 230   }
 231
 232   {
 233           register integer for_end;
 234           i = 0;
 235           for_end = 126;
 236           if(i <= for_end)
 237                   do xord[xchr[i]] = i;
 238           while(i++ < for_end);
 239   }
 240 #endif
 241
 242 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
 243 /*      Now invert the xchr mapping to get xord mapping */
 244
 245   {
 246           register integer for_end;
 247           i = 0;
 248           for_end = 255;
 249           if(i <= for_end)
 250                   do xord[xchr[i]] = (char) i;
 251           while(i++ < for_end);
 252   }
 253
 254   xord[127]= 127;               /* hmm, a fixed point ? why ? */
 255
 256   flag = 0;                                     /* 93/Dec/28 - bkph */
 257   if (trace_flag != 0) {
 258           for (k = 0; k < 256; k++)             /*  entries in xord / xchr */
 259                   if (xord[k]!= k){
 260                           flag = 1;
 261                           break;
 262                   }
 263           if (flag) {           /* 127 here means mapping undefined */
 264                   show_line("Inverted mapping xord[] pairs:\n", 0);
 265                   for (k = 0; k < 256; k++) {   /*  entries in xord / xchr */
 266                           if (xord[k]!= 127) {
 267                                   sprintf(log_line, "%d => %d\n", k, xord[k]);
 268                                   show_line(log_line, 0);
 269                           }
 270                   }
 271           }
 272   }
 273   if (interaction < 0)                          /* may now set in local.c bkph */
 274 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
 275           interaction = 3;
 276   deletions_allowed = true;
 277   set_box_allowed = true;
 278   error_count = 0;
 279   help_ptr = 0;
 280   use_err_help = false;
 281   interrupt = 0;
 282   OK_to_interrupt = true;
 283         ;
 284 /* darn, need to know mem_top, mem_max etc for the following ... */
 285 #ifdef DEBUG
 286   was_mem_end = mem_min;
 287 /*  was_lo_max = mem_min;  */
 288   was_lo_max = mem_bot;
 289 /*  was_hi_min = mem_max; */
 290   was_hi_min = mem_top;
 291   panicking = false;
 292 #endif /* DEBUG */
 293   nest_ptr = 0;
 294   max_nest_stack = 0;
 295   mode = 1;
 296   head = contrib_head;
 297   tail = contrib_head;
 298   cur_list.aux_field.cint = ignore_depth;
 299   mode_line = 0;
 300   prev_graf = 0;
 301   shown_mode = 0;
 302   page_contents = 0;
 303   page_tail = page_head;
 304 #ifdef ALLOCATEMAIN
 305   if (is_initex)                        /* in iniTeX we did already allocate mem [] */
 306 #endif
 307           mem[page_head].hh.v.RH = 0;
 308 /*  last_glue = 262143L;  */ /* NO! */
 309   last_glue = empty_flag;
 310   last_penalty = 0;
 311   last_kern = 0;
 312   page_so_far[7]= 0;
 313   page_max_depth = 0;
 314 /* from int_base to eqtb_size */
 315   {
 316           register integer for_end;
 317           k = (hash_size + 3163);
 318           for_end = (hash_size + 4006);
 319           if(k <= for_end)
 320                   do  xeq_level[k]= 1;
 321           while(k++ < for_end);
 322   }
 323   no_new_control_sequence = true;
 324   hash[514].v.LH = 0;                   /* next(hash_base):= 0 */
 325   hash[514].v.RH = 0;                   /* text(hash_base):= 0 */
 326 /* 514 + hash_size + 266 = hashbase + hashsize + 10 + font_max  */
 327 /* for k <- hashbase+1 to undefined_control_sequence - 1 do ... p.257 */
 328   {
 329           register integer for_end;
 330           k = 515;
 331           for_end = (hash_size + 780);
 332           if(k <= for_end)
 333                   do hash[k]= hash[514];
 334           while(k++ < for_end);
 335   }
 336   save_ptr = 0;
 337   cur_level = 1;
 338   cur_group = 0;
 339   cur_boundary = 0;
 340   max_save_stack = 0;
 341   mag_set = 0;
 342   cur_mark[0]= 0;
 343   cur_mark[1]= 0;
 344   cur_mark[2]= 0;
 345   cur_mark[3]= 0;
 346   cur_mark[4]= 0;
 347   cur_val = 0;
 348   cur_val_level = 0;
 349   radix = 0;
 350   cur_order = 0;
 351   {
 352           register integer for_end;
 353           k = 0;
 354           for_end = 16;
 355           if(k <= for_end)
 356                   do read_open[k]= 2;
 357           while(k++ < for_end);
 358   }
 359   cond_ptr = 0;
 360   if_limit = 0;
 361   cur_if = 0;
 362   if_line = 0;
 363   {
 364           register integer for_end;
 365           k = 0;
 366           for_end = font_max;
 367           if(k <= for_end)
 368                   do font_used[k]= false;
 369           while(k++ < for_end);
 370   }
 371   null_character.b0 = 0;
 372   null_character.b1 = 0;
 373   null_character.b2 = 0;
 374   null_character.b3 = 0;
 375   total_pages = 0;
 376   max_v = 0;
 377   max_h = 0;
 378   max_push = 0;
 379   last_bop = -1;
 380   doing_leaders = false;
 381   dead_cycles = 0;
 382   cur_s = -1;
 383   half_buf = dvi_buf_size / 2;
 384   dvi_limit = dvi_buf_size;
 385   dvi_ptr = 0;
 386   dvi_offset = 0;
 387   dvi_gone = 0;
 388 /* down_ptr:=null; right_ptr:=null; l.12027 */
 389   down_ptr = 0;
 390   right_ptr = 0;
 391   adjust_tail = 0;
 392   last_badness = 0;
 393   pack_begin_line = 0;
 394   empty_field.v.RH = 0;
 395   empty_field.v.LH = 0;
 396   null_delimiter.b0 = 0;
 397   null_delimiter.b1 = 0;
 398   null_delimiter.b2 = 0;
 399   null_delimiter.b3 = 0;
 400   align_ptr = 0;
 401   cur_align = 0;
 402   cur_span = 0;
 403   cur_loop = 0;
 404   cur_head = 0;
 405   cur_tail = 0;
 406 /*      *not* OK with ALLOCATEHYPHEN, since may not be allocated yet */
 407 #ifndef ALLOCATEHYPHEN
 408 /*  {register integer for_end; z = 0; for_end = 607; if(z <= for_end) do */
 409   {
 410           register integer for_end;
 411           z = 0;
 412           for_end = hyphen_prime;
 413           if(z <= for_end) do
 414           {
 415                   hyph_word[z]= 0;
 416                   hyph_list[z]= 0;
 417           }
 418           while(z++ < for_end);
 419   }
 420 #endif
 421   hyph_count = 0;
 422   output_active = false;
 423   insert_penalties = 0;
 424   ligature_present = false;
 425   cancel_boundary = false;
 426   lft_hit = false;
 427   rt_hit = false;
 428   ins_disc = false;
 429   after_token = 0;
 430   long_help_seen = false;
 431   format_ident = 0;
 432   {
 433           register integer for_end;
 434           k = 0;
 435           for_end = 17;
 436           if(k <= for_end)
 437                   do  write_open[k]= false;
 438           while(k++ < for_end);
 439   }
 440   edit_name_start = 0;
 441         ;
 442 #ifdef INITEX
 443 /* initex stuff split off for convenience of optimization adjustments */
 444   if (is_initex)  do_initex ();
 445 #else
 446 /* trap the -i on command line situation if INITEX was NOT defined */
 447   if (is_initex) {
 448           show_line("Sorry, somebody forgot to make an INITEX!\n", 1);
 449   }
 450 #endif /* not INITEX */
 451 }
 452
 453 /* do the part of initialize() that requires mem_top, mem_max or mem[] */
 454 /* do this part after allocating main memory */
 455
 456 #ifdef ALLOCATEMAIN
 457 void initialize_aux (void)
 458 {
 459 #ifdef DEBUG
 460   was_mem_end = mem_min;
 461 /*  was_lo_max = mem_min; */
 462   was_lo_max = mem_bot;
 463 /*  was_hi_min = mem_max;  */
 464   was_hi_min = mem_top;
 465   panicking = false;
 466 #endif /* DEBUG */
 467 /*  nest_ptr = 0; */
 468 /*  max_nest_stack = 0; */
 469   mode = 1;
 470   head = contrib_head;
 471   tail = contrib_head;
 472   cur_list.aux_field.cint = ignore_depth;
 473   mode_line = 0;
 474   prev_graf = 0;
 475 /*  shown_mode = 0;  */
 476 /*  page_contents = 0;  */
 477   page_tail = page_head;
 478   //mem[mem_top - 2].hh.v.RH = 0;
 479   link(page_head) = 0;
 480 }
 481 #endif  // end of ifdef ALLOCATEMAIN
 482
 483 void line_break_ (integer finalwidowpenalty)
 484 {/* 30 31 32 33 34 35 22 */
 485   bool autobreaking;
 486   halfword prevp;
 487   halfword q, r, s, prevs;
 488   internal_font_number f;
 489 /*  small_number j;  */
 490   int j;                                                                /* 95/Jan/7 */
 491 /*  unsigned char c;  */
 492   unsigned int c;                                               /* 95/Jan/7 */
 493
 494 /*  savedbadness = 0; */                                /* 96/Feb/9 */
 495   pack_begin_line = mode_line;
 496   mem[temp_head].hh.v.RH = link(head);
 497   if((tail >= hi_mem_min))
 498   {
 499     link(tail) = new_penalty(10000);
 500     tail = link(tail);
 501   }
 502   else if(mem[tail].hh.b0 != 10)
 503   {
 504     link(tail) = new_penalty(10000);
 505     tail = link(tail);
 506   }
 507   else {
 508     type(tail) = 12;
 509     delete_glue_ref(mem[tail + 1].hh.v.LH);
 510     flush_node_list(mem[tail + 1].hh.v.RH);
 511     mem[tail + 1].cint = 10000;
 512   }
 513   link(tail) = new_param_glue(par_fill_skip_code);
 514 /* *********************************************************************** */
 515 /* following is new in 3.14159 */
 516   init_cur_lang = prev_graf % 65536L;
 517   init_l_hyf = prev_graf / 4194304L; /* 2^22 */
 518   init_r_hyf =(prev_graf / 65536L)% 64;
 519 /* *********************************************************************** */
 520   pop_nest ();
 521   noshrinkerroryet = true;
 522   if((mem[eqtb[(hash_size + 789)].hh.v.RH].hh.b1 != 0)&&
 523           (mem[eqtb[(hash_size + 789)].hh.v.RH + 3].cint != 0))
 524   {
 525     eqtb[(hash_size + 789)].hh.v.RH =
 526                 finite_shrink(eqtb[(hash_size + 789)].hh.v.RH);
 527   }
 528   if((mem[eqtb[(hash_size + 790)].hh.v.RH].hh.b1 != 0)&&
 529           (mem[eqtb[(hash_size + 790)].hh.v.RH + 3].cint != 0))
 530   {
 531     eqtb[(hash_size + 790)].hh.v.RH =
 532                 finite_shrink(eqtb[(hash_size + 790)].hh.v.RH);
 533   }
 534   q = eqtb[(hash_size + 789)].hh.v.RH;
 535   r = eqtb[(hash_size + 790)].hh.v.RH;
 536   background[1]= mem[q + 1].cint + mem[r + 1].cint;
 537   background[2]= 0;
 538   background[3]= 0;
 539   background[4]= 0;
 540   background[5]= 0;
 541   background[2 + mem[q].hh.b0]= mem[q + 2].cint;
 542   background[2 + mem[r].hh.b0]= background[2 + mem[r].hh.b0]+
 543   mem[r + 2].cint;
 544   background[6]= mem[q + 3].cint + mem[r + 3].cint;
 545   minimum_demerits = 1073741823L;               /* 2^30 - 1 */  /* 40000000 hex - 1 */
 546   minimal_demerits[3]= 1073741823L;
 547   minimal_demerits[2]= 1073741823L;
 548   minimal_demerits[1]= 1073741823L;
 549   minimal_demerits[0]= 1073741823L;
 550   if(eqtb[(hash_size + 1312)].hh.v.RH == 0)
 551   if(eqtb[(hash_size + 3747)].cint == 0)
 552   {
 553     last_special_line = 0;
 554     second_width = eqtb[(hash_size + 3733)].cint;
 555     second_indent = 0;
 556   }
 557   else {
 558     last_special_line = abs(eqtb[(hash_size + 3204)].cint);
 559     if(eqtb[(hash_size + 3204)].cint < 0)
 560     {
 561       first_width = eqtb[(hash_size + 3733)].cint -
 562                   abs(eqtb[(hash_size + 3747)].cint);
 563       if(eqtb[(hash_size + 3747)].cint >= 0)
 564       first_indent = eqtb[(hash_size + 3747)].cint;
 565       else first_indent = 0;
 566       second_width = eqtb[(hash_size + 3733)].cint;
 567       second_indent = 0;
 568     } else {
 569       first_width = eqtb[(hash_size + 3733)].cint;
 570       first_indent = 0;
 571       second_width = eqtb[(hash_size + 3733)].cint -
 572                    abs(eqtb[(hash_size + 3747)].cint);
 573       if(eqtb[(hash_size + 3747)].cint >= 0)
 574       second_indent = eqtb[(hash_size + 3747)].cint;
 575       else second_indent = 0;
 576     }
 577   }
 578   else {
 579     last_special_line = mem[eqtb[(hash_size + 1312)].hh.v.RH].hh.v.LH - 1;
 580     second_width = mem[eqtb[(hash_size + 1312)].hh.v.RH + 2 *(last_special_line + 1)].cint;
 581     second_indent = mem[eqtb[(hash_size + 1312)].hh.v.RH + 2 * last_special_line + 1].cint;
 582   }
 583 /* if looseness=0 then easy_line:=last_special_line */
 584   if(eqtb[(hash_size + 3182)].cint == 0)
 585   easyline = last_special_line;
 586 /*  else easyline = 262143L;  */ /* NO! */
 587   else easyline = empty_flag;
 588 /* threshold:=pretolerance; */
 589   threshold = eqtb[(hash_size + 3163)].cint;
 590   if(threshold >= 0)
 591   {
 592         ;
 593 #ifdef STAT
 594 /*   if tracing_paragraphs>0 then */
 595     if(eqtb[(hash_size + 3195)].cint > 0)
 596     {
 597       begin_diagnostic ();
 598       print_nl("@firstpass");
 599     }
 600 #endif /* STAT */
 601     second_pass = false;
 602     final_pass = false;
 603         first_pass_count++;                                     /* 96 Feb 9 */
 604   }
 605   else {
 606 /*  threshold:=tolerance; second_pass:=true; */
 607     threshold = eqtb[(hash_size + 3164)].cint;
 608     second_pass = true;
 609 /*   final_pass:=(emergency_stretch<=0); */
 610     final_pass =(eqtb[(hash_size + 3750)].cint <= 0);
 611         ;
 612 #ifdef STAT
 613     if(eqtb[(hash_size + 3195)].cint > 0)
 614     begin_diagnostic ();
 615 #endif /* STAT */
 616   }
 617   while(true){
 618 /*  if threshold>inf_bad then threshold:=inf_bad; */
 619     if(threshold > 10000)
 620                 threshold = 10000;
 621     if(second_pass)
 622     {
 623         ;
 624 #ifdef INITEX
 625   if (is_initex)  {     /* bkph */
 626       if(trie_not_ready)init_trie ();
 627   }                                     /* bkph */
 628 #endif /* INITEX */
 629 /* ********************************************************************* */
 630 /* following has changed in 3.14159 */
 631 /*      cur_lang = 0;  */
 632       cur_lang = init_cur_lang;
 633 /*      lhyf = cur_list .lhmfield; */
 634       lhyf = init_l_hyf;
 635 /*      rhyf = cur_list .rhmfield;  */
 636       rhyf = init_r_hyf;
 637 /* ********************************************************************* */
 638     }
 639     q = get_node(3);
 640     mem[q].hh.b0 = 0;
 641     mem[q].hh.b1 = 2;
 642     mem[q].hh.v.RH = active;
 643     mem[q + 1].hh.v.RH = 0;
 644     mem[q + 1].hh.v.LH = prev_graf + 1;
 645     mem[q + 2].cint = 0;
 646     mem[active].hh.v.RH = q;
 647     active_width[1] = background[1];
 648     active_width[2] = background[2];
 649     active_width[3] = background[3];
 650     active_width[4] = background[4];
 651     active_width[5] = background[5];
 652     active_width[6] = background[6];
 653 /*      passive:=null; printed_node:=temp_head; pass_number:=0; */
 654     passive = 0;
 655     printed_node = temp_head;
 656     pass_number = 0;
 657     font_in_short_display = 0;
 658     cur_p = mem[temp_head].hh.v.RH;
 659     autobreaking = true;
 660     prevp = cur_p;
 661 /*  while (cur_p<>null)and(link(active)<>last_active) do */
 662     while((cur_p != 0)&&(mem[active].hh.v.RH != active))
 663     {
 664       if((cur_p >= hi_mem_min))
 665       {
 666         prevp = cur_p;
 667         do {
 668             f = mem[cur_p].hh.b0;
 669           active_width[1]= active_width[1]+ font_info[width_base[f]+
 670           font_info[char_base[f]+ mem[cur_p].hh.b1].qqqq.b0].cint
 671         ;
 672           cur_p = mem[cur_p].hh.v.RH;
 673         } while(!(!(cur_p >= hi_mem_min)));
 674       }
 675       switch(mem[cur_p].hh.b0)
 676       {case 0 :
 677       case 1 :
 678       case 2 :
 679         active_width[1]= active_width[1]+ mem[cur_p + 1].cint;
 680         break;
 681       case 8 :
 682         if(mem[cur_p].hh.b1 == 4)
 683         {
 684           cur_lang = mem[cur_p + 1].hh.v.RH;    /* ASCII_code */
 685           lhyf = mem[cur_p + 1].hh.b0;
 686           rhyf = mem[cur_p + 1].hh.b1;
 687         }
 688         break;
 689       case 10 :
 690         {
 691           if(autobreaking)
 692           {
 693             if((prevp >= hi_mem_min))
 694             try_break(0, 0);
 695             else if((mem[prevp].hh.b0 < 9))
 696             try_break(0, 0);
 697 /* *********************************************************************** */
 698 /* following is new in 3.14159 */
 699             else if((mem[prevp].hh.b0 == 11)&&(mem[prevp].hh.b1
 700             != 1))
 701             try_break(0, 0);
 702 /* *********************************************************************** */
 703           }
 704           if((mem[mem[cur_p + 1].hh.v.LH].hh.b1 != 0)&&(mem[
 705           mem[cur_p + 1].hh.v.LH + 3].cint != 0))
 706           {
 707             mem[cur_p + 1].hh.v.LH = finite_shrink(mem[cur_p + 1].hh.v.LH);
 708           }
 709           q = mem[cur_p + 1].hh.v.LH;
 710           active_width[1]= active_width[1]+ mem[q + 1].cint;
 711           active_width[2 + mem[q].hh.b0]= active_width[2 + mem[q]
 712           .hh.b0]+ mem[q + 2].cint;
 713           active_width[6]= active_width[6]+ mem[q + 3].cint;
 714           if(second_pass && autobreaking)
 715           {
 716             prevs = cur_p;
 717             s = mem[prevs].hh.v.RH;
 718             if(s != 0)
 719             {
 720               while(true){
 721                 if((s >= hi_mem_min))
 722                 {
 723                   c = mem[s].hh.b1;
 724                   hf = mem[s].hh.b0;
 725                 }
 726                 else if(mem[s].hh.b0 == 6)
 727                 if(mem[s + 1].hh.v.RH == 0)
 728                 goto lab22;
 729                 else {
 730
 731                   q = mem[s + 1].hh.v.RH;
 732                   c = mem[q].hh.b1;
 733                   hf = mem[q].hh.b0;
 734                 }
 735                 else if((mem[s].hh.b0 == 11)&&(mem[s].hh.b1 ==
 736                 0))
 737                 goto lab22;
 738                 else if(mem[s].hh.b0 == 8)
 739                 {
 740                   if(mem[s].hh.b1 == 4)
 741                   {
 742                     cur_lang = mem[s + 1].hh.v.RH;      /* ASCII_code */
 743                     lhyf = mem[s + 1].hh.b0;
 744                     rhyf = mem[s + 1].hh.b1;
 745                   }
 746                   goto lab22;
 747                 }
 748                 else goto lab31;
 749                 if(eqtb[(hash_size + 2139) + c].hh.v.RH != 0)
 750 /*              signed unsigned mismatch ? (c is unsigned) */
 751                 if((eqtb[(hash_size + 2139) + c].hh.v.RH == c)||
 752                         (eqtb[(hash_size + 3201)].cint > 0))
 753                 goto lab32;
 754                 else goto lab31;
 755                 lab22: prevs = s;
 756                 s = mem[prevs].hh.v.RH;
 757               }
 758               lab32: hyf_char = hyphen_char[hf];
 759 /* if hyf_char<0 then goto done1; */
 760               if(hyf_char < 0) goto lab31;
 761 /* if hyf_char>255 then goto done1; */
 762               if(hyf_char > 255) goto lab31; /* ? */
 763               ha = prevs;
 764               if(lhyf + rhyf > 63) goto lab31;
 765               hn = 0;
 766               while(true){
 767                 if((s >= hi_mem_min)) {
 768                   if(mem[s].hh.b0 != hf)
 769                   goto lab33;
 770                   hyfbchar = mem[s].hh.b1;
 771                   c = hyfbchar;                 /*  unsigned char c;  */
 772                   if(eqtb[(hash_size + 2139) + c].hh.v.RH == 0)
 773                   goto lab33;
 774                   if(hn == 63)
 775                   goto lab33;
 776                   hb = s;
 777                   incr(hn);
 778                   hu[hn]= c;
 779 /*                long to short ... */
 780                   hc[hn]= eqtb[(hash_size + 2139) + c].hh.v.RH;
 781                   hyfbchar = 256;               /* special mark */
 782                 }
 783                 else if(mem[s].hh.b0 == 6)
 784                 {
 785                   if(mem[s + 1].hh.b0 != hf)
 786                   goto lab33;
 787 /* j:=hn; q:=lig_ptr(s); l.17554 */
 788                   j = hn;
 789                   q = mem[s + 1].hh.v.RH;
 790 /* if q>null then hyf_bchar:=character(q); l.17554  BUG ??? */
 791 /*                if(q > 0) */
 792                   if(q != 0)                                            /* 94/Mar/23 BUG FIX */
 793                   hyfbchar = mem[q].hh.b1;
 794 /* while q>null do l.17555 BUG ??? */
 795 /*                while(q > 0)*/
 796                   while(q != 0){                                /* 94/Mar/23 BUG FIX */
 797                     c = mem[q].hh.b1;
 798                     if(eqtb[(hash_size + 2139) + c].hh.v.RH == 0)
 799                     goto lab33;
 800                     if(j == 63)
 801                     goto lab33;
 802                     incr(j);
 803                     hu[j]= c;
 804 /*                      long to short ... */
 805                     hc[j]= eqtb[(hash_size + 2139) + c].hh.v.RH;
 806                     q = mem[q].hh.v.RH;
 807                   }
 808                   hb = s;
 809                   hn = j;
 810                   if(odd(mem[s].hh.b1))
 811                   hyfbchar = font_bchar[hf];
 812                   else hyfbchar = 256;          /* special mark */
 813                 }
 814                 else if((mem[s].hh.b0 == 11)&&(mem[s].hh.b1 ==
 815                 0))
 816                 {
 817                   hb = s;
 818 /* ******************************************************************** */
 819                   hyfbchar = font_bchar[hf];            /* new code in 3.14159 */
 820 /* ******************************************************************** */
 821                 }
 822                 else goto lab33;
 823                 s = mem[s].hh.v.RH;
 824               }
 825               lab33:;
 826               if(hn < lhyf + rhyf)
 827               goto lab31;
 828               while(true){
 829                 if(!((s >= hi_mem_min)))
 830                 switch(mem[s].hh.b0)
 831                 {case 6 :
 832                 ;
 833                   break;
 834                 case 11 :
 835                   if(mem[s].hh.b1 != 0)
 836                   goto lab34;
 837                   break;
 838                 case 8 :
 839                 case 10 :
 840                 case 12 :
 841                 case 3 :
 842                 case 5 :
 843                 case 4 :
 844                   goto lab34;
 845                   break;
 846                   default:
 847                   goto lab31;
 848                   break;
 849                 }
 850                 s = mem[s].hh.v.RH;
 851               }
 852               lab34:;
 853               hyphenate ();
 854             }
 855             lab31:;
 856           }
 857         }
 858         break;
 859       case 11 :
 860 /* ******************************************************************* */
 861         if(mem[cur_p].hh.b1 == 1)/*  change in 3.14159 */
 862 /* ******************************************************************* */
 863         {
 864           if(!(mem[cur_p].hh.v.RH >= hi_mem_min)&& autobreaking)
 865           if(mem[mem[cur_p].hh.v.RH].hh.b0 == 10)
 866           try_break(0, 0);
 867           active_width[1]= active_width[1]+ mem[cur_p + 1].cint;
 868         }
 869 /* ******************************************************************* */
 870 /*  change in 3.14159 */
 871         else active_width[1]= active_width[1]+ mem[cur_p + 1].cint;
 872 /* ******************************************************************* */
 873         break;
 874       case 6 :
 875         {
 876           f = mem[cur_p + 1].hh.b0;
 877           active_width[1]= active_width[1]+ font_info[width_base[f]+
 878           font_info[char_base[f]+ mem[cur_p + 1].hh.b1].qqqq.b0]
 879          .cint;
 880         }
 881         break;
 882       case 7 :
 883         {
 884           s = mem[cur_p + 1].hh.v.LH;
 885           disc_width = 0;
 886           if(s == 0)
 887           try_break(eqtb[(hash_size + 3167)].cint, 1);
 888           else {
 889
 890             do {
 891                 if((s >= hi_mem_min))
 892               {
 893                 f = mem[s].hh.b0;
 894                 disc_width = disc_width + font_info[width_base[f]+ font_info
 895                 [ char_base[f]+ mem[s].hh.b1].qqqq.b0].cint;
 896               }
 897               else switch(mem[s].hh.b0)
 898               {case 6 :
 899                 {
 900                   f = mem[s + 1].hh.b0;
 901                   disc_width = disc_width + font_info[width_base[f]+
 902                   font_info[char_base[f]+ mem[s + 1].hh.b1].qqqq.b0
 903                 ].cint;
 904                 }
 905                 break;
 906               case 0 :
 907               case 1 :
 908               case 2 :
 909               case 11 :
 910                 disc_width = disc_width + mem[s + 1].cint;
 911                 break;
 912                 default:
 913                         {
 914                                 confusion(931);         /* disc3 */
 915                                 return;                         // abort_flag set
 916                         }
 917                         break;
 918               }
 919               s = mem[s].hh.v.RH;
 920             } while(!(s == 0));
 921             active_width[1]= active_width[1]+ disc_width;
 922             try_break(eqtb[(hash_size + 3166)].cint, 1);
 923             active_width[1]= active_width[1]- disc_width;
 924           }
 925           r = mem[cur_p].hh.b1;
 926           s = mem[cur_p].hh.v.RH;
 927           while(r > 0){
 928             if((s >= hi_mem_min))
 929             {
 930               f = mem[s].hh.b0;
 931               active_width[1]= active_width[1]+ font_info[width_base[f
 932             ]+ font_info[char_base[f]+ mem[s].hh.b1].qqqq.b0]
 933              .cint;
 934             }
 935             else switch(mem[s].hh.b0)
 936             {case 6 :
 937               {
 938                 f = mem[s + 1].hh.b0;
 939                 active_width[1]= active_width[1]+ font_info[width_base[
 940                 f]+ font_info[char_base[f]+ mem[s + 1].hh.b1].qqqq
 941                 .b0].cint;
 942               }
 943               break;
 944             case 0 :
 945             case 1 :
 946             case 2 :
 947             case 11 :
 948               active_width[1]= active_width[1]+ mem[s + 1].cint;
 949               break;
 950               default:
 951                           {
 952                                   confusion(932);       /* disc4 */
 953                                   return;                               // abort_flag set
 954                           }
 955                           break;
 956             }
 957             decr(r);
 958             s = mem[s].hh.v.RH;
 959           }
 960           prevp = cur_p;
 961           cur_p = s;
 962           goto lab35;
 963         }
 964         break;
 965       case 9 :
 966         {
 967           autobreaking =(mem[cur_p].hh.b1 == 1);
 968           {
 969             if(!(mem[cur_p].hh.v.RH >= hi_mem_min)&& autobreaking)
 970             if(mem[mem[cur_p].hh.v.RH].hh.b0 == 10)
 971             try_break(0, 0);
 972             active_width[1]= active_width[1]+ mem[cur_p + 1].cint;
 973           }
 974         }
 975         break;
 976       case 12 :
 977         try_break(mem[cur_p + 1].cint, 0);
 978         break;
 979       case 4 :
 980       case 3 :
 981       case 5 :
 982         ;
 983         break;
 984         default:
 985                 {
 986                         confusion(930);         /* paragraph */
 987                         return;                         // abort_flag set
 988                 }
 989                 break;
 990       }
 991       prevp = cur_p;
 992       cur_p = mem[cur_p].hh.v.RH;
 993       lab35:;
 994     }
 995     if(cur_p == 0)
 996     {
 997       try_break(-10000, 1);
 998       if(mem[active].hh.v.RH != active)
 999       {
1000         r = mem[active].hh.v.RH;
1001         fewest_demerits = 1073741823L; /* 2^30 - 1 */
1002         do {
1003             if(mem[r].hh.b0 != 2)
1004           if(mem[r + 2].cint < fewest_demerits)
1005           {
1006             fewest_demerits = mem[r + 2].cint;
1007             best_bet = r;
1008           }
1009           r = mem[r].hh.v.RH;
1010         } while(!(r == active));
1011         best_line = mem[best_bet + 1].hh.v.LH;
1012 /*  if looseness=0 then goto done; */
1013         if(eqtb[(hash_size + 3182)].cint == 0){
1014 /*              if (final_pass && eqtb[(hash_size + 3750)].cint > 0){ */
1015 /*                      paragraph_failed++; */
1016 /*              } */
1017                 goto lab30;                                             /* normal exit */
1018         }
1019         {
1020 /* r:=link(active); actual_looseness:=0; */
1021           r = mem[active].hh.v.RH;
1022           actual_looseness = 0;
1023           do {
1024               if(mem[r].hh.b0 != 2)
1025             {
1026 /*   line_diff:=line_number(r)-best_line; */
1027               line_diff = toint(mem[r + 1].hh.v.LH)- toint(best_line
1028             );
1029 /*   if ((line_diff<actual_looseness)and(looseness<=line_diff))or@|
1030         ((line_diff>actual_looseness)and(looseness>=line_diff)) then */
1031               if(((line_diff < actual_looseness)&&
1032                                 (eqtb[(hash_size + 3182)].cint
1033               <= line_diff)) ||((line_diff > actual_looseness)&&
1034                                 (eqtb[(hash_size + 3182)].cint >= line_diff)))
1035               {
1036                 best_bet = r;
1037                 actual_looseness = line_diff;
1038                 fewest_demerits = mem[r + 2].cint;
1039               }
1040               else if((line_diff == actual_looseness)&&(mem[r + 2]
1041              .cint < fewest_demerits))
1042               {
1043                 best_bet = r;
1044                 fewest_demerits = mem[r + 2].cint;
1045               }
1046             }
1047             r = mem[r].hh.v.RH;
1048           } while(!(r == active));
1049           best_line = mem[best_bet + 1].hh.v.LH;
1050         }
1051 /*  if (actual_looseness=looseness)or final_pass then goto done; */
1052 /*      if((actual_looseness == eqtb[(hash_size + 3182)].cint)|| final_pass)*/
1053         if((actual_looseness == eqtb[(hash_size + 3182)].cint)) {
1054                 goto lab30;
1055         }
1056         if(final_pass){
1057                 goto lab30;
1058         }
1059       }
1060     }
1061     q = mem[active].hh.v.RH;
1062     while(q != active){
1063       cur_p = mem[q].hh.v.RH;
1064       if(mem[q].hh.b0 == 2)
1065       free_node(q, 7);
1066       else free_node(q, 3);
1067       q = cur_p;
1068     }
1069     q = passive;
1070     while(q != 0){
1071       cur_p = mem[q].hh.v.RH;
1072       free_node(q, 2);
1073       q = cur_p;
1074     }
1075     if(! second_pass)
1076     {
1077         ;
1078 #ifdef STAT
1079       if(eqtb[(hash_size + 3195)].cint > 0)
1080       print_nl("@second_pass");                 /*  */
1081 #endif /* STAT */
1082 /* threshold:=tolerance; */
1083       threshold = eqtb[(hash_size + 3164)].cint;
1084       second_pass = true;
1085           second_pass_count++;                                  /* 96 Feb 9 */
1086 /*   final_pass:=(emergency_stretch<=0); */
1087       final_pass =(eqtb[(hash_size + 3750)].cint <= 0);
1088     }
1089     else {
1090
1091         ;
1092 #ifdef STAT
1093       if(eqtb[(hash_size + 3195)].cint > 0)     /* tracing_paragraphs */
1094       print_nl("@emergencypass");                       /*  */
1095 #endif /* STAT */
1096 /*     can only get here is \emergencystretch has been set positive */
1097 /*     background[2]:=background[2]+emergency_stretch; final_pass:=true; */
1098       background[2]= background[2]+ eqtb[(hash_size + 3750)].cint;
1099           final_pass = true;
1100           final_pass_count++;                                   /* 96 Feb 9 */
1101         } /* end of if second_pass */
1102   } /* end of while(true)do */
1103 /* cannot drop through from above loop */
1104   lab30:                                                                /* common exit point */
1105 /*  if (badness > (pre)tolerance) */
1106 /*    if(last_badness > threshold){ */
1107 /*    if(savedbadness > threshold){ */  /* do we believe this ??? */
1108 /*              paragraph_failed++;     */      /* 96/Feb/9 */
1109 /*      } */
1110 /*        if (prevgraf == 1) singleline++; */
1111 /*        if (nest[nest_ptr].pg_field == 1) singleline++; */
1112 /*        At this point best_line is number of lines in paragraph + 1 */
1113           if (best_line == 2) singleline++;
1114         ;
1115 #ifdef STAT
1116   if(eqtb[(hash_size + 3195)].cint > 0)
1117   {
1118     end_diagnostic(true);
1119     normalize_selector ();
1120   }
1121 #endif /* STAT */
1122   post_line_break(finalwidowpenalty);
1123   q = mem[active].hh.v.RH;
1124   while(q != active){
1125     cur_p = mem[q].hh.v.RH;
1126     if(mem[q].hh.b0 == 2)
1127     free_node(q, 7);
1128     else free_node(q, 3);
1129     q = cur_p;
1130   }
1131   q = passive;
1132   while(q != 0){ /* while q<>null do l.16979 */
1133     cur_p = mem[q].hh.v.RH;
1134     free_node(q, 2);
1135     q = cur_p;
1136   }
1137   pack_begin_line = 0;
1138 }
1139
1140 void prefixed_command (void)
1141 {/* 30 10 */
1142   small_number a;
1143   internal_font_number f;
1144   halfword j;
1145   font_index k;
1146   halfword p, q;
1147   integer n;
1148   bool e;
1149   a = 0;
1150   while(cur_cmd == 93){
1151     if(! odd(a / cur_chr))
1152     a = a + cur_chr;                    /*   small_number a;  */
1153     do {
1154         get_x_token ();
1155     } while(!((cur_cmd != 10)&&(cur_cmd != 0)));
1156     if(cur_cmd <= 70)
1157     {
1158       print_err("You can't use a prefix with `");
1159       print_cmd_chr(cur_cmd, cur_chr);
1160       print_char(39);   /* ' */
1161           help1("I'll pretend you didn't say \\long or \\outer or \\global.");
1162       back_error ();
1163       return;
1164     }
1165   }
1166   if((cur_cmd != 97)&&(a % 4 != 0)) {
1167     print_err("You can't use `");
1168     print_esc("long");
1169     print_string("' or `");
1170     print_esc("outer");
1171     print_string("' with `");
1172     print_cmd_chr(cur_cmd, cur_chr);
1173     print_char(39);             /* ' */
1174         help1("I'll pretend you didn't say \\long or \\outer here.");
1175     error ();
1176   }
1177   if(eqtb[(hash_size + 3206)].cint != 0)
1178   if(eqtb[(hash_size + 3206)].cint < 0)
1179   {
1180     if((a >= 4))
1181     a = a - 4;
1182   }
1183   else {
1184
1185     if(!(a >= 4))
1186     a = a + 4;
1187   }
1188
1189   switch(cur_cmd){
1190           case 87 :
1191 /* set_font: define(cur_font_loc,data,cur_chr); */
1192     if((a >= 4))
1193     geq_define((hash_size + 1834), 120, cur_chr);
1194     else eq_define((hash_size + 1834), 120, cur_chr);
1195     break;
1196   case 97 :
1197     {
1198       if(odd(cur_chr)&& !(a >= 4)&&
1199                   (eqtb[(hash_size + 3206)].cint >= 0))
1200       a = a + 4;
1201       e =(cur_chr >= 2);
1202       get_r_token ();
1203       p = cur_cs;
1204       q = scan_toks(true, e);
1205       if((a >= 4)) geq_define(p, 111 +(a % 4), def_ref);
1206       else eq_define(p, 111 +(a % 4), def_ref);
1207     }
1208     break;
1209   case 94 :
1210     {
1211       n = cur_chr;
1212       get_r_token ();
1213       p = cur_cs;
1214       if(n == 0)
1215       {
1216         do {
1217             get_token ();
1218         } while(!(cur_cmd != 10));
1219         if(cur_tok == 3133)
1220         {
1221           get_token ();
1222           if(cur_cmd == 10)
1223           get_token ();
1224         }
1225       }
1226       else {
1227
1228         get_token ();
1229         q = cur_tok;
1230         get_token ();
1231         back_input ();
1232         cur_tok = q;
1233         back_input ();
1234       }
1235       if(cur_cmd >= 111)
1236       incr(mem[cur_chr].hh.v.LH);
1237       if((a >= 4))
1238       geq_define(p, cur_cmd, cur_chr);
1239       else eq_define(p, cur_cmd, cur_chr);
1240     }
1241     break;
1242   case 95 :
1243     {
1244       n = cur_chr;
1245       get_r_token ();
1246       p = cur_cs;
1247       if((a >= 4))  geq_define(p, 0, 256);
1248       else eq_define(p, 0, 256);
1249       scan_optional_equals ();
1250       switch(n){
1251                   case 0 :
1252         {
1253           scan_char_num ();
1254           if((a >= 4))
1255           geq_define(p, 68, cur_val);
1256           else eq_define(p, 68, cur_val);
1257         }
1258         break;
1259       case 1 :
1260         {
1261           scan_fifteen_bit_int ();
1262           if((a >= 4))
1263           geq_define(p, 69, cur_val);
1264           else eq_define(p, 69, cur_val);
1265         }
1266         break;
1267         default:
1268         {
1269           scan_eight_bit_int ();
1270           switch(n){
1271                   case 2 :
1272             if((a >= 4))
1273             geq_define(p, 73, (hash_size + 3218) + cur_val);
1274             else eq_define(p, 73, (hash_size + 3218) + cur_val);
1275             break;
1276           case 3 :
1277             if((a >= 4))
1278             geq_define(p, 74, (hash_size + 3751) + cur_val);
1279             else eq_define(p, 74, (hash_size + 3751) + cur_val);
1280             break;
1281           case 4 :
1282             if((a >= 4))
1283             geq_define(p, 75, (hash_size + 800) + cur_val);
1284             else eq_define(p, 75, (hash_size + 800) + cur_val);
1285             break;
1286           case 5 :
1287             if((a >= 4))
1288             geq_define(p, 76, (hash_size + 1056) + cur_val);
1289             else eq_define(p, 76, (hash_size + 1056) + cur_val);
1290             break;
1291           case 6 :
1292             if((a >= 4))
1293             geq_define(p, 72, (hash_size + 1322) + cur_val);
1294             else eq_define(p, 72, (hash_size + 1322) + cur_val);
1295             break;
1296           }
1297         }
1298         break;
1299       }
1300     }
1301     break;
1302   case 96 :
1303     {
1304       scan_int ();
1305       n = cur_val;
1306       if(! scan_keyword(836))   /* to */
1307       {
1308       print_err("Missing `to' inserted");
1309           help2("You should have said `\\read<number> to \\cs'.",
1310                   "I'm going to look for the \\cs now.");
1311         error ();
1312       }
1313       get_r_token ();
1314       p = cur_cs;
1315           read_toks(n, p);
1316       if((a >= 4)) geq_define(p, 111, cur_val);
1317       else eq_define(p, 111, cur_val);
1318     }
1319     break;
1320   case 71 :
1321   case 72 :
1322     {
1323       q = cur_cs;
1324       if(cur_cmd == 71)
1325       {
1326         scan_eight_bit_int ();
1327         p = (hash_size + 1322) + cur_val;
1328       }
1329       else p = cur_chr;
1330       scan_optional_equals ();
1331       do {
1332           get_x_token ();
1333       } while(!((cur_cmd != 10)&&(cur_cmd != 0)));
1334       if(cur_cmd != 1)
1335       {
1336         if(cur_cmd == 71)
1337         {
1338           scan_eight_bit_int ();
1339           cur_cmd = 72;
1340           cur_chr = (hash_size + 1322) + cur_val;
1341         }
1342         if(cur_cmd == 72)
1343         {
1344           q = eqtb[cur_chr].hh.v.RH;
1345           if(q == 0)
1346           if((a >= 4))
1347           geq_define(p, 101, 0);
1348           else eq_define(p, 101, 0);
1349           else {
1350
1351             incr(mem[q].hh.v.LH);
1352             if((a >= 4))
1353             geq_define(p, 111, q);
1354             else eq_define(p, 111, q);
1355           }
1356           goto lab30;
1357         }
1358       }
1359       back_input ();
1360       cur_cs = q;
1361       q = scan_toks(false, false);
1362       if(mem[def_ref].hh.v.RH == 0){
1363         if((a >= 4))
1364         geq_define(p, 101, 0);
1365         else eq_define(p, 101, 0);
1366         {
1367           mem[def_ref].hh.v.RH = avail;
1368           avail = def_ref;
1369         ;
1370 #ifdef STAT
1371           decr(dyn_used);
1372 #endif /* STAT */
1373         }
1374       }
1375       else {
1376
1377         if(p == (hash_size + 1313))                     /* output ? */
1378         {
1379           mem[q].hh.v.RH = get_avail ();
1380           q = mem[q].hh.v.RH;
1381           mem[q].hh.v.LH = 637;
1382           q = get_avail ();
1383           mem[q].hh.v.LH = 379;
1384           mem[q].hh.v.RH = mem[def_ref].hh.v.RH;
1385           mem[def_ref].hh.v.RH = q;
1386         }
1387         if((a >= 4))
1388         geq_define(p, 111, def_ref);
1389         else eq_define(p, 111, def_ref);
1390       }
1391     }
1392     break;
1393   case 73 :
1394     {
1395       p = cur_chr;
1396       scan_optional_equals ();
1397       scan_int ();
1398       if((a >= 4))
1399       geq_word_define(p, cur_val);
1400       else eq_word_define(p, cur_val);
1401     }
1402     break;
1403   case 74 :
1404     {
1405       p = cur_chr;
1406       scan_optional_equals ();
1407       scan_dimen(false, false, false);
1408       if((a >= 4))
1409       geq_word_define(p, cur_val);
1410       else eq_word_define(p, cur_val);
1411     }
1412     break;
1413   case 75 :
1414   case 76 :
1415     {
1416       p = cur_chr;
1417       n = cur_cmd;
1418       scan_optional_equals ();
1419       if(n == 76) scan_glue(3);
1420       else scan_glue(2);
1421       trap_zero_glue ();
1422       if((a >= 4))
1423       geq_define(p, 117, cur_val);
1424       else eq_define(p, 117, cur_val);
1425     }
1426     break;
1427   case 85 :
1428     {
1429       if(cur_chr == (hash_size + 1883))
1430       n = 15;
1431       else if(cur_chr == (hash_size + 2907))
1432       n = 32768L;                                                               /* 2^15 */
1433       else if(cur_chr == (hash_size + 2651))
1434       n = 32767;                                                                /* 2^15 - 1*/
1435       else if(cur_chr == (hash_size + 3474))
1436       n = 16777215L;                                                    /* 2^24 - 1 */
1437       else n = 255;                                                     /* 2^8 - 1 */
1438       p = cur_chr;
1439       scan_char_num ();
1440       p = p + cur_val;
1441       scan_optional_equals ();
1442       scan_int ();
1443       if(((cur_val < 0)&&(p < (hash_size + 3474))) ||(cur_val > n))
1444       {
1445                   print_err("Invalid code(");
1446         print_int(cur_val);
1447         if(p < (hash_size + 3474))
1448                 print_string("), should be in the range 0..");
1449         else
1450                 print_string("), should be at most ");
1451         print_int(n);
1452         help1("I'm going to use 0 instead of that illegal code value.");
1453         error ();
1454         cur_val = 0;
1455       }
1456       if(p < (hash_size + 2907))
1457       if((a >= 4))
1458       geq_define(p, 120, cur_val);
1459       else eq_define(p, 120, cur_val);
1460       else if(p < (hash_size + 3474))
1461       if((a >= 4))
1462       geq_define(p, 120, cur_val);
1463       else eq_define(p, 120, cur_val);
1464       else if((a >= 4))
1465       geq_word_define(p, cur_val);
1466       else eq_word_define(p, cur_val);
1467     }
1468     break;
1469   case 86 :
1470     {
1471       p = cur_chr;
1472       scan_four_bit_int ();
1473       p = p + cur_val;
1474       scan_optional_equals ();
1475       scan_font_ident ();
1476       if((a >= 4))
1477       geq_define(p, 120, cur_val);
1478       else eq_define(p, 120, cur_val);
1479     }
1480     break;
1481   case 89 :
1482   case 90 :
1483   case 91 :
1484   case 92 :
1485     do_register_command(a);
1486     break;
1487   case 98 :
1488     {
1489       scan_eight_bit_int ();
1490       if((a >= 4))
1491       n = 256 + cur_val;
1492       else n = cur_val;
1493       scan_optional_equals ();
1494       if(set_box_allowed){
1495                   scan_box(1073741824L + n); /* 2^30 + n */ /* box_flag + n */
1496           }
1497       else {
1498           print_err("Improper ");
1499         print_esc("setbox");            /*  */
1500         help2("Sorry, \\setbox is not allowed after \\halign in a display,",
1501                 "or between \\accent and an accented character.");
1502         error ();
1503       }
1504     }
1505     break;
1506   case 79 :
1507     alter_aux ();
1508     break;
1509   case 80 :
1510     alter_prev_graf ();
1511     break;
1512   case 81 :
1513     alter_page_so_far ();
1514     break;
1515   case 82 :
1516     alter_integer ();
1517     break;
1518   case 83 :
1519     alter_box_dimen ();
1520     break;
1521   case 84 :
1522     {
1523       scan_optional_equals ();
1524       scan_int ();
1525       n = cur_val;
1526       if(n <= 0)
1527       p = 0;
1528       else {
1529
1530         p = get_node(2 * n + 1);
1531         mem[p].hh.v.LH = n;
1532         {
1533                 register integer for_end;
1534                 j = 1;
1535                 for_end = n;
1536                 if(j <= for_end) do
1537                 {
1538                         scan_dimen(false, false, false);
1539                         mem[p + 2 * j - 1].cint = cur_val;
1540                         scan_dimen(false, false, false);
1541                         mem[p + 2 * j].cint = cur_val;
1542                 }
1543                 while(j++ < for_end);
1544         }
1545       }
1546       if((a >= 4))
1547       geq_define((hash_size + 1312), 118, p);
1548       else eq_define((hash_size + 1312), 118, p);
1549     }
1550     break;
1551   case 99 :
1552     if(cur_chr == 1)
1553     {
1554         ;
1555 #ifdef INITEX
1556   if (is_initex) {              /* bkph */
1557       new_patterns ();
1558       goto lab30;
1559   }                                             /* bkph */
1560 #endif /* INITEX */
1561      print_err("Patterns can be loaded only by INITEX");
1562       help_ptr = 0;
1563       error ();
1564       do {
1565                   get_token ();
1566       } while(!(cur_cmd == 2));
1567       return;
1568     }
1569     else {
1570
1571       new_hyph_exceptions ();
1572       goto lab30;
1573     }
1574     break;
1575   case 77 :
1576     {
1577       find_font_dimen(true);
1578       k = cur_val;
1579       scan_optional_equals ();
1580       scan_dimen(false, false, false);
1581       font_info[k].cint = cur_val;
1582     }
1583     break;
1584   case 78 :
1585     {
1586       n = cur_chr;
1587       scan_font_ident ();
1588       f = cur_val;
1589       scan_optional_equals ();
1590       scan_int ();
1591       if(n == 0)hyphen_char[f]= cur_val;
1592       else skew_char[f]= cur_val;
1593     }
1594     break;
1595   case 88 :
1596     new_font(a);
1597     break;
1598   case 100 :
1599     new_interaction ();
1600     break;
1601     default:
1602         {
1603                 confusion(1172);        /* prefix */
1604                 return;                         // abort_flag set
1605         }
1606         break;
1607   } /* end of cur_cmd switch */
1608
1609
1610 lab30:
1611   if(after_token != 0) {
1612           cur_tok = after_token;
1613           back_input ();
1614           after_token = 0;
1615   }
1616 }
1617
1618 /* added following explanations 96/Jan/10 */
1619
1620 void bad_formator_pool (char *name, char *defaultname, char *envvar)
1621 {
1622         if (name == NULL) name = defaultname;
1623         sprintf(log_line, "(Perhaps %s is for an older version of TeX)\n", name);
1624         show_line(log_line, 0);
1625         name_of_file[name_length + 1] = '\0';   /* null terminate */
1626         sprintf(log_line, "(Alternatively, %s may have been corrupted)\n", name_of_file+1);
1627         show_line(log_line, 0);
1628         name_of_file[name_length + 1] = ' ';    /* space terminate */
1629         sprintf(log_line,
1630                 "(Perhaps your %s environment variable is not set correctly)\n", envvar);
1631         show_line(log_line, 0);
1632         {
1633                 char *s;                                                /* extra info 99/April/28 */
1634                 if ((s = grabenv(envvar)) != NULL) {
1635                         sprintf(log_line, "(%s=%s)\n", envvar, s);
1636                         show_line(log_line, 0);
1637                 }
1638                 else {
1639                         sprintf(log_line, "%s environment variable not set\n", envvar);
1640                         show_line(log_line, 0);
1641                 }
1642         }
1643 #ifndef _WINDOWS
1644         fflush(stdout);
1645 #endif
1646 }
1647 /* sec 1303 */
1648 bool load_fmt_file (void)
1649 {/* 6666 10 */
1650   register bool Result;
1651   integer j, k;
1652   halfword p, q;
1653   integer x;
1654
1655 /* sec 1308 */
1656   undump_int(x); /* CHECKSUM */
1657   if (x != BEGINFMTCHECKSUM) /* magic FMT file start 4C 20 E6 15 hex */
1658     goto lab6666;
1659
1660   undump_int(x); /* mem_bot */
1661   if(x != mem_bot)
1662     goto lab6666;
1663
1664   undump_int(x); /* mem_top */
1665
1666 #ifdef ALLOCATEMAIN
1667 /* we already read this once earlier to grab mem_top */
1668   if (trace_flag) {
1669     sprintf(log_line, "Read from fmt file mem_top = %d TeX words\n", x);
1670     show_line(log_line, 0);
1671   }
1672   mem = allocate_main_memory(x); /* allocate main memory at this point */
1673   if (mem == NULL) exit(1);      /* redundant sanity test ! */
1674   initialize_aux();              /* do `mem' part of initialize */
1675 /*  mem = zmem; */               /* update pointer to main memory */
1676 #endif
1677
1678   if(x != mem_top)
1679     goto lab6666;
1680
1681   undump_int(x); /* eqtbsize */
1682   if(x != (hash_size + 4006)) /* eqtbsize */
1683     goto lab6666;
1684   undump_int(x); /* hash_prime */
1685   if(x != hash_prime)
1686     goto lab6666;
1687   undump_int(x); /* hyphen_prime */
1688
1689 #ifdef ALLOCATEHYPHEN
1690 /* allow format files dumped with arbitrary (prime) hyphenation exceptions */
1691   realloc_hyphen (x);            /* reset_hyphen(); */
1692   hyphen_prime = x;
1693 #endif
1694
1695   if(x != hyphen_prime)
1696     goto lab6666;
1697   {
1698     undump_int(x); /* pool_size */
1699     if(x < 0)
1700       goto lab6666;
1701
1702 #ifdef ALLOCATESTRING
1703     if (x > current_pool_size) {
1704       if (trace_flag) {
1705         sprintf(log_line, "undump string pool reallocation (%d > %d)\n", x, current_pool_size);
1706         show_line(log_line, 0);
1707       }
1708       str_pool = realloc_str_pool (x - current_pool_size + increment_pool_size);
1709     }
1710     if(x > current_pool_size)   /* 94/Jan/24 */
1711 #else
1712     if(x > pool_size)
1713 #endif
1714     {
1715       ;
1716       sprintf(log_line, "%s%s\n",  "---! Must increase the ", "string pool size");
1717       show_line(log_line, 0);
1718       goto lab6666;
1719     } else pool_ptr = x;
1720   }
1721   {
1722     undump_int(x);      /* max_strings */
1723     if(x < 0)
1724       goto lab6666;
1725
1726 #ifdef ALLOCATESTRING
1727     if (x > current_max_strings) {
1728       if (trace_flag) {
1729         sprintf(log_line, "undump string pointer reallocation (%d > %d)\n", x, current_max_strings);
1730         show_line(log_line, 0);
1731       }
1732       str_start = realloc_str_start(x - current_max_strings + increment_max_strings);
1733     }
1734     if(x > current_max_strings) /* 94/Jan/24 */
1735 #else
1736 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
1737     if(x > max_strings)
1738 #endif
1739     {
1740       ;
1741       sprintf(log_line,  "%s%s\n",  "---! Must increase the ", "max strings");
1742       show_line(log_line, 0);
1743       goto lab6666;
1744     }
1745     else str_ptr = x;
1746   }
1747
1748   if (undumpthings(str_start[0], str_ptr + 1)) return -1; /* undump string ptrs */
1749   if (undumpthings(str_pool[0], pool_ptr)) return -1; /*        undump string pool */
1750
1751   init_str_ptr = str_ptr;
1752   init_pool_ptr = pool_ptr;
1753 /*      undump the dynamic memory - paragraph 1312 in the book */
1754   {
1755     undump_int(x);
1756     if((x < 1019)||(x > mem_top - 14))
1757     goto lab6666;
1758     else lo_mem_max = x;
1759   }
1760   {
1761     undump_int(x);
1762     if((x < 20)||(x > lo_mem_max))
1763     goto lab6666;
1764     else rover = x;
1765   }
1766   p = 0;                                                                        /* mem_bot */
1767   q = rover;
1768   do {
1769       if (undumpthings(mem[p], q + 2 - p)
1770                 )return -1;
1771     p = q + mem[q].hh.v.LH;
1772     if((p > lo_mem_max)||((q >= mem[q + 1].hh.v.RH)&&(mem[q +
1773     1].hh.v.RH != rover)))
1774     goto lab6666;
1775     q = mem[q + 1].hh.v.RH;
1776   } while(!(q == rover));
1777   if (undumpthings(mem[p], lo_mem_max + 1 - p)
1778         )return -1;
1779 /*  if(mem_min < -2) */
1780   if(mem_min < mem_bot - 2)                                     /*  ? splice in block below */
1781   {
1782 /*      or call add_variable_space(mem_bot - (mem_min + 1)) */
1783
1784     if (trace_flag) show_line("Splicing in mem_min space in undump!\n", 0);
1785
1786     p = mem[rover + 1].hh.v.LH;
1787     q = mem_min + 1;
1788     mem[mem_min].hh.v.RH = 0;                           /* null */
1789     mem[mem_min].hh.v.LH = 0;                           /* null */
1790     mem[p + 1].hh.v.RH = q;
1791     mem[rover + 1].hh.v.LH = q;
1792     mem[q + 1].hh.v.RH = rover;
1793     mem[q + 1].hh.v.LH = p;
1794 /*    mem[q].hh.v.RH = 262143L;  */     /* NO! */
1795     mem[q].hh.v.RH = empty_flag;
1796 /*    mem[q].hh.v.LH = -0 - q;  */
1797     mem[q].hh.v.LH = mem_bot - q;               /* ? size of block  */
1798   }
1799   {
1800     undump_int(x);
1801     if((x < lo_mem_max + 1)||(x > mem_top - 13))
1802     goto lab6666;
1803     else hi_mem_min = x;
1804   }
1805   {
1806     undump_int(x);
1807 /*    if((x < 0)||(x > mem_top))  */
1808     if((x < mem_bot)||(x > mem_top))
1809     goto lab6666;
1810     else avail = x;
1811   }
1812   mem_end = mem_top;
1813   if (undumpthings(mem[hi_mem_min], mem_end + 1 - hi_mem_min)
1814         )return -1;
1815   undump_int(var_used);
1816   undump_int(dyn_used);
1817   k = 1;
1818   do {
1819       undump_int(x);
1820     if((x < 1)||(k + x > (hash_size + 4007)))
1821     goto lab6666;
1822     if (undumpthings(eqtb[k], x)
1823          )return -1;
1824     k = k + x;
1825     undump_int(x);
1826     if((x < 0)||(k + x > (hash_size + 4007)))
1827     goto lab6666;
1828     {
1829                 register integer for_end;
1830                 j = k;
1831                 for_end = k + x - 1;
1832                 if(j <= for_end) do
1833                         eqtb[j]= eqtb[k - 1];
1834                 while(j++ < for_end);
1835         }
1836     k = k + x;
1837   } while(!(k > (hash_size + 4006)));
1838   {
1839     undump_int(x);
1840 /*      if((x < hashbase)||(x > hashbase + hashsize)) */
1841 /*    if((x < 514)||(x > (hash_size + 514)))  */
1842     if((x < 514)||(x > (hash_size + hash_extra + 514)))  /*96/Jan/10*/
1843     goto lab6666;
1844     else par_loc = x;
1845   }
1846   par_token = 4095 + par_loc;
1847   {
1848     undump_int(x);
1849 /*  if((x < hashbase)||(x > hashbase + hashsize)) */
1850 /*    if((x < 514)||(x > (hash_size + 514)))  */
1851     if((x < 514)||(x > (hash_size + hash_extra + 514))) /*96/Jan/10*/
1852     goto lab6666;
1853     else
1854     write_loc = x;
1855   }
1856   {
1857     undump_int(x);
1858 /*  if((x < hashbase)||(x > hashbase + hashsize)) */
1859 /*    if((x < 514)||(x > (hash_size + 514)))  */
1860     if((x < 514)||(x > (hash_size + hash_extra + 514))) /*96/Jan/10*/
1861     goto lab6666;
1862     else hash_used = x;
1863   }
1864   p = 513;
1865   do {
1866       {
1867       undump_int(x);
1868       if((x < p + 1)||(x > hash_used))
1869       goto lab6666;
1870       else p = x;
1871     }
1872     undump_hh(hash[p]);
1873   } while(!(p == hash_used));
1874   if (undumpthings(hash[hash_used + 1], (hash_size + 780) - hash_used)
1875         )return -1;
1876
1877   undump_int(cs_count);                 /* cs_count */
1878   if (trace_flag) {
1879           sprintf(log_line, "itex undump cs_count %d ", cs_count); /* debugging */
1880           show_line(log_line, 0);
1881   }
1882   {
1883     undump_int(x);                              /* font_mem_size */
1884     if(x < 7)
1885     goto lab6666;
1886 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
1887 #ifdef ALLOCATEFONT
1888     if (trace_flag) {
1889       sprintf(log_line, "Read from fmt fmem_ptr = %d\n", x);
1890       show_line(log_line, 0);
1891     }
1892     if(x > current_font_mem_size) { /* 93/Nov/28 dynamic allocate font_info */
1893       if (trace_flag) {
1894         sprintf(log_line, "Undump realloc font_info (%d > %d)\n",
1895             x, current_font_mem_size);
1896         show_line(log_line, 0);
1897       }
1898       font_info = realloc_font_info (x - current_font_mem_size + increment_font_mem_size);
1899     }
1900     if(x > current_font_mem_size)  /* in case allocation failed 94/Jan/24 */
1901 #else
1902 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
1903     if(x > font_mem_size)
1904 #endif
1905     {
1906       ;
1907       sprintf(log_line, "%s%s\n",  "---! Must increase the ", "font mem size");
1908       show_line(log_line, 0);
1909       goto lab6666;
1910     } else fmem_ptr = x;
1911   }
1912   {
1913     if (undumpthings(font_info[0], fmem_ptr)) return -1;
1914     {
1915       undump_int(x); /* font_max */
1916       if(x < 0)
1917         goto lab6666;
1918       if(x > font_max)
1919       {
1920         ;
1921         sprintf(log_line, "%s%s\n",  "---! Must increase the ", "font max");
1922         show_line(log_line, 0);
1923         goto lab6666;
1924       }
1925       else font_ptr = x;
1926     }
1927     frozenfontptr = font_ptr; /* remember number of fonts frozen into format */
1928     if (undumpthings(font_check[0], font_ptr + 1)) return -1;
1929     if (undumpthings(font_size[0], font_ptr + 1)) return -1;
1930     if (undumpthings(font_dsize[0], font_ptr + 1)) return -1;
1931     if (undumpthings(font_params[0], font_ptr + 1)) return -1;
1932     if (undumpthings(hyphen_char[0], font_ptr + 1)) return -1;
1933     if (undumpthings(skew_char[0], font_ptr + 1)) return -1;
1934     if (undumpthings(font_name[0], font_ptr + 1)) return -1;
1935     if (undumpthings(font_area[0], font_ptr + 1)) return -1;
1936     if (undumpthings(font_bc[0], font_ptr + 1)) return -1;
1937     if (undumpthings(font_ec[0], font_ptr + 1)) return -1;
1938     if (undumpthings(char_base[0], font_ptr + 1)) return -1;
1939     if (undumpthings(width_base[0], font_ptr + 1)) return -1;
1940     if (undumpthings(height_base[0], font_ptr + 1)) return -1;
1941     if (undumpthings(depth_base[0], font_ptr + 1)) return -1;
1942     if (undumpthings(italic_base[0], font_ptr + 1)) return -1;
1943     if (undumpthings(lig_kern_base[0], font_ptr + 1)) return -1;
1944     if (undumpthings(kern_base[0], font_ptr + 1)) return -1;
1945     if (undumpthings(exten_base[0], font_ptr + 1)) return -1;
1946     if (undumpthings(param_base[0], font_ptr + 1)) return -1;
1947     if (undumpthings(font_glue[0], font_ptr + 1)) return -1;
1948     if (undumpthings(bchar_label[0], font_ptr + 1)) return -1;
1949     if (undumpthings(font_bchar[0], font_ptr + 1)) return -1;
1950     if (undumpthings(font_false_bchar[0], font_ptr + 1)) return -1;
1951   }
1952
1953 /* log not opened yet, so can't show fonts frozen into format */
1954
1955 /* May be able to avoid the following since we switched to */
1956 /* non_address from font_mem_size to 0 96/Jan/15 ??? */
1957 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
1958 #ifdef ALLOCATEFONT
1959 /* deal with fmt files dumped with *different* font_mem_size 93/Nov/29 */
1960  { int count = 0, oldfont_mem_size = 0;
1961    for (x = 0; x <= font_ptr; x++) {
1962      if(bchar_label[x] > oldfont_mem_size) oldfont_mem_size = bchar_label[x];
1963    }
1964
1965 /* somewhat arbitrary sanity check ... */
1966 /* if (oldfont_mem_size != font_mem_size && oldfont_mem_size > font_max) { */
1967    if (oldfont_mem_size != non_address && oldfont_mem_size > font_max) { /* 96/Jan/16 */
1968      for (x = 0; x <= font_ptr; x++) {
1969        if(bchar_label[x] == oldfont_mem_size) {
1970          /* bchar_label[x] = font_mem_size; */
1971          bchar_label[x] = non_address;  /* 96/Jan/16 */
1972          count++;
1973        }
1974      }
1975      if (trace_flag) {
1976        sprintf(log_line,
1977            "oldfont_mem_size is %d --- hit %d times. Using non_address %d\n",
1978            oldfont_mem_size, count, non_address);
1979        show_line(log_line, 0);
1980      }
1981    }
1982  }
1983 #endif
1984 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
1985 /* undump(0)(hyph_size)(hyph_count); */
1986   {
1987     undump_int(x);
1988 /* if((x < 0)||(x > 607))  */
1989     if((x < 0)||(x > hyphen_prime))
1990       goto lab6666;
1991     else
1992       hyph_count = x;
1993   }
1994 /* undump hypenation exception tables p.1325 */
1995   {
1996     register integer for_end;
1997     k = 1;
1998     for_end = hyph_count;
1999     if(k <= for_end)
2000       do
2001       {
2002         {
2003           undump_int(x);
2004 /* if((x < 0)||(x > 607))  */
2005           if((x < 0)||(x > hyphen_prime))
2006             goto lab6666;
2007           else
2008             j = x;
2009         }
2010 /* undump(0)(str_ptr)(hyph_word[j]); */
2011         {
2012           undump_int(x);
2013           if((x < 0)||(x > str_ptr))
2014             goto lab6666;
2015           else
2016             hyph_word[j]= x;
2017         }
2018 /* undump(min_halfword)(max_halfword)(hyph_list[j]); */
2019         {
2020           undump_int(x);
2021 /* if((x < 0)||(x > 262143L)) */
2022           if((x < 0)||(x > max_halfword)) /* mem_top ? no p.1325 */
2023             goto lab6666;
2024           else
2025             hyph_list[j]= x;
2026         }
2027       } while(k++ < for_end);
2028   }
2029 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
2030 #ifdef ALLOCATEHYPHEN
2031 /* if user specified new hyphen prime - flush existing exception patterns ! */
2032 /* but, we can reclaim the string storage wasted ... */
2033   if (is_initex) {
2034     if (new_hyphen_prime != 0) {
2035       realloc_hyphen(new_hyphen_prime); /*      reset_hyphen(); */
2036       hyphen_prime = new_hyphen_prime;
2037     }
2038   }
2039 #endif
2040 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
2041   {
2042     undump_int(x);
2043     if(x < 0)
2044       goto lab6666;
2045 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
2046 #ifdef ALLOCATETRIES
2047     if (!is_initex) {
2048       allocate_tries(x); /* allocate only as much as is needed */
2049 /* trie_size = x; */ /* ??? */
2050     }
2051 #endif
2052 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
2053     if(x > trie_size)
2054     {
2055       ;
2056       sprintf(log_line, "%s%s\n",  "---! Must increase the ", "trie size");
2057       show_line(log_line, 0);
2058       goto lab6666;
2059     } else j = x;
2060   }
2061   ;
2062 #ifdef INITEX
2063 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
2064   if (is_initex) /* bkph */
2065 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
2066     trie_max = j;
2067 #endif /* INITEX */
2068   if (undumpthings(trie_trl[0], j + 1)) return -1;
2069   if (undumpthings(trie_tro[0], j + 1)) return -1;
2070   if (undumpthings(trie_trc[0], j + 1)) return -1;
2071   {
2072     undump_int(x);
2073     if(x < 0)
2074       goto lab6666;
2075     if(x > trie_op_size)
2076     {
2077       ;
2078       sprintf(log_line, "%s%s\n",  "---! Must increase the ", "trie op size");
2079       show_line(log_line, 0);
2080       goto lab6666;
2081     } else j = x;
2082   }
2083 ;
2084 #ifdef INITEX
2085 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
2086   if (is_initex)   /* bkph */
2087 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
2088     trie_op_ptr = j;
2089 #endif /* INITEX */
2090 /* for k:=1 to j do
2091   begin undump(0)(63)(hyf_distance[k]); {a |small_number|}
2092   undump(0)(63)(hyf_num[k]);
2093   undump(min_quarterword)(max_quarterword)(hyf_next[k]); end; */
2094
2095   if (undumpthings(hyf_distance[1], j)) return -1;
2096   if (undumpthings(hyf_num[1], j)) return -1;
2097   if (undumpthings(hyf_next[1], j)) return -1;
2098   ;
2099 #ifdef INITEX
2100 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
2101   if (is_initex) {     /* bkph */
2102 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
2103     {
2104       register integer for_end;
2105       k = 0;
2106       for_end = 255;
2107       if(k <= for_end) do
2108         trie_used[k]= 0;
2109       while(k++ < for_end);
2110     }
2111   }
2112 #endif /* INITEX */
2113   k = 256;
2114   while(j > 0){
2115 /* undump(0)(k-1)(k) */
2116     {
2117       undump_int(x);
2118       if((x < 0)||(x > k - 1))
2119         goto lab6666;
2120       else k = x;
2121     }
2122 /* undump(1)(j)(x) */
2123     {
2124       undump_int(x);
2125       if((x < 1)||(x > j))
2126       goto lab6666;
2127       else x = x;
2128     }
2129         ;
2130 #ifdef INITEX
2131 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
2132   if (is_initex)                                        /* bkph */
2133 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
2134     trie_used[k]= x;
2135 #endif /* INITEX */
2136 /*   j:=j-x; op_start[k]:=qo(j); */
2137     j = j - x;
2138     op_start[k]= j;
2139   }
2140         ;
2141 #ifdef INITEX
2142 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
2143   if (is_initex)                                        /* bkph */
2144 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
2145           trie_not_ready = false
2146 #endif /* INITEX */
2147 ;
2148   {
2149     undump_int(x);
2150     if((x < 0)||(x > 3))
2151     goto lab6666;
2152 /*    else interaction = x;  */
2153 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
2154     if (interaction < 0)                /* may now set in local.c bkph 94/Jan/8 */
2155 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
2156                 interaction = x;
2157   }
2158   {
2159     undump_int(x);
2160     if((x < 0)||(x > str_ptr))
2161     goto lab6666;
2162     else format_ident = x;
2163   }
2164   undump_int(x);
2165 /*      test_eof(fmt_file)? */
2166
2167   if((x != ENDFMTCHECKSUM)|| feof(fmt_file)) /* magic checksum --- change ? */
2168     goto lab6666;
2169
2170   Result = true;
2171   return(Result);
2172
2173   lab6666:;
2174   sprintf(log_line, "(Fatal format file error; I'm stymied)\n");
2175   show_line(log_line, 1);
2176 /* added following bit of explanation 96/Jan/10 */
2177   if (! knuth_flag)
2178     bad_formator_pool(format_file, "the format file", "TEXFORMATS");
2179   Result = false;
2180   return Result;
2181 }
2182 /* sec 1335 */
2183 void final_cleanup (void)
2184 {/* 10 */
2185   small_number c;
2186   c = cur_chr;                                  /* small_number  c */
2187   if (job_name == 0) open_log_file ();
2188   while (input_ptr > 0) {
2189           if (cur_input.state_field == 0) {
2190                   end_token_list ();
2191           } else end_file_reading ();
2192   }
2193   while (open_parens > 0) {
2194           print_string(" )");
2195           decr(open_parens);
2196   }
2197   if(cur_level > level_one)  {
2198     print_nl("(");
2199     print_esc("end occurred ");
2200     print_string("inside a group at level ");
2201     print_int(cur_level - 1);
2202     print_char(')');
2203   }
2204   while (cond_ptr != 0) {
2205     print_nl("(");
2206     print_esc("end occurred ");
2207     print_string("when ");
2208     print_cmd_chr(105, cur_if); /* i */
2209     if(if_line != 0)
2210     {
2211       print_string("on line ");
2212       print_int(if_line);
2213     }
2214     print_string(" was incomplete)");
2215     if_line = mem[cond_ptr + 1].cint;
2216     cur_if = mem[cond_ptr].hh.b1;
2217 /* *********************************************************************** */
2218     temp_ptr = cond_ptr; /* new in 3.14159 */
2219     cond_ptr = mem[cond_ptr].hh.v.RH;
2220         free_node(temp_ptr, 2); /* new in 3.14159 */
2221 /* *********************************************************************** */
2222   }
2223   if(history != 0)
2224   if(((history == 1)||(interaction < 3)))
2225   if(selector == 19)
2226   {
2227     selector = 17;
2228     print_nl(" (see the transcript file for additional information)");
2229     selector = 19;
2230   }
2231   if(c == 1){
2232         ;
2233 #ifdef INITEX
2234 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
2235     if (is_initex) {                                    /* bkph */
2236 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
2237 /* *************************** new in 3.14159 ***************************** */
2238     {
2239                 register integer for_end;
2240                 c = 0;
2241                 for_end = 4;
2242                 if(c <= for_end) do
2243                         if(cur_mark[c]!= 0)
2244                                 delete_token_ref(cur_mark[c]);
2245                 while(c++ < for_end);
2246         }
2247 /* *********************************************************************** */
2248 /* 422. Amendment to bugfix 414 (reported by David Fuchs, September 2007) */
2249                 if (last_glue != max_halfword) delete_glue_ref(last_glue);
2250                 store_fmt_file ();      // returns a value ?
2251         }
2252 #endif /* INITEX */
2253         if (!is_initex)                         /* 2000/March/3 */
2254                 print_nl(" (\\dump is performed only by INITEX)");              /*  */
2255   }
2256 }
2257
2258 // debugging code for checking the string pool
2259
2260 #ifdef CHECKPOOL
2261 int checkpool (char *task)
2262 {
2263         int c, i, k, n, st, flag, bad=0;
2264
2265         if (task != NULL) {
2266                 sprintf(log_line, "Check on string pool start (%s)\n", task);
2267                 show_line(log_line, 0);
2268         }
2269         for (k = 0; k < 32; k++) {
2270                 if (str_start[k] != 3 * k) {
2271                         sprintf(log_line, "k %d str_start[k] %d\n", k, str_start[k]);
2272                         show_line(log_line, 0);
2273                 }
2274         }
2275         for (k = 32; k < 128; k++) {
2276                 if (str_start[k] != 96 + (k - 32)) {
2277                         sprintf(log_line, "k %d str_start[k] %d\n", k, str_start[k]);
2278                         show_line(log_line, 0);
2279                 }
2280         }
2281         for (k = 128; k < 256; k++) {
2282                 if (str_start[k] != 194 + 4 * (k - 128)){
2283                         sprintf(log_line, "k %d str_start[k] %d\n", k, str_start[k]);
2284                         show_line(log_line, 0);
2285                 }
2286         }
2287         if (task != NULL) {
2288                 sprintf(log_line, "Check on string pool (%s)\n", task);
2289                 show_line(log_line, 0);
2290         }
2291         for (k = 0; k < str_ptr; k++) {
2292                 if (str_start[k+1] == 0) break;
2293                 n = str_start[k+1] - str_start[k];
2294                 if (n < 0) break;
2295                 st = str_start[k];
2296                 flag = 0;
2297                 for (i = 0; i < n; i++) {
2298                         if (str_pool[st + i] == 0) {
2299                                 flag = 1; break;
2300                         }
2301                         if (str_pool[st + i] > 255) {
2302                                 flag = 1; break;
2303                         }
2304                 }
2305                 if (flag) {
2306                         bad++;
2307                         sprintf(log_line, "BAD %d (start at %d): ", k, st);
2308                         show_line(log_line, 0);
2309                         s = log_line;
2310                         for (i = 0; i < n; i++) {
2311                                 c = str_pool[st + i];
2312                                 if (c > 255) {
2313                                         sprintf(s, "%d ", c);
2314                                         s += strlen(s);
2315                                         continue;
2316                                 }
2317                                 if (c >= 128) {
2318                                         c -= 128;
2319                                         sprintf(s, "M-");
2320                                         s += strlen(s);
2321                                 }
2322                                 if (c < 32) {
2323                                         c += 64;
2324                                         sprintf(s, "C-");
2325                                         s += strlen(s);
2326                                 }
2327 //                              putc(c, stdout);
2328                                 *s++ = c;               // ???
2329                         }
2330                         *s++ = '\n';
2331                         *s++ = '\0';
2332                         show_line(log_line, stdout);
2333                 }
2334         }
2335         sprintf(log_line, "end of check (%s)\n", bad ? "BAD" : "OK");
2336         show_line(log_line, 0);
2337         if (bad) {
2338                 if (task == NULL) return bad;
2339                 else exit(1);
2340         }
2341         return bad;
2342 }  /* DEBUGGING ONLY */
2343 #endif
2344
2345 void show_frozen (void)
2346 {
2347         int i, j, n;
2348         fprintf(log_file, "\n");
2349         fprintf(log_file, "(%d fonts frozen in format file:\n", font_ptr);
2350 /*      ignore font 0 which is nullfont */
2351 /*      for (i = 1; i < font_ptr+1; i++) */
2352         for (i = 1; i <= font_ptr; i++) {
2353                 if (i > 1) fprintf(log_file, ", ");
2354                 if ((i % 8) == 0) fprintf(log_file, "\n");
2355                 n = str_start[font_name[i]+1]-str_start[font_name[i]];
2356                 for (j = 0; j < n; j++) {
2357                         putc(str_pool[str_start[font_name[i]]+j], log_file);
2358 /*                               str_pool[str_start[font_name[i]]+j] = '?'; */
2359                 }
2360         }
2361         fprintf(log_file, ") ");
2362 }
2363
2364 /* Main entry point called from texmf.c int main(int ac, char *av[]) */
2365 /* call from main_program in texmf.c */
2366 /* This in turn calls initialize() */
2367
2368 #pragma warning(disable:4127)           // conditional expression is constant
2369
2370 /* void texbody()  */
2371 int texbody (void)                                      /* now returns a value --- bkph */
2372 {
2373   history = 3;
2374
2375   set_paths(TEXFORMATPATHBIT + TEXINPUTPATHBIT + TEXPOOLPATHBIT + TFMFILEPATHBIT);
2376
2377   if(ready_already == 314159L)goto lab1; /* magic number */
2378 /*      These tests are almost all compile time tests and so could be eliminated */
2379   bad = 0;
2380   if((half_error_line < 30)||(half_error_line > error_line - 15))
2381           bad = 1;
2382   if(max_print_line < 60)       bad = 2;
2383   if(dvi_buf_size % 8 != 0) bad = 3;
2384   if(1100 > mem_top)bad = 4;            /* not compile time */
2385 /*  if(hash_prime > hash_size) */
2386   if(hash_prime > (hash_size + hash_extra)) bad = 5;
2387   if(max_in_open >= 128)bad = 6;                /* p.14 */
2388   if(mem_top < 267)bad = 7;             /* where from ? *//* not compile time */
2389         ;
2390 #ifdef INITEX
2391 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
2392   if (is_initex) {                                      /* bkph */
2393 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
2394           if((mem_min != 0)||(mem_max != mem_top))   bad = 10;
2395   }
2396 #endif /* INITEX */
2397 /*  if((mem_min > 0)||(mem_max < mem_top))  */
2398   if((mem_min > mem_bot)||(mem_max < mem_top))  bad = 10;
2399 /*  if((0 > 0)||(255 < 127))  */
2400   if((min_quarterword > 0)||(max_quarterword < 255))  bad = 11;
2401 /*  if((0 > 0)||(262143L < 32767))  */
2402   if((min_halfword > 0)||(max_halfword < 32767))  bad = 12;
2403 /*  if((0 < 0)||(255 > 262143L))  */
2404   if((min_quarterword < min_halfword)||(max_quarterword > max_halfword))
2405           bad = 13;
2406 /*  if((mem_min < 0)||(mem_max >= 262143L)||(-0 - mem_min > 262144L))  */
2407   if((mem_min < min_halfword)||(mem_max >= max_halfword)||(mem_bot - mem_min >= max_halfword))
2408           bad = 14;
2409 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
2410   if(mem_max > mem_top + mem_extra_high)                        /* not compile time */
2411           bad = 14;                             /* ha ha */
2412 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
2413 /*  if((0 < 0)||(font_max > 255)) */
2414   if((0 < min_quarterword)||(font_max > max_quarterword))  /* 93/Dec/3 */
2415           bad = 15;
2416 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
2417 #ifdef INCREASEFONTS
2418 /*  if(font_max > 512)*/                                                        /* 93/Dec/3 */
2419   if(font_max > 1024)                                                           /* 96/Jan/17 */
2420 #else
2421 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
2422   if(font_max > 256)
2423 #endif
2424           bad = 16;
2425 /*  if((save_size > 262143L)||(max_strings > 262143L)) */
2426   if((save_size > max_halfword)||(max_strings > max_halfword))
2427           bad = 17;
2428 /*  if(buf_size > 262143L)*/
2429   if(buf_size > max_halfword)bad = 18;
2430 /*  if(255 < 255) */
2431   if(max_quarterword - min_quarterword < 255) bad = 19;
2432 /* if cs_token_flag + undefined_control_sequence > max_halfword then bad <- 21;*/
2433 /*  if((hash_size + 4876) > 262143L)*/
2434 /*  if((hash_size + 4876) > max_halfword) */
2435   if((hash_size + 4095 + 781) > max_halfword) bad = 21;
2436   if(format_default_length > PATHMAX)   bad = 31;
2437 /*  if(2 * 262143L < mem_top - mem_min) */
2438   if(max_halfword < (mem_top - mem_min) / 2) bad = 41;
2439   if(bad > 0) {
2440     sprintf(log_line,  "%s%s%ld\n",  "Ouch---my internal constants have been clobbered!",
2441                         "---case ", (long) bad);
2442         show_line(log_line, 1);
2443     if (! knuth_flag)
2444                 bad_formator_pool(format_file, "the format file", "TEXFORMATS");        /* 96/Jan/17 */
2445     goto lab9999;                       // abort
2446   }
2447   initialize ();
2448         ;
2449 #ifdef INITEX
2450 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
2451   if (is_initex) {
2452 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
2453           if(! get_strings_started ()) goto lab9999;            // abort
2454           init_prim ();
2455           init_str_ptr = str_ptr;
2456           init_pool_ptr = pool_ptr;
2457           dateandtime(eqtb[(hash_size + 3183)].cint,
2458                         eqtb[(hash_size + 3184)].cint,
2459                                 eqtb[(hash_size + 3185)].cint,
2460                                         eqtb[(hash_size + 3186)].cint);
2461   }
2462 #endif /* INITEX */
2463   ready_already = 314159L;                      /* magic number */
2464
2465 lab1:                   /* get here directly if ready_already already set ... */
2466   selector = 17;
2467   tally = 0;
2468   term_offset = 0;
2469   file_offset = 0;
2470   show_line(tex_version, 0);
2471   sprintf(log_line, " (%s %s)", application, yandyversion);
2472   show_line(log_line, 0);
2473   if(format_ident > 0)slow_print(format_ident);
2474   print_ln ();
2475 #ifndef _WINDOWS
2476   fflush(stdout);
2477 #endif
2478   job_name = 0;
2479   name_in_progress = false;
2480   log_opened = false;
2481   output_file_name = 0;
2482   {
2483     {
2484       input_ptr = 0;
2485       max_in_stack = 0;
2486       in_open = 0;
2487           high_in_open = 0;     /* max_in_open name already used 1999 Jan 17 */
2488       open_parens = 0;
2489           max_open_parens = 0;  /* max_open_parens */
2490       max_buf_stack = 0;
2491       param_ptr = 0;
2492       max_param_stack = 0;
2493 #ifdef ALLOCATEBUFFER
2494 /*        first = current_buf_size; */
2495           memset (buffer, 0, current_buf_size); /* redundant */
2496 #else
2497 /*        first = buf_size; */
2498           memset (buffer, 0, buf_size);                 /* redundant ? */
2499 #endif
2500 /*      do {
2501                   buffer[first]= 0;
2502                   decr(first);
2503       } while(!(first == 0)); */
2504           first = 0;                                                    /* 1999/Jan/22 */
2505
2506       scanner_status = 0;
2507       warning_index = 0; /* warning_index:=null; l.7068 */
2508       first = 1;
2509       cur_input.state_field = 33;
2510       cur_input.start_field = 1;
2511       cur_input.index_field = 0;
2512       line = 0;
2513       cur_input.name_field = 0;
2514       force_eof = false;
2515       align_state = 1000000L;
2516       if(! init_terminal ())goto lab9999;       // abort
2517       cur_input.limit_field = last;
2518       first = last + 1;
2519     }
2520 /*    if((format_ident == 0)||(buffer[cur_input.loc_field]== 38)) */
2521 /*              For Windows NT, lets allow + instead of & for format specification */
2522     if((format_ident == 0)||
2523                 (buffer[cur_input.loc_field]== '&')||
2524                 (buffer[cur_input.loc_field]==  '+'))
2525     {
2526       if(format_ident != 0)initialize ();
2527       if(! open_fmt_file ())goto lab9999; // abort
2528       if(! load_fmt_file ()){
2529                   w_close(fmt_file);
2530                   goto lab9999; // abort
2531       }
2532       w_close(fmt_file);
2533       while((cur_input.loc_field < cur_input.limit_field)&&
2534                          (buffer[cur_input.loc_field]== 32))
2535                   incr(cur_input.loc_field);
2536     }
2537 #ifdef CHECKEQTB
2538         if (debug_flag) check_eqtb("after format");     /* debugging 94/Apr/5 */
2539 #endif
2540     if((eqtb[(hash_size + 3211)].cint < 0)||
2541                 (eqtb[(hash_size + 3211)].cint > 255))
2542                 decr(cur_input.limit_field);
2543 /*      long to unsigned char ... */
2544     else buffer[cur_input.limit_field]= eqtb[(hash_size + 3211)].cint;
2545     dateandtime(eqtb[(hash_size + 3183)].cint,
2546                 eqtb[(hash_size + 3184)].cint,
2547                           eqtb[(hash_size + 3185)].cint,
2548                                   eqtb[(hash_size + 3186)].cint);
2549     magic_offset = str_start[886]- 9 * 16;      /* following: */
2550 /*      "0234000122*4000133**3**344*0400400*000000234000111*1111112341011" */
2551     if(interaction == 0)        selector = 16;
2552     else selector = 17;
2553      if((cur_input.loc_field < cur_input.limit_field)&&
2554                 (eqtb[(hash_size + 1883) +
2555                    buffer[cur_input.loc_field]].hh.v.RH != 0))
2556     start_input ();
2557   }
2558
2559 /*      show font TFMs frozen into format file */
2560 /*      moved here after start_input to ensure the log file is open */
2561   if (show_tfm_flag && log_opened && font_ptr > 0)              /* 98/Sep/28 */
2562           show_frozen();
2563
2564
2565 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
2566   main_time = clock();
2567 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
2568   history = 0;
2569
2570   if (show_cs_names) print_cs_names(stdout, 0);         /* 98/Mar/31 */
2571
2572   main_control();                       /* read-eval-print loop :-) in tex8.c */
2573
2574 //      what if abort_flag is set now ?
2575
2576   if (show_cs_names) print_cs_names(stdout, 1);         /* 98/Mar/31 */
2577
2578 //      what if abort_flag is set now ?
2579
2580   final_cleanup();
2581
2582 //  if (abort_flag) return -1;
2583
2584   close_files_and_terminate();
2585
2586   lab9999:
2587   {
2588           int code;
2589 #ifndef _WINDOWS
2590           fflush(stdout);
2591 #endif
2592           ready_already = 0;
2593           if((history != 0)&&(history != 1)) code = 1;
2594           else code = 0;
2595 //        now return instead of exit to allow cleanup in local.c
2596           return code;
2597 //        uexit(code);
2598   }
2599 }       /* end of texbody */
2600
2601 #ifdef ALLOCATEMAIN
2602 /* add a block of variable size node space below mem_bot */
2603 void add_variable_space(int size)
2604 {       /* used in tex0.c, local.c, itex.c */
2605
2606         halfword p;
2607         halfword q;
2608         integer t;
2609
2610         if (mem_min == 0) t = mem_min;  /* bottom of present block */
2611         else t = mem_min + 1;
2612         mem_min = t - (size + 1);                       /* first word in new block - 1 */
2613 /*      mem_min = mem_start; */                         /* allocate all of it at once */
2614         if (mem_min < mem_start) {                      /* sanity test */
2615                 if (trace_flag) show_line("WARNING: mem_min < mem_start!\n", 0);
2616                 mem_min = mem_start;
2617         }
2618         p = mem[rover + 1].hh.v.LH;
2619         q = mem_min + 1;
2620         mem[mem_min].hh.v.RH = 0;       /* insert blank word below ??? */
2621         mem[mem_min].hh.v.LH = 0;       /* insert blank word below ??? */
2622         mem[p + 1].hh.v.RH = q;
2623         mem[rover + 1].hh.v.LH = q;
2624         mem[q + 1].hh.v.RH = rover;
2625         mem[q + 1].hh.v.LH = p;
2626         mem[q].hh.v.RH = empty_flag;
2627         mem[q].hh.v.LH = t - q; /* block size */
2628         rover = q;
2629 }
2630 #endif
2631
2632 /*************************************************************************/
2633
2634 /* All ini TeX code is here at end so can use same pragma optimize for it */
2635
2636 /* Ini-TeX code is rarely needed/used so make it small rather than fast */
2637
2638 #pragma optimize("t", off)
2639 /* #pragma optimize("2", off) */
2640 #pragma optimize("s", on)
2641 /* #pragma optimize("1", on) */
2642
2643 #ifdef INITEX
2644 /* split out to allow sharing of code from do_initex and newpattern */
2645 void reset_trie (void)
2646 {
2647         integer k;
2648         {
2649                 register integer for_end;
2650                 k = - (integer) trie_op_size;
2651                 for_end = trie_op_size;
2652                 if(k <= for_end)
2653                         do trie_op_hash[k]= 0;
2654                 while(k++ < for_end);
2655         }
2656         {
2657                 register integer for_end;
2658                 k = 0; for_end = 255;
2659                 if(k <= for_end)
2660                         do   trie_used[k]= min_trie_op;
2661                 while(k++ < for_end);
2662         }
2663         max_op_used = min_trie_op;
2664         trie_op_ptr = 0;
2665         trie_not_ready = true;
2666         trie_l[0]= 0;
2667         trie_c[0]= 0;
2668         trie_ptr = 0;
2669         trie_not_ready = true;
2670 }
2671
2672 void reset_hyphen (void)
2673 {       /* borrowed code from initialize() */
2674         hyph_pointer z;
2675   {
2676           register integer for_end;
2677           z = 0;
2678           for_end = hyphen_prime;
2679           if(z <= for_end) do
2680           {
2681                   hyph_word[z]= 0;
2682                   hyph_list[z]= 0; /* hyph_list[z]:=null; l.18131 */
2683           }
2684           while(z++ < for_end);
2685   }
2686   hyph_count = 0;
2687 }
2688
2689 /* split out to allow optimize for space, not time */
2690 void do_initex (void)
2691 {
2692 /*  integer i; */
2693   integer k;
2694 /*  hyph_pointer z; */
2695
2696 /* for k:=mem_bot+1 to lo_mem_stat_max do mem[k].sc:=0; p.164 */
2697   {
2698           register integer for_end;
2699           k = 1;
2700           for_end = 19;
2701           if(k <= for_end)
2702                   do mem[k].cint = 0;
2703           while(k++ < for_end);
2704   }
2705   k = 0;
2706   while(k <= 19){                       /* while k <= lo_mem_stat-max ... */
2707 /*  glue_ref_count(k):=null+1; */
2708     mem[k].hh.v.RH = 1;
2709     mem[k].hh.b0 = 0;
2710     mem[k].hh.b1 = 0;
2711     k = k + 4;
2712   }
2713   mem[6].cint = 65536L;
2714   mem[4].hh.b0 = 1;
2715   mem[10].cint = 65536L;
2716   mem[8].hh.b0 = 2;
2717   mem[14].cint = 65536L;
2718   mem[12].hh.b0 = 1;
2719   mem[15].cint = 65536L;
2720   mem[12].hh.b1 = 1;
2721   mem[18].cint = -65536L;
2722   mem[16].hh.b0 = 1;
2723   rover = 20;                                   /* rover = lo_mem_stat-max + 1 ... */
2724 /*  mem[rover].hh.v.RH = 262143L;  */
2725   mem[rover].hh.v.RH = empty_flag;
2726 /*  mem[rover].hh.v.LH = 1000; */
2727   mem[rover].hh.v.LH = block_size;
2728   mem[rover + 1].hh.v.LH = rover;
2729   mem[rover + 1].hh.v.RH = rover;
2730 /*  lo_mem_max = rover + 1000; */
2731   lo_mem_max = rover + block_size;
2732   mem[lo_mem_max].hh.v.RH = 0;
2733   mem[lo_mem_max].hh.v.LH = 0;
2734 /* for k <- hi_mem_stat_min to mem_top do mem[k] = mem[lo_mem_max]; */
2735   {
2736           register integer for_end;
2737           k = mem_top - 13;
2738           for_end = mem_top;
2739           if(k <= for_end)
2740                   do  mem[k]= mem[lo_mem_max];
2741           while(k++ < for_end);
2742   }
2743 /* info(omit_template) <- end_template_token; p.790 */
2744 /* @d end_template_token==cs_token_flag+frozen_end_template */
2745 /*  mem[omit_template].hh.v.LH = 14114;  */
2746 /*  mem[omit_template].hh.v.LH = 10019 + 4095; */  /* + eqtbextra ? NO */
2747 /*  mem[omit_template].hh.v.LH = (hash_size + 4614); */
2748 /*  mem[omit_template].hh.v.LH = (hash_size + 4095 + 519); */
2749   mem[omit_template].hh.v.LH = (hash_size + hash_extra + 4095 + 519);
2750 /* link(end_span) <- max_quarterword + 1 p.797 */
2751 /*  mem[end_span].hh.v.RH = 256;  */                    /* 94/Apr/4 ? */
2752   mem[end_span].hh.v.RH = max_quarterword + 1;   /* 96/Oct/12 ??? */
2753 /* info(end_span) <- null p.797 */
2754   mem[end_span].hh.v.LH = 0;
2755 /* type(last_active) <- hyphenated; p.820 */
2756   mem[active].hh.b0 = 1;
2757 /* line_number(last_active) <- max_halfword; p.820 */
2758 /*  mem[mem_top - 6].hh.v.LH = 262143L;  */
2759   mem[mem_top - 6].hh.v.LH = empty_flag;        /* max_halfword ? */
2760 /* subtype(last_active) <- 0; p.820 */
2761   mem[active].hh.b1 = 0;
2762 /* subtype(page_ins_head) <- 255; p.981 */
2763   mem[mem_top].hh.b1 = 255;     /* subtype(page_ins_head) = qi(255)  p.981 */
2764 /* type(page_ins_head) <- split_up; p.981 */
2765   mem[mem_top].hh.b0 = 1;
2766 /* link(page_ins_head) <- page_ins_head; p.981 */
2767   mem[mem_top].hh.v.RH = mem_top;
2768 /* type(page_head) <- glue_node; p. 988 */
2769   mem[page_head].hh.b0 = 10;
2770 /* subtype(page_head) <- normal; p. 988 */
2771   mem[page_head].hh.b1 = 0;
2772   avail = 0;                                                    /* avail <- null p.164 */
2773   mem_end = mem_top;                                            /* mem_end <- mem_top */
2774   hi_mem_min = mem_top - 13;                            /* hi_mem_min <- hi_mem_stat_min */
2775   var_used = 20;                                                /* var_used <- lo_mem_stat_max */
2776   dyn_used = 14;                                                /* dyn_used <- hi_mem_stat_usage */
2777 /* eq_type(undefined_control_sequence) <- undefined_cs; */
2778 /* equiv(undefined_control_sequence) <- null; */
2779 /* eq_level(undefined_control_sequence) <- level_zero; */
2780   eqtb[(hash_size + 781)].hh.b0 = 101;
2781   eqtb[(hash_size + 781)].hh.v.RH = 0;
2782   eqtb[(hash_size + 781)].hh.b1 = 0;
2783 /* for k <- active_base to undefined_control_sequence -1 do */
2784 /*                              eqtb[k] <- eqtb(undefined_control_sequence); */
2785 /*  {register integer for_end; k = 1; for_end = 10280; if(k <= for_end) do */
2786   {
2787           register integer for_end;
2788           k = 1;
2789           for_end = (hash_size + 780);
2790           if(k <= for_end) do
2791                   eqtb[k]= eqtb[(hash_size + 781)];
2792           while(k++ < for_end);
2793   }
2794   eqtb[(hash_size + 782)].hh.v.RH = 0; /* glue_base (hash_size + 782) */
2795   eqtb[(hash_size + 782)].hh.b1 = 1;
2796   eqtb[(hash_size + 782)].hh.b0 = 117;
2797 /* equiv(glue_base):=zero_glue; eq_level(glue_base):=level_one; */
2798 /* eq_type(glue_base):=glue_ref; */
2799 /*  {register integer for_end; k = 10283; for_end = 10811; if(k <= for_end) */
2800   {
2801           register integer for_end;
2802           k = (hash_size + 783);
2803           for_end = (hash_size + 1311);
2804           if(k <= for_end)
2805                   do eqtb[k]= eqtb[(hash_size + 782)];
2806           while(k++ < for_end);
2807   }
2808 /* glue_ref_count(zero_glue):=glue_ref_count(zero_glue)+local_base-glue_base; */
2809 /* local_base - glue_base = 530 = 17 glue_pars + 256 skip + 256 mu_skip */
2810   mem[0].hh.v.RH = mem[0].hh.v.RH + 530; /* mem[mem_bot]? */
2811 /* box(0):=null; eq_type(box_base):=box_ref; eq_level(box_base):=level_one; */
2812   eqtb[(hash_size + 1312)].hh.v.RH = 0;
2813   eqtb[(hash_size + 1312)].hh.b0 = 118;
2814   eqtb[(hash_size + 1312)].hh.b1 = 1;
2815 /* for k:=box_base+1 to box_base+255 do eqtb[k]:=eqtb[box_base]; */
2816 /*  {register integer for_end; k = 10813; for_end = 11077; if(k <= for_end) */
2817   {
2818           register integer for_end;
2819           k = (hash_size + 1313);
2820           for_end = (hash_size + 1577);
2821           if(k <= for_end)
2822                   do  eqtb[k]= eqtb[(hash_size + 781)];
2823           while(k++ < for_end);
2824   }
2825   eqtb[(hash_size + 1578)].hh.v.RH = 0;
2826   eqtb[(hash_size + 1578)].hh.b0 = 119;
2827   eqtb[(hash_size + 1578)].hh.b1 = 1;
2828 /*  {register integer for_end; k = 11079; for_end = 11333; if(k <= for_end) */
2829   {
2830           register integer for_end;
2831           k = (hash_size + 1579);
2832           for_end = (hash_size + 1833);
2833           if(k <= for_end)
2834                   do eqtb[k]= eqtb[(hash_size + 1578)];
2835           while(k++ < for_end);
2836   }
2837   eqtb[(hash_size + 1834)].hh.v.RH = 0;
2838   eqtb[(hash_size + 1834)].hh.b0 = 120;
2839   eqtb[(hash_size + 1834)].hh.b1 = 1;
2840 /*  {register integer for_end; k = 11335; for_end = 11382; if(k <= for_end) */
2841   {
2842           register integer for_end;
2843           k = (hash_size + 1835);
2844           for_end = (hash_size + 1882);
2845           if(k <= for_end)
2846                   do  eqtb[k]= eqtb[(hash_size + 1834)];
2847           while(k++ < for_end);
2848   }
2849   eqtb[(hash_size + 1883)].hh.v.RH = 0;
2850   eqtb[(hash_size + 1883)].hh.b0 = 120;
2851   eqtb[(hash_size + 1883)].hh.b1 = 1;
2852 /* initialize cat_code, lc_code, uc_code, sf_code, math_code 256 * 5 */
2853 /*  {register integer for_end; k = 11384; for_end = 12662; if(k <= for_end) */
2854   {
2855           register integer for_end;
2856           k = (hash_size + 1884);
2857           for_end = (hash_size + 3162);
2858           if(k <= for_end)
2859                   do eqtb[k]= eqtb[(hash_size + 1883)];
2860           while(k++ < for_end);
2861   }
2862 /* cat_code(k) <- other_char; math_code(k) <- hi(k); sf_code(k) = 1000; */
2863   {
2864           register integer for_end;
2865           k = 0;
2866           for_end = 255;
2867           if(k <= for_end) do
2868           {
2869                   eqtb[(hash_size + 1883) + k].hh.v.RH = 12;
2870                   eqtb[(hash_size + 2907) + k].hh.v.RH = k;
2871                   eqtb[(hash_size + 2651) + k].hh.v.RH = 1000;
2872           }
2873           while(k++ < for_end);
2874   }
2875 /* cat_base == 11383 */
2876 /* cat_code(carriage_return) <- car_ret; cat_code(" ") <- space */
2877 /* cat_code("\") <- escape; cat_code("%") <- comment; ... */
2878   eqtb[(hash_size + 1896)].hh.v.RH = 5;
2879   eqtb[(hash_size + 1915)].hh.v.RH = 10;
2880   eqtb[(hash_size + 1975)].hh.v.RH = 0;
2881   eqtb[(hash_size + 1920)].hh.v.RH = 14;
2882   eqtb[(hash_size + 2010)].hh.v.RH = 15;
2883   eqtb[(hash_size + 1883)].hh.v.RH = 9;
2884 /* for k:="0" to "9" do math_code(k):=hi(k+var_code); */
2885   {
2886           register integer for_end;
2887           k = 48;
2888           for_end = 57;
2889           if(k <= for_end) do
2890                   eqtb[(hash_size + 2907) + k].hh.v.RH = k + 28672; /* '70000 */
2891           while(k++ < for_end);
2892   }
2893 /* cat_code of uppercase and lowercase letters ... */
2894   {
2895           register integer for_end;
2896           k = 65;
2897           for_end = 90;
2898           if(k <= for_end) do
2899     {
2900 /* cat_code ... */
2901       eqtb[(hash_size + 1883) + k].hh.v.RH = 11;
2902       eqtb[(hash_size + 1883) + k + 32].hh.v.RH = 11;
2903 /* mathcode(k) = hi(k + var_code + "100); */ /* '70000 + 256 */
2904       eqtb[(hash_size + 2907) + k].hh.v.RH =
2905                   k + 28928;    /* '70000 + 256 */
2906 /* mathcode(k + "a" - "A") = hi(k + "a" - "A" + var_code + "100); */
2907       eqtb[(hash_size + 2907) + k + 32].hh.v.RH =
2908                   k + 28960;    /* '70000 + 256 + 32 */
2909 /* lc_code ... */
2910       eqtb[(hash_size + 2139) + k].hh.v.RH = k + 32;
2911       eqtb[(hash_size + 2139) + k + 32].hh.v.RH = k + 32;
2912 /* uc_code ... */
2913       eqtb[(hash_size + 2395) + k].hh.v.RH = k;
2914       eqtb[(hash_size + 2395) + k + 32].hh.v.RH = k;
2915 /* sf_code */
2916       eqtb[(hash_size + 2651) + k].hh.v.RH = 999;
2917     }
2918   while(k++ < for_end);
2919   }
2920 /*  {register integer for_end; k = 12663; for_end = 12973; if(k <= for_end) */
2921   {
2922           register integer for_end;
2923           k = (hash_size + 3163);
2924           for_end = (hash_size + 3473);
2925           if(k <= for_end)
2926                   do
2927                           eqtb[k].cint = 0;
2928           while(k++ < for_end);
2929   }
2930   eqtb[(hash_size + 3180)].cint = 1000;
2931   eqtb[(hash_size + 3164)].cint = 10000;
2932   eqtb[(hash_size + 3204)].cint = 1;
2933   eqtb[(hash_size + 3203)].cint = 25;
2934   eqtb[(hash_size + 3208)].cint = 92;
2935   eqtb[(hash_size + 3211)].cint = 13;
2936 /*  {register integer for_end; k = 13230; for_end = 13506; if(k <= for_end) */
2937   {
2938           register integer for_end;
2939           k = 0;
2940           for_end = 255;
2941           if(k <= for_end) do
2942                   eqtb[(hash_size + 3474) + k].cint = -1;
2943           while(k++ < for_end);
2944   }
2945   eqtb[(hash_size + 3520)].cint = 0;
2946 /*  {register integer for_end; k = 13230; for_end = 13506; if(k <= for_end) */
2947   {
2948           register integer for_end;
2949           k = (hash_size + 3730);
2950           for_end = (hash_size + 4006);
2951           if(k <= for_end)
2952                   do  eqtb[k].cint = 0;
2953           while(k++ < for_end);
2954   }
2955 /*  hash_used = 10014;  */ /*   hash_used = frozen_control_sequence */
2956 /* frozen_control_sequence =  hashsize + hashbase p.222 */
2957 /*  hash_used = (hash_size + 514);  */
2958   hash_used = (hash_size + hash_extra + 514);   /* 96/Jan/10 */
2959   cs_count = 0;
2960   if (trace_flag) show_line("itex cs_count = 0 ", 0);           /* debugging */
2961 /* eq_type(frozen_dont_expand) <- dont_expand; */
2962 /*  eqtb[10023].hh.b0 = 116;  */
2963 /*  eqtb[(hash_size + 523)].hh.b0 = 116;  */
2964   eqtb[(hash_size + hash_extra + 523)].hh.b0 = 116;
2965 /*  hash[(hash_size + 523)].v.RH = 499;  */
2966   hash[(hash_size + hash_extra + 523)].v.RH = 499;      /* notexpanded */
2967 /* @<Initialize table...@>= l.10750 */
2968   font_ptr = 0;                         /* font_ptr:=null_font; */
2969   fmem_ptr = 7;                         /* fmem_ptr:=7; */
2970   font_name[0]= 795;    /* nullfont */
2971   font_area[0]= 335;    /* "" */
2972   hyphen_char[0]= 45;   /* - */
2973   skew_char[0]= -1;
2974 /* ************************************************************************ */
2975 /* bchar_label[null_font]:=non_address; */ /* 3.14159 */
2976 /*  bchar_label[0]= font_mem_size; */   /* OK ? 93/Nov/26 */
2977   bchar_label[0]= non_address;  /* i.e. 0 --- 96/Jan/16  */
2978 /* ************************************************************************ */
2979   font_bchar[0]       = 256; /* font_bchar[null_font]:=non_char; */
2980   font_false_bchar[0] = 256; /* font_false_bchar[null_font]:=non_char; */
2981   font_bc[0]          = 1;
2982   font_ec[0]          = 0;
2983   font_size[0]        = 0;
2984   font_dsize[0]       = 0;
2985   char_base[0]        = 0;
2986   width_base[0]       = 0;
2987   height_base[0]      = 0;
2988   depth_base[0]       = 0;
2989   italic_base[0]      = 0;
2990   lig_kern_base[0]    = 0;
2991   kern_base[0]        = 0;
2992   exten_base[0]       = 0;
2993   font_glue[0]        = 0;
2994   font_params[0]      = 7;
2995   param_base[0]       = -1;
2996 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***  */
2997   reset_trie ();                                        /* shared 93/Nov/26 */
2998 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***  */
2999 /*  {register integer for_end; k = 0; for_end = 6; if(k <= for_end) do
3000     font_info[k].cint = 0;
3001   while(k++ < for_end); }
3002   {register integer for_end; k = - (integer) trie_op_size; for_end =
3003   trie_op_size; if(k <= for_end) do
3004     trie_op_hash[k]= 0;
3005   while(k++ < for_end); }
3006   {register integer for_end; k = 0; for_end = 255; if(k <= for_end) do
3007     trie_used[k]= min_trie_op;
3008   while(k++ < for_end); }
3009   max_op_used = min_trie_op;
3010   trie_op_ptr = 0;
3011   trie_not_ready = true;
3012   trie_l[0]= 0;
3013   trie_c[0]= 0;
3014   trie_ptr = 0; */
3015 /* text(frozen_protection):="inaccessible"; */
3016 /*  hash[10014].v.RH = 1183; */
3017 /*  hash[(hash_size + 514)].v.RH = 1184;  */
3018   hash[(hash_size + hash_extra + 514)].v.RH = 1184; /* 1183 */
3019   format_ident = 1251;  /* 1250 */
3020 /*  hash[(hash_size + 522)].v.RH = 1290; */ /* 1288 */
3021   hash[(hash_size + hash_extra + 522)].v.RH = 1290; /* 1288 */
3022 /*  eqtb[(hash_size + 522)].hh.b1 = 1;  */
3023   eqtb[(hash_size + hash_extra + 522)].hh.b1 = 1;
3024 /*  eqtb[(hash_size + 522)].hh.b0 = 113;  */
3025   eqtb[(hash_size + hash_extra + 522)].hh.b0 = 113;
3026 /*  eqtb[(hash_size + 522)].hh.v.RH = 0;  */
3027   eqtb[(hash_size + hash_extra + 522)].hh.v.RH = 0;
3028 }
3029 #endif /* INITEX */
3030
3031 #ifdef INITEX
3032 /* starts string pool with strings for 256 chars and then reads tex.pool */
3033 /* adjusted to try both "tex.pool" and "tex.poo" 95/Feb/19               */
3034 /* I have added a texpool file, but I need merge the pool to the binary  */
3035 /* lots of things updates the kpathsea sources -- Clerk Ma               */
3036 bool get_strings_started (void)
3037 {/* 30 10 */
3038   register bool Result;
3039   unsigned char k, l;
3040   ASCII_code m, n;
3041   str_number g;
3042   integer a;
3043   bool c;
3044 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
3045   int flag; /* 95/Feb/19 */
3046 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
3047   pool_ptr = 0;
3048   str_ptr = 0;
3049   str_start[0]= 0;
3050   {
3051     register integer for_end;
3052     k = 0;
3053     for_end = 255;
3054     if(k <= for_end) do
3055     {
3056       if(((k < 32)||(k > 126)))
3057       {
3058         {
3059           str_pool[pool_ptr]= 94; /* ^ */
3060           incr(pool_ptr);
3061         }
3062         {
3063           str_pool[pool_ptr]= 94; /* ^ */
3064           incr(pool_ptr);
3065         }
3066         if(k < 64)
3067         {
3068           str_pool[pool_ptr]= k + 64;
3069           incr(pool_ptr);
3070         }
3071         else if(k < 128)
3072         {
3073           str_pool[pool_ptr]= k - 64;
3074           incr(pool_ptr);
3075         } else {
3076           l = k / 16;
3077           if(l < 10)
3078           {
3079             str_pool[pool_ptr]= l + 48; /* '0' */
3080             incr(pool_ptr);
3081           } else {
3082             str_pool[pool_ptr]= l + 87; /* 'a' - 10 */
3083             incr(pool_ptr);
3084           }
3085           l = k % 16;
3086           /* l = k & 15; */
3087           if(l < 10)
3088           {
3089             str_pool[pool_ptr]= l + 48; /* '0' */
3090             incr(pool_ptr);
3091           } else {
3092             str_pool[pool_ptr]= l + 87; /* 'a' - 10 */
3093             incr(pool_ptr);
3094           }
3095         }
3096       } else {
3097         str_pool[pool_ptr]= k;
3098         incr(pool_ptr);
3099       }
3100       g = make_string ();
3101     }
3102     while(k++ < for_end);
3103   }
3104   vstrcpy((char *) name_of_file + 1, pool_name);
3105   name_of_file[0]= ' ';
3106   name_of_file[strlen(pool_name) + 1]= ' ';
3107   name_length = strlen(pool_name);
3108 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
3109 /*  if(a_open_in(pool_file, TEXPOOLPATH))  */
3110   flag = a_open_in(pool_file, TEXPOOLPATH);
3111   if (flag == 0) { /* 95/Feb/19 */
3112     pool_name [name_length - 1] = '\0'; /* `tex.pool' => `tex.poo' */
3113     vstrcpy((char *) name_of_file + 1, pool_name);
3114     name_of_file[0]= ' ';
3115     name_of_file[strlen(pool_name)+ 1]= ' ';
3116     name_length = strlen(pool_name);
3117     flag = a_open_in(pool_file, TEXPOOLPATH);
3118   }
3119   if (flag) {
3120     c = false;
3121     do {
3122       {
3123 /* if(eof(pool_file)) */ /* feof(pool_file)??? */
3124         if(test_eof(pool_file))
3125         {
3126           ;
3127 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
3128           show_line("! string pool file has no check sum.\n", 1);
3129 /* added following bit of explanation 96/Jan/16 */
3130           if (! knuth_flag)
3131             bad_formator_pool(string_file, "the pool file", "TEXPOOL");
3132 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
3133           (void) a_close(pool_file);
3134           Result = false;
3135           return(Result);
3136         }
3137         read(pool_file, m);
3138         read(pool_file, n);
3139         if(m == '*') /* last line starts with * */
3140         {
3141           a = 0;
3142           k = 1;
3143           while (true) {
3144             if((xord[n]< 48)||(xord[n]> 57))
3145             {
3146               ;
3147 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
3148               show_line("! string pool file check sum doesn't have nine digits.\n", 1);
3149 /* added following bit of explanation 96/Jan/16 */
3150               if (! knuth_flag)
3151                 bad_formator_pool(string_file, "the pool file", "TEXPOOL");
3152 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
3153               (void) a_close(pool_file);
3154               Result = false;
3155               return(Result);
3156             }
3157             a = 10 * a + xord[n]- 48;
3158             if(k == 9)
3159               goto lab30;
3160             incr(k);
3161             read(pool_file, n);
3162           }
3163 /* tex.pool file check sum *367403084 */
3164 lab30:
3165           if(a != BEGINFMTCHECKSUM) {
3166             ;
3167 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
3168             show_line("! string pool check sum doesn't match; tangle me again.\n", 1);
3169 /* added following bit of explanation 96/Jan/16 */
3170             if (! knuth_flag)
3171               bad_formator_pool(string_file, "the pool file", "TEXPOOL");
3172 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
3173             (void) a_close(pool_file);
3174             Result = false;
3175             return(Result);
3176           }
3177           c = true;
3178         } else {
3179           if((xord[m] < 48)||(xord[m] > 57)||(xord[n] < 48)||(xord[n] > 57))
3180           {
3181             ;
3182 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
3183             show_line("! string pool line doesn't begin with two digits.\n", 1);
3184 /* added following bit of explanation 96/Jan/16 */
3185             if (! knuth_flag)
3186               bad_formator_pool(string_file, "the pool file", "TEXPOOL");
3187 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
3188             (void) a_close(pool_file);
3189             Result = false;
3190             return(Result);
3191           }
3192           l = xord[m]* 10 + xord[n]- 48 * 11;
3193 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
3194 #ifdef ALLOCATESTRING
3195 /* can freely extend memory, so we need not be paranoid - stringvacancies */
3196 /* if(pool_ptr + l + stringvacancies > current_pool_size)*/
3197           if(pool_ptr + l + stringmargin > current_pool_size){
3198             if (trace_flag) show_line("String margin reallocation\n", 0);
3199 /* str_pool =  realloc_str_pool (pool_ptr + l + stringvacancies */
3200             str_pool =  realloc_str_pool (pool_ptr + l + stringmargin - current_pool_size  + increment_pool_size);
3201           }
3202           if(pool_ptr + l + stringmargin > current_pool_size) /* 94/Jan/24 */
3203 #else
3204 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
3205           if(pool_ptr + l + stringvacancies > pool_size)
3206 #endif
3207           {
3208             ;
3209             show_line("! You have to increase POOLSIZE.\n", 1);
3210             (void) a_close(pool_file);
3211             Result = false;
3212             return(Result);
3213           }
3214           {
3215             register integer for_end;
3216             k = 1;
3217             for_end = l;
3218             if(k <= for_end)
3219               do {
3220                 if(eoln(pool_file))
3221                   m = ' ';
3222                 else read(pool_file, m);
3223                 {
3224                   str_pool[pool_ptr]= xord[m];
3225                   incr(pool_ptr);
3226                 }
3227               } while(k++ < for_end);
3228           }
3229           readln(pool_file); /* flush rest to end of file / end of line */
3230           g = make_string ();
3231         }
3232       }
3233     } while(!(c));
3234     (void) a_close(pool_file);
3235     Result = true;
3236   }
3237   else {
3238  ;
3239 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
3240     sprintf(log_line, "! I can't read %s.\n", pool_name);
3241         show_line(log_line, 1);
3242         if (! knuth_flag)
3243         show_line("  (Was unable to find tex.poo or tex.pool)\n", 0); /* extra explain */
3244 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
3245     Result = false;
3246     return(Result);
3247   }
3248   return Result;
3249 }
3250 #endif /* INITEX */
3251
3252 #ifdef INITEX
3253 void sort_avail (void)
3254 {
3255   halfword p, q, r;
3256   halfword oldrover;
3257   p = get_node(1073741824L); /* 2^30 merge adjacent free nodes */
3258   p = mem[rover + 1].hh.v.RH;
3259 /*  mem[rover + 1].hh.v.RH = 262143L;  */ /* NO! */
3260   mem[rover + 1].hh.v.RH = empty_flag;
3261   oldrover = rover;
3262   while(p != oldrover)if(p < rover)
3263   {
3264     q = p;
3265     p = mem[q + 1].hh.v.RH;
3266     mem[q + 1].hh.v.RH = rover;
3267     rover = q;
3268   } else {
3269     q = rover;
3270     while(mem[q + 1].hh.v.RH < p)q = mem[q + 1].hh.v.RH;
3271     r = mem[p + 1].hh.v.RH;
3272     mem[p + 1].hh.v.RH = mem[q + 1].hh.v.RH;
3273     mem[q + 1].hh.v.RH = p;
3274     p = r;
3275   }
3276   p = rover;
3277 /*  while(mem[p + 1].hh.v.RH != 262143L){ */    /* NO! */
3278   while (mem[p + 1].hh.v.RH != empty_flag) {
3279     mem[mem[p + 1].hh.v.RH + 1].hh.v.LH = p;
3280     p = mem[p + 1].hh.v.RH;
3281   }
3282   mem[p + 1].hh.v.RH = rover;
3283   mem[rover + 1].hh.v.LH = p;
3284 }
3285 #endif /* INITEX */
3286
3287 #ifdef INITEX
3288 void primitive_ (str_number s, quarterword c, halfword o)
3289 {
3290   pool_pointer k;
3291   small_number j;
3292 /*  small_number l;  */
3293   int l;                                                /* 95/Jan/7 */
3294   if(s < 256)
3295           cur_val = s + 257;    /* cur_val <- s + single_base; p.264 */
3296   else {
3297     k = str_start[s];
3298     l = str_start[s + 1]- k;                    /* small_number l */
3299     {
3300                 register integer for_end;
3301                 j = 0;
3302                 for_end = l - 1;
3303                 if(j <= for_end)
3304                         do buffer[j]= str_pool[k + j];
3305                 while(j++ < for_end);
3306         }
3307     cur_val = id_lookup(0, l);
3308     {
3309       decr(str_ptr);
3310       pool_ptr = str_start[str_ptr];
3311     }
3312 /*      **********************  debugging only  96/Jan/20 should not happen */
3313 #ifdef SHORTHASH
3314         if (s > 65535L) show_line("ERROR: hash entry too large\n", 1);
3315 #endif
3316     hash[cur_val].v.RH = s;
3317   }
3318   eqtb[cur_val].hh.b1 = 1;
3319   eqtb[cur_val].hh.b0 = c;
3320   eqtb[cur_val].hh.v.RH = o;
3321 }
3322 #endif /* INITEX */
3323
3324 /* more weird constants ? page 394 */
3325
3326 #ifdef INITEX
3327 trie_op_code new_trie_op_ (small_number d, small_number n, trie_op_code v)
3328 {/* 10 */
3329   register trie_op_code Result;
3330   integer h;
3331   trie_op_code u;
3332   integer l;
3333 /* the 313, 361 and 1009 are hard-wired constants here p.944 */
3334 /* begin h:=abs(n+313*d+361*v+1009*cur_lang) mod (trie_op_size+trie_op_size) */
3335   h = abs(toint(n)+ 313 * toint(d)+ 361 * toint(v)+ 1009 *
3336                 toint(cur_lang)) %(trie_op_size - neg_trie_op_size)+ neg_trie_op_size;
3337   while (true) {
3338 /*  if l=0 then {empty position found for a new op} */
3339     l = trie_op_hash[h];
3340     if(l == 0)
3341     {
3342       if(trie_op_ptr == trie_op_size){
3343                   overflow("pattern memory ops", trie_op_size); /* pattern memory ops  - NOT DYNAMIC */
3344                   return 0;                     // abort_flag set
3345           }
3346       u = trie_used[cur_lang];
3347 /*    if u=max_quarterword then ??? */
3348       if(u == max_trie_op){
3349 /*                overflow("pattern memory ops per language",
3350                   max_quarterword-min_quarterword); ??? */
3351                   overflow("pattern memory ops per language", max_trie_op - min_trie_op); /* pattern memory ops per language */
3352                   return 0;                     // abort_flag set
3353           }
3354       incr(trie_op_ptr);
3355       incr(u);
3356       trie_used[cur_lang]= u;
3357       if(u > max_op_used)
3358       max_op_used = u;
3359       hyf_distance[trie_op_ptr]= d;
3360       hyf_num[trie_op_ptr]= n;
3361       hyf_next[trie_op_ptr]= v;
3362       trie_op_lang[trie_op_ptr]= cur_lang;
3363       trie_op_hash[h]= trie_op_ptr;
3364       trie_op_val[trie_op_ptr]= u;
3365       Result = u;
3366       return(Result);
3367     }
3368     if((hyf_distance[l]== d)&&(hyf_num[l]== n)&&(hyf_next[l
3369   ]== v)&&(trie_op_lang[l]== cur_lang))
3370     {
3371       Result = trie_op_val[l];
3372       return(Result);
3373     }
3374     if(h > - (integer) trie_op_size)
3375                 decr(h);
3376     else h = trie_op_size;
3377   }
3378 /*  return Result;  */  /* unreachable code */
3379 }
3380 /* what are those horrible constants there ? page 395 */
3381 trie_pointer trie_node_ (trie_pointer p)
3382 {/* 10 */ register trie_pointer Result;
3383   trie_pointer h;
3384   trie_pointer q;
3385 /* the 1009, 2718, 3142 are hard-wired constants here (not hyphen_prime) */
3386   h = abs(toint(trie_c[p])+ 1009 * toint(trie_o[p])+ 2718 *
3387   toint(trie_l[p])+ 3142 * toint(trie_r[p])) % trie_size;
3388   while(true){
3389     q = trie_hash[h];
3390     if(q == 0)
3391     {
3392       trie_hash[h]= p;
3393       Result = p;
3394       return(Result);
3395     }
3396     if((trie_c[q]== trie_c[p])&&(trie_o[q]== trie_o[p])&&(
3397     trie_l[q]== trie_l[p])&&(trie_r[q]== trie_r[p]))
3398     {
3399       Result = q;
3400       return(Result);
3401     }
3402     if(h > 0)
3403                 decr(h);
3404     else h = trie_size;
3405   }
3406 /*  return Result;  */  /* unreachable code */
3407 }
3408 trie_pointer compress_trie_ (trie_pointer p)
3409 {register trie_pointer Result;
3410   if(p == 0)
3411   Result = 0;
3412   else {
3413     trie_l[p]= compress_trie(trie_l[p]);
3414     trie_r[p]= compress_trie(trie_r[p]);
3415     Result = trie_node(p);
3416   }
3417   return Result;
3418 }
3419 void first_fit_ (trie_pointer p)
3420 {/* 45 40 */
3421   trie_pointer h;
3422   trie_pointer z;
3423   trie_pointer q;
3424   ASCII_code c;
3425   trie_pointer l, r;
3426   short ll;
3427   c = trie_c[p];
3428   z = trie_min[c];
3429   while(true){
3430     h = z - c;
3431     if(trie_max < h + 256)
3432     {
3433       if(trie_size <= h + 256){
3434                   overflow("pattern memory", trie_size);  /* pattern memory - NOT DYNAMIC */
3435 /*                not dynamic ---- but can be set -h=... from command line in ini-TeX */
3436                   return;                       // abort_flag set
3437           }
3438       do {
3439           incr(trie_max);
3440         trie_taken[trie_max]= false;
3441         trie_trl[trie_max]= trie_max + 1;
3442         trie_tro[trie_max]= trie_max - 1;
3443       } while(!(trie_max == h + 256));
3444     }
3445     if(trie_taken[h])
3446     goto lab45;
3447     q = trie_r[p];
3448     while(q > 0){
3449       if(trie_trl[h + trie_c[q]] == 0)
3450       goto lab45;
3451       q = trie_r[q];
3452     }
3453     goto lab40;
3454     lab45: z = trie_trl[z];
3455   }
3456 lab40:
3457   trie_taken[h]= true; /* h may be used without ... */
3458   trie_hash[p]= h;
3459   q = p;
3460   do {
3461       z = h + trie_c[q];
3462     l = trie_tro[z];
3463     r = trie_trl[z];
3464     trie_tro[r]= l;
3465     trie_trl[l]= r;
3466     trie_trl[z]= 0;
3467     if(l < 256)
3468     {
3469       if(z < 256)
3470       ll = z;                                   /* short ll */
3471       else ll = 256;
3472       do {
3473           trie_min[l]= r;
3474         incr(l);
3475       } while(!(l == ll));
3476     }
3477     q = trie_r[q];
3478   } while(!(q == 0));
3479 }
3480 void trie_pack_ (trie_pointer p)
3481 {
3482   trie_pointer q;
3483   do {
3484       q = trie_l[p];
3485     if((q > 0)&&(trie_hash[q]== 0))
3486     {
3487       first_fit(q);
3488       trie_pack(q);
3489     }
3490     p = trie_r[p];
3491   } while(!(p == 0));
3492 }
3493 void trie_fix_ (trie_pointer p)
3494 {
3495   trie_pointer q;
3496   ASCII_code c;
3497   trie_pointer z;
3498   z = trie_hash[p];
3499   do {
3500       q = trie_l[p];
3501     c = trie_c[p];
3502     trie_trl[z + c]= trie_hash[q];
3503     trie_trc[z + c]= c;
3504     trie_tro[z + c]= trie_o[p];
3505     if(q > 0)
3506     trie_fix(q);
3507     p = trie_r[p];
3508   } while(!(p == 0));
3509 }
3510 void new_patterns (void)
3511 {/* 30 31 */
3512 /* ******************************************************************* */
3513 /*  was small_number k, l;  in 3.141 */
3514   char k, l;
3515 /* ******************************************************************* */
3516   bool digitsensed;
3517   trie_op_code v;
3518   trie_pointer p, q;
3519   bool firstchild;
3520 /*  ASCII_code c;  */
3521   int c;                                                                /* 95/Jan/7 */
3522 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
3523   if (! trie_not_ready) {                                       /* new stuff */
3524           if (allow_patterns) {
3525                   if (trace_flag) show_line("Resetting patterns\n", 0);
3526                   reset_trie();                                 /* RESET PATTERNS -  93/Nov/26 */
3527                   if (reset_exceptions) {
3528                           if (trace_flag) show_line("Resetting exceptions\n", 0);
3529                           reset_hyphen();                       /* RESET HYPHENEXCEPTIONS -  93/Nov/26 */
3530                   }
3531           }
3532   }
3533 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
3534   if(trie_not_ready)
3535   {
3536     if(eqtb[(hash_size + 3213)].cint <= 0)
3537     cur_lang = 0;
3538     else if(eqtb[(hash_size + 3213)].cint > 255)
3539     cur_lang = 0;
3540     else cur_lang = eqtb[(hash_size + 3213)].cint;
3541     scan_left_brace ();
3542     k = 0;
3543     hyf[0]= 0;
3544     digitsensed = false;
3545     while(true){
3546       get_x_token ();
3547       switch(cur_cmd)
3548       {case 11 :
3549       case 12 :
3550         if(digitsensed ||(cur_chr < 48)||(cur_chr > 57))
3551         {
3552           if(cur_chr == 46)             /* . */
3553           cur_chr = 0;
3554           else {
3555
3556             cur_chr = eqtb[(hash_size + 2139) + cur_chr].hh.v.RH;
3557             if(cur_chr == 0)
3558             {
3559                         print_err("Nonletter");
3560                         help1("(See Appendix H.)");
3561               error ();
3562             }
3563           }
3564           if(k < 63)
3565           {
3566             incr(k);
3567             hc[k]= cur_chr;
3568             hyf[k]= 0;
3569             digitsensed = false;
3570           }
3571         }
3572         else if(k < 63)
3573         {
3574           hyf[k]= cur_chr - 48;
3575           digitsensed = true;
3576         }
3577         break;
3578       case 10 :
3579       case 2 :
3580         {
3581           if(k > 0)
3582           {
3583             if(hc[1]== 0)
3584             hyf[0]= 0;
3585             if(hc[k]== 0)
3586             hyf[k]= 0;
3587             l = k;
3588             v = min_trie_op;
3589             while(true){
3590               if(hyf[l]!= 0)
3591               v = new_trie_op(k - l, hyf[l], v);
3592               if(l > 0)
3593               decr(l);
3594               else goto lab31;
3595             }
3596             lab31:;
3597             q = 0;
3598             hc[0]= cur_lang;
3599             while(l <= k){
3600               c = hc[l];
3601               incr(l);
3602               p = trie_l[q];
3603               firstchild = true;
3604               while((p > 0)&&(c > trie_c[p])) {
3605                 q = p;
3606                 p = trie_r[q];
3607                 firstchild = false;
3608               }
3609               if((p == 0)||(c < trie_c[p]))
3610               {
3611                 if(trie_ptr == trie_size){
3612                         overflow("pattern memory", trie_size);  /* pattern memory - NOT DYNAMIC */
3613 /*                      not dynamic ---- but can be set -h=... from command line in ini-TeX */
3614                         return;                 // abort_flag set
3615                 }
3616                 incr(trie_ptr);
3617                 trie_r[trie_ptr]= p;
3618                 p = trie_ptr;
3619                 trie_l[p]= 0;
3620                 if(firstchild)
3621                 trie_l[q]= p;
3622                 else trie_r[q]= p;
3623                 trie_c[p]= c;
3624                 trie_o[p]= min_trie_op;
3625               }
3626               q = p;
3627             }
3628             if(trie_o[q]!= min_trie_op)
3629             {
3630                         print_err("Duplicate pattern");
3631                         help1("(See Appendix H.)");
3632               error ();
3633             }
3634             trie_o[q]= v;
3635           }
3636           if(cur_cmd == 2)
3637           goto lab30;
3638           k = 0;
3639           hyf[0]= 0;
3640           digitsensed = false;
3641         }
3642         break;
3643         default:
3644         {
3645                 print_err("Bad ");
3646           print_esc("patterns");
3647           help1("(See Appendix H.)");
3648           error ();
3649         }
3650         break;
3651       }
3652     }
3653     lab30:;
3654   }
3655   else {
3656       print_err("Too late for ");
3657     print_esc("patterns");
3658         help1("All patterns must be given before typesetting begins.");
3659     error ();
3660     mem[lig_trick].hh.v.RH = scan_toks(false, false);
3661     flush_list(def_ref);
3662   }
3663 }
3664 void init_trie (void)
3665 {
3666   trie_pointer p;
3667 /*  integer j, k, t;  */
3668   integer j, k;
3669   int t;                                                                        /* 95/Jan/7 */
3670   trie_pointer r, s;
3671   op_start[0]= - (integer) min_trie_op;
3672   {
3673           register integer for_end;
3674           j = 1;
3675           for_end = 255;
3676           if(j <= for_end) do
3677                   op_start[j]= op_start[j - 1]+ trie_used[j - 1];
3678           while(j++ < for_end);
3679   }
3680   {
3681           register integer for_end;
3682           j = 1;
3683           for_end = trie_op_ptr;
3684           if(j <= for_end)
3685                   do
3686                           trie_op_hash[j]= op_start[trie_op_lang[j]] + trie_op_val[j];
3687           while(j++ < for_end);
3688   }
3689   {
3690           register integer for_end;
3691           j = 1;
3692           for_end = trie_op_ptr;
3693           if(j <= for_end)
3694                   do
3695           while(trie_op_hash[j]> j){
3696                   k = trie_op_hash[j];
3697                   t = hyf_distance[k];
3698                   hyf_distance[k]= hyf_distance[j];
3699                   hyf_distance[j]= t;
3700                   t = hyf_num[k];
3701                   hyf_num[k]= hyf_num[j];
3702                   hyf_num[j]= t;
3703                   t = hyf_next[k];
3704                   hyf_next[k]= hyf_next[j];
3705                   hyf_next[j]= t;
3706                   trie_op_hash[j]= trie_op_hash[k];
3707                   trie_op_hash[k]= k;
3708           }
3709           while(j++ < for_end);
3710   }
3711   {
3712           register integer for_end;
3713           p = 0;
3714           for_end = trie_size;
3715           if(p <= for_end)
3716                   do trie_hash[p]= 0;
3717           while(p++ < for_end);
3718   }
3719   trie_l[0]= compress_trie(trie_l[0]);
3720   {
3721           register integer for_end;
3722           p = 0;
3723           for_end = trie_ptr;
3724           if(p <= for_end)
3725                   do trie_hash[p]= 0;
3726           while(p++ < for_end);
3727   }
3728   {
3729           register integer for_end;
3730           p = 0;
3731           for_end = 255;
3732           if(p <= for_end) do
3733                   trie_min[p]= p + 1;
3734           while(p++ < for_end);
3735   }
3736   trie_trl[0]= 1;
3737   trie_max = 0;
3738   if(trie_l[0]!= 0)
3739   {
3740     first_fit(trie_l[0]);
3741     trie_pack(trie_l[0]);
3742   }
3743   if(trie_l[0]== 0)
3744   {
3745     {
3746                 register integer for_end;
3747                 r = 0;
3748                 for_end = 256;
3749                 if(r <= for_end) do
3750                 {
3751                         trie_trl[r]= 0;
3752                         trie_tro[r]= min_trie_op;
3753                         trie_trc[r]= 0;
3754                 }
3755                 while(r++ < for_end);
3756         }
3757     trie_max = 256;
3758   }
3759   else {
3760     trie_fix(trie_l[0]);
3761     r = 0;
3762     do {
3763         s = trie_trl[r];
3764       {
3765         trie_trl[r]= 0;
3766         trie_tro[r]= min_trie_op;
3767         trie_trc[r]= 0;
3768       }
3769       r = s;
3770     } while(!(r > trie_max));
3771   }
3772   trie_trc[0]= 63;
3773   trie_not_ready = false;
3774 }
3775 #endif /* INITEX */
3776
3777 #ifdef INITEX
3778 void store_fmt_file (void)
3779 {/* 41 42 31 32 */
3780   integer j, k, l;
3781   halfword p, q;
3782   integer x;
3783 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
3784   if (!is_initex) {                     /* redundant check 94/Feb/14 */
3785           show_line("! \\dump is performed only by INITEX\n", 1);
3786           if (! knuth_flag)
3787                   show_line("  (Use -i on the command line)\n", 0);
3788           abort_flag++;
3789           return;
3790   }
3791 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
3792   if(save_ptr != 0) {
3793           print_err("You can't dump inside a group");
3794           help1("`{...\\dump}' is a no-no..");
3795     {
3796       if(interaction == 3) interaction = 2;
3797       if(log_opened){
3798                   error ();
3799           }
3800         ;
3801 #ifdef DEBUG
3802       if(interaction > 0) debug_help ();
3803 #endif /* DEBUG */
3804       history = 3;
3805       jump_out ();              // trying to \dump inside a group
3806 //        return;                       // drops through now
3807         }
3808   } /* end of if save_ptr != 0 */
3809
3810   selector = 21;
3811   print_string(" (format=");
3812   print(job_name);
3813   print_char(32);       /*   */
3814 /*  print_int(eqtb[(hash_size + 3186)].cint % 100);  */ /* Y2K */
3815   print_int(eqtb[(hash_size + 3186)].cint);             /* 98/Oct/12 */
3816 /*  {
3817           int n= eqtb[(hash_size + 3186)].cint;
3818           sprintf(log_line, "YEAR: %ld\n", n);
3819           show_line(log_line, 0);
3820   } */
3821   print_char(46); /* . */
3822   print_int(eqtb[(hash_size + 3185)].cint);
3823   print_char(46); /* . */
3824   print_int(eqtb[(hash_size + 3184)].cint);
3825   print_char(41); /*)*/
3826   if(interaction == 0)selector = 18;
3827   else selector = 19;
3828   {
3829 #ifdef ALLOCATESTRING
3830     if(pool_ptr + 1 > current_pool_size)
3831                 str_pool = realloc_str_pool (increment_pool_size);
3832     if(pool_ptr + 1 > current_pool_size){ /* in case it failed 94/Jan/24 */
3833                 overflow("pool size", current_pool_size - init_pool_ptr); /* 97/Mar/9 */
3834                 return;                 // abort_flag set
3835         }
3836 #else
3837     if(pool_ptr + 1 > pool_size){
3838                 overflow("pool size", pool_size - init_pool_ptr); /* pool size */
3839                 return;                 // abort_flag set
3840         }
3841 #endif
3842   }
3843   format_ident = make_string ();
3844   pack_job_name(780);           /* .fmt */
3845   while(! w_open_out(fmt_file)) {
3846           prompt_file_name(1267, 780); /* format file name  .fmt */
3847   }
3848   print_nl(" Beginning to dump on file ");              /*  */
3849   slow_print(w_make_name_string(fmt_file));
3850   {
3851     decr(str_ptr);
3852     pool_ptr = str_start[str_ptr];
3853   }
3854   print_nl("");         /* */
3855   slow_print(format_ident);
3856   dump_int(BEGINFMTCHECKSUM); /* magic FMT file start 4C 20 E6 15 hex */
3857 /*  dump_int(0); */
3858   dump_int(mem_bot);
3859   dump_int(mem_top);
3860   dump_int((hash_size + 4006)); /* eqtbsize */
3861   dump_int(hash_prime);
3862 /*  dump_int(607);  */
3863   dump_int(hyphen_prime);               /* bkph */
3864   dump_int(pool_ptr);
3865   dump_int(str_ptr);
3866   if (dumpthings(str_start[0], str_ptr + 1)
3867         )return;
3868   if (dumpthings(str_pool[0], pool_ptr)
3869         )return;
3870   print_ln ();
3871   print_int(str_ptr);
3872   print_string("strings of total length ");
3873   print_int(pool_ptr);
3874   sort_avail ();
3875   var_used = 0;
3876   dump_int(lo_mem_max);
3877   dump_int(rover);
3878   p = 0;
3879   q = rover;
3880   x = 0;
3881   do {
3882       if (dumpthings(mem[p], q + 2 - p)
3883                 )return;
3884     x = x + q + 2 - p;
3885     var_used = var_used + q - p;
3886     p = q + mem[q].hh.v.LH;
3887     q = mem[q + 1].hh.v.RH;
3888   } while(!(q == rover));
3889   var_used = var_used + lo_mem_max - p;
3890   dyn_used = mem_end + 1 - hi_mem_min;
3891   if (dumpthings(mem[p], lo_mem_max + 1 - p)
3892         )return;
3893   x = x + lo_mem_max + 1 - p;
3894   dump_int(hi_mem_min);
3895   dump_int(avail);
3896   if (dumpthings(mem[hi_mem_min], mem_end + 1 - hi_mem_min)
3897         )return;
3898   x = x + mem_end + 1 - hi_mem_min;
3899   p = avail;
3900   while(p != 0){
3901     decr(dyn_used);
3902     p = mem[p].hh.v.RH;
3903   }
3904   dump_int(var_used);
3905   dump_int(dyn_used);
3906   print_ln ();
3907   print_int(x);
3908   print_string("memory locations dumped; current usage is ");
3909   print_int(var_used);
3910   print_char(38);       /* & */
3911   print_int(dyn_used);
3912   k = 1;
3913   do {
3914       j = k;
3915     while(j < (hash_size + 3162)){
3916       if((eqtb[j].hh.v.RH == eqtb[j + 1].hh.v.RH)&&(eqtb[j
3917     ].hh.b0 == eqtb[j + 1].hh.b0)&&(eqtb[j].hh.b1 == eqtb[j +
3918       1].hh.b1))
3919       goto lab41;
3920       incr(j);
3921     }
3922     l = (hash_size + 3163);
3923     goto lab31;
3924     lab41: incr(j);
3925     l = j;
3926     while(j < (hash_size + 3162)){
3927       if((eqtb[j].hh.v.RH != eqtb[j + 1].hh.v.RH)||(eqtb[j
3928     ].hh.b0 != eqtb[j + 1].hh.b0)||(eqtb[j].hh.b1 != eqtb[j +
3929       1].hh.b1))
3930       goto lab31;
3931       incr(j);
3932     }
3933     lab31: dump_int(l - k);
3934     if (dumpthings(eqtb[k], l - k)
3935          )return;
3936     k = j + 1;
3937     dump_int(k - l);
3938   } while(!(k == (hash_size + 3163)));
3939   do {
3940       j = k;
3941     while(j < (hash_size + 4006)){
3942       if(eqtb[j].cint == eqtb[j + 1].cint)
3943       goto lab42;
3944       incr(j);
3945     }
3946     l = (hash_size + 4007);
3947     goto lab32;
3948     lab42: incr(j);
3949     l = j;
3950     while(j < (hash_size + 4006)){
3951       if(eqtb[j].cint != eqtb[j + 1].cint)
3952       goto lab32;
3953       incr(j);
3954     }
3955     lab32: dump_int(l - k);
3956     if (dumpthings(eqtb[k], l - k)
3957          )return;
3958     k = j + 1;
3959     dump_int(k - l);
3960   } while(!(k > (hash_size + 4006)));
3961   dump_int(par_loc);
3962   dump_int(write_loc);
3963   dump_int(hash_used);
3964 /*  cs_count:=frozen_control_sequence-1-hash_used; */
3965 /*  cs_count = (hash_size + 513) - hash_used;  */
3966   cs_count = (hash_size + hash_extra + 513) - hash_used;
3967 /*  cs_count = (hash_size + 780) - hash_used;  */ /* ??? */
3968   if (trace_flag) {
3969           sprintf(log_line, "itex cs_count %d hash_size %d hash_extra %d hash_used %d",
3970                  cs_count, hash_size, hash_extra, hash_used);                   /* debugging */
3971           show_line(log_line, 0);
3972   }
3973 /*      for p <- hash_base to hash_used do */
3974   {
3975           register integer for_end;
3976           p = 514;
3977           for_end = hash_used;
3978           if(p <= for_end) do
3979                   if(hash[p].v.RH != 0){
3980                           dump_int(p);
3981                           dump_hh(hash[p]);
3982                           incr(cs_count);
3983                           if (trace_flag) {
3984                                   sprintf(log_line, "itex cs_count++ ");
3985                                   show_line(log_line, 0); /* debugging */
3986                           }
3987                   }
3988           while(p++ < for_end);
3989   }
3990 /*      ??? */
3991 /* for p <- hash_used+1 to undefined_control_sequence-1 do dump_hh(hash[p]) */
3992   if (dumpthings(hash[hash_used + 1], (hash_size + 780) - hash_used)
3993         )return;
3994   dump_int(cs_count);
3995   print_ln ();
3996   print_int(cs_count);
3997   print_string(" multiletter control sequences");
3998   dump_int(fmem_ptr);
3999   {
4000     if (dumpthings(font_info[0], fmem_ptr)) return;
4001 /*      frozenfontptr = font_ptr; */            /* number of fonts frozen into format */
4002     dump_int(font_ptr);
4003     if (dumpthings(font_check[0], font_ptr + 1))return;
4004     if (dumpthings(font_size[0], font_ptr + 1))return;
4005     if (dumpthings(font_dsize[0], font_ptr + 1))return;
4006     if (dumpthings(font_params[0], font_ptr + 1))return;
4007     if (dumpthings(hyphen_char[0], font_ptr + 1))return;
4008     if (dumpthings(skew_char[0], font_ptr + 1))return;
4009     if (dumpthings(font_name[0], font_ptr + 1))return;
4010     if (dumpthings(font_area[0], font_ptr + 1))return;
4011     if (dumpthings(font_bc[0], font_ptr + 1))return;
4012     if (dumpthings(font_ec[0], font_ptr + 1))return;
4013     if (dumpthings(char_base[0], font_ptr + 1))return;
4014     if (dumpthings(width_base[0], font_ptr + 1))return;
4015     if (dumpthings(height_base[0], font_ptr + 1))return;
4016     if (dumpthings(depth_base[0], font_ptr + 1))return;
4017     if (dumpthings(italic_base[0], font_ptr + 1))return;
4018     if (dumpthings(lig_kern_base[0], font_ptr + 1))return;
4019     if (dumpthings(kern_base[0], font_ptr + 1))return;
4020     if (dumpthings(exten_base[0], font_ptr + 1))return;
4021     if (dumpthings(param_base[0], font_ptr + 1))return;
4022     if (dumpthings(font_glue[0], font_ptr + 1))return;
4023     if (dumpthings(bchar_label[0], font_ptr + 1))return;
4024     if (dumpthings(font_bchar[0], font_ptr + 1))return;
4025     if (dumpthings(font_false_bchar[0], font_ptr + 1))return;
4026     {
4027                 register integer for_end;
4028                 k = 0;
4029                 for_end = font_ptr;
4030                 if(k <= for_end)
4031                         do
4032       {
4033         print_nl("\\font");
4034 /*      print_esc(hash[(hash_size + 524) + k].v.RH);  */
4035         //print_esc(hash[(hash_size + hash_extra + 524) + k].v.RH);
4036         print_esc("");print(hash[(hash_size + hash_extra + 524) + k].v.RH);
4037         print_char(61); /* = */
4038         print_file_name(font_name[k], font_area[k], 335);
4039         if(font_size[k]!= font_dsize[k])
4040         {
4041           print_string(" at ");
4042           print_scaled(font_size[k]);
4043           print_string("pt");
4044         }
4045       }
4046     while(k++ < for_end);
4047         }
4048   }
4049   print_ln ();
4050   print_int(fmem_ptr - 7);
4051   print_string("words of font info for");
4052   print_int(font_ptr - 0);
4053   print_string(" preloaded font");
4054   if(font_ptr != 1)
4055           print_char(115);      /* s */
4056   dump_int(hyph_count);
4057 /*  {register integer for_end; k = 0; for_end = 607; if(k <= for_end) do */
4058   {
4059           register integer for_end;
4060           k = 0;
4061           for_end = hyphen_prime;
4062           if(k <= for_end) do
4063                   if(hyph_word[k]!= 0)
4064                   {
4065                           dump_int(k);
4066                           dump_int(hyph_word[k]);
4067                           dump_int(hyph_list[k]);
4068                   }
4069           while(k++ < for_end);
4070   }
4071   print_ln ();
4072   print_int(hyph_count);
4073   print_string(" hyphenation exception");
4074   if(hyph_count != 1)
4075   print_char(115);      /* s */
4076   if(trie_not_ready)
4077   init_trie ();
4078   dump_int(trie_max);
4079   if (dumpthings(trie_trl[0], trie_max + 1)
4080         )return;
4081   if (dumpthings(trie_tro[0], trie_max + 1)
4082         )return;
4083   if (dumpthings(trie_trc[0], trie_max + 1)
4084         )return;
4085   dump_int(trie_op_ptr);
4086   if (dumpthings(hyf_distance[1], trie_op_ptr)
4087         )return;
4088   if (dumpthings(hyf_num[1], trie_op_ptr)
4089         )return;
4090   if (dumpthings(hyf_next[1], trie_op_ptr)
4091         )return;
4092   print_nl("Hyphenation trie of length ");      /*  */
4093   print_int(trie_max);
4094   print_string("has");
4095   print_int(trie_op_ptr);
4096   print_string("op");
4097   if(trie_op_ptr != 1)
4098   print_char(115);      /* s */
4099   print_string("out of");
4100   print_int(trie_op_size);
4101   {
4102           register integer for_end;
4103           k = 255;
4104           for_end = 0;
4105           if(k >= for_end) do
4106                   if(trie_used[k]> 0)
4107                   {
4108                           print_nl("  ");
4109                           print_int(trie_used[k]);
4110                           print_string("for language");
4111                           print_int(k);
4112                           dump_int(k);
4113                           dump_int(trie_used[k]);
4114                   }
4115           while(k-- > for_end);
4116   }
4117   dump_int(interaction);
4118   dump_int(format_ident);
4119   dump_int(ENDFMTCHECKSUM);     /* magic checksum end of FMT file --- change ??? */
4120   eqtb[(hash_size + 3194)].cint = 0;    /* tracingstats  */
4121   w_close(fmt_file);
4122 //  return 0;
4123 } /* end of store_fmt_file */
4124 #endif /* INITEX */
4125
4126 #ifdef INITEX
4127 void init_prim (void)
4128 {
4129   no_new_control_sequence = false;
4130   primitive(373, assign_glue, (hash_size + 782)); /* lineskip */
4131   primitive(374, assign_glue, (hash_size + 783)); /* baselineskip */
4132   primitive(375, assign_glue, (hash_size + 784)); /* parskip */
4133   primitive(376, assign_glue, (hash_size + 785)); /* abovedisplayskip */
4134   primitive(377, assign_glue, (hash_size + 786)); /* belowdisplayskip */
4135   primitive(378, assign_glue, (hash_size + 787)); /* abovedisplayshortskip */
4136   primitive(379, assign_glue, (hash_size + 788)); /* belowdisplayshortskip */
4137   primitive(380, assign_glue, (hash_size + 789)); /* leftskip */
4138   primitive(381, assign_glue, (hash_size + 790)); /* rightskip */
4139   primitive(382, assign_glue, (hash_size + 791)); /* topskip */
4140   primitive(383, assign_glue, (hash_size + 792)); /* splittopskip */
4141   primitive(384, assign_glue, (hash_size + 793)); /* tabskip */
4142   primitive(385, assign_glue, (hash_size + 794)); /* spaceskip */
4143   primitive(386, assign_glue, (hash_size + 795)); /* xspaceskip */
4144   primitive(387, assign_glue, (hash_size + 796)); /* parfillskip */
4145   primitive(388, assign_mu_glue, (hash_size + 797)); /* thinmuskip */
4146   primitive(389, assign_mu_glue, (hash_size + 798)); /* medmuskip */
4147   primitive(390, assign_mu_glue, (hash_size + 799)); /* thickmuskip */
4148   primitive(395, assign_toks, (hash_size + 1313)); /* output */
4149   primitive(396, assign_toks, (hash_size + 1314)); /* everypar */
4150   primitive(397, assign_toks, (hash_size + 1315)); /* everymath */
4151   primitive(398, assign_toks, (hash_size + 1316)); /* everydisplay */
4152   primitive(399, assign_toks, (hash_size + 1317)); /* everyhbox */
4153   primitive(400, assign_toks, (hash_size + 1318)); /* everyvbox */
4154   primitive(401, assign_toks, (hash_size + 1319)); /* everyjob */
4155   primitive(402, assign_toks, (hash_size + 1320)); /* everycr */
4156   primitive(403, assign_toks, (hash_size + 1321)); /* errhelp */
4157   primitive(417, assign_int, (hash_size + 3163)); /* pretolerance */
4158   primitive(418, assign_int, (hash_size + 3164)); /* tolerance */
4159   primitive(419, assign_int, (hash_size + 3165)); /* linepenalty */
4160   primitive(420, assign_int, (hash_size + 3166)); /* hyphenpenalty */
4161   primitive(421, assign_int, (hash_size + 3167)); /* exhyphenpenalty */
4162   primitive(422, assign_int, (hash_size + 3168)); /* clubpenalty */
4163   primitive(423, assign_int, (hash_size + 3169)); /* widowpenalty */
4164   primitive(424, assign_int, (hash_size + 3170)); /* displaywidowpenalty */
4165   primitive(425, assign_int, (hash_size + 3171)); /* brokenpenalty */
4166   primitive(426, assign_int, (hash_size + 3172)); /* binoppenalty */
4167   primitive(427, assign_int, (hash_size + 3173)); /* relpenalty */
4168   primitive(428, assign_int, (hash_size + 3174)); /* predisplaypenalty */
4169   primitive(429, assign_int, (hash_size + 3175)); /* postdisplaypenalty */
4170   primitive(430, assign_int, (hash_size + 3176)); /* interlinepenalty */
4171   primitive(431, assign_int, (hash_size + 3177)); /* doublehyphendemerits */
4172   primitive(432, assign_int, (hash_size + 3178)); /* finalhyphendemerits */
4173   primitive(433, assign_int, (hash_size + 3179)); /* adjdemerits */
4174   primitive(434, assign_int, (hash_size + 3180)); /* mag */
4175   primitive(435, assign_int, (hash_size + 3181)); /* delimiterfactor */
4176   primitive(436, assign_int, (hash_size + 3182)); /* looseness */
4177   primitive(437, assign_int, (hash_size + 3183)); /* time */
4178   primitive(438, assign_int, (hash_size + 3184)); /* day */
4179   primitive(439, assign_int, (hash_size + 3185)); /* month */
4180   primitive(440, assign_int, (hash_size + 3186)); /* year */
4181   primitive(441, assign_int, (hash_size + 3187)); /* showboxbreadth */
4182   primitive(442, assign_int, (hash_size + 3188)); /* showboxdepth */
4183   primitive(443, assign_int, (hash_size + 3189)); /* hbadness */
4184   primitive(444, assign_int, (hash_size + 3190)); /* vbadness */
4185   primitive(445, assign_int, (hash_size + 3191)); /* pausing */
4186   primitive(446, assign_int, (hash_size + 3192)); /* tracingonline */
4187   primitive(447, assign_int, (hash_size + 3193)); /* tracingmacros */
4188   primitive(448, assign_int, (hash_size + 3194)); /* tracingstats */
4189   primitive(449, assign_int, (hash_size + 3195)); /* tracingparagraphs */
4190   primitive(450, assign_int, (hash_size + 3196)); /* tracingpages */
4191   primitive(451, assign_int, (hash_size + 3197)); /* tracingoutput */
4192   primitive(452, assign_int, (hash_size + 3198)); /* tracinglostchars */
4193   primitive(453, assign_int, (hash_size + 3199)); /* tracingcommands */
4194   primitive(454, assign_int, (hash_size + 3200)); /* tracingrestores */
4195   primitive(455, assign_int, (hash_size + 3201)); /* uchyph */
4196   primitive(456, assign_int, (hash_size + 3202)); /* outputpenalty */
4197   primitive(457, assign_int, (hash_size + 3203)); /* maxdeadcycles */
4198   primitive(458, assign_int, (hash_size + 3204)); /* hangafter */
4199   primitive(459, assign_int, (hash_size + 3205)); /* floatingpenalty */
4200   primitive(460, assign_int, (hash_size + 3206)); /* globaldefs */
4201   primitive(461, assign_int, (hash_size + 3207)); /* fam */
4202   primitive(462, assign_int, (hash_size + 3208)); /* escapechar */
4203   primitive(463, assign_int, (hash_size + 3209)); /* defaulthyphenchar */
4204   primitive(464, assign_int, (hash_size + 3210)); /* defaultskewchar */
4205   primitive(465, assign_int, (hash_size + 3211)); /* endlinechar */
4206   primitive(466, assign_int, (hash_size + 3212)); /* newlinechar */
4207   primitive(467, assign_int, (hash_size + 3213)); /* language */
4208   primitive(468, assign_int, (hash_size + 3214)); /* lefthyphenmin */
4209   primitive(469, assign_int, (hash_size + 3215)); /* righthyphenmin */
4210   primitive(470, assign_int, (hash_size + 3216)); /* holdinginserts */
4211   primitive(471, assign_int, (hash_size + 3217)); /* errorcontextlines */
4212   primitive(475, assign_dimen, (hash_size + 3730)); /* parindent */
4213   primitive(476, assign_dimen, (hash_size + 3731)); /* mathsurround */
4214   primitive(477, assign_dimen, (hash_size + 3732)); /* lineskiplimit */
4215   primitive(478, assign_dimen, (hash_size + 3733)); /* hsize */
4216   primitive(479, assign_dimen, (hash_size + 3734)); /* vsize */
4217   primitive(480, assign_dimen, (hash_size + 3735)); /* maxdepth */
4218   primitive(481, assign_dimen, (hash_size + 3736)); /* splitmaxdepth */
4219   primitive(482, assign_dimen, (hash_size + 3737)); /* boxmaxdepth */
4220   primitive(483, assign_dimen, (hash_size + 3738)); /* hfuzz */
4221   primitive(484, assign_dimen, (hash_size + 3739)); /* vfuzz */
4222   primitive(485, assign_dimen, (hash_size + 3740)); /* delimitershortfall */
4223   primitive(486, assign_dimen, (hash_size + 3741)); /* nulldelimiterspace */
4224   primitive(487, assign_dimen, (hash_size + 3742)); /* scriptspace */
4225   primitive(488, assign_dimen, (hash_size + 3743)); /* predisplaysize */
4226   primitive(489, assign_dimen, (hash_size + 3744)); /* displaywidth */
4227   primitive(490, assign_dimen, (hash_size + 3745)); /* displayindent */
4228   primitive(491, assign_dimen, (hash_size + 3746)); /* overfullrule */
4229   primitive(492, assign_dimen, (hash_size + 3747)); /* hangindent */
4230   primitive(493, assign_dimen, (hash_size + 3748)); /* hoffset */
4231   primitive(494, assign_dimen, (hash_size + 3749)); /* voffset */
4232   primitive(495, assign_dimen, (hash_size + 3750));     /* emergencystretch */
4233   primitive(32, ex_space, 0);   /*   */
4234   primitive(47, ital_corr, 0);  /* / */
4235   primitive(505, accent, 0);    /* accent */
4236   primitive(506, advance, 0);   /* advance */
4237   primitive(507, after_assignment, 0);  /* afterassignment */
4238   primitive(508, after_group, 0);       /* aftergroup */
4239   primitive(509, begin_group, 0);       /* begingroup */
4240   primitive(510, char_num, 0);  /* char */
4241   primitive(501, cs_name, 0);           /* csname */
4242   primitive(511, delim_num, 0); /* delimiter */
4243   primitive(512, divide, 0);    /* divide */
4244   primitive(502, end_cs_name, 0);       /* endcsname */
4245   primitive(513, end_group, 0); /* endgroup */
4246 /*  hash[(hash_size + 516)].v.RH = 513; */
4247   hash[(hash_size + hash_extra + 516)].v.RH = 513;      /* endgroup */
4248 /*  eqtb[(hash_size + 516)]= eqtb[cur_val]; */
4249   eqtb[(hash_size + hash_extra + 516)]= eqtb[cur_val];
4250   primitive(514, expand_after, 0);              /* expandafter */
4251   primitive(515, def_font, 0);  /* font */
4252   primitive(516, assign_font_dimen, 0); /* fontdimen */
4253   primitive(517, halign, 0);    /* halign */
4254   primitive(518, hrule, 0);     /* hrule */
4255   primitive(519, ignore_spaces, 0);     /* ignorespaces */
4256   primitive(327, insert, 0); /* insert */
4257   primitive(348, mark, 0); /* mark */
4258   primitive(520, math_accent, 0);       /* mathaccent */
4259   primitive(521, math_char_num, 0);     /* mathchar */
4260   primitive(522, math_choice, 0);       /* mathchoice */
4261   primitive(523, multiply, 0);  /* multiply */
4262   primitive(524, no_align, 0);  /* noalign */
4263   primitive(525, no_boundary, 0);       /* noboundary */
4264   primitive(526, no_expand, 0);         /* noexpand */
4265   primitive(332, non_script, 0); /* nonscript */
4266   primitive(527, omit, 0);      /* omit */
4267   primitive(405, set_shape, 0); /* parshape */
4268   primitive(528, break_penalty, 0);     /* penalty */
4269   primitive(529, set_prev_graf, 0);     /* prevgraf */
4270   primitive(530, radical, 0);   /* radical */
4271   primitive(531, read_to_cs, 0);        /* read */
4272   primitive(532, relax, 256);           /* primitive("relax",relax,256); */
4273 /*  hash[(hash_size + 521)].v.RH = 532; */
4274   hash[(hash_size + hash_extra + 521)].v.RH = 532;  /* read */
4275 /*  eqtb[(hash_size + 521)]= eqtb[cur_val];  */
4276   eqtb[(hash_size + hash_extra + 521)]= eqtb[cur_val];
4277   primitive(533, set_box, 0);   /* setbox */
4278   primitive(534, the, 0);               /* the */
4279   primitive(404, toks_register, 0);     /* toks */
4280   primitive(349, vadjust, 0); /* vadjust */
4281   primitive(535, valign, 0);    /* valign */
4282   primitive(536, vcenter, 0);   /* vcenter */
4283   primitive(537, vrule, 0);     /* vrule */
4284   primitive(594, par_end, 256); /* par */
4285   par_loc = cur_val;
4286   par_token = 4095 + par_loc;
4287   primitive(626, input, 0);             /* input */
4288   primitive(627, input, 1);             /* endinput */
4289   primitive(628, top_bot_mark, 0);              /* topmark */
4290   primitive(629, top_bot_mark, 1);              /* firstmark */
4291   primitive(630, top_bot_mark, 2);              /* botmark */
4292   primitive(631, top_bot_mark, 3);              /* splitfirstmark */
4293   primitive(632, top_bot_mark, 4);              /* splitbotmark */
4294   primitive(473, tex_register, 0);      /* count */
4295   primitive(497, tex_register, 1);      /* dimen */
4296   primitive(392, tex_register, 2);      /* skip */
4297   primitive(393, tex_register, 3);      /* muskip */
4298   primitive(665, set_aux, 102); /* spacefactor */
4299   primitive(666, set_aux, 1);   /* prevdepth */
4300   primitive(667, set_page_int, 0);      /* dead_cycles */
4301   primitive(668, set_page_int, 1);      /* insert_penalties */
4302   primitive(669, set_box_dimen, 1);     /* wd */
4303   primitive(670, set_box_dimen, 3);     /* ht */
4304   primitive(671, set_box_dimen, 2);     /* dp */
4305   primitive(672, last_item, 0); /* last_penalty */
4306   primitive(673, last_item, 1); /* last_kern */
4307   primitive(674, last_item, 2); /* lastskip */
4308   primitive(675, last_item, 3); /* inputlineno */
4309   primitive(676, last_item, 4); /* badness */
4310   primitive(732, convert, 0);           /* number */
4311   primitive(733, convert, 1);           /* romannumeral */
4312   primitive(734, convert, 2);           /* string */
4313   primitive(735, convert, 3);           /* meaning */
4314   primitive(736, convert, 4);           /* font_name */
4315   primitive(737, convert, 5);           /* job_name */
4316   primitive(753, if_test, 0);           /* if */
4317   primitive(754, if_test, 1);           /* ifcat */
4318   primitive(755, if_test, 2);           /* ifnum */
4319   primitive(756, if_test, 3);           /* ifdim */
4320   primitive(757, if_test, 4);           /* ifodd */
4321   primitive(758, if_test, 5);           /* ifvmode */
4322   primitive(759, if_test, 6);           /* ifhmode */
4323   primitive(760, if_test, 7);           /* ifmmode */
4324   primitive(761, if_test, 8);           /* ifinner */
4325   primitive(762, if_test, 9);           /* ifvoid */
4326   primitive(763, if_test, 10);  /* ifhbox */
4327   primitive(764, if_test, 11);  /* ifvbox */
4328   primitive(765, if_test, 12);  /* ifx */
4329   primitive(766, if_test, 13);  /* ifeof */
4330   primitive(767, if_test, 14);  /* iftrue */
4331   primitive(768, if_test, 15);  /* iffalse */
4332   primitive(769, if_test, 16);  /* ifcase */
4333   primitive(770, fi_or_else, 2);                /* fi */
4334 /*  hash[(hash_size + 518)].v.RH = 770; */
4335   hash[(hash_size + hash_extra + 518)].v.RH = 770;              /* fi */
4336 /*  eqtb[(hash_size + 518)]= eqtb[cur_val];  */
4337   eqtb[(hash_size + hash_extra + 518)]= eqtb[cur_val];
4338   primitive(771, fi_or_else, 4);                /* or */
4339   primitive(772, fi_or_else, 3);                /* else */
4340   primitive(795, set_font, 0);          /* nullfont */
4341 /*  hash[(hash_size + 524)].v.RH = 795; */      /* hash[frozen_null_font] */
4342   hash[(hash_size + hash_extra + 524)].v.RH = 795;      /* nullfont */
4343 /*  eqtb[(hash_size + 524)]= eqtb[cur_val];  */
4344   eqtb[(hash_size + hash_extra + 524)]= eqtb[cur_val];
4345   primitive(892, tab_mark, 256);                /* span */
4346                   /* primitive("span",tab_mark,span_code); */
4347   primitive(893, car_ret, 257);         /* cr */
4348                   /* primitive("cr",car_ret,cr_code); */
4349 /*  hash[(hash_size + 515)].v.RH = 893; */
4350   hash[(hash_size + hash_extra + 515)].v.RH = 893;              /* cr */
4351 /*  eqtb[(hash_size + 515)]= eqtb[cur_val];  */
4352   eqtb[(hash_size + hash_extra + 515)]= eqtb[cur_val];
4353   primitive(894, car_ret, 258);                 /* cr cr */
4354 /*  hash[(hash_size + 519)].v.RH = 895;  */
4355   hash[(hash_size + hash_extra + 519)].v.RH = 895; /* endtemplate */
4356 /*  hash[(hash_size + 520)].v.RH = 895;  */
4357   hash[(hash_size + hash_extra + 520)].v.RH = 895; /* endtemplate */
4358 /*  eqtb[(hash_size + 520)].hh.b0 = 9;  */
4359   eqtb[(hash_size + hash_extra + 520)].hh.b0 = 9;
4360 /*  eqtb[(hash_size + 520)].hh.v.RH = null_list;  */
4361   eqtb[(hash_size + hash_extra + 520)].hh.v.RH = null_list;
4362 /*  eqtb[(hash_size + 520)].hh.b1 = 1;  */
4363   eqtb[(hash_size + hash_extra + 520)].hh.b1 = 1;
4364 /*  eqtb[(hash_size + 519)]= eqtb[(hash_size + 520)];  */
4365   eqtb[(hash_size + hash_extra + 519)]=
4366                 eqtb[(hash_size + hash_extra + 520)];
4367 /*  eqtb[(hash_size + 519)].hh.b0 = 115;  */
4368   eqtb[(hash_size + hash_extra + 519)].hh.b0 = 115;
4369   primitive(964, set_page_dimen, 0);    /* pagegoal */
4370   primitive(965, set_page_dimen, 1);    /* pagetotal */
4371   primitive(966, set_page_dimen, 2);    /* pagestretch */
4372   primitive(967, set_page_dimen, 3);    /* pagefilstretch */
4373   primitive(968, set_page_dimen, 4);    /* pagefillstretch */
4374   primitive(969, set_page_dimen, 5);    /* pagefilllstretch */
4375   primitive(970, set_page_dimen, 6);    /* pageshrink */
4376   primitive(971, set_page_dimen, 7);    /* pagedepth */
4377   primitive(1019, end_match, 0);                /* end */
4378   primitive(1020, stop, 1);             /* dump */
4379   primitive(1021, hskip, 4);            /* hskip */
4380   primitive(1022, hskip, 0);            /* hfil */
4381   primitive(1023, hskip, 1);            /* hfill */
4382   primitive(1024, hskip, 2);            /* hss */
4383   primitive(1025, hskip, 3);            /* hfilneg */
4384   primitive(1026, vskip, 4);            /* vskip */
4385   primitive(1027, vskip, 0);            /* vfil */
4386   primitive(1028, vskip, 1);            /* vfill */
4387   primitive(1029, vskip, 2);            /* vss */
4388   primitive(1030, vskip, 3);            /* vfilneg */
4389   primitive(333, mskip, 5); /* mskip */
4390   primitive(337, kern, 1); /* kern */
4391   primitive(339, mkern, 99); /* mkern */
4392   primitive(1048, hmove, 1);            /* moveleft */
4393   primitive(1049, hmove, 0);            /* moveright */
4394   primitive(1050, vmove, 1);            /* raise */
4395   primitive(1051, vmove, 0);            /* lower */
4396   primitive(406, make_box, 0);  /* box */
4397   primitive(1052, make_box, 1);         /* copy */
4398   primitive(1053, make_box, 2);         /* lastbox */
4399   primitive(959, make_box, 3);  /* vsplit */
4400   primitive(1054, make_box, 4);         /* vtop */
4401   primitive(961, make_box, 5);  /* vbox */
4402   primitive(1055, make_box, 106);       /* hbox */
4403   primitive(1056, leader_ship, 99);     /* ship_out */
4404   primitive(1057, leader_ship, 100);    /* leaders */
4405   primitive(1058, leader_ship, 101);    /* cleaders */
4406   primitive(1059, leader_ship, 102);    /* xleaders */
4407   primitive(1074, start_par, 1);                /* indent */
4408   primitive(1075, start_par, 0);                /* noindent */
4409   primitive(1084, remove_item, 12);     /* unpenalty */
4410   primitive(1085, remove_item, 11);     /* unkern */
4411   primitive(1086, remove_item, 10);     /* unskip */
4412   primitive(1087, un_hbox, 0);          /* unhbox */
4413   primitive(1088, un_hbox, 1);          /* unhcopy */
4414   primitive(1089, un_vbox, 0);          /* unvbox */
4415   primitive(1090, un_vbox, 1);          /* unvcopy */
4416   primitive(45, discretionary, 1);              /* - */
4417   primitive(346, discretionary, 0); /* discretionary */
4418   primitive(1121, eq_no, 0);            /* eqno */
4419   primitive(1122, eq_no, 1);            /* leqno */
4420   primitive(860, math_comp, 16);                /* mathord */
4421   primitive(861, math_comp, 17); /* mathop */
4422   primitive(862, math_comp, 18); /* mathbin */
4423   primitive(863, math_comp, 19); /* mathrel */
4424   primitive(864, math_comp, 20); /* mathopen */
4425   primitive(865, math_comp, 21); /* mathclose */
4426   primitive(866, math_comp, 22); /* mathpunct */
4427   primitive(867, math_comp, 23); /* mathinner */
4428   primitive(869, math_comp, 26); /* underline */
4429   primitive(868, math_comp, 27); /* overline */
4430   primitive(1123, limit_switch, 0); /* displaylimits */
4431   primitive(872, limit_switch, 1); /* limits */
4432   primitive(873, limit_switch, 2); /* nolimits */
4433   primitive(855, math_style, 0); /* displaystyle */
4434   primitive(856, math_style, 2); /* textstyle */
4435   primitive(857, math_style, 4); /* scriptstyle */
4436   primitive(858, math_style, 6); /* scriptscriptstyle */
4437   primitive(1141, above, 0); /* above */
4438   primitive(1142, above, 1); /* over */
4439   primitive(1143, above, 2); /* atop */
4440   primitive(1144, above, 3); /* abovewithdelims */
4441   primitive(1145, above, 4); /* overwithdelims */
4442   primitive(1146, above, 5); /* atopwithdelims */
4443   primitive(870, left_right, 30); /* left */
4444   primitive(871, left_right, 31); /* right */
4445 /*  hash[(hash_size + 517)].v.RH = 871;  */
4446   hash[(hash_size + hash_extra + 517)].v.RH = 871;              /* right */
4447 /*  eqtb[(hash_size + 517)]= eqtb[cur_val];  */
4448   eqtb[(hash_size + hash_extra + 517)]= eqtb[cur_val];
4449   primitive(1165, prefix, 1); /* long */
4450   primitive(1166, prefix, 2); /* outer */
4451   primitive(1167, prefix, 4); /* global */
4452   primitive(1168, def, 0); /* def */
4453   primitive(1169, def, 1); /* gdef */
4454   primitive(1170, def, 2); /* edef */
4455   primitive(1171, def, 3); /* xdef */
4456   primitive(1185, let, 0); /* let */
4457   primitive(1186, let, 1); /* futurelet */
4458   primitive(1187, shorthand_def, 0); /* chardef */
4459   primitive(1188, shorthand_def, 1); /* mathchardef */
4460   primitive(1189, shorthand_def, 2); /* countdef */
4461   primitive(1190, shorthand_def, 3); /* dimendef */
4462   primitive(1191, shorthand_def, 4); /* skipdef */
4463   primitive(1192, shorthand_def, 5); /* muskipdef */
4464   primitive(1193, shorthand_def, 6); /* toksdef */
4465   primitive(412, def_code, (hash_size + 1883)); /* catcode */
4466   primitive(416, def_code, (hash_size + 2907)); /* mathcode */
4467   primitive(413, def_code, (hash_size + 2139)); /* lccode */
4468   primitive(414, def_code, (hash_size + 2395)); /* uccode */
4469   primitive(415, def_code, (hash_size + 2651)); /* sfcode */
4470   primitive(474, def_code, (hash_size + 3474)); /* delcode */
4471   primitive(409, def_family, (hash_size + 1835)); /* textfont */
4472   primitive(410, def_family, (hash_size + 1851)); /* scriptfont */
4473   primitive(411, def_family, (hash_size + 1867)); /* scriptscriptfont */
4474   primitive(935, hyph_data, 0); /* hyphenation */
4475   primitive(947, hyph_data, 1); /* patterns */
4476   primitive(1211, assign_font_int, 0); /* hyphen_char */
4477   primitive(1212, assign_font_int, 1); /* skew_char */
4478   primitive(272, set_interaction, 0); /* batchmode */
4479   primitive(273, set_interaction, 1); /* nonstopmode */
4480   primitive(274, set_interaction, 2); /* scrollmode */
4481   primitive(1221, set_interaction, 3); /* errorstopmode */
4482   primitive(1222, in_stream, 1); /* openin */
4483   primitive(1223, in_stream, 0); /* closein */
4484   primitive(1224, message, 0); /* message */
4485   primitive(1225, message, 1); /* errmessage */
4486   primitive(1231, case_shift, (hash_size + 2139)); /* lowercase */
4487   primitive(1232, case_shift, (hash_size + 2395)); /* uppercase */
4488   primitive(1233, xray, 0); /* show */
4489   primitive(1234, xray, 1); /* show_box */
4490   primitive(1235, xray, 2); /* showthe */
4491   primitive(1236, xray, 3); /* showlists */
4492   primitive(1279, extension, 0); /* openout */
4493   primitive(591, extension, 1); /* write */
4494   write_loc = cur_val;
4495   primitive(1280, extension, 2);                /* closeout */
4496   primitive(1281, extension, 3);                /* special */
4497   primitive(1282, extension, 4);                /* immediate */
4498   primitive(1283, extension, 5);                /* setlanguage */
4499   no_new_control_sequence = true;
4500 }
4501 #endif /* INITEX */
4502
4503 #pragma optimize("s", off)                                              /* 96/Sep/12 */
4504 /* #pragma optimize("1", off) */
4505 #pragma optimize("t", on)                                               /* 96/Sep/12 */
4506 /* #pragma optimize("2", on) */
4507