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