src/texsourc/itex.c

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