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