src/texsourc/tex1.c

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