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 \r
  24 #include "yandytex.h"\r
  25 \r
  26 #define BEGINFMTCHECKSUM 367403084L\r
  27 #define ENDFMTCHECKSUM   69069L\r
  28 \r
  29 #ifdef INITEX\r
  30   void do_initex (void);\r
  31 #endif\r
  32 \r
  33 /* sec 0004 */\r
  34 void initialize (void)\r
  35 {\r
  36   integer i;\r
  37   integer k;\r
  38   integer flag;\r
  39 \r
  40 #ifndef ALLOCATEHYPHEN\r
  41   hyph_pointer z;\r
  42 #endif\r
  43 \r
  44   if (!non_ascii)\r
  45   {\r
  46     for (i = 0; i <= 255; i++)\r
  47       xchr[i] = (char) i;\r
  48 \r
  49 #ifdef JOKE\r
  50     xchr[32] = ' ';  xchr[33] = '!';  xchr[34] = '"';  xchr[35] = '#';\r
  51     xchr[36] = '$';  xchr[37] = '%';  xchr[38] = '&';  xchr[39] = '\'';\r
  52     xchr[40] = '(';  xchr[41] = ')';  xchr[42] = '*';  xchr[43] = '+';\r
  53     xchr[44] = ',';  xchr[45] = '-';  xchr[46] = '.';  xchr[47] = '/';\r
  54     xchr[48] = '0';  xchr[49] = '1';  xchr[50] = '2';  xchr[51] = '3';\r
  55     xchr[52] = '4';  xchr[53] = '5';  xchr[54] = '6';  xchr[55] = '7';\r
  56     xchr[56] = '8';  xchr[57] = '9';  xchr[58] = ':';  xchr[59] = ';';\r
  57     xchr[60] = '<';  xchr[61] = '=';  xchr[62] = '>';  xchr[63] = '?';\r
  58     xchr[64] = '@';  xchr[65] = 'A';  xchr[66] = 'B';  xchr[67] = 'C';\r
  59     xchr[68] = 'D';  xchr[69] = 'E';  xchr[70] = 'F';  xchr[71] = 'G';\r
  60     xchr[72] = 'H';  xchr[73] = 'I';  xchr[74] = 'J';  xchr[75] = 'K';\r
  61     xchr[76] = 'L';  xchr[77] = 'M';  xchr[78] = 'N';  xchr[79] = 'O';\r
  62     xchr[80] = 'P';  xchr[81] = 'Q';  xchr[82] = 'R';  xchr[83] = 'S';\r
  63     xchr[84] = 'T';  xchr[85] = 'U';  xchr[86] = 'V';  xchr[87] = 'W';\r
  64     xchr[88] = 'X';  xchr[89] = 'Y';  xchr[90] = 'Z';  xchr[91] = '[';\r
  65     xchr[92] = '\\'; xchr[93] = ']';  xchr[94] = '^';  xchr[95] = '_';\r
  66     xchr[96] = '`';  xchr[97] = 'a';  xchr[98] = 'b';  xchr[99] = 'c';\r
  67     xchr[100] = 'd'; xchr[101] = 'e'; xchr[102] = 'f'; xchr[103] = 'g';\r
  68     xchr[104] = 'h'; xchr[105] = 'i'; xchr[106] = 'j'; xchr[107] = 'k';\r
  69     xchr[108] = 'l'; xchr[109] = 'm'; xchr[110] = 'n'; xchr[111] = 'o';\r
  70     xchr[112] = 'p'; xchr[113] = 'q'; xchr[114] = 'r'; xchr[115] = 's';\r
  71     xchr[116] = 't'; xchr[117] = 'u'; xchr[118] = 'v'; xchr[119] = 'w';\r
  72     xchr[120] = 'x'; xchr[121] = 'y'; xchr[122] = 'z'; xchr[123] = '{';\r
  73     xchr[124] = '|'; xchr[125] = '}'; xchr[126] = '~';\r
  74 \r
  75     for (i = 0; i <= 31; i++)\r
  76       xchr[i] = chr(i);\r
  77 \r
  78     for (i = 127; i <= 255; i++)\r
  79       xchr[i]= chr(i);\r
  80 #endif\r
  81   }\r
  82 \r
  83   for (i = 0; i <= 255; i++)\r
  84     xord[chr(i)] = invalid_code;\r
  85 \r
  86 #ifdef JOKE\r
  87   for (i = 128; i <= 255 ; i++)\r
  88     xord[xchr[i]] = i;\r
  89 \r
  90   for (i = 0; i <= 126; i++)\r
  91     xord[xchr[i]] = i;\r
  92 #endif\r
  93 \r
  94   for (i = 0; i <= 255; i++)\r
  95     xord[xchr[i]] = (char) i;\r
  96 \r
  97   xord[127] = 127;\r
  98 \r
  99   flag = 0;\r
 100 \r
 101   if (trace_flag != 0)\r
 102   {\r
 103     for (k = 0; k < 256; k++)\r
 104       if (xord[k] != k)\r
 105       {\r
 106         flag = 1;\r
 107         break;\r
 108       }\r
 109 \r
 110     if (flag)\r
 111     {\r
 112       puts("Inverted mapping xord[] pairs:");\r
 113 \r
 114       for (k = 0; k < 256; k++)\r
 115       {\r
 116         if (xord[k] != 127)\r
 117           printf("%lld => %d\n", k, xord[k]);\r
 118       }\r
 119     }\r
 120   }\r
 121 \r
 122   if (interaction < batch_mode)\r
 123     interaction = error_stop_mode;\r
 124 \r
 125   deletions_allowed = true;\r
 126   set_box_allowed = true;\r
 127   error_count = 0;\r
 128   help_ptr = 0;\r
 129   use_err_help = false;\r
 130   interrupt = 0;\r
 131   OK_to_interrupt = true;\r
 132 \r
 133 #ifdef DEBUG\r
 134   was_mem_end = mem_min;\r
 135   was_lo_max = mem_bot; // mem_min\r
 136   was_hi_min = mem_top; // mem_max\r
 137   panicking = false;\r
 138 #endif\r
 139 \r
 140   nest_ptr = 0;\r
 141   max_nest_stack = 0;\r
 142   mode = vmode;\r
 143   head = contrib_head;\r
 144   tail = contrib_head;\r
 145   prev_depth = ignore_depth;\r
 146   mode_line = 0;\r
 147   prev_graf = 0;\r
 148   shown_mode = 0;\r
 149   page_contents = 0;\r
 150   page_tail = page_head;\r
 151 \r
 152 #ifdef ALLOCATEMAIN\r
 153   if (is_initex)\r
 154 #endif\r
 155     link(page_head) = 0;\r
 156 \r
 157   last_glue = max_halfword;\r
 158   last_penalty = 0;\r
 159   last_kern = 0;\r
 160   page_depth = 0;\r
 161   page_max_depth = 0;\r
 162 \r
 163   for (k = int_base; k <= eqtb_size; k++)\r
 164     xeq_level[k] = level_one;\r
 165 \r
 166   no_new_control_sequence = true;\r
 167   next(hash_base) = 0;\r
 168   text(hash_base) = 0;\r
 169 \r
 170   for (k = hash_base + 1; k <= undefined_control_sequence - 1; k++)\r
 171     hash[k] = hash[hash_base];\r
 172 \r
 173   save_ptr = 0;\r
 174   cur_level = 1;\r
 175   cur_group = 0;\r
 176   cur_boundary = 0;\r
 177   max_save_stack = 0;\r
 178   mag_set = 0;\r
 179   cur_mark[0] = 0;\r
 180   cur_mark[1] = 0;\r
 181   cur_mark[2] = 0;\r
 182   cur_mark[3] = 0;\r
 183   cur_mark[4] = 0;\r
 184   cur_val = 0;\r
 185   cur_val_level = int_val;\r
 186   radix = 0;\r
 187   cur_order = normal;\r
 188 \r
 189   for (k = 0; k <= 16; k++)\r
 190     read_open[k] = closed;\r
 191 \r
 192   cond_ptr = 0;\r
 193   if_limit = normal;\r
 194   cur_if = 0;\r
 195   if_line = 0;\r
 196 \r
 197   for (k = 0; k <= font_max; k++)\r
 198     font_used[k] = false;\r
 199 \r
 200   null_character.b0 = min_quarterword;\r
 201   null_character.b1 = min_quarterword;\r
 202   null_character.b2 = min_quarterword;\r
 203   null_character.b3 = min_quarterword;\r
 204   total_pages = 0;\r
 205   max_v = 0;\r
 206   max_h = 0;\r
 207   max_push = 0;\r
 208   last_bop = -1;\r
 209   doing_leaders = false;\r
 210   dead_cycles = 0;\r
 211   cur_s = -1;\r
 212   half_buf = dvi_buf_size / 2;\r
 213   dvi_limit = dvi_buf_size;\r
 214   dvi_ptr = 0;\r
 215   dvi_offset = 0;\r
 216   dvi_gone = 0;\r
 217   down_ptr = 0;\r
 218   right_ptr = 0;\r
 219   adjust_tail = 0;\r
 220   last_badness = 0;\r
 221   pack_begin_line = 0;\r
 222   empty_field.rh = 0;\r
 223   empty_field.lh = 0;\r
 224   null_delimiter.b0 = 0;\r
 225   null_delimiter.b1 = 0;\r
 226   null_delimiter.b2 = 0;\r
 227   null_delimiter.b3 = 0;\r
 228   align_ptr = 0;\r
 229   cur_align = 0;\r
 230   cur_span = 0;\r
 231   cur_loop = 0;\r
 232   cur_head = 0;\r
 233   cur_tail = 0;\r
 234 \r
 235 /*  *not* OK with ALLOCATEHYPHEN, since may not be allocated yet */\r
 236 #ifndef ALLOCATEHYPHEN\r
 237   for (z = 0; z <= hyphen_prime; z++)\r
 238   {\r
 239     hyph_word[z] = 0;\r
 240     hyph_list[z] = 0;\r
 241   }\r
 242 #endif\r
 243 \r
 244   hyph_count = 0;\r
 245   output_active = false;\r
 246   insert_penalties = 0;\r
 247   ligature_present = false;\r
 248   cancel_boundary = false;\r
 249   lft_hit = false;\r
 250   rt_hit = false;\r
 251   ins_disc = false;\r
 252   after_token = 0;\r
 253   long_help_seen = false;\r
 254   format_ident = 0;\r
 255 \r
 256   for (k = 0; k <= 17; k++)\r
 257     write_open[k] = false;\r
 258 \r
 259   edit_name_start = 0;\r
 260 \r
 261 #ifdef INITEX\r
 262   if (is_initex)\r
 263     do_initex();\r
 264 #endif\r
 265 }\r
 266 \r
 267 /* do the part of initialize() that requires mem_top, mem_max or mem[] */\r
 268 /* do this part after allocating main memory */\r
 269 \r
 270 #ifdef ALLOCATEMAIN\r
 271 void initialize_aux (void)\r
 272 {\r
 273 #ifdef DEBUG\r
 274   was_mem_end = mem_min;\r
 275   was_lo_max = mem_bot; // mem_min\r
 276   was_hi_min = mem_top; // mem_max\r
 277   panicking = false;\r
 278 #endif\r
 279 \r
 280 /*  nest_ptr = 0; */\r
 281 /*  max_nest_stack = 0; */\r
 282   mode = vmode;\r
 283   head = contrib_head;\r
 284   tail = contrib_head;\r
 285   prev_depth = ignore_depth;\r
 286   mode_line = 0;\r
 287   prev_graf = 0;\r
 288 /*  shown_mode = 0; */\r
 289 /*  page_contents = 0; */\r
 290   page_tail = page_head;\r
 291   link(page_head) = 0;\r
 292 }\r
 293 #endif\r
 294 /* sec 0815 */\r
 295 void line_break (integer final_widow_penalty)\r
 296 {\r
 297   boolean auto_breaking;\r
 298   pointer prev_p;\r
 299   pointer q, r, s, prev_s;\r
 300   internal_font_number f;\r
 301   /* small_number j; */\r
 302   int j;\r
 303   /* unsigned char c; */\r
 304   unsigned int c;\r
 305 \r
 306   pack_begin_line = mode_line;\r
 307   link(temp_head) = link(head);\r
 308 \r
 309   if (is_char_node(tail))\r
 310     tail_append(new_penalty(inf_penalty));\r
 311   else if (type(tail) != glue_node)\r
 312     tail_append(new_penalty(inf_penalty));\r
 313   else\r
 314   {\r
 315     type(tail) = penalty_node;\r
 316     delete_glue_ref(glue_ptr(tail));\r
 317     flush_node_list(leader_ptr(tail));\r
 318     penalty(tail) = inf_penalty;\r
 319   }\r
 320 \r
 321   link(tail) = new_param_glue(par_fill_skip_code);\r
 322   init_cur_lang = prev_graf % 65536L;\r
 323   init_l_hyf = prev_graf / 4194304L; /* 2^22 */\r
 324   init_r_hyf = (prev_graf / 65536L) % 64;\r
 325   pop_nest();\r
 326   no_shrink_error_yet = true;\r
 327   check_shrinkage(left_skip);\r
 328   check_shrinkage(right_skip);\r
 329   q = left_skip;\r
 330   r = right_skip;\r
 331   background[1] = width(q) + width(r);\r
 332   background[2] = 0;\r
 333   background[3] = 0;\r
 334   background[4] = 0;\r
 335   background[5] = 0;\r
 336   background[2 + stretch_order(q)] = stretch(q);\r
 337   background[2 + stretch_order(r)] = background[2 + stretch_order(r)] + stretch(r);\r
 338   background[6] = shrink(q) + shrink(r);\r
 339   minimum_demerits = awful_bad;\r
 340   minimal_demerits[tight_fit] = awful_bad;\r
 341   minimal_demerits[decent_fit] = awful_bad;\r
 342   minimal_demerits[loose_fit] = awful_bad;\r
 343   minimal_demerits[very_loose_fit] = awful_bad;\r
 344 \r
 345   if (par_shape_ptr == 0)\r
 346     if (hang_indent == 0)\r
 347     {\r
 348       last_special_line = 0;\r
 349       second_width = hsize;\r
 350       second_indent = 0;\r
 351     }\r
 352     else\r
 353     {\r
 354       last_special_line = abs(hang_after);\r
 355 \r
 356       if (hang_after < 0)\r
 357       {\r
 358         first_width = hsize - abs(hang_indent);\r
 359 \r
 360         if (hang_indent >= 0)\r
 361           first_indent = hang_indent;\r
 362         else\r
 363           first_indent = 0;\r
 364 \r
 365         second_width = hsize;\r
 366         second_indent = 0;\r
 367       }\r
 368       else\r
 369       {\r
 370         first_width = hsize;\r
 371         first_indent = 0;\r
 372         second_width = hsize - abs(hang_indent);\r
 373 \r
 374         if (hang_indent >= 0)\r
 375           second_indent = hang_indent;\r
 376         else\r
 377           second_indent = 0;\r
 378       }\r
 379     }\r
 380   else\r
 381   {\r
 382     last_special_line = info(par_shape_ptr) - 1;\r
 383     second_width = mem[par_shape_ptr + 2 * (last_special_line + 1)].cint;\r
 384     second_indent = mem[par_shape_ptr + 2 * last_special_line + 1].cint;\r
 385   }\r
 386 \r
 387   if (looseness == 0)\r
 388     easy_line = last_special_line;\r
 389   else\r
 390     easy_line = empty_flag;\r
 391 \r
 392   threshold = pretolerance;\r
 393 \r
 394   if (threshold >= 0)\r
 395   {\r
 396 #ifdef STAT\r
 397     if (tracing_paragraphs > 0)\r
 398     {\r
 399       begin_diagnostic();\r
 400       print_nl("@firstpass");\r
 401     }\r
 402 #endif\r
 403 \r
 404     second_pass = false;\r
 405     final_pass = false;\r
 406     first_pass_count++;\r
 407   }\r
 408   else\r
 409   {\r
 410     threshold = tolerance;\r
 411     second_pass = true;\r
 412     final_pass = (emergency_stretch <= 0);\r
 413 \r
 414 #ifdef STAT\r
 415     if (tracing_paragraphs > 0)\r
 416       begin_diagnostic();\r
 417 #endif\r
 418   }\r
 419 \r
 420   while (true)\r
 421   {\r
 422     if (threshold > inf_bad)\r
 423       threshold = inf_bad;\r
 424 \r
 425     if (second_pass)\r
 426     {\r
 427 #ifdef INITEX\r
 428       if (is_initex)\r
 429       {\r
 430         if (trie_not_ready)\r
 431           init_trie();\r
 432       }\r
 433 #endif\r
 434 \r
 435       cur_lang = init_cur_lang;\r
 436       l_hyf = init_l_hyf;\r
 437       r_hyf = init_r_hyf;\r
 438     }\r
 439 \r
 440     q = get_node(active_node_size);\r
 441     type(q) = unhyphenated;\r
 442     fitness(q) = decent_fit;\r
 443     link(q) = active;\r
 444     break_node(q) = 0;\r
 445     line_number(q) = prev_graf + 1;\r
 446     total_demerits(q) = 0;\r
 447     link(active) = q;\r
 448     act_width = background[1];\r
 449     do_all_six(store_background);\r
 450     passive = 0;\r
 451     printed_node = temp_head;\r
 452     pass_number = 0;\r
 453     font_in_short_display = null_font;\r
 454     cur_p = link(temp_head);\r
 455     auto_breaking = true;\r
 456     prev_p = cur_p;\r
 457 \r
 458     while ((cur_p != 0) && (link(active) != active))\r
 459     {\r
 460       if (is_char_node(cur_p))\r
 461       {\r
 462         prev_p = cur_p;\r
 463 \r
 464         do\r
 465           {\r
 466             f = font(cur_p);\r
 467             act_width = act_width + char_width(f, char_info(f, character(cur_p)));\r
 468             cur_p = link(cur_p);\r
 469           }\r
 470         while (!(!is_char_node(cur_p)));\r
 471       }\r
 472 \r
 473       switch (type(cur_p))\r
 474       {\r
 475         case hlist_node:\r
 476         case vlist_node:\r
 477         case rule_node:\r
 478           act_width = act_width + width(cur_p);\r
 479           break;\r
 480 \r
 481         case whatsit_node:\r
 482           if (subtype(cur_p) == language_node)\r
 483           {\r
 484             cur_lang = what_lang(cur_p);\r
 485             l_hyf = what_lhm(cur_p);\r
 486             r_hyf = what_rhm(cur_p);\r
 487           }\r
 488           break;\r
 489 \r
 490         case glue_node:\r
 491           {\r
 492             if (auto_breaking)\r
 493             {\r
 494               if (is_char_node(prev_p))\r
 495                 try_break(0, unhyphenated);\r
 496               else if (precedes_break(prev_p))\r
 497                 try_break(0, unhyphenated);\r
 498               else if ((type(prev_p) == kern_node) && (subtype(prev_p) != explicit))\r
 499                 try_break(0, unhyphenated);\r
 500             }\r
 501 \r
 502             check_shrinkage(glue_ptr(cur_p));\r
 503             q = glue_ptr(cur_p);\r
 504             act_width = act_width+ width(q);\r
 505             active_width[2 + stretch_order(q)] = active_width[2 + stretch_order(q)] + stretch(q);\r
 506             active_width[6] = active_width[6] + shrink(q);\r
 507 \r
 508             if (second_pass && auto_breaking)\r
 509             {\r
 510               prev_s = cur_p;\r
 511               s = link(prev_s);\r
 512 \r
 513               if (s != 0)\r
 514               {\r
 515                 while (true)\r
 516                 {\r
 517                   if (is_char_node(s))\r
 518                   {\r
 519                     c = character(s);\r
 520                     hf = font(s);\r
 521                   }\r
 522                   else if (type(s) == ligature_node)\r
 523                     if (lig_ptr(s) == 0)\r
 524                       goto continu;\r
 525                     else\r
 526                     {\r
 527                       q = lig_ptr(s);\r
 528                       c = character(q);\r
 529                       hf = font(q);\r
 530                     }\r
 531                   else if ((type(s) == kern_node) && (subtype(s) == normal))\r
 532                     goto continu;\r
 533                   else if (type(s) == whatsit_node)\r
 534                   {\r
 535                     if (subtype(s) == language_node)\r
 536                     {\r
 537                       cur_lang = what_lang(s);\r
 538                       l_hyf = what_lhm(s);\r
 539                       r_hyf = what_rhm(s);\r
 540                     }\r
 541                     goto continu;\r
 542                   }\r
 543                   else\r
 544                     goto done1;\r
 545 \r
 546                   if (lc_code(c) != 0)\r
 547                     if ((lc_code(c) == (halfword) c) || (uc_hyph > 0))\r
 548                       goto done2;\r
 549                     else\r
 550                       goto done1;\r
 551 continu:\r
 552                   prev_s = s;\r
 553                   s = link(prev_s);\r
 554                 }\r
 555 done2:\r
 556                 hyf_char = hyphen_char[hf];\r
 557 \r
 558                 if (hyf_char < 0)\r
 559                   goto done1; \r
 560 \r
 561                 if (hyf_char > 255)\r
 562                   goto done1;\r
 563 \r
 564                 ha = prev_s;\r
 565 \r
 566                 if (l_hyf + r_hyf > 63)\r
 567                   goto done1;\r
 568 \r
 569                 hn = 0;\r
 570 \r
 571                 while (true)\r
 572                 {\r
 573                   if (is_char_node(s))\r
 574                   {\r
 575                     if (font(s) != hf)\r
 576                       goto done3;\r
 577 \r
 578                     hyf_bchar = character(s);\r
 579 \r
 580                     c = hyf_bchar;\r
 581 \r
 582                     if (lc_code(c) == 0)\r
 583                       goto done3;\r
 584 \r
 585                     if (hn == 63)\r
 586                       goto done3;\r
 587 \r
 588                     hb = s;\r
 589                     incr(hn);\r
 590                     hu[hn] = c;\r
 591                     hc[hn]= lc_code(c);\r
 592                     hyf_bchar = non_char;\r
 593                   }\r
 594                   else if (type(s) == ligature_node)\r
 595                   {\r
 596                     if (font(lig_char(s)) != hf)\r
 597                       goto done3;\r
 598 \r
 599                     j = hn;\r
 600                     q = lig_ptr(s);\r
 601 \r
 602                     if (q != 0)\r
 603                       hyf_bchar = character(q);\r
 604 \r
 605                     while (q != 0)\r
 606                     {\r
 607                       c = character(q);\r
 608 \r
 609                       if (lc_code(c) == 0)\r
 610                         goto done3;\r
 611 \r
 612                       if (j == 63)\r
 613                         goto done3;\r
 614 \r
 615                       incr(j);\r
 616                       hu[j] = c;\r
 617                       hc[j] = lc_code(c);\r
 618                       q = link(q);\r
 619                     }\r
 620 \r
 621                     hb = s;\r
 622                     hn = j;\r
 623 \r
 624                     if (odd(subtype(s)))\r
 625                       hyf_bchar = font_bchar[hf];\r
 626                     else\r
 627                       hyf_bchar = non_char;\r
 628                   }\r
 629                   else if ((type(s) == kern_node) && (subtype(s) == normal))\r
 630                   {\r
 631                     hb = s;\r
 632                     hyf_bchar = font_bchar[hf];\r
 633                   }\r
 634                   else\r
 635                     goto done3;\r
 636 \r
 637                   s = link(s);\r
 638                 }\r
 639 done3:\r
 640                 if (hn < l_hyf + r_hyf)\r
 641                   goto done1;\r
 642 \r
 643                 while (true)\r
 644                 {\r
 645                   if (!(is_char_node(s)))\r
 646                     switch (type(s))\r
 647                     {\r
 648                       case ligature_node:\r
 649                         break;\r
 650     \r
 651                       case kern_node:\r
 652                         if (subtype(s) != normal)\r
 653                           goto done4;\r
 654                         break;\r
 655 \r
 656                       case whatsit_node:\r
 657                       case glue_node:\r
 658                       case penalty_node:\r
 659                       case ins_node:\r
 660                       case adjust_node:\r
 661                       case mark_node:\r
 662                         goto done4;\r
 663                         break;\r
 664 \r
 665                       default:\r
 666                         goto done1;\r
 667                         break;\r
 668                     }\r
 669                   s = link(s);\r
 670                 }\r
 671 done4:\r
 672                 hyphenate();\r
 673               }\r
 674 done1:;\r
 675             }\r
 676           }\r
 677           break;\r
 678 \r
 679         case kern_node:\r
 680           if (subtype(cur_p) == explicit)\r
 681             kern_break();\r
 682           else\r
 683             act_width = act_width + width(cur_p);\r
 684           break;\r
 685 \r
 686         case ligature_node:\r
 687           {\r
 688             f = font(lig_char(cur_p));\r
 689             act_width = act_width + char_width(f, char_info(f, character(lig_char(cur_p))));\r
 690           }\r
 691           break;\r
 692 \r
 693         case disc_node:\r
 694           {\r
 695             s = pre_break(cur_p);\r
 696             disc_width = 0;\r
 697 \r
 698             if (s == 0)\r
 699               try_break(ex_hyphen_penalty, hyphenated);\r
 700             else\r
 701             {\r
 702               do\r
 703                 {\r
 704                   if (is_char_node(s))\r
 705                   {\r
 706                     f = font(s);\r
 707                     disc_width = disc_width + char_width(f, char_info(f, character(s)));\r
 708                   }\r
 709                   else switch (type(s))\r
 710                   {\r
 711                     case ligature_node:\r
 712                       {\r
 713                         f = font(lig_char(s));\r
 714                         disc_width = disc_width + char_width(f, char_info(f, character(lig_char(s))));\r
 715                       }\r
 716                       break;\r
 717 \r
 718                     case hlist_node:\r
 719                     case vlist_node:\r
 720                     case rule_node:\r
 721                     case kern_node:\r
 722                       disc_width = disc_width + width(s);\r
 723                       break;\r
 724 \r
 725                     default:\r
 726                       {\r
 727                         confusion("disc3");\r
 728                         return;\r
 729                       }\r
 730                       break;\r
 731                   }\r
 732 \r
 733                   s = link(s);\r
 734                 }\r
 735               while (!(s == 0));\r
 736 \r
 737               act_width = act_width + disc_width;\r
 738               try_break(hyphen_penalty, hyphenated);\r
 739               act_width = act_width - disc_width;\r
 740             }\r
 741 \r
 742             r = replace_count(cur_p);\r
 743             s = link(cur_p);\r
 744 \r
 745             while (r > 0)\r
 746             {\r
 747               if (is_char_node(s))\r
 748               {\r
 749                 f = font(s);\r
 750                 act_width = act_width + char_width(f, char_info(f, character(s)));\r
 751               }\r
 752               else switch (type(s))\r
 753               {\r
 754                 case ligature_node:\r
 755                   {\r
 756                     f = font(lig_char(s));\r
 757                     act_width = act_width + char_width(f, char_info(f, character(lig_char(s))));\r
 758                   }\r
 759                   break;\r
 760 \r
 761                 case hlist_node:\r
 762                 case vlist_node:\r
 763                 case rule_node:\r
 764                 case kern_node:\r
 765                   act_width = act_width + width(s);\r
 766                   break;\r
 767 \r
 768                 default:\r
 769                   {\r
 770                     confusion("disc4");\r
 771                     return;\r
 772                   }\r
 773                   break;\r
 774               }\r
 775 \r
 776               decr(r);\r
 777               s = link(s);\r
 778             }\r
 779 \r
 780             prev_p = cur_p;\r
 781             cur_p = s;\r
 782             goto done5;\r
 783           }\r
 784           break;\r
 785 \r
 786         case math_node:\r
 787           {\r
 788             auto_breaking = (subtype(cur_p) == after);\r
 789             kern_break();\r
 790           }\r
 791           break;\r
 792 \r
 793         case penalty_node:\r
 794           try_break(penalty(cur_p), unhyphenated);\r
 795           break;\r
 796 \r
 797         case mark_node:\r
 798         case ins_node:\r
 799         case adjust_node:\r
 800           break;\r
 801 \r
 802         default:\r
 803           {\r
 804             confusion("paragraph");\r
 805             return;\r
 806           }\r
 807           break;\r
 808       }\r
 809 \r
 810       prev_p = cur_p;\r
 811       cur_p = link(cur_p);\r
 812 done5:;\r
 813     }\r
 814 \r
 815     if (cur_p == 0)\r
 816     {\r
 817       try_break(eject_penalty, hyphenated);\r
 818 \r
 819       if (link(active) != active)\r
 820       {\r
 821         r = link(active);\r
 822         fewest_demerits = awful_bad;\r
 823 \r
 824         do\r
 825           {\r
 826             if (type(r) != delta_node)\r
 827               if (total_demerits(r) < fewest_demerits)\r
 828               {\r
 829                 fewest_demerits = total_demerits(r);\r
 830                 best_bet = r;\r
 831               }\r
 832 \r
 833             r = link(r);\r
 834           }\r
 835         while (!(r == active));\r
 836 \r
 837         best_line = line_number(best_bet);\r
 838 \r
 839         if (looseness == 0)\r
 840         {\r
 841           goto done;\r
 842         }\r
 843 \r
 844         {\r
 845           r = link(active);\r
 846           actual_looseness = 0;\r
 847 \r
 848           do\r
 849             {\r
 850               if (type(r) != delta_node)\r
 851               {\r
 852                 line_diff = toint(line_number(r)) - toint(best_line);\r
 853 \r
 854                 if (((line_diff < actual_looseness) && (looseness <= line_diff)) ||\r
 855                     ((line_diff > actual_looseness) && (looseness >= line_diff)))\r
 856                 {\r
 857                   best_bet = r;\r
 858                   actual_looseness = line_diff;\r
 859                   fewest_demerits = total_demerits(r);\r
 860                 }\r
 861                 else if ((line_diff == actual_looseness) && (total_demerits(r) < fewest_demerits))\r
 862                 {\r
 863                   best_bet = r;\r
 864                   fewest_demerits = total_demerits(r);\r
 865                 }\r
 866               }\r
 867 \r
 868               r = link(r);\r
 869             }\r
 870           while (!(r == active));\r
 871 \r
 872           best_line = line_number(best_bet);\r
 873         }\r
 874 \r
 875         if ((actual_looseness == looseness) || final_pass)\r
 876         {\r
 877           goto done;\r
 878         }\r
 879       }\r
 880     }\r
 881 \r
 882     q = link(active);\r
 883 \r
 884     while (q != active)\r
 885     {\r
 886       cur_p = link(q);\r
 887 \r
 888       if (type(q) == delta_node)\r
 889         free_node(q, delta_node_size);\r
 890       else\r
 891         free_node(q, active_node_size);\r
 892 \r
 893       q = cur_p;\r
 894     }\r
 895 \r
 896     q = passive;\r
 897 \r
 898     while (q != 0)\r
 899     {\r
 900       cur_p = link(q);\r
 901       free_node(q, passive_node_size);\r
 902       q = cur_p;\r
 903     }\r
 904 \r
 905     if (!second_pass)\r
 906     {\r
 907 #ifdef STAT\r
 908       if (tracing_paragraphs > 0)\r
 909         print_nl("@secondpass");\r
 910 #endif\r
 911       threshold = tolerance;\r
 912       second_pass = true;\r
 913       second_pass_count++;\r
 914       final_pass = (emergency_stretch <= 0);\r
 915     }\r
 916     else\r
 917     {\r
 918 #ifdef STAT\r
 919       if (tracing_paragraphs > 0)\r
 920         print_nl("@emergencypass");\r
 921 #endif\r
 922 \r
 923       background[2] = background[2] + emergency_stretch;\r
 924       final_pass = true;\r
 925       ++final_pass_count;\r
 926     }\r
 927   }\r
 928 \r
 929 done:\r
 930   if (best_line == decent_fit)\r
 931     single_line++;\r
 932 \r
 933 #ifdef STAT\r
 934   if (tracing_paragraphs > 0)\r
 935   {\r
 936     end_diagnostic(true);\r
 937     normalize_selector();\r
 938   }\r
 939 #endif\r
 940 \r
 941   post_line_break(final_widow_penalty);\r
 942   q = link(active);\r
 943 \r
 944   while (q != active)\r
 945   {\r
 946     cur_p = link(q);\r
 947 \r
 948     if (type(q) == delta_node)\r
 949       free_node(q, delta_node_size);\r
 950     else\r
 951       free_node(q, active_node_size);\r
 952 \r
 953     q = cur_p;\r
 954   }\r
 955 \r
 956   q = passive;\r
 957 \r
 958   while (q != 0)\r
 959   {\r
 960     cur_p = link(q);\r
 961     free_node(q, passive_node_size);\r
 962     q = cur_p;\r
 963   }\r
 964 \r
 965   pack_begin_line = 0;\r
 966 }\r
 967 /* sec 1211 */\r
 968 void prefixed_command (void)\r
 969 {\r
 970   small_number a;\r
 971   internal_font_number f;\r
 972   halfword j;\r
 973   font_index k;\r
 974   pointer p, q;\r
 975   integer n;\r
 976   boolean e;\r
 977 \r
 978   a = 0;\r
 979 \r
 980   while (cur_cmd == prefix)\r
 981   {\r
 982     if (!odd(a / cur_chr))\r
 983       a = a + cur_chr;\r
 984 \r
 985     do\r
 986       {\r
 987         get_x_token();\r
 988       }\r
 989     while (!((cur_cmd != spacer) && (cur_cmd != relax)));\r
 990 \r
 991     if (cur_cmd <= max_non_prefixed_command)\r
 992     {\r
 993       print_err("You can't use a prefix with `");\r
 994       print_cmd_chr(cur_cmd, cur_chr);\r
 995       print_char('\'');\r
 996       help1("I'll pretend you didn't say \\long or \\outer or \\global.");\r
 997       back_error();\r
 998       return;\r
 999     }\r
1000   }\r
1001 \r
1002   if ((cur_cmd != def) && (a % 4 != 0))\r
1003   {\r
1004     print_err("You can't use `");\r
1005     print_esc("long");\r
1006     prints("' or `");\r
1007     print_esc("outer");\r
1008     prints("' with `");\r
1009     print_cmd_chr(cur_cmd, cur_chr);\r
1010     print_char('\'');\r
1011     help1("I'll pretend you didn't say \\long or \\outer here.");\r
1012     error();\r
1013   }\r
1014 \r
1015   if (global_defs != 0)\r
1016     if (global_defs < 0)\r
1017     {\r
1018       if ((a >= 4))\r
1019         a = a - 4;\r
1020     }\r
1021     else\r
1022     {\r
1023       if (!(a >= 4))\r
1024         a = a + 4;\r
1025     }\r
1026 \r
1027   switch (cur_cmd)\r
1028   {\r
1029     case set_font:\r
1030       define(cur_font_loc, data, cur_chr);\r
1031       break;\r
1032 \r
1033     case def:\r
1034       {\r
1035         if (odd(cur_chr) && !(a >= 4) && (global_defs >= 0))\r
1036           a = a + 4;\r
1037 \r
1038         e = (cur_chr >= 2);\r
1039         get_r_token();\r
1040         p = cur_cs;\r
1041         q = scan_toks(true, e);\r
1042         define(p, call + (a % 4), def_ref);\r
1043       }\r
1044       break;\r
1045 \r
1046     case let:\r
1047       {\r
1048         n = cur_chr;\r
1049         get_r_token();\r
1050         p = cur_cs;\r
1051 \r
1052         if (n == 0)\r
1053         {\r
1054           do\r
1055             {\r
1056               get_token();\r
1057             }\r
1058           while (!(cur_cmd != spacer));\r
1059 \r
1060           if (cur_tok == other_token + '=')\r
1061           {\r
1062             get_token();\r
1063 \r
1064             if (cur_cmd == spacer)\r
1065               get_token();\r
1066           }\r
1067         }\r
1068         else\r
1069         {\r
1070           get_token();\r
1071           q = cur_tok;\r
1072           get_token();\r
1073           back_input();\r
1074           cur_tok = q;\r
1075           back_input();\r
1076         }\r
1077 \r
1078         if (cur_cmd >= call)\r
1079           add_token_ref(cur_chr);\r
1080 \r
1081         define(p, cur_cmd, cur_chr);\r
1082       }\r
1083       break;\r
1084 \r
1085     case shorthand_def:\r
1086       {\r
1087         n = cur_chr;\r
1088         get_r_token();\r
1089         p = cur_cs;\r
1090         define(p, relax, 256);\r
1091         scan_optional_equals();\r
1092 \r
1093         switch (n)\r
1094         {\r
1095           case char_def_code:\r
1096             {\r
1097               scan_char_num();\r
1098               define(p, char_given, cur_val);\r
1099             }\r
1100             break;\r
1101 \r
1102           case math_char_def_code:\r
1103             {\r
1104               scan_fifteen_bit_int();\r
1105               define(p, math_given, cur_val);\r
1106             }\r
1107             break;\r
1108 \r
1109           default:\r
1110             {\r
1111               scan_eight_bit_int();\r
1112 \r
1113               switch (n)\r
1114               {\r
1115                 case count_def_code:\r
1116                   define(p, assign_int, count_base + cur_val);\r
1117                   break;\r
1118 \r
1119                 case dimen_def_code:\r
1120                   define(p, assign_dimen, scaled_base + cur_val);\r
1121                   break;\r
1122 \r
1123                 case skip_def_code:\r
1124                   define(p, assign_glue, skip_base + cur_val);\r
1125                   break;\r
1126 \r
1127                 case mu_skip_def_code:\r
1128                   define(p, assign_mu_glue, mu_skip_base + cur_val);\r
1129                   break;\r
1130 \r
1131                 case toks_def_code:\r
1132                   define(p, assign_toks, toks_base + cur_val);\r
1133                   break;\r
1134               }\r
1135             }\r
1136             break;\r
1137         }\r
1138       }\r
1139       break;\r
1140 \r
1141     case read_to_cs:\r
1142       {\r
1143         scan_int();\r
1144         n = cur_val;\r
1145 \r
1146         if (!scan_keyword("to"))\r
1147         {\r
1148           print_err("Missing `to' inserted");\r
1149           help2("You should have said `\\read<number> to \\cs'.",\r
1150               "I'm going to look for the \\cs now.");\r
1151           error();\r
1152         }\r
1153 \r
1154         get_r_token();\r
1155         p = cur_cs;\r
1156         read_toks(n, p);\r
1157         define(p, call, cur_val);\r
1158       }\r
1159       break;\r
1160 \r
1161     case toks_register:\r
1162     case assign_toks:\r
1163       {\r
1164         q = cur_cs;\r
1165 \r
1166         if (cur_cmd == toks_register)\r
1167         {\r
1168           scan_eight_bit_int();\r
1169           p = toks_base + cur_val;\r
1170         }\r
1171         else\r
1172           p = cur_chr;\r
1173 \r
1174         scan_optional_equals();\r
1175 \r
1176         do\r
1177           {\r
1178             get_x_token();\r
1179           }\r
1180         while (!((cur_cmd != spacer) && (cur_cmd != relax)));\r
1181 \r
1182         if (cur_cmd != left_brace)\r
1183         {\r
1184           if (cur_cmd == toks_register)\r
1185           {\r
1186             scan_eight_bit_int();\r
1187             cur_cmd = assign_toks;\r
1188             cur_chr = toks_base + cur_val;\r
1189           }\r
1190 \r
1191           if (cur_cmd == assign_toks)\r
1192           {\r
1193             q = equiv(cur_chr);\r
1194 \r
1195             if (q == 0)\r
1196               define(p, undefined_cs, 0);\r
1197             else\r
1198             {\r
1199               add_token_ref(q);\r
1200               define(p, call, q);\r
1201             }\r
1202             goto done;\r
1203           }\r
1204         }\r
1205 \r
1206         back_input();\r
1207         cur_cs = q;\r
1208         q = scan_toks(false, false);\r
1209 \r
1210         if (link(def_ref) == 0)\r
1211         {\r
1212           define(p, undefined_cs, 0);\r
1213           free_avail(def_ref);\r
1214         }\r
1215         else\r
1216         {\r
1217           if (p == output_routine_loc)\r
1218           {\r
1219             link(q) = get_avail();\r
1220             q = link(q);\r
1221             info(q) = right_brace_token + '}';\r
1222             q = get_avail();\r
1223             info(q) = left_brace_token + '{';\r
1224             link(q) = link(def_ref);\r
1225             link(def_ref) = q;\r
1226           }\r
1227 \r
1228           define(p, call, def_ref);\r
1229         }\r
1230       }\r
1231       break;\r
1232 \r
1233     case assign_int:\r
1234       {\r
1235         p = cur_chr;\r
1236         scan_optional_equals();\r
1237         scan_int();\r
1238         word_define(p, cur_val);\r
1239       }\r
1240       break;\r
1241 \r
1242     case assign_dimen:\r
1243       {\r
1244         p = cur_chr;\r
1245         scan_optional_equals();\r
1246         scan_dimen(false, false, false);\r
1247         word_define(p, cur_val);\r
1248       }\r
1249       break;\r
1250 \r
1251     case assign_glue:\r
1252     case assign_mu_glue:\r
1253       {\r
1254         p = cur_chr;\r
1255         n = cur_cmd;\r
1256         scan_optional_equals();\r
1257 \r
1258         if (n == assign_mu_glue)\r
1259           scan_glue(mu_val);\r
1260         else\r
1261           scan_glue(glue_val);\r
1262 \r
1263         trap_zero_glue();\r
1264         define(p, glue_ref, cur_val);\r
1265       }\r
1266       break;\r
1267 \r
1268     case def_code:\r
1269       {\r
1270         if (cur_chr == cat_code_base)\r
1271           n = max_char_code;\r
1272         else if (cur_chr == math_code_base)\r
1273           n = 32768L; /* 2^15 */\r
1274         else if (cur_chr == sf_code_base)\r
1275           n = 32767; /* 2^15 - 1*/\r
1276         else if (cur_chr == del_code_base)\r
1277           n = 16777215L; /* 2^24 - 1 */\r
1278         else\r
1279           n = 255;\r
1280 \r
1281         p = cur_chr;\r
1282         scan_char_num();\r
1283         p = p + cur_val;\r
1284         scan_optional_equals();\r
1285         scan_int();\r
1286 \r
1287         if (((cur_val < 0) && (p < del_code_base)) || (cur_val > n))\r
1288         {\r
1289           print_err("Invalid code(");\r
1290           print_int(cur_val);\r
1291 \r
1292           if (p < del_code_base)\r
1293             prints("), should be in the range 0..");\r
1294           else\r
1295             prints("), should be at most ");\r
1296 \r
1297           print_int(n);\r
1298           help1("I'm going to use 0 instead of that illegal code value.");\r
1299           error();\r
1300           cur_val = 0;\r
1301         }\r
1302 \r
1303         if (p < math_code_base)\r
1304           define(p, data, cur_val);\r
1305         else if (p < del_code_base)\r
1306           define(p, data, cur_val);\r
1307         else \r
1308           word_define(p, cur_val);\r
1309       }\r
1310       break;\r
1311 \r
1312     case def_family:\r
1313       {\r
1314         p = cur_chr;\r
1315         scan_four_bit_int();\r
1316         p = p + cur_val;\r
1317         scan_optional_equals();\r
1318         scan_font_ident();\r
1319         define(p, data, cur_val);\r
1320       }\r
1321       break;\r
1322 \r
1323     case tex_register:\r
1324     case advance:\r
1325     case multiply:\r
1326     case divide:\r
1327       do_register_command(a);\r
1328       break;\r
1329 \r
1330     case set_box:\r
1331       {\r
1332         scan_eight_bit_int();\r
1333 \r
1334         if ((a >= 4))\r
1335           n = 256 + cur_val;\r
1336         else\r
1337           n = cur_val;\r
1338 \r
1339         scan_optional_equals();\r
1340 \r
1341         if (set_box_allowed)\r
1342           scan_box(box_flag + n);\r
1343         else\r
1344         {\r
1345           print_err("Improper ");\r
1346           print_esc("setbox");\r
1347           help2("Sorry, \\setbox is not allowed after \\halign in a display,",\r
1348               "or between \\accent and an accented character.");\r
1349           error();\r
1350         }\r
1351       }\r
1352       break;\r
1353 \r
1354     case set_aux:\r
1355       alter_aux();\r
1356       break;\r
1357 \r
1358     case set_prev_graf:\r
1359       alter_prev_graf();\r
1360       break;\r
1361 \r
1362     case set_page_dimen:\r
1363       alter_page_so_far();\r
1364       break;\r
1365 \r
1366     case set_page_int:\r
1367       alter_integer();\r
1368       break;\r
1369 \r
1370     case set_box_dimen:\r
1371       alter_box_dimen();\r
1372       break;\r
1373 \r
1374     case set_shape:\r
1375       {\r
1376         scan_optional_equals();\r
1377         scan_int();\r
1378         n = cur_val;\r
1379 \r
1380         if (n <= 0)\r
1381           p = 0;\r
1382         else\r
1383         {\r
1384           p = get_node(2 * n + 1);\r
1385           info(p) = n;\r
1386 \r
1387           for (j = 1; j <= n; j++)\r
1388           {\r
1389             scan_dimen(false, false, false);\r
1390             mem[p + 2 * j - 1].cint = cur_val;\r
1391             scan_dimen(false, false, false);\r
1392             mem[p + 2 * j].cint = cur_val;\r
1393           }\r
1394         }\r
1395 \r
1396         define(par_shape_loc, shape_ref, p);\r
1397       }\r
1398       break;\r
1399 \r
1400     case hyph_data:\r
1401       if (cur_chr == 1)\r
1402       {\r
1403 #ifdef INITEX\r
1404         if (is_initex)\r
1405         {\r
1406           new_patterns();\r
1407           goto done;\r
1408         }\r
1409 #endif\r
1410         print_err("Patterns can be loaded only by INITEX");\r
1411         help_ptr = 0;\r
1412         error();\r
1413 \r
1414         do\r
1415           {\r
1416             get_token();\r
1417           }\r
1418         while (!(cur_cmd == right_brace));\r
1419 \r
1420         return;\r
1421       }\r
1422       else\r
1423       {\r
1424         new_hyph_exceptions();\r
1425         goto done;\r
1426       }\r
1427       break;\r
1428 \r
1429     case assign_font_dimen:\r
1430       {\r
1431         find_font_dimen(true);\r
1432         k = cur_val;\r
1433         scan_optional_equals();\r
1434         scan_dimen(false, false, false);\r
1435         font_info[k].cint = cur_val;\r
1436       }\r
1437       break;\r
1438 \r
1439     case assign_font_int:\r
1440       {\r
1441         n = cur_chr;\r
1442         scan_font_ident();\r
1443         f = cur_val;\r
1444         scan_optional_equals();\r
1445         scan_int();\r
1446 \r
1447         if (n == 0)\r
1448           hyphen_char[f] = cur_val;\r
1449         else\r
1450           skew_char[f] = cur_val;\r
1451       }\r
1452       break;\r
1453 \r
1454     case def_font:\r
1455       new_font(a);\r
1456       break;\r
1457 \r
1458     case set_interaction:\r
1459       new_interaction();\r
1460       break;\r
1461 \r
1462     default:\r
1463       {\r
1464         confusion("prefix");\r
1465         return;\r
1466       }\r
1467       break;\r
1468   }\r
1469 \r
1470 done:\r
1471   if (after_token != 0)\r
1472   {\r
1473     cur_tok = after_token;\r
1474     back_input();\r
1475     after_token = 0;\r
1476   }\r
1477 }\r
1478 /* sec 1303 */\r
1479 boolean load_fmt_file (void)\r
1480 {\r
1481   integer j, k;\r
1482   pointer p, q;\r
1483   integer x;\r
1484 \r
1485   undump_int(x);\r
1486 \r
1487   if (x != BEGINFMTCHECKSUM)\r
1488     goto bad_fmt;\r
1489 \r
1490   undump_int(x); /* mem_bot */\r
1491 \r
1492   if (x != mem_bot)\r
1493     goto bad_fmt;\r
1494 \r
1495   undump_int(x); /* mem_top */\r
1496 \r
1497 #ifdef ALLOCATEMAIN\r
1498 /* we already read this once earlier to grab mem_top */\r
1499   if (trace_flag)\r
1500     printf("Read from fmt file mem_top = %lld TeX words\n", x);\r
1501 \r
1502   mem = allocate_main_memory(x);\r
1503 \r
1504   if (mem == NULL)\r
1505     exit(EXIT_FAILURE);\r
1506 \r
1507   initialize_aux(); /* do `mem' part of initialize */\r
1508 #endif\r
1509 \r
1510   if (x != mem_top)\r
1511     goto bad_fmt;\r
1512 \r
1513   undump_int(x); /* eqtb_size */\r
1514 \r
1515   if (x != eqtb_size)\r
1516     goto bad_fmt;\r
1517 \r
1518   undump_int(x); /* hash_prime */\r
1519 \r
1520   if (x != hash_prime)\r
1521     goto bad_fmt;\r
1522 \r
1523   undump_int(x); /* hyphen_prime */\r
1524 \r
1525 #ifdef ALLOCATEHYPHEN\r
1526 /* allow format files dumped with arbitrary (prime) hyphenation exceptions */\r
1527   realloc_hyphen(x);\r
1528   hyphen_prime = x;\r
1529 #endif\r
1530 \r
1531   if (x != hyphen_prime)\r
1532     goto bad_fmt;\r
1533 \r
1534   {\r
1535     undump_int(x); /* pool_size */\r
1536 \r
1537     if (x < 0)\r
1538       goto bad_fmt; \r
1539 \r
1540 #ifdef ALLOCATESTRING\r
1541     if (x > current_pool_size)\r
1542     {\r
1543       if (trace_flag)\r
1544         printf("undump string pool reallocation (%lld > %d)\n", x, current_pool_size);\r
1545 \r
1546       str_pool = realloc_str_pool(x - current_pool_size + increment_pool_size);\r
1547     }\r
1548 \r
1549     if (x > current_pool_size)\r
1550 #else\r
1551     if (x > pool_size)\r
1552 #endif\r
1553     {\r
1554       printf("%s%s\n", "---! Must increase the ", "string pool size");\r
1555       goto bad_fmt;\r
1556     }\r
1557     else\r
1558       pool_ptr = x;\r
1559   }\r
1560 \r
1561   {\r
1562     undump_int(x);  /* max_strings */\r
1563 \r
1564     if (x < 0)\r
1565       goto bad_fmt;\r
1566 \r
1567 #ifdef ALLOCATESTRING\r
1568     if (x > current_max_strings)\r
1569     {\r
1570       if (trace_flag)\r
1571         printf("undump string pointer reallocation (%lld > %d)\n", x, current_max_strings);\r
1572 \r
1573       str_start = realloc_str_start(x - current_max_strings + increment_max_strings);\r
1574     }\r
1575 \r
1576     if (x > current_max_strings)\r
1577 #else\r
1578     if (x > max_strings)\r
1579 #endif\r
1580     {\r
1581       printf("%s%s\n", "---! Must increase the ", "max strings");\r
1582       goto bad_fmt;\r
1583     }\r
1584     else\r
1585       str_ptr = x;\r
1586   }\r
1587 \r
1588   undumpthings(str_start[0], str_ptr + 1);\r
1589   undumpthings(str_pool[0], pool_ptr);\r
1590   init_str_ptr = str_ptr;\r
1591   init_pool_ptr = pool_ptr;\r
1592   undump(lo_mem_stat_max + 1000, hi_mem_stat_min - 1, lo_mem_max);\r
1593   undump(lo_mem_stat_max + 1, lo_mem_max, rover);\r
1594   p = mem_bot;\r
1595   q = rover;\r
1596 \r
1597   do\r
1598     {\r
1599       if (undumpthings(mem[p], q + 2 - p))\r
1600         return -1;\r
1601 \r
1602       p = q + node_size(q);\r
1603 \r
1604       if ((p > lo_mem_max) || ((q >= rlink(q)) && (rlink(q) != rover)))\r
1605         goto bad_fmt;\r
1606 \r
1607       q = rlink(q);\r
1608     }\r
1609   while (!(q == rover));\r
1610 \r
1611   if (undumpthings(mem[p], lo_mem_max + 1 - p))\r
1612     return -1;\r
1613 \r
1614   if (mem_min < mem_bot - 2)\r
1615   {\r
1616 /*  or call add_variable_space(mem_bot - (mem_min + 1)) */\r
1617     if (trace_flag)\r
1618       puts("Splicing in mem_min space in undump!");\r
1619 \r
1620     p = llink(rover);\r
1621     q = mem_min + 1;\r
1622     link(mem_min) = 0;       /* null */\r
1623     info(mem_min) = 0;       /* null */\r
1624     rlink(p) = q;\r
1625     llink(rover) = q;\r
1626     rlink(q) = rover;\r
1627     llink(q) = p;\r
1628     link(q) = empty_flag;\r
1629     node_size(q) = mem_bot - q;\r
1630   }\r
1631 \r
1632   undump(lo_mem_max + 1, hi_mem_stat_min, hi_mem_min);\r
1633   undump(mem_bot, mem_top, avail);\r
1634   mem_end = mem_top;\r
1635 \r
1636   if (undumpthings(mem[hi_mem_min], mem_end + 1 - hi_mem_min))\r
1637     return -1;\r
1638 \r
1639   undump_int(var_used);\r
1640   undump_int(dyn_used);\r
1641 \r
1642   k = active_base;\r
1643 \r
1644   do\r
1645     {\r
1646       undump_int(x);\r
1647 \r
1648       if ((x < 1) || (k + x > (eqtb_size + 1)))\r
1649         goto bad_fmt;\r
1650 \r
1651       if (undumpthings(eqtb[k], x))\r
1652         return -1;\r
1653 \r
1654       k = k + x;\r
1655       undump_int(x);\r
1656 \r
1657       if ((x < 0) || (k + x > (eqtb_size + 1)))\r
1658         goto bad_fmt;\r
1659 \r
1660       for (j = k; j <= k + x - 1; j++)\r
1661         eqtb[j] = eqtb[k - 1];\r
1662 \r
1663       k = k + x;\r
1664     }\r
1665   while (!(k > eqtb_size));\r
1666 \r
1667   undump(hash_base, frozen_control_sequence, par_loc);\r
1668   par_token = cs_token_flag + par_loc;\r
1669   undump(hash_base, frozen_control_sequence, write_loc);\r
1670   undump(hash_base, frozen_control_sequence, hash_used);\r
1671 \r
1672   p = hash_base - 1;\r
1673 \r
1674   do\r
1675     {\r
1676       undump(p + 1, hash_used, p);\r
1677       undump_hh(hash[p]);\r
1678     }\r
1679   while (!(p == hash_used));\r
1680 \r
1681   if (undumpthings(hash[hash_used + 1], undefined_control_sequence - 1 - hash_used))\r
1682     return -1;\r
1683 \r
1684   undump_int(cs_count);\r
1685 \r
1686   if (trace_flag)\r
1687     printf("itex undump cs_count %lld ", cs_count);\r
1688 \r
1689   {\r
1690     undump_int(x); /* font_mem_size */\r
1691 \r
1692     if (x < 7)\r
1693       goto bad_fmt;\r
1694 \r
1695 #ifdef ALLOCATEFONT\r
1696     if (trace_flag)\r
1697       printf("Read from fmt fmem_ptr = %lld\n", x);\r
1698 \r
1699     if (x > current_font_mem_size)\r
1700     {\r
1701       if (trace_flag)\r
1702         printf("Undump realloc font_info (%lld > %d)\n", x, current_font_mem_size);\r
1703 \r
1704       font_info = realloc_font_info (x - current_font_mem_size + increment_font_mem_size);\r
1705     }\r
1706 \r
1707     if (x > current_font_mem_size)\r
1708 #else\r
1709     if (x > font_mem_size)\r
1710 #endif\r
1711     {\r
1712       puts("---! Must increase the font mem size");\r
1713       goto bad_fmt;\r
1714     }\r
1715     else\r
1716       fmem_ptr = x;\r
1717   }\r
1718 \r
1719   {\r
1720     undumpthings(font_info[0], fmem_ptr);\r
1721     undump_size(font_base, font_max, "font max", font_ptr);\r
1722     frozen_font_ptr = font_ptr;\r
1723     undumpthings(font_check[0], font_ptr + 1);\r
1724     undumpthings(font_size[0], font_ptr + 1);\r
1725     undumpthings(font_dsize[0], font_ptr + 1);\r
1726     undumpthings(font_params[0], font_ptr + 1);\r
1727     undumpthings(hyphen_char[0], font_ptr + 1);\r
1728     undumpthings(skew_char[0], font_ptr + 1);\r
1729     undumpthings(font_name[0], font_ptr + 1);\r
1730     undumpthings(font_area[0], font_ptr + 1);\r
1731     undumpthings(font_bc[0], font_ptr + 1);\r
1732     undumpthings(font_ec[0], font_ptr + 1);\r
1733     undumpthings(char_base[0], font_ptr + 1);\r
1734     undumpthings(width_base[0], font_ptr + 1);\r
1735     undumpthings(height_base[0], font_ptr + 1);\r
1736     undumpthings(depth_base[0], font_ptr + 1);\r
1737     undumpthings(italic_base[0], font_ptr + 1);\r
1738     undumpthings(lig_kern_base[0], font_ptr + 1);\r
1739     undumpthings(kern_base[0], font_ptr + 1);\r
1740     undumpthings(exten_base[0], font_ptr + 1);\r
1741     undumpthings(param_base[0], font_ptr + 1);\r
1742     undumpthings(font_glue[0], font_ptr + 1);\r
1743     undumpthings(bchar_label[0], font_ptr + 1);\r
1744     undumpthings(font_bchar[0], font_ptr + 1);\r
1745     undumpthings(font_false_bchar[0], font_ptr + 1);\r
1746   }\r
1747 \r
1748 /* log not opened yet, so can't show fonts frozen into format */\r
1749 /* May be able to avoid the following since we switched to */\r
1750 /* non_address from font_mem_size to 0 96/Jan/15 ??? */\r
1751 \r
1752 #ifdef ALLOCATEFONT\r
1753   {\r
1754     int count = 0, oldfont_mem_size = 0;\r
1755     \r
1756     for (x = 0; x <= font_ptr; x++)\r
1757     {\r
1758       if (bchar_label[x] > oldfont_mem_size)\r
1759         oldfont_mem_size = bchar_label[x];\r
1760     }\r
1761 \r
1762     if (oldfont_mem_size != non_address && oldfont_mem_size > font_max)\r
1763     {\r
1764       for (x = 0; x <= font_ptr; x++)\r
1765       {\r
1766         if (bchar_label[x] == oldfont_mem_size)\r
1767         {\r
1768           bchar_label[x] = non_address;\r
1769           count++;\r
1770         }\r
1771       }\r
1772 \r
1773       if (trace_flag)\r
1774         printf("oldfont_mem_size is %d --- hit %d times. Using non_address %d\n",\r
1775             oldfont_mem_size, count, non_address);\r
1776     }\r
1777   }\r
1778 #endif\r
1779 \r
1780   undump(0, hyphen_prime, hyph_count);\r
1781 \r
1782   for (k = 1; k <= hyph_count; k++)\r
1783   {\r
1784     undump(0, hyphen_prime, j);\r
1785     undump(0, str_ptr, hyph_word[j]);\r
1786     undump(0, max_halfword, hyph_list[j]);\r
1787   }\r
1788 \r
1789 #ifdef ALLOCATEHYPHEN\r
1790 /* if user specified new hyphen prime - flush existing exception patterns ! */\r
1791 /* but, we can reclaim the string storage wasted ... */\r
1792   if (is_initex)\r
1793   {\r
1794     if (new_hyphen_prime != 0)\r
1795     {\r
1796       realloc_hyphen(new_hyphen_prime); /* reset_hyphen(); */\r
1797       hyphen_prime = new_hyphen_prime;\r
1798     }\r
1799   }\r
1800 #endif\r
1801 \r
1802   {\r
1803     undump_int(x);\r
1804 \r
1805     if (x < 0)\r
1806       goto bad_fmt;\r
1807 \r
1808 #ifdef ALLOCATETRIES\r
1809     if (!is_initex)\r
1810     {\r
1811       allocate_tries(x); /* allocate only as much as is needed */\r
1812     }\r
1813 #endif\r
1814 \r
1815     if (x > trie_size)\r
1816     {\r
1817       puts("---! Must increase the trie size");\r
1818       goto bad_fmt;\r
1819     }\r
1820     else\r
1821       j = x;\r
1822   }\r
1823 \r
1824 #ifdef INITEX\r
1825   if (is_initex)\r
1826     trie_max = j;\r
1827 #endif\r
1828 \r
1829   undumpthings(trie_trl[0], j + 1);\r
1830   undumpthings(trie_tro[0], j + 1);\r
1831   undumpthings(trie_trc[0], j + 1);\r
1832   undump_size(0, trie_op_size, "trie op size", j);\r
1833 \r
1834 #ifdef INITEX\r
1835   if (is_initex)\r
1836     trie_op_ptr = j;\r
1837 #endif\r
1838   \r
1839   undumpthings(hyf_distance[1], j);\r
1840   undumpthings(hyf_num[1], j);\r
1841   undumpthings(hyf_next[1], j);\r
1842 \r
1843 #ifdef INITEX\r
1844   if (is_initex)\r
1845   {\r
1846     for (k = 0; k <= 255; k++)\r
1847       trie_used[k] = min_quarterword;\r
1848   }\r
1849 #endif\r
1850 \r
1851   k = 256;\r
1852 \r
1853   while (j > 0)\r
1854   {\r
1855     undump(0, k - 1, k);\r
1856     undump(1, j, x);\r
1857 \r
1858 #ifdef INITEX\r
1859     if (is_initex)\r
1860       trie_used[k] = x;\r
1861 #endif\r
1862 \r
1863     j = j - x;\r
1864     op_start[k] = j;\r
1865   }\r
1866 \r
1867 #ifdef INITEX\r
1868   if (is_initex)\r
1869     trie_not_ready = false;\r
1870 #endif\r
1871 \r
1872   undump(batch_mode, error_stop_mode, interaction);\r
1873   undump(0, str_ptr, format_ident);\r
1874   undump_int(x);\r
1875   \r
1876   if ((x != ENDFMTCHECKSUM) || feof(fmt_file))\r
1877     goto bad_fmt;\r
1878 \r
1879   return true;\r
1880 \r
1881 bad_fmt:\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   fprintf(log_file, "\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       fprintf(log_file, ", ");\r
1980 \r
1981     if ((i % 8) == 0)\r
1982       fprintf(log_file, "\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   fprintf(log_file, ") ");\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