src/texsourc/tex1.c

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