src/texsourc/itex.c

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