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