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