src/texsourc/tex1.c

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