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