src/texsourc/tex1.c

   1
   2 #pragma warning(disable:4996)
   3 #pragma warning(disable:4131) // old style declarator
   4 #pragma warning(disable:4135) // conversion between different integral types
   5 #pragma warning(disable:4127) // conditional expression is constant
   6
   7 #define EXTERN extern
   8
   9 #include "texd.h"
  10
  11 #pragma warning(disable:4244)       /* 96/Jan/10 */
  12
  13 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
  14 /* sec 0198 */
  15 void show_box_(halfword p)
  16 {
  17   depth_threshold = show_box_depth;
  18   breadth_max = show_box_breadth;
  19
  20   if (breadth_max <= 0)
  21     breadth_max = 5;
  22
  23 #ifdef ALLOCATESTRING
  24   if (pool_ptr + depth_threshold >= current_pool_size)
  25     str_pool = realloc_str_pool(increment_pool_size);
  26
  27   if (pool_ptr + depth_threshold >= current_pool_size)
  28     depth_threshold = current_pool_size - pool_ptr - 1;
  29 #else
  30   if (pool_ptr + depth_threshold >= pool_size)
  31     depth_threshold = pool_size - pool_ptr - 1;
  32 #endif
  33
  34   show_node_list(p);
  35   print_ln();
  36 }
  37 /* sec 0200 */
  38 void delete_token_ref_(halfword p)
  39 {
  40   if (token_ref_count(p) == 0)
  41     flush_list(p);
  42   else
  43     decr(token_ref_count(p));
  44 }
  45 /* sec 0201 */
  46 void delete_glue_ref_(halfword p)
  47 {
  48   if (glue_ref_count(p) == 0)
  49     free_node(p, glue_spec_size);
  50   else
  51     decr(glue_ref_count(p));
  52 }
  53 /* sec 0202 */
  54 void flush_node_list_(halfword p)
  55 {
  56   halfword q;
  57
  58   while (p != 0) {      /* while p<>null */
  59     q = link(p);
  60
  61     if (is_char_node(p))
  62       free_avail(p);
  63     else
  64     {
  65       switch (type(p))
  66       {
  67         case hlist_node:
  68         case vlist_node:
  69         case unset_node:
  70           {
  71             flush_node_list(list_ptr(p));
  72             free_node(p, box_node_size);
  73             goto lab30;
  74           }
  75           break;
  76         case rule_node:
  77           {
  78             free_node(p, rule_node_size);
  79             goto lab30;
  80           }
  81           break;
  82         case ins_node:
  83           {
  84             flush_node_list(ins_ptr(p));
  85             delete_glue_ref(split_top_ptr(p));
  86             free_node(p, ins_node_size);
  87             goto lab30;
  88           }
  89           break;
  90         case whatsit_node:
  91           {
  92             switch (subtype(p))
  93             {
  94               case open_node:
  95                 free_node(p, open_node_size);
  96                 break;
  97               case write_node:
  98               case special_node:
  99                 {
 100                   delete_token_ref(write_tokens(p));
 101                   free_node(p, write_node_size);
 102                   goto lab30;
 103                 }
 104                 break;
 105               case close_node:
 106               case set_language_code:
 107                 free_node(p, small_node_size);
 108                 break;
 109               default:
 110                 {
 111                   confusion("ext3");
 112                   return;         // abort_flag set
 113                 }
 114                 break;
 115             }
 116             goto lab30;
 117           }
 118           break;
 119         case glue_node:
 120           {
 121             if (mem[mem[p + 1].hh.v.LH].hh.v.RH == 0)
 122               free_node(mem[p + 1].hh.v.LH, 4);
 123             else
 124               decr(mem[mem[p + 1].hh.v.LH].hh.v.RH);
 125           }
 126
 127           if (leader_ptr(p) != 0)
 128             flush_node_list(leader_ptr(p));
 129           break;
 130         case kern_node:
 131         case math_node:
 132         case penalty_node:
 133           break;
 134         case ligature_node:
 135           flush_node_list(lig_ptr(p));
 136           break;
 137         case mark_node:
 138           delete_token_ref(mark_ptr(p));
 139           break;
 140         case disc_node:
 141           flush_node_list(pre_break(p));
 142           flush_node_list(post_break(p));
 143           break;
 144         case adjust_node:
 145           flush_node_list(adjust_ptr(p));
 146           break;
 147         case style_node:
 148           {
 149             free_node(p, style_node_size);
 150             goto lab30;
 151           }
 152           break;
 153         case choice_node:
 154           {
 155             flush_node_list(display_mlist(p));
 156             flush_node_list(text_mlist(p));
 157             flush_node_list(script_mlist(p));
 158             flush_node_list(script_script_mlist(p));
 159             free_node(p, style_node_size);
 160             goto lab30;
 161           }
 162           break;
 163         case ord_noad:
 164         case op_noad:
 165         case bin_noad:
 166         case rel_noad:
 167         case open_noad:
 168         case close_noad:
 169         case punct_noad:
 170         case inner_noad:
 171         case radical_noad:
 172         case over_noad:
 173         case under_noad:
 174         case vcenter_noad:
 175         case accent_noad:
 176           {
 177             if (math_type(nucleus(p)) >= sub_box)
 178               flush_node_list(info(nucleus(p)));
 179
 180             if (math_type(supscr(p)) >= sub_box)
 181               flush_node_list(info(supscr(p)));
 182
 183             if (math_type(subscr(p)) >= sub_box)
 184               flush_node_list(info(subscr(p)));
 185
 186             if (type(p) == radical_noad)
 187               free_node(p, radical_noad_size);
 188             else
 189             {
 190               if (type(p) == accent_noad)
 191                 free_node(p, accent_noad_size);
 192               else
 193                 free_node(p, noad_size);
 194             }
 195             goto lab30;
 196           }
 197           break;
 198         case left_noad:
 199         case right_noad:
 200           {
 201             free_node(p, noad_size);
 202             goto lab30;
 203           }
 204           break;
 205         case fraction_noad:
 206           {
 207             flush_node_list(info(numerator(p)));
 208             flush_node_list(info(denominator(p)));
 209             free_node(p, fraction_noad_size);
 210             goto lab30;
 211           }
 212           break;
 213         default:
 214           {
 215             confusion("flushing");
 216             return;         // abort_flag set
 217           }
 218           break;
 219       }
 220       free_node(p, small_node_size);
 221 lab30:;
 222     }
 223     p = q;
 224   }
 225 }
 226 /* sec 0204 */
 227 halfword copy_node_list_(halfword p)
 228 {
 229   register halfword Result;
 230   halfword h;
 231   halfword q;
 232   halfword r;
 233   char words;
 234
 235   h = get_avail();
 236   q = h;
 237
 238   while (p != 0) {      /* while p<>null do l.3969 */
 239     words = 1;
 240
 241     if ((p >= hi_mem_min))
 242       r = get_avail();
 243     else switch (type(p))
 244     {
 245       case hlist_node:
 246       case vlist_node:
 247       case unset_node:
 248         {
 249           r = get_node(box_node_size);
 250           mem[r + 6] = mem[p + 6];
 251           mem[r + 5] = mem[p + 5];
 252           list_ptr(r) = copy_node_list(list_ptr(p));
 253           words = 5;
 254         }
 255         break;
 256       case rule_node:
 257         {
 258           r = get_node(rule_node_size);
 259           words = rule_node_size;
 260         }
 261         break;
 262       case ins_node:
 263         {
 264           r = get_node(ins_node_size);
 265           mem[r + 4] = mem[p + 4];
 266           add_glue_ref(split_top_ptr(p));
 267           ins_ptr(r) = copy_node_list(ins_ptr(p));
 268           words = ins_node_size - 1;
 269         }
 270         break;
 271       case whatsit_node:
 272         switch (subtype(p))
 273         {
 274           case open_node:
 275             {
 276               r = get_node(open_node_size);
 277               words = open_node_size;
 278             }
 279             break;
 280
 281           case write_node:
 282           case special_node:
 283             {
 284               r = get_node(write_node_size);
 285               add_token_ref(write_tokens(p));
 286               words = write_node_size;
 287             }
 288             break;
 289
 290           case close_node:
 291           case language_node:
 292             {
 293               r = get_node(small_node_size);
 294               words = small_node_size;
 295             }
 296             break;
 297
 298           default:
 299             {
 300               confusion("ext2");
 301               return 0;         // abort_flag set
 302             }
 303             break;
 304         }
 305         break;
 306
 307       case glue_node:
 308         {
 309           r = get_node(small_node_size);
 310           add_glue_ref(glue_ptr(p));
 311           glue_ptr(r) = glue_ptr(p);
 312           leader_ptr(r) = copy_node_list(leader_ptr(p));
 313         }
 314         break;
 315
 316       case kern_node:
 317       case math_node:
 318       case penalty_node:
 319         {
 320           r = get_node(small_node_size);
 321           words = small_node_size;
 322         }
 323         break;
 324
 325       case ligature_node:
 326         {
 327           r = get_node(small_node_size);
 328           mem[lig_char(r)] = mem[lig_char(p)];
 329           lig_ptr(r) = copy_node_list(lig_ptr(p));
 330         }
 331         break;
 332
 333       case disc_node:
 334         {
 335           r = get_node(small_node_size);
 336           pre_break(r) = copy_node_list(pre_break(p));
 337           post_break(r) = copy_node_list(pre_break(p));
 338         }
 339         break;
 340
 341       case mark_node:
 342         {
 343           r = get_node(small_node_size);
 344           add_token_ref(mark_ptr(p));
 345           words = small_node_size;
 346         }
 347         break;
 348
 349       case adjust_node:
 350         {
 351           r = get_node(small_node_size);
 352           adjust_ptr(r) = copy_node_list(adjust_ptr(p));
 353         }
 354         break;
 355
 356       default:
 357         {
 358           confusion("copying");
 359           return 0;       // abort_flag set
 360         }
 361         break;
 362     }
 363
 364     while (words > 0)
 365     {
 366       decr(words);
 367       mem[r + words] = mem[p + words]; /* r may be used without having ... */
 368     }
 369
 370     link(q) = r;
 371     q = r;
 372     p = link(p);
 373   }
 374
 375   link(q) = 0;
 376   q = link(h);
 377   free_avail(h);
 378
 379   Result = q;
 380   return Result;
 381 }
 382 /* sec 0211 */
 383 void print_mode_(integer m)
 384 {
 385   if (m > 0)
 386   {
 387     switch (m / (max_command + 1))
 388     {
 389       case 0:
 390         print_string("vertical");
 391         break;
 392       case 1:
 393         print_string("horizontal");
 394         break;
 395       case 2:
 396         print_string("display math");
 397         break;
 398     }
 399   }
 400   else
 401   {
 402     if (m == 0)
 403     {
 404       print_string("no");
 405     }
 406     else
 407     {
 408       switch ((- (integer) m) / (max_command + 1))
 409       {
 410         case 0:
 411           print_string("internal vertical");
 412           break;
 413         case 1:
 414           print_string("restricted horizontal");
 415           break;
 416         case 2:
 417           print_string("math");
 418           break;
 419       }
 420     }
 421   }
 422   print_string(" mode");
 423 }
 424 /* sec 0216 */
 425 void push_nest (void)
 426 {
 427   if (nest_ptr > max_nest_stack)
 428   {
 429     max_nest_stack = nest_ptr;
 430
 431 #ifdef ALLOCATEINPUTSTACK
 432     if (nest_ptr == current_nest_size)
 433       nest = realloc_nest_stack(increment_nest_size);
 434
 435     if (nest_ptr == current_nest_size) /* check again after allocation */
 436     {
 437       overflow("semantic nest size", current_nest_size);
 438       return;     // abort_flag set
 439     }
 440 #else
 441     if (nest_ptr == nest_size)
 442     {
 443       overflow("semantic nest size", nest_size); /* semantic next size - not dynamic */
 444       return;     // abort_flag set
 445     }
 446 #endif
 447   }
 448   nest[nest_ptr]= cur_list;
 449   incr(nest_ptr);
 450   head = get_avail();
 451   tail = head;
 452   prev_graf = 0;
 453   mode_line = line;
 454 }
 455 /* sec 0217 */
 456 void pop_nest (void)
 457 {
 458   free_avail(head);
 459   decr(nest_ptr);
 460   cur_list = nest[nest_ptr];
 461 }
 462 /* sec 0218 */
 463 void show_activities (void)
 464 {
 465   integer p;
 466   short m;
 467   memory_word a;
 468   halfword q, r;
 469   integer t;
 470
 471   nest[nest_ptr] = cur_list;
 472   print_nl("");
 473   print_ln();
 474
 475   for (p = nest_ptr; p >= 0; p--)
 476   {
 477     m = nest[p].mode_field;
 478     a = nest[p].aux_field;
 479     print_nl("### ");
 480     print_mode(m);
 481     print_string(" entered at line ");
 482     print_int(abs(nest[p].ml_field));
 483
 484     if (m == hmode)
 485     {
 486       if (nest[p].pg_field != 040600000)
 487       {
 488         print_string(" (language");
 489         print_int(nest[p].pg_field % 65536L);
 490         print_string(":hyphenmin");
 491         print_int(nest[p].pg_field / 4194304L);
 492         print_char(',');
 493         print_int((nest[p].pg_field / 65536L) % 64);
 494         print_char(')');
 495       }
 496     }
 497
 498     if (nest[p].ml_field < 0)
 499     {
 500       print_string(" (\\output routine)");
 501     }
 502
 503     if (p == 0)
 504     {
 505       if (page_head != page_tail)
 506       {
 507         print_nl("### current page:");
 508
 509         if (output_active)
 510         {
 511           print_string(" (held over for next output)");
 512         }
 513
 514         show_box(link(page_head));
 515
 516         if (page_contents > 0)
 517         {
 518           print_nl("total height ");
 519           print_totals();
 520           print_nl(" goal height ");
 521           print_scaled(page_so_far[0]);
 522           r = link(page_ins_head);
 523
 524           while (r != mem_top)
 525           {
 526             print_ln();
 527             print_esc("insert");
 528             t = subtype(r);
 529             print_int(t);
 530             print_string(" adds ");
 531
 532             if (count(t) == 1000)
 533               t = height(r);
 534             else
 535               t = x_over_n(height(r), 1000) * count(t);
 536
 537             print_scaled(t);
 538
 539             if (type(r) == split_up)
 540             {
 541               q = page_head;
 542               t = 0;
 543
 544               do
 545                 {
 546                   q = link(q);
 547
 548                   if ((type(q) == ins_node) && (subtype(q) == subtype(r)))
 549                     incr(t);
 550                 }
 551               while (!(q == broken_ins(r)));
 552
 553               print_string(", #");
 554               print_int(t);
 555               print_string(" might split");
 556             }
 557             r = link(r);
 558           }
 559         }
 560       }
 561
 562       if (link(contrib_head) != 0)
 563         print_nl("### recent contributions:");
 564     }
 565
 566     show_box(link(nest[p].head_field));
 567
 568     switch (abs(m) / (max_command + 1))
 569     {
 570       case 0:
 571         {
 572           print_nl("prevdepth ");
 573
 574           if  (a.cint <= ignore_depth)
 575             print_string("ignored");
 576           else
 577             print_scaled(a.cint);
 578
 579           if (nest[p].pg_field != 0)
 580           {
 581             print_string(", prevgraf ");
 582             print_int(nest[p].pg_field);
 583             print_string(" line");
 584
 585             if (nest[p].pg_field != 1)
 586               print_char('s');
 587           }
 588         }
 589         break;
 590
 591       case 1:
 592         {
 593           print_nl("spacefactor ");
 594           print_int(a.hh.v.LH);
 595
 596           if (m > 0)
 597           {
 598             if (a.hh.v.RH > 0)
 599             {
 600               print_string(", current language ");
 601               print_int(a.hh.v.RH);
 602             }
 603           }
 604         }
 605         break;
 606
 607       case 2:
 608         if (a.cint != 0)
 609         {
 610           print_string("this will be denominator of:");
 611           show_box(a.cint);
 612         }
 613         break;
 614     }
 615   }
 616 }
 617 /* sec 0237 */
 618 void print_param_(integer n)
 619 {
 620   switch (n)
 621   {
 622     case pretolerance_code:
 623       print_esc("pretolerance");
 624       break;
 625
 626     case tolerance_code:
 627       print_esc("tolerance");
 628       break;
 629
 630     case line_penalty_code:
 631       print_esc("linepenalty");
 632       break;
 633
 634     case hyphen_penalty_code:
 635       print_esc("hyphenpenalty");
 636       break;
 637
 638     case ex_hyphen_penalty_code:
 639       print_esc("exhyphenpenalty");
 640       break;
 641
 642     case club_penalty_code:
 643       print_esc("clubpenalty");
 644       break;
 645
 646     case widow_penalty_code:
 647       print_esc("widowpenalty");
 648       break;
 649
 650     case display_widow_penalty_code:
 651       print_esc("displaywidowpenalty");
 652       break;
 653
 654     case broken_penalty_code:
 655       print_esc("brokenpenalty");
 656       break;
 657
 658     case bin_op_penalty_code:
 659       print_esc("binoppenalty");
 660       break;
 661
 662     case rel_penalty_code:
 663       print_esc("relpenalty");
 664       break;
 665
 666     case pre_display_penalty_code:
 667       print_esc("predisplaypenalty");
 668       break;
 669
 670     case post_display_penalty_code:
 671       print_esc("postdisplaypenalty");
 672       break;
 673
 674     case inter_line_penalty_code:
 675       print_esc("interlinepenalty");
 676       break;
 677
 678     case double_hyphen_demerits_code:
 679       print_esc("doublehyphendemerits");
 680       break;
 681
 682     case final_hyphen_demerits_code:
 683       print_esc("finalhyphendemerits");
 684       break;
 685
 686     case adj_demerits_code:
 687       print_esc("adjdemerits");
 688       break;
 689
 690     case mag_code:
 691       print_esc("mag");
 692       break;
 693
 694     case delimiter_factor_code:
 695       print_esc("delimiterfactor");
 696       break;
 697
 698     case looseness_code:
 699       print_esc("looseness");
 700       break;
 701
 702     case time_code:
 703       print_esc("time");
 704       break;
 705
 706     case day_code:
 707       print_esc("day");
 708       break;
 709
 710     case month_code:
 711       print_esc("month");
 712       break;
 713
 714     case year_code:
 715       print_esc("year");
 716       break;
 717
 718     case show_box_breadth_code:
 719       print_esc("showboxbreadth");
 720       break;
 721
 722     case show_box_depth_code:
 723       print_esc("showboxdepth");
 724       break;
 725
 726     case hbadness_code:
 727       print_esc("hbadness");
 728       break;
 729
 730     case vbadness_code:
 731       print_esc("vbadness");
 732       break;
 733
 734     case pausing_code:
 735       print_esc("pausing");
 736       break;
 737
 738     case tracing_online_code:
 739       print_esc("tracingonline");
 740       break;
 741
 742     case tracing_macros_code:
 743       print_esc("tracingmacros");
 744       break;
 745
 746     case tracing_stats_code:
 747       print_esc("tracingstats");
 748       break;
 749
 750     case tracing_paragraphs_code:
 751       print_esc("tracingparagraphs");
 752       break;
 753
 754     case tracing_pages_code:
 755       print_esc("tracingpages");
 756       break;
 757
 758     case tracing_output_code:
 759       print_esc("tracingoutput");
 760       break;
 761
 762     case tracing_lost_chars_code:
 763       print_esc("tracinglostchars");
 764       break;
 765
 766     case tracing_commands_code:
 767       print_esc("tracingcommands");
 768       break;
 769
 770     case tracing_restores_code:
 771       print_esc("tracingrestores");
 772       break;
 773
 774     case uc_hyph_code:
 775       print_esc("uchyph");
 776       break;
 777
 778     case output_penalty_code:
 779       print_esc("outputpenalty");
 780       break;
 781
 782     case max_dead_cycles_code:
 783       print_esc("maxdeadcycles");
 784       break;
 785
 786     case hang_after_code:
 787       print_esc("hangafter");
 788       break;
 789
 790     case floating_penalty_code:
 791       print_esc("floatingpenalty");
 792       break;
 793
 794     case global_defs_code:
 795       print_esc("globaldefs");
 796       break;
 797
 798     case cur_fam_code:
 799       print_esc("fam");
 800       break;
 801
 802     case escape_char_code:
 803       print_esc("escapechar");
 804       break;
 805
 806     case default_hyphen_char_code:
 807       print_esc("defaulthyphenchar");
 808       break;
 809
 810     case default_skew_char_code:
 811       print_esc("defaultskewchar");
 812       break;
 813
 814     case end_line_char_code:
 815       print_esc("endlinechar");
 816       break;
 817
 818     case new_line_char_code:
 819       print_esc("newlinechar");
 820       break;
 821
 822     case language_code:
 823       print_esc("language");
 824       break;
 825
 826     case left_hyphen_min_code:
 827       print_esc("lefthyphenmin");
 828       break;
 829
 830     case right_hyphen_min_code:
 831       print_esc("righthyphenmin");
 832       break;
 833
 834     case holding_inserts_code:
 835       print_esc("holdinginserts");
 836       break;
 837
 838     case error_context_lines_code:
 839       print_esc("errorcontextlines");
 840       break;
 841
 842     default:
 843       print_string("[unknown integer parameter!]");
 844       break;
 845   }
 846 }
 847 /* sec 0245 */
 848 void begin_diagnostic (void)
 849 {
 850   old_setting = selector;
 851
 852   if ((tracing_online <= 0) && (selector == term_and_log))
 853   {
 854     decr(selector);
 855
 856     if (history == spotless)
 857       history = warning_issued;
 858   }
 859 }
 860 /* sec 0245 */
 861 void end_diagnostic_(bool blankline)
 862 {
 863   print_nl("");
 864
 865   if (blankline)
 866     print_ln();
 867
 868   selector = old_setting;
 869 }
 870 /* sec 0247 */
 871 void print_length_param_ (integer n)
 872 {
 873   switch (n)
 874   {
 875     case par_indent_code:
 876       print_esc("parindent");
 877       break;
 878
 879     case math_surround_code:
 880       print_esc("mathsurround");
 881       break;
 882
 883     case line_skip_limit_code:
 884       print_esc("lineskiplimit");
 885       break;
 886
 887     case hsize_code:
 888       print_esc("hsize");
 889       break;
 890
 891     case vsize_code:
 892       print_esc("vsize");
 893       break;
 894
 895     case max_depth_code:
 896       print_esc("maxdepth");
 897       break;
 898
 899     case split_max_depth_code:
 900       print_esc("splitmaxdepth");
 901       break;
 902
 903     case box_max_depth_code:
 904       print_esc("boxmaxdepth");
 905       break;
 906
 907     case hfuzz_code:
 908       print_esc("hfuzz");
 909       break;
 910
 911     case vfuzz_code:
 912       print_esc("vfuzz");
 913       break;
 914
 915     case delimiter_shortfall_code:
 916       print_esc("delimitershortfall");
 917       break;
 918
 919     case null_delimiter_space_code:
 920       print_esc("nulldelimiterspace");
 921       break;
 922
 923     case script_space_code:
 924       print_esc("scriptspace");
 925       break;
 926
 927     case pre_display_size_code:
 928       print_esc("predisplaysize");
 929       break;
 930
 931     case display_width_code:
 932       print_esc("displaywidth");
 933       break;
 934
 935     case display_indent_code:
 936       print_esc("displayindent");
 937       break;
 938
 939     case overfull_rule_code:
 940       print_esc("overfullrule");
 941       break;
 942
 943     case hang_indent_code:
 944       print_esc("hangindent");
 945       break;
 946
 947     case h_offset_code:
 948       print_esc("hoffset");
 949       break;
 950
 951     case v_offset_code:
 952       print_esc("voffset");
 953       break;
 954
 955     case emergency_stretch_code:
 956       print_esc("emergencystretch");
 957       break;
 958
 959     default:
 960       print_string("[unknown dimen parameter!]");
 961       break;
 962   }
 963 }
 964 /* sec 0298 */
 965 void print_cmd_chr_ (quarterword cmd, halfword chr_code)
 966 {
 967   switch (cmd)
 968   {
 969     case left_brace:
 970       print_string("begin-group character ");
 971       print(chr_code);
 972       break;
 973
 974     case right_brace:
 975       print_string("end-group character ");
 976       print(chr_code);
 977       break;
 978
 979     case math_shift:
 980       print_string("math shift character ");
 981       print(chr_code);
 982       break;
 983
 984     case mac_param:
 985       print_string("macro parameter character ");
 986       print(chr_code);
 987       break;
 988
 989     case sup_mark:
 990       print_string("superscript character ");
 991       print(chr_code);
 992       break;
 993
 994     case sub_mark:
 995       print_string("subscript character ");
 996       print(chr_code);
 997       break;
 998
 999     case endv:
1000       print_string("end of alignment template");
1001       break;
1002
1003     case spacer:
1004       print_string("blank space ");
1005       print(chr_code);
1006       break;
1007
1008     case letter:
1009       print_string("the letter ");
1010       print(chr_code);
1011       break;
1012
1013     case other_char:
1014       print_string("the character ");
1015       print(chr_code);
1016       break;
1017
1018     case assign_glue:
1019     case assign_mu_glue:
1020       if (chr_code < skip_base)
1021       {
1022         print_skip_param(chr_code - glue_base);
1023       }
1024       else
1025       {
1026         if (chr_code < mu_skip_base)
1027         {
1028           print_esc("skip");
1029           print_int(chr_code - skip_base);
1030         }
1031         else
1032         {
1033           print_esc("muskip");
1034           print_int(chr_code - mu_skip_base);
1035         }
1036       }
1037       break;
1038
1039     case assign_toks:
1040       if (chr_code >= toks_base)
1041       {
1042         print_esc("toks");
1043         print_int(chr_code - toks_base);
1044       }
1045       else
1046       {
1047         switch (chr_code)
1048         {
1049           case output_routine_loc:
1050             print_esc("output");
1051             break;
1052
1053           case every_par_loc:
1054             print_esc("everypar");
1055             break;
1056
1057           case every_math_loc:
1058             print_esc("everymath");
1059             break;
1060
1061           case every_display_loc:
1062             print_esc("everydisplay");
1063             break;
1064
1065           case every_hbox_loc:
1066             print_esc("everyhbox");
1067             break;
1068
1069           case every_vbox_loc:
1070             print_esc("everyvbox");
1071             break;
1072
1073           case every_job_loc:
1074             print_esc("everyjob");
1075             break;
1076
1077           case every_cr_loc:
1078             print_esc("everycr");
1079             break;
1080
1081           default:
1082             print_esc("errhelp");
1083             break;
1084         }
1085       }
1086       break;
1087
1088     case assign_int:
1089       if (chr_code < count_base)
1090       {
1091         print_param(chr_code - int_base);
1092       }
1093       else
1094       {
1095         print_esc("count");
1096         print_int(chr_code - count_base);
1097       }
1098       break;
1099
1100     case assign_dimen:
1101       if (chr_code < scaled_base)
1102       {
1103         print_length_param(chr_code - dimen_base);
1104       }
1105       else
1106       {
1107         print_esc("dimen");
1108         print_int(chr_code - scaled_base);
1109       }
1110       break;
1111
1112     case accent:
1113       print_esc("accent");
1114       break;
1115
1116     case advance:
1117       print_esc("advance");
1118       break;
1119
1120     case after_assignment:
1121       print_esc("afterassignment");
1122       break;
1123
1124     case after_group:
1125       print_esc("aftergroup");
1126       break;
1127
1128     case assign_font_dimen:
1129       print_esc("fontdimen");
1130       break;
1131
1132     case begin_group:
1133       print_esc("begingroup");
1134       break;
1135
1136     case break_penalty:
1137       print_esc("penalty");
1138       break;
1139
1140     case char_num:
1141       print_esc("char");
1142       break;
1143
1144     case cs_name:
1145       print_esc("csname");
1146       break;
1147
1148     case def_font:
1149       print_esc("font");
1150       break;
1151
1152     case delim_num:
1153       print_esc("delimiter");
1154       break;
1155
1156     case divide:
1157       print_esc("divide");
1158       break;
1159
1160     case end_cs_name:
1161       print_esc("endcsname");
1162       break;
1163
1164     case end_group:
1165       print_esc("endgroup");
1166       break;
1167
1168     case ex_space:
1169       print_esc(" ");
1170       break;
1171
1172     case expand_after:
1173       print_esc("expandafter");
1174       break;
1175
1176     case halign:
1177       print_esc("halign");
1178       break;
1179
1180     case hrule:
1181       print_esc("hrule");
1182       break;
1183
1184     case ignore_spaces:
1185       print_esc("ignorespaces");
1186       break;
1187
1188     case insert:
1189       print_esc("insert");
1190       break;
1191
1192     case ital_corr:
1193       print_esc("/");
1194       break;
1195
1196     case mark:
1197       print_esc("mark");
1198       break;
1199
1200     case math_accent:
1201       print_esc("mathaccent");
1202       break;
1203
1204     case math_char_num:
1205       print_esc("mathchar");
1206       break;
1207
1208     case math_choice:
1209       print_esc("mathchoice");
1210       break;
1211
1212     case multiply:
1213       print_esc("multiply");
1214       break;
1215
1216     case no_align:
1217       print_esc("noalign");
1218       break;
1219
1220     case no_boundary:
1221       print_esc("noboundary");
1222       break;
1223
1224     case no_expand:
1225       print_esc("noexpand");
1226       break;
1227
1228     case non_script:
1229       print_esc("nonscript");
1230       break;
1231
1232     case omit:
1233       print_esc("omit");
1234       break;
1235
1236     case radical:
1237       print_esc("radical");
1238       break;
1239
1240     case read_to_cs:
1241       print_esc("read");
1242       break;
1243
1244     case relax:
1245       print_esc("relax");
1246       break;
1247
1248     case set_box:
1249       print_esc("setbox");
1250       break;
1251
1252     case set_prev_graf:
1253       print_esc("prevgraf");
1254       break;
1255
1256     case set_shape:
1257       print_esc("parshape");
1258       break;
1259
1260     case the:
1261       print_esc("the");
1262       break;
1263
1264     case toks_register:
1265       print_esc("toks");
1266       break;
1267
1268     case vadjust:
1269       print_esc("vadjust");
1270       break;
1271
1272     case valign:
1273       print_esc("valign");
1274       break;
1275
1276     case vcenter:
1277       print_esc("vcenter");
1278       break;
1279
1280     case vrule:
1281       print_esc("vrule");
1282       break;
1283
1284     case par_end:
1285       print_esc("par");
1286       break;
1287
1288     case input:
1289       if (chr_code == 0)
1290         print_esc("input");
1291       else
1292         print_esc("endinput");
1293       break;
1294
1295     case top_bot_mark:
1296       switch (chr_code)
1297       {
1298         case first_mark_code:
1299           print_esc("firstmark");
1300           break;
1301
1302         case bot_mark_code:
1303           print_esc("botmark");
1304           break;
1305
1306         case split_first_mark_code:
1307           print_esc("splitfirstmark");
1308           break;
1309
1310         case split_bot_mark_code:
1311           print_esc("splitbotmark");
1312           break;
1313
1314         default:
1315           print_esc("topmark");
1316           break;
1317       }
1318       break;
1319
1320     case tex_register:
1321       if (chr_code == int_val)
1322         print_esc("count");
1323       else if (chr_code == dimen_val)
1324         print_esc("dimen");
1325       else if (chr_code == glue_val)
1326         print_esc("skip");
1327       else
1328         print_esc("muskip");
1329       break;
1330
1331     case set_aux:
1332       if (chr_code == vmode)
1333         print_esc("prevdepth");
1334       else
1335         print_esc("spacefactor");
1336       break;
1337
1338     case set_page_int:
1339       if (chr_code == 0)
1340         print_esc("deadcycles");
1341       else
1342         print_esc("insertpenalties");
1343       break;
1344
1345     case set_box_dimen:
1346       if (chr_code == width_offset)
1347         print_esc("wd");
1348       else if (chr_code == height_offset)
1349         print_esc("ht");
1350       else
1351         print_esc("dp");
1352       break;
1353
1354     case last_item:
1355       switch (chr_code)
1356       {
1357         case int_val:
1358           print_esc("lastpenalty");
1359           break;
1360
1361         case dimen_val:
1362           print_esc("lastkern");
1363           break;
1364
1365         case glue_val:
1366           print_esc("lastskip");
1367           break;
1368
1369         case input_line_no_code:
1370           print_esc("inputlineno");
1371           break;
1372
1373         default:
1374           print_esc("badness");
1375           break;
1376       }
1377       break;
1378
1379     case convert:
1380       switch (chr_code)
1381       {
1382         case number_code:
1383           print_esc("number");
1384           break;
1385
1386         case roman_numeral_code:
1387           print_esc("romannumeral");
1388           break;
1389
1390         case string_code:
1391           print_esc("string");
1392           break;
1393
1394         case meaning_code:
1395           print_esc("meaning");
1396           break;
1397
1398         case font_name_code:
1399           print_esc("fontname");
1400           break;
1401
1402         default:
1403           print_esc("jobname");
1404           break;
1405       }
1406       break;
1407
1408     case if_test:
1409       switch (chr_code)
1410       {
1411         case if_cat_code:
1412           print_esc("ifcat");
1413           break;
1414
1415         case if_int_code:
1416           print_esc("ifnum");
1417           break;
1418
1419         case if_dim_code:
1420           print_esc("ifdim");
1421           break;
1422
1423         case if_odd_code:
1424           print_esc("ifodd");
1425           break;
1426
1427         case if_vmode_code:
1428           print_esc("ifvmode");
1429           break;
1430
1431         case if_hmode_code:
1432           print_esc("ifhmode");
1433           break;
1434
1435         case if_mmode_code:
1436           print_esc("ifmmode");
1437           break;
1438
1439         case if_inner_code:
1440           print_esc("ifinner");
1441           break;
1442
1443         case if_void_code:
1444           print_esc("ifvoid");
1445           break;
1446
1447         case if_hbox_code:
1448           print_esc("ifhbox");
1449           break;
1450
1451         case if_vbox_code:
1452           print_esc("ifvbox");
1453           break;
1454
1455         case ifx_code:
1456           print_esc("ifx");
1457           break;
1458
1459         case if_eof_code:
1460           print_esc("ifeof");
1461           break;
1462
1463         case if_true_code:
1464           print_esc("iftrue");
1465           break;
1466
1467         case if_false_code:
1468           print_esc("iffalse");
1469           break;
1470
1471         case if_case_code:
1472           print_esc("ifcase");
1473           break;
1474
1475         default:
1476           print_esc("if");
1477           break;
1478       }
1479       break;
1480
1481     case fi_or_else:
1482       if (chr_code == fi_code)
1483         print_esc("fi");
1484       else if (chr_code == or_code)
1485         print_esc("or");
1486       else
1487         print_esc("else");
1488       break;
1489
1490     case tab_mark:
1491       if (chr_code == span_code)
1492         print_esc("span");
1493       else
1494       {
1495         print_string("alignment tab character ");
1496         print(chr_code);
1497       }
1498       break;
1499
1500     case car_ret:
1501       if (chr_code == cr_code)
1502         print_esc("cr");
1503       else
1504         print_esc("crcr");
1505       break;
1506
1507     case set_page_dimen:
1508       switch (chr_code)
1509       {
1510         case 0:
1511           print_esc("pagegoal");
1512           break;
1513
1514         case 1:
1515           print_esc("pagetotal");
1516           break;
1517
1518         case 2:
1519           print_esc("pagestretch");
1520           break;
1521
1522         case 3:
1523           print_esc("pagefilstretch");
1524           break;
1525
1526         case 4:
1527           print_esc("pagefillstretch");
1528           break;
1529
1530         case 5:
1531           print_esc("pagefilllstretch");
1532           break;
1533
1534         case 6:
1535           print_esc("pageshrink");
1536           break;
1537
1538         default:
1539           print_esc("pagedepth");
1540           break;
1541       }
1542       break;
1543
1544     case stop:
1545       if (chr_code == 1)
1546         print_esc("dump");
1547       else
1548         print_esc("end");
1549       break;
1550
1551     case hskip:
1552       switch (chr_code)
1553       {
1554         case skip_code:
1555           print_esc("hskip");
1556           break;
1557
1558         case fil_code:
1559           print_esc("hfil");
1560           break;
1561
1562         case fill_code:
1563           print_esc("hfill");
1564           break;
1565
1566         case ss_code:
1567           print_esc("hss");
1568           break;
1569
1570         default:
1571           print_esc("hfilneg");
1572           break;
1573       }
1574       break;
1575
1576     case vskip:
1577       switch (chr_code)
1578       {
1579         case skip_code:
1580           print_esc("vskip");
1581           break;
1582
1583         case fil_code:
1584           print_esc("vfil");
1585           break;
1586
1587         case fill_code:
1588           print_esc("vfill");
1589           break;
1590
1591         case ss_code:
1592           print_esc("vss");
1593           break;
1594
1595         default:
1596           print_esc("vfilneg");
1597           break;
1598       }
1599       break;
1600
1601     case mskip:
1602       print_esc("mskip");
1603       break;
1604
1605     case kern:
1606       print_esc("kern");
1607       break;
1608
1609     case mkern:
1610       print_esc("mkern");
1611       break;
1612
1613     case hmove:
1614       if (chr_code == 1)
1615         print_esc("moveleft");
1616       else
1617         print_esc("moveright");
1618       break;
1619
1620     case vmove:
1621       if (chr_code == 1)
1622         print_esc("raise");
1623       else
1624         print_esc("lower");
1625       break;
1626
1627     case make_box:
1628       switch (chr_code)
1629       {
1630         case box_code:
1631           print_esc("box");
1632           break;
1633
1634         case copy_code:
1635           print_esc("copy");
1636           break;
1637
1638         case last_box_code:
1639           print_esc("lastbox");
1640           break;
1641
1642         case vsplit_code:
1643           print_esc("vsplit");
1644           break;
1645
1646         case vtop_code:
1647           print_esc("vtop");
1648           break;
1649
1650         case vtop_code + vmode:
1651           print_esc("vbox");
1652           break;
1653
1654         default:
1655           print_esc("hbox");
1656           break;
1657       }
1658       break;
1659
1660     case leader_ship:
1661       if (chr_code == a_leaders)
1662         print_esc("leaders");
1663       else if (chr_code == c_leaders)
1664         print_esc("cleaders");
1665       else if (chr_code == x_leaders)
1666         print_esc("xleaders");
1667       else
1668         print_esc("shipout");
1669       break;
1670
1671     case start_par:
1672       if (chr_code == 0)
1673         print_esc("noindent");
1674       else
1675         print_esc("indent");
1676       break;
1677
1678     case remove_item:
1679       if (chr_code == glue_node)
1680         print_esc("unskip");
1681       else if (chr_code == kern_node)
1682         print_esc("unkern");
1683       else
1684         print_esc("unpenalty");
1685       break;
1686
1687     case un_hbox:
1688       if (chr_code == copy_code)
1689         print_esc("unhcopy");
1690       else
1691         print_esc("unhbox");
1692       break;
1693
1694     case un_vbox:
1695       if (chr_code == copy_code)
1696         print_esc("unvcopy");
1697       else
1698         print_esc("unvbox");
1699       break;
1700
1701     case discretionary:
1702       if (chr_code == 1)
1703         print_esc("-");
1704       else
1705         print_esc("discretionary");
1706       break;
1707
1708     case eq_no:
1709       if (chr_code == 1)
1710         print_esc("leqno");
1711       else
1712         print_esc("eqno");
1713       break;
1714
1715     case math_comp:
1716       switch (chr_code)
1717       {
1718         case ord_noad:
1719           print_esc("mathord");
1720           break;
1721
1722         case op_noad:
1723           print_esc("mathop");
1724           break;
1725
1726         case bin_noad:
1727           print_esc("mathbin");
1728           break;
1729
1730         case rel_noad:
1731           print_esc("mathrel");
1732           break;
1733
1734         case open_noad:
1735           print_esc("mathopen");
1736           break;
1737
1738         case close_noad:
1739           print_esc("mathclose");
1740           break;
1741
1742         case punct_noad:
1743           print_esc("mathpunct");
1744           break;
1745
1746         case inner_noad:
1747           print_esc("mathinner");
1748           break;
1749
1750         case under_noad:
1751           print_esc("underline");
1752           break;
1753
1754         default:
1755           print_esc("overline");
1756           break;
1757       }
1758       break;
1759
1760     case limit_switch:
1761       if (chr_code == limits)
1762         print_esc("limits");
1763       else if (chr_code == no_limits)
1764         print_esc("nolimits");
1765       else
1766         print_esc("displaylimits");
1767       break;
1768
1769     case math_style:
1770       print_style(chr_code);
1771       break;
1772
1773     case above:
1774       switch (chr_code)
1775       {
1776         case over_code:
1777           print_esc("over");
1778           break;
1779
1780         case atop_code:
1781           print_esc("atop");
1782           break;
1783
1784         case delimited_code + above_code:
1785           print_esc("abovewithdelims");
1786           break;
1787
1788         case delimited_code + over_code:
1789           print_esc("overwithdelims");
1790           break;
1791
1792         case delimited_code + atop_code:
1793           print_esc("atopwithdelims");
1794           break;
1795
1796         default:
1797           print_esc("above");
1798           break;
1799       }
1800       break;
1801
1802     case left_right:
1803       if (chr_code == left_noad)
1804         print_esc("left");
1805       else
1806         print_esc("right");
1807       break;
1808
1809     case prefix:
1810       if (chr_code == 1)
1811         print_esc("long");
1812       else if (chr_code == 2)
1813         print_esc("outer");
1814       else
1815         print_esc("global");
1816       break;
1817
1818     case def:
1819       if (chr_code == 0)
1820         print_esc("def");
1821       else if (chr_code == 1)
1822         print_esc("gdef");
1823       else if (chr_code == 2)
1824         print_esc("edef");
1825       else
1826         print_esc("xdef");
1827       break;
1828
1829     case let:
1830       if (chr_code != normal)
1831         print_esc("futurelet");
1832       else
1833         print_esc("let");
1834       break;
1835
1836     case shorthand_def:
1837       switch (chr_code)
1838       {
1839         case char_def_code:
1840           print_esc("chardef");
1841           break;
1842
1843         case math_char_def_code:
1844           print_esc("mathchardef");
1845           break;
1846
1847         case count_def_code:
1848           print_esc("countdef");
1849           break;
1850
1851         case dimen_def_code:
1852           print_esc("dimendef");
1853           break;
1854
1855         case skip_def_code:
1856           print_esc("skipdef");
1857           break;
1858
1859         case mu_skip_def_code:
1860           print_esc("muskipdef");
1861           break;
1862
1863         default:
1864           print_esc("toksdef");
1865           break;
1866       }
1867       break;
1868
1869     case char_given:
1870       print_esc("char");
1871       print_hex(chr_code);
1872       break;
1873
1874     case math_given:
1875       print_esc("mathchar");
1876       print_hex(chr_code);
1877       break;
1878
1879     case def_code:
1880       if (chr_code == cat_code_base)
1881         print_esc("catcode");
1882       else if (chr_code == math_code_base)
1883         print_esc("mathcode");
1884       else if (chr_code == lc_code_base)
1885         print_esc("lccode");
1886       else if (chr_code == uc_code_base)
1887         print_esc("uccode");
1888       else if (chr_code == sf_code_base)
1889         print_esc("sfcode");
1890       else
1891         print_esc("delcode");
1892       break;
1893
1894     case def_family:
1895       print_size(chr_code - math_font_base);
1896       break;
1897
1898     case hyph_data:
1899       if (chr_code == 1)
1900         print_esc("patterns");
1901       else
1902         print_esc("hyphenation");
1903       break;
1904
1905     case assign_font_int:
1906       if (chr_code == 0)
1907         print_esc("hyphenchar");
1908       else
1909         print_esc("skewchar");
1910       break;
1911
1912     case set_font:
1913       print_string("select font ");
1914       slow_print(font_name[chr_code]);
1915
1916       if (font_size[chr_code] != font_dsize[chr_code])
1917       {
1918         print_string(" at ");
1919         print_scaled(font_size[chr_code]);
1920         print_string("pt");
1921       }
1922       break;
1923
1924     case set_interaction:
1925       switch (chr_code)
1926       {
1927         case batch_mode:
1928           print_esc("batchmode");
1929           break;
1930
1931         case nonstop_mode:
1932           print_esc("nonstopmode");
1933           break;
1934
1935         case scroll_mode:
1936           print_esc("scrollmode");
1937           break;
1938
1939         default:
1940           print_esc("errorstopmode");
1941           break;
1942       }
1943       break;
1944
1945     case in_stream:
1946       if (chr_code == 0)
1947         print_esc("closein");
1948       else
1949         print_esc("openin");
1950       break;
1951
1952     case message:
1953       if (chr_code == 0)
1954         print_esc("message");
1955       else
1956         print_esc("errmessage");
1957       break;
1958
1959     case case_shift:
1960       if (chr_code == lc_code_base)
1961         print_esc("lowercase");
1962       else
1963         print_esc("uppercase");
1964       break;
1965
1966     case xray:
1967       switch (chr_code)
1968       {
1969         case show_box_code:
1970           print_esc("showbox");
1971           break;
1972
1973         case show_the_code:
1974           print_esc("showthe");
1975           break;
1976
1977         case show_lists:
1978           print_esc("showlists");
1979           break;
1980
1981         default:
1982           print_esc("show");
1983           break;
1984       }
1985       break;
1986
1987     case undefined_cs:
1988       print_string("undefined");
1989       break;
1990
1991     case call:
1992       print_string("macro");
1993       break;
1994
1995     case long_call:
1996       print_esc("long macro");
1997       break;
1998
1999     case outer_call:
2000       print_esc("outer macro");
2001       break;
2002
2003     case long_outer_call:
2004       print_esc("long");
2005       print_esc("outer macro");
2006       break;
2007
2008     case end_template:
2009       print_esc("outer endtemplate");
2010       break;
2011
2012     case extension:
2013       switch (chr_code)
2014       {
2015         case open_node:
2016           print_esc("openout");
2017           break;
2018
2019         case write_node:
2020           print_esc("write");
2021           break;
2022
2023         case close_node:
2024           print_esc("closeout");
2025           break;
2026
2027         case special_node:
2028           print_esc("special");
2029           break;
2030
2031         case immediate_code:
2032           print_esc("immediate");
2033           break;
2034
2035         case set_language_code:
2036           print_esc("setlanguage");
2037           break;
2038
2039         default:
2040           print_string("[unknown extension!]");
2041           break;
2042       }
2043       break;
2044
2045     default:
2046       print_string("[unknown command code!]");
2047       break;
2048   }
2049 }
2050 #ifdef STAT
2051 /* sec 0252 */
2052 void show_eqtb_(halfword n)
2053 {
2054   if (n < active_base)
2055     print_char('?');
2056   else
2057     if (n < glue_base)
2058     {
2059       sprint_cs(n);
2060       print_char('=');
2061       print_cmd_chr(eq_type(n), equiv(n));
2062
2063       if (eq_type(n) >= call)
2064       {
2065         print_char(':');
2066         show_token_list(link(equiv(n)), 0, 32);
2067       }
2068     }
2069     else
2070       if (n < local_base)
2071         if (n < skip_base)
2072         {
2073           print_skip_param(n - glue_base);
2074           print_char('=');
2075
2076           if (n < glue_base + thin_mu_skip_code)
2077             print_spec(equiv(n), "pt");
2078           else
2079             print_spec(equiv(n), "mu");
2080         }
2081         else
2082           if (n < mu_skip_base)
2083           {
2084             print_esc("skip");
2085             print_int(n - skip_base);
2086             print_char('=');
2087             print_spec(equiv(n), "pt");
2088           }
2089           else
2090           {
2091             print_esc("muskip");
2092             print_int(n - mu_skip_base);
2093             print_char('=');
2094             print_spec(equiv(n), "mu");
2095           }
2096       else
2097         if (n < int_base)
2098           if (n == par_shape_loc)
2099           {
2100             print_esc("parshape");
2101             print_char('=');
2102
2103             if (par_shape_ptr == 0)
2104               print_char('0');
2105             else
2106               print_int(info(par_shape_ptr));
2107           }
2108           else
2109             if (n < toks_base)
2110             {
2111               print_cmd_chr(assign_toks, n);
2112               print_char('=');
2113
2114               if (equiv(n) != 0)
2115                 show_token_list(link(equiv(n)), 0, 32);
2116             }
2117             else
2118               if (n < box_base)
2119               {
2120                 print_esc("toks");
2121                 print_int(n - toks_base);
2122                 print_char('=');
2123
2124                 if (equiv(n) != 0)
2125                   show_token_list(link(equiv(n)), 0, 32);
2126               }
2127               else
2128                 if (n < cur_font_loc)
2129                 {
2130                   print_esc("box");
2131                   print_int(n - box_base);
2132                   print_char('=');
2133
2134                   if (equiv(n) == 0)
2135                     print_string("void");
2136                   else
2137                   {
2138                     depth_threshold = 0;
2139                     breadth_max = 1;
2140                     show_node_list(equiv(n));
2141                   }
2142                 }
2143                 else
2144                   if (n < cat_code_base)
2145                   {
2146                     if (n == cur_font_loc)
2147                       print_string("current font");
2148                     else
2149                       if (n < math_font_base + 16)
2150                       {
2151                         print_esc("textfont");
2152                         print_int(n - math_font_base);
2153                       }
2154                       else
2155                         if (n < math_font_base + 32)
2156                         {
2157                           print_esc("scriptfont");
2158                           print_int(n - math_font_base - 16);
2159                         }
2160                         else
2161                         {
2162                           print_esc("scriptscriptfont");
2163                           print_int(n - math_font_base - 32);
2164                         }
2165
2166                     print_char('=');
2167                     print_esc("");
2168                     print(hash[font_id_base + equiv(n)].v.RH);
2169                   }
2170                   else
2171                     if (n < math_code_base)
2172                     {
2173                       if (n < lc_code_base)
2174                       {
2175                         print_esc("catcode");
2176                         print_int(n - cat_code_base);
2177                       }
2178                       else
2179                         if (n < uc_code_base)
2180                         {
2181                           print_esc("lccode");
2182                           print_int(n - lc_code_base);
2183                         }
2184                         else
2185                           if (n < sf_code_base)
2186                           {
2187                             print_esc("uccode");
2188                             print_int(n - uc_code_base);
2189                           }
2190                           else
2191                           {
2192                             print_esc("sfcode");
2193                             print_int(n - sf_code_base);
2194                           }
2195
2196                       print_char('=');
2197                       print_int(equiv(n));
2198                     }
2199                     else
2200                     {
2201                       print_esc("mathcode");
2202                       print_int(n - math_code_base);
2203                       print_char('=');
2204                       print_int(equiv(n));
2205                     }
2206   else
2207     if (n < dimen_base)
2208     {
2209       if (n < count_base)
2210         print_param(n - int_base);
2211       else
2212         if (n < del_code_base)
2213         {
2214           print_esc("count");
2215           print_int(n - count_base);
2216         }
2217         else
2218         {
2219           print_esc("delcode");
2220           print_int(n - del_code_base);
2221         }
2222
2223       print_char('=');
2224       print_int(eqtb[n].cint);
2225     }
2226     else
2227       if (n <= eqtb_size)
2228       {
2229         if (n < scaled_base)
2230           print_length_param(n - dimen_base);
2231         else
2232         {
2233           print_esc("dimen");
2234           print_int(n - scaled_base);
2235         }
2236
2237         print_char('=');
2238         print_scaled(eqtb[n].cint);
2239         print_string("pt");
2240       }
2241       else
2242         print_char('?');
2243 }
2244 #endif /* STAT */
2245 /* sec 0259 */
2246 halfword id_lookup_(integer j, integer l)
2247 {
2248   integer h;
2249   integer d;
2250   halfword p;
2251   halfword k;
2252
2253   h = buffer[j];
2254
2255   for (k = j + 1; k <= j + l - 1; k++)
2256   {
2257     h = h + h + buffer[k];
2258
2259     while (h >= hash_prime)
2260       h = h - hash_prime;
2261   }
2262
2263   p = h + hash_base;
2264
2265   while (true)
2266   {
2267     if (text(p) > 0)
2268       if (length(text(p)) == l)
2269         if (str_eq_buf(text(p), j))
2270           goto lab40;
2271
2272     if (next(p) == 0)
2273     {
2274       if (no_new_control_sequence)
2275       {
2276         p = undefined_control_sequence;
2277       }
2278       else
2279       {
2280         if (text(p) > 0)
2281         {
2282           do
2283             {
2284               if (hash_is_full)
2285               {
2286                 overflow("hash size", hash_size + hash_extra); /* 96/Jan/10 */
2287                 return 0;     // abort_flag set
2288               }
2289
2290               decr(hash_used);
2291             }
2292           while (!(text(hash_used) == 0));
2293
2294 #ifdef SHORTHASH
2295           if (hash_used > 65535L) /* debugging only 1996/Jan/20 */
2296           {
2297             sprintf(log_line, "ERROR: %s too large %d\n", "hash entry", hash_used);
2298             show_line(log_line, 1);
2299           }
2300 #endif
2301
2302           next(p) = hash_used;
2303           p = hash_used;
2304         }
2305
2306         str_room(l);
2307         d = cur_length;
2308
2309         while (pool_ptr > str_start[str_ptr])
2310         {
2311           decr(pool_ptr);
2312           str_pool[pool_ptr + l] = str_pool[pool_ptr];
2313         }
2314
2315         for (k = j; k <= j + l - 1; k++)
2316           append_char(buffer[k]);
2317
2318 #ifdef SHORTHASH
2319         {
2320           pool_pointer tempstring = make_string();
2321
2322           if (tempstring > 65535L) /* cannot happen */
2323           {
2324             sprintf(log_line, "ERROR: %s too large %d\n", "string ptr", tempstring);
2325             show_line(log_line, 1);
2326           }
2327           text(p) = tempstring;
2328         }
2329 #else
2330         text(p) = make_string();
2331 #endif
2332
2333         pool_ptr = pool_ptr + d;
2334
2335 #ifdef STAT
2336         incr(cs_count);
2337
2338         if (trace_flag)
2339         {
2340           str_pool[pool_ptr] = '\0';
2341           sprintf(log_line, " tex1 cs_count++ '%s' ", &str_pool[pool_ptr-l-d]);
2342           show_line(log_line, 0);      /* debugging */
2343         }
2344 #endif /* STAT */
2345       }
2346
2347       goto lab40;
2348     }
2349     p = next(p);
2350   }
2351
2352 lab40:
2353   return p;
2354 }
2355 /* sec 0274 */
2356 void new_save_level_(group_code c)
2357 {
2358    if (save_ptr > max_save_stack)
2359    {
2360      max_save_stack = save_ptr;
2361
2362 #ifdef ALLOCATESAVESTACK
2363      if (max_save_stack > current_save_size - 6)
2364        save_stack = realloc_save_stack(increment_save_size);
2365
2366      if (max_save_stack > current_save_size - 6) /* check again after allocation */
2367      {
2368        overflow("save size", current_save_size);
2369        return;     // abort_flag set
2370      }
2371 #else
2372      if (max_save_stack > save_size - 6) /* save size - not dynamic */
2373      {
2374        overflow("save size", save_size);
2375        return;     // abort_flag set
2376      }
2377 #endif
2378   }
2379   save_type(save_ptr) = level_boundary;
2380   save_level(save_ptr) = (quarterword) cur_group;
2381   save_index(save_ptr) = cur_boundary;
2382
2383   if (cur_level == max_quarterword)
2384   {
2385     overflow("grouping levels", max_quarterword - min_quarterword); /* 96/Oct/12 ??? */
2386     return;     // abort_flag set
2387   }
2388
2389   cur_boundary = save_ptr;
2390   incr(cur_level);
2391   incr(save_ptr);
2392   cur_group = c;
2393 }
2394 /* sec 0275 */
2395 void eq_destroy_(memory_word w)
2396 {
2397   halfword q;
2398
2399   switch (eq_type_field(w))
2400   {
2401     case call:
2402     case long_call:
2403     case outer_call:
2404     case long_outer_call:
2405       delete_token_ref(equiv_field(w));
2406       break;
2407
2408     case glue_ref:
2409       delete_glue_ref(equiv_field(w));
2410       break;
2411
2412     case shape_ref:
2413       q = equiv_field(w);
2414
2415       if (q != 0)
2416         free_node(q, info(q) + info(q) + 1);
2417       break;
2418
2419     case box_ref:
2420       flush_node_list(equiv_field(w));
2421       break;
2422
2423     default:
2424       break;
2425   }
2426 }
2427 /* sec 0276 */
2428 void eq_save_(halfword p, quarterword l)
2429 {
2430   if (save_ptr > max_save_stack)
2431   {
2432     max_save_stack = save_ptr;
2433
2434 #ifdef ALLOCATESAVESTACK
2435     if (max_save_stack > current_save_size - 6)
2436       save_stack = realloc_save_stack (increment_save_size);
2437
2438     if (max_save_stack > current_save_size - 6) /* check again after allocation */
2439     {
2440       overflow("save size", current_save_size);
2441       return;     // abort_flag set
2442     }
2443 #else
2444     if (max_save_stack > save_size - 6) /* save size not dynamic */
2445     {
2446       overflow("save size", save_size);
2447       return;     // abort_flag set
2448     }
2449 #endif
2450   }
2451
2452   if (l == level_zero)
2453     save_type(save_ptr) = restore_zero;
2454   else
2455   {
2456     save_stack[save_ptr] = eqtb[p];
2457     incr(save_ptr);
2458     save_type(save_ptr) = restore_old_value;
2459   }
2460
2461   save_level(save_ptr) = l;
2462   save_index(save_ptr) = p;
2463   incr(save_ptr);
2464 }
2465 /* sec 0277 */
2466 void eq_define_(halfword p, quarterword t, halfword e)
2467 {
2468   if (eq_level(p) == cur_level)
2469     eq_destroy(eqtb[p]);
2470   else if (cur_level > level_one)
2471     eq_save(p, eq_level(p));
2472
2473   eq_level(p) = (quarterword) cur_level; /* because cur_level padded out */
2474   eq_type(p) = t;
2475   equiv(p) = e;
2476 }
2477 /* sec 0278 */
2478 void eq_word_define_(halfword p, integer w)
2479 {
2480   if (xeq_level[p] != cur_level)
2481   {
2482     eq_save(p, xeq_level[p]);
2483     xeq_level[p] = (quarterword) cur_level; /* because cur_level padded out */
2484   }
2485
2486   eqtb[p].cint = w;
2487 }
2488 /* sec 0279 */
2489 void geq_define_(halfword p, quarterword t, halfword e)
2490 {
2491   eq_destroy(eqtb[p]);
2492   eq_level(p) = level_one;
2493   eq_type(p) = t;
2494   equiv(p) = e;
2495 }
2496 /* sec 0279 */
2497 void geq_word_define_(halfword p, integer w)
2498 {
2499   eqtb[p].cint = w;
2500   xeq_level[p]= 1;
2501 }
2502 /* sec 0280 */
2503 void save_for_after_(halfword t)
2504 {
2505   if (cur_level > 1)
2506   {
2507     if (save_ptr > max_save_stack)
2508     {
2509       max_save_stack = save_ptr;
2510
2511 #ifdef ALLOCATESAVESTACK
2512       if (max_save_stack > current_save_size - 6)
2513         save_stack = realloc_save_stack (increment_save_size);
2514
2515       if (max_save_stack > current_save_size - 6) /* check again after allocation */
2516       {
2517         overflow("save size", current_save_size);
2518         return;     // abort_flag set
2519       }
2520 #else
2521       if (max_save_stack > save_size - 6) /* save satck - not dynamic */
2522       {
2523         overflow("save size", save_size);
2524         return;     // abort_flag set
2525       }
2526 #endif
2527     }
2528
2529     save_type(save_ptr) = insert_token;
2530     save_level(save_ptr) = level_zero;
2531     save_index(save_ptr) = t;
2532     incr(save_ptr);
2533   }
2534 }
2535 /* restore_trace_, unsave followed in the old tex1.c */