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 /* sec 0237 */
 580 void print_param_(integer n)
 581 {
 582   switch (n)
 583   {
 584     case pretolerance_code:
 585       print_esc("pretolerance");
 586       break;
 587     case tolerance_code:
 588       print_esc("tolerance");
 589       break;
 590     case line_penalty_code:
 591       print_esc("linepenalty");
 592       break;
 593     case hyphen_penalty_code:
 594       print_esc("hyphenpenalty");
 595       break;
 596     case ex_hyphen_penalty_code:
 597       print_esc("exhyphenpenalty");
 598       break;
 599     case club_penalty_code:
 600       print_esc("clubpenalty");
 601       break;
 602     case widow_penalty_code:
 603       print_esc("widowpenalty");
 604       break;
 605     case display_widow_penalty_code:
 606       print_esc("displaywidowpenalty");
 607       break;
 608     case broken_penalty_code:
 609       print_esc("brokenpenalty");
 610       break;
 611     case bin_op_penalty_code:
 612       print_esc("binoppenalty");
 613       break;
 614     case rel_penalty_code:
 615       print_esc("relpenalty");
 616       break;
 617     case pre_display_penalty_code:
 618       print_esc("predisplaypenalty");
 619       break;
 620     case post_display_penalty_code:
 621       print_esc("postdisplaypenalty");
 622       break;
 623     case inter_line_penalty_code:
 624       print_esc("interlinepenalty");
 625       break;
 626     case double_hyphen_demerits_code:
 627       print_esc("doublehyphendemerits");
 628       break;
 629     case final_hyphen_demerits_code:
 630       print_esc("finalhyphendemerits");
 631       break;
 632     case adj_demerits_code:
 633       print_esc("adjdemerits");
 634       break;
 635     case mag_code:
 636       print_esc("mag");
 637       break;
 638     case delimiter_factor_code:
 639       print_esc("delimiterfactor");
 640       break;
 641     case looseness_code:
 642       print_esc("looseness");
 643       break;
 644     case time_code:
 645       print_esc("time");
 646       break;
 647     case day_code:
 648       print_esc("day");
 649       break;
 650     case month_code:
 651       print_esc("month");
 652       break;
 653     case year_code:
 654       print_esc("year");
 655       break;
 656     case show_box_breadth_code:
 657       print_esc("showboxbreadth");
 658       break;
 659     case show_box_depth_code:
 660       print_esc("showboxdepth");
 661       break;
 662     case hbadness_code:
 663       print_esc("hbadness");
 664       break;
 665     case vbadness_code:
 666       print_esc("vbadness");
 667       break;
 668     case pausing_code:
 669       print_esc("pausing");
 670       break;
 671     case tracing_online_code:
 672       print_esc("tracingonline");
 673       break;
 674     case tracing_macros_code:
 675       print_esc("tracingmacros");
 676       break;
 677     case tracing_stats_code:
 678       print_esc("tracingstats");
 679       break;
 680     case tracing_paragraphs_code:
 681       print_esc("tracingparagraphs");
 682       break;
 683     case tracing_pages_code:
 684       print_esc("tracingpages");
 685       break;
 686     case tracing_output_code:
 687       print_esc("tracingoutput");
 688       break;
 689     case tracing_lost_chars_code:
 690       print_esc("tracinglostchars");
 691       break;
 692     case tracing_commands_code:
 693       print_esc("tracingcommands");
 694       break;
 695     case tracing_restores_code:
 696       print_esc("tracingrestores");
 697       break;
 698     case uc_hyph_code:
 699       print_esc("uchyph");
 700       break;
 701     case output_penalty_code:
 702       print_esc("outputpenalty");
 703       break;
 704     case max_dead_cycles_code:
 705       print_esc("maxdeadcycles");
 706       break;
 707     case hang_after_code:
 708       print_esc("hangafter");
 709       break;
 710     case floating_penalty_code:
 711       print_esc("floatingpenalty");
 712       break;
 713     case global_defs_code:
 714       print_esc("globaldefs");
 715       break;
 716     case cur_fam_code:
 717       print_esc("fam");
 718       break;
 719     case escape_char_code:
 720       print_esc("escapechar");
 721       break;
 722     case default_hyphen_char_code:
 723       print_esc("defaulthyphenchar");
 724       break;
 725     case default_skew_char_code:
 726       print_esc("defaultskewchar");
 727       break;
 728     case end_line_char_code:
 729       print_esc("endlinechar");
 730       break;
 731     case new_line_char_code:
 732       print_esc("newlinechar");
 733       break;
 734     case language_code:
 735       print_esc("language");
 736       break;
 737     case left_hyphen_min_code:
 738       print_esc("lefthyphenmin");
 739       break;
 740     case right_hyphen_min_code:
 741       print_esc("righthyphenmin");
 742       break;
 743     case holding_inserts_code:
 744       print_esc("holdinginserts");
 745       break;
 746     case error_context_lines_code:
 747       print_esc("errorcontextlines");
 748       break;
 749     default:
 750       print_string("[unknown integer parameter!]");
 751       break;
 752   }
 753 }
 754 /* sec 0245 */
 755 void begin_diagnostic (void)
 756 {
 757   old_setting = selector;
 758   if ((tracing_online <= 0) && (selector == term_and_log))
 759   {
 760     decr(selector);
 761     if (history == spotless)
 762       history = warning_issued;
 763   }
 764 }
 765 /* sec 0245 */
 766 void end_diagnostic_(bool blankline)
 767 {
 768   print_nl("");
 769   if (blankline)
 770     print_ln();
 771   selector = old_setting;
 772 }
 773 /* sec 0247 */
 774 void print_length_param_ (integer n)
 775 {
 776   switch (n)
 777   {
 778     case par_indent_code:
 779       print_esc("parindent");
 780       break;
 781     case math_surround_code:
 782       print_esc("mathsurround");
 783       break;
 784     case line_skip_limit_code:
 785       print_esc("lineskiplimit");
 786       break;
 787     case hsize_code:
 788       print_esc("hsize");
 789       break;
 790     case vsize_code:
 791       print_esc("vsize");
 792       break;
 793     case max_depth_code:
 794       print_esc("maxdepth");
 795       break;
 796     case split_max_depth_code:
 797       print_esc("splitmaxdepth");
 798       break;
 799     case box_max_depth_code:
 800       print_esc("boxmaxdepth");
 801       break;
 802     case hfuzz_code:
 803       print_esc("hfuzz");
 804       break;
 805     case vfuzz_code:
 806       print_esc("vfuzz");
 807       break;
 808     case delimiter_shortfall_code:
 809       print_esc("delimitershortfall");
 810       break;
 811     case null_delimiter_space_code:
 812       print_esc("nulldelimiterspace");
 813       break;
 814     case script_space_code:
 815       print_esc("scriptspace");
 816       break;
 817     case pre_display_size_code:
 818       print_esc("predisplaysize");
 819       break;
 820     case display_width_code:
 821       print_esc("displaywidth");
 822       break;
 823     case display_indent_code:
 824       print_esc("displayindent");
 825       break;
 826     case overfull_rule_code:
 827       print_esc("overfullrule");
 828       break;
 829     case hang_indent_code:
 830       print_esc("hangindent");
 831       break;
 832     case h_offset_code:
 833       print_esc("hoffset");
 834       break;
 835     case v_offset_code:
 836       print_esc("voffset");
 837       break;
 838     case emergency_stretch_code:
 839       print_esc("emergencystretch");
 840       break;
 841     default:
 842       print_string("[unknown dimen parameter!]");
 843       break;
 844   }
 845 }
 846 /* sec 0298 */
 847 void print_cmd_chr_ (quarterword cmd, halfword chrcode)
 848 {
 849   switch (cmd)
 850   {
 851     case 1:
 852       print_string("begin-group character ");
 853       print(chrcode);
 854       break;
 855     case 2:
 856       print_string("end-group character ");
 857       print(chrcode);
 858       break;
 859     case 3:
 860       print_string("math shift character ");
 861       print(chrcode);
 862       break;
 863     case 6:
 864       print_string("macro parameter character ");
 865       print(chrcode);
 866       break;
 867     case 7:
 868       print_string("superscript character ");
 869       print(chrcode);
 870       break;
 871     case 8:
 872       print_string("subscript character ");
 873       print(chrcode);
 874       break;
 875     case 9:
 876       print_string("end of alignment template");
 877       break;
 878     case 10:
 879       print_string("blank space ");
 880       print(chrcode);
 881       break;
 882     case 11:
 883       print_string("the letter ");
 884       print(chrcode);
 885       break;
 886     case 12:
 887       print_string("the character ");
 888       print(chrcode);
 889       break;
 890     case 75:
 891     case 76:
 892       if (chrcode < skip_base)
 893         print_skip_param(chrcode - glue_base);
 894       else if (chrcode < mu_skip_base)
 895       {
 896         print_esc("skip");
 897         print_int(chrcode - skip_base);
 898       }
 899       else
 900       {
 901         print_esc("muskip");
 902         print_int(chrcode - mu_skip_base);
 903       }
 904       break;
 905     case 72:
 906       if (chrcode >= toks_base)
 907       {
 908         print_esc("toks");
 909         print_int(chrcode - toks_base);
 910       }
 911       else switch (chrcode)
 912       {
 913         case output_routine_loc:
 914           print_esc("output");
 915           break;
 916         case every_par_loc:
 917           print_esc("everypar");
 918           break;
 919         case every_math_loc:
 920           print_esc("everymath");
 921           break;
 922         case every_display_loc:
 923           print_esc("everydisplay");
 924           break;
 925         case every_hbox_loc:
 926           print_esc("everyhbox");
 927           break;
 928         case every_vbox_loc:
 929           print_esc("everyvbox");
 930           break;
 931         case every_job_loc:
 932           print_esc("everyjob");
 933           break;
 934         case every_cr_loc:
 935           print_esc("everycr");
 936           break;
 937         default:
 938           print_esc("errhelp");
 939           break;
 940       }
 941       break;
 942     case 73:
 943       if (chrcode < count_base)
 944         print_param(chrcode - int_base);
 945       else {
 946         print_esc("count");
 947         print_int(chrcode - count_base);
 948       }
 949       break;
 950     case 74:
 951       if (chrcode < scaled_base)
 952         print_length_param(chrcode - dimen_base);
 953       else {
 954         print_esc("dimen");
 955         print_int(chrcode - scaled_base);
 956       }
 957       break;
 958     case 45:
 959       print_esc("accent");
 960       break;
 961     case 90:
 962       print_esc("advance");
 963       break;
 964     case 40:
 965       print_esc("afterassignment");
 966       break;
 967     case 41:
 968       print_esc("aftergroup");
 969       break;
 970     case 77:
 971       print_esc("fontdimen");
 972       break;
 973     case 61:
 974       print_esc("begingroup");
 975       break;
 976     case 42:
 977       print_esc("penalty");
 978       break;
 979     case 16:
 980       print_esc("char");
 981       break;
 982     case 107:
 983       print_esc("csname");
 984       break;
 985     case 88:
 986       print_esc("font");
 987       break;
 988     case 15:
 989       print_esc("delimiter");
 990       break;
 991     case 92:
 992       print_esc("divide");
 993       break;
 994     case 67:
 995       print_esc("endcsname");
 996       break;
 997     case 62:
 998       print_esc("endgroup");
 999       break;
1000     case 64:
1001       print_esc(" ");
1002       break;
1003     case 102:
1004       print_esc("expandafter");
1005       break;
1006     case 32:
1007       print_esc("halign");
1008       break;
1009     case 36:
1010       print_esc("hrule");
1011       break;
1012     case 39:
1013       print_esc("ignorespaces");
1014       break;
1015     case 37:
1016       print_esc("insert");
1017       break;
1018     case 44:
1019       print_esc("/");
1020       break;
1021     case 18:
1022       print_esc("mark");
1023       break;
1024     case 46:
1025       print_esc("mathaccent");
1026       break;
1027     case 17:
1028       print_esc("mathchar");
1029       break;
1030     case 54:
1031       print_esc("mathchoice");
1032       break;
1033     case 91:
1034       print_esc("multiply");
1035       break;
1036     case 34:
1037       print_esc("noalign");
1038       break;
1039     case 65:
1040       print_esc("noboundary");
1041       break;
1042     case 103:
1043       print_esc("noexpand");
1044       break;
1045     case 55:
1046       print_esc("nonscript");
1047       break;
1048     case 63:
1049       print_esc("omit");
1050       break;
1051     case 66:
1052       print_esc("radical");
1053       break;
1054     case 96:
1055       print_esc("read");
1056       break;
1057     case 0:
1058       print_esc("relax");
1059       break;
1060     case 98:
1061       print_esc("setbox");
1062       break;
1063     case 80:
1064       print_esc("prevgraf");
1065       break;
1066     case 84:
1067       print_esc("parshape");
1068       break;
1069     case 109:
1070       print_esc("the");
1071       break;
1072     case 71:
1073       print_esc("toks");
1074       break;
1075     case 38:
1076       print_esc("vadjust");
1077       break;
1078     case 33:
1079       print_esc("valign");
1080       break;
1081     case 56:
1082       print_esc("vcenter");
1083       break;
1084     case 35:
1085       print_esc("vrule");
1086       break;
1087     case 13:
1088       print_esc("par");
1089       break;
1090     case 104:
1091       if (chrcode == 0)
1092         print_esc("input");
1093       else
1094         print_esc("endinput");
1095       break;
1096     case 110:
1097       switch (chrcode)
1098       {
1099         case 1:
1100           print_esc("firstmark");
1101           break;
1102         case 2:
1103           print_esc("botmark");
1104           break;
1105         case 3:
1106           print_esc("splitfirstmark");
1107           break;
1108         case 4:
1109           print_esc("splitbotmark");
1110           break;
1111         default:
1112           print_esc("topmark");
1113           break;
1114       }
1115       break;
1116     case 89:
1117       if (chrcode == 0)
1118         print_esc("count");
1119       else if (chrcode == 1)
1120         print_esc("dimen");
1121       else if (chrcode == 2)
1122         print_esc("skip");
1123       else
1124         print_esc("muskip");
1125       break;
1126     case 79:
1127       if (chrcode == 1)
1128         print_esc("prevdepth");
1129       else
1130         print_esc("spacefactor");
1131       break;
1132     case 82:
1133       if (chrcode == 0)
1134         print_esc("deadcycles");
1135       else
1136         print_esc("insertpenalties");
1137       break;
1138     case 83:
1139       if (chrcode == 1)
1140         print_esc("wd");
1141       else if (chrcode == 3)
1142         print_esc("ht");
1143       else
1144         print_esc("dp");
1145       break;
1146     case 70:
1147       switch (chrcode)
1148       {
1149         case 0:
1150           print_esc("lastpenalty");
1151           break;
1152         case 1:
1153           print_esc("lastkern");
1154           break;
1155         case 2:
1156           print_esc("lastskip");
1157           break;
1158         case 3:
1159           print_esc("inputlineno");
1160           break;
1161         default:
1162           print_esc("badness");
1163           break;
1164       }
1165       break;
1166     case 108:
1167       switch (chrcode)
1168       {
1169         case 0:
1170           print_esc("number");
1171           break;
1172         case 1:
1173           print_esc("romannumeral");
1174           break;
1175         case 2:
1176           print_esc("string");
1177           break;
1178         case 3:
1179           print_esc("meaning");
1180           break;
1181         case 4:
1182           print_esc("fontname");
1183           break;
1184         default:
1185           print_esc("jobname");
1186           break;
1187       }
1188       break;
1189     case 105:
1190       switch (chrcode)
1191       {
1192         case 1:
1193           print_esc("ifcat");
1194           break;
1195         case 2:
1196           print_esc("ifnum");
1197           break;
1198         case 3:
1199           print_esc("ifdim");
1200           break;
1201         case 4:
1202           print_esc("ifodd");
1203           break;
1204         case 5:
1205           print_esc("ifvmode");
1206           break;
1207         case 6:
1208           print_esc("ifhmode");
1209           break;
1210         case 7:
1211           print_esc("ifmmode");
1212           break;
1213         case 8:
1214           print_esc("ifinner");
1215           break;
1216         case 9:
1217           print_esc("ifvoid");
1218           break;
1219         case 10:
1220           print_esc("ifhbox");
1221           break;
1222         case 11:
1223           print_esc("ifvbox");
1224           break;
1225         case 12:
1226           print_esc("ifx");
1227           break;
1228         case 13:
1229           print_esc("ifeof");
1230           break;
1231         case 14:
1232           print_esc("iftrue");
1233           break;
1234         case 15:
1235           print_esc("iffalse");
1236           break;
1237         case 16:
1238           print_esc("ifcase");
1239           break;
1240         default:
1241           print_esc("if");
1242           break;
1243       }
1244       break;
1245     case 106:
1246       if (chrcode == 2)
1247         print_esc("fi");
1248       else if (chrcode == 4)
1249         print_esc("or");
1250       else print_esc("else");
1251       break;
1252     case 4:
1253       if (chrcode == 256)  /* pool size */ /* max_quarterword + 1 ? */
1254         print_esc("span");
1255       else {
1256         print_string("alignment tab character ");
1257         print(chrcode);
1258       }
1259       break;
1260     case 5:
1261       if (chrcode == 257)    /* cr_code */
1262         print_esc("cr");
1263       else print_esc("crcr");
1264       break;
1265     case 81:
1266       switch (chrcode)
1267       {
1268         case 0:
1269           print_esc("pagegoal");
1270           break;
1271         case 1:
1272           print_esc("pagetotal");
1273           break;
1274         case 2:
1275           print_esc("pagestretch");
1276           break;
1277         case 3:
1278           print_esc("pagefilstretch");
1279           break;
1280         case 4:
1281           print_esc("pagefillstretch");
1282           break;
1283         case 5:
1284           print_esc("pagefilllstretch");
1285           break;
1286         case 6:
1287           print_esc("pageshrink");
1288           break;
1289         default:
1290           print_esc("pagedepth");
1291           break;
1292       }
1293       break;
1294     case 14:
1295       if (chrcode == 1)
1296         print_esc("dump");
1297       else print_esc("end");
1298       break;
1299     case 26:
1300       switch (chrcode)
1301       {
1302         case 4:
1303           print_esc("hskip");
1304           break;
1305         case 0:
1306           print_esc("hfil");
1307           break;
1308         case 1:
1309           print_esc("hfill");
1310           break;
1311         case 2:
1312           print_esc("hss");
1313           break;
1314         default:
1315           print_esc("hfilneg");
1316           break;
1317       }
1318       break;
1319     case 27:
1320       switch (chrcode)
1321       {
1322         case 4:
1323           print_esc("vskip");
1324           break;
1325         case 0:
1326           print_esc("vfil");
1327           break;
1328         case 1:
1329           print_esc("vfill");
1330           break;
1331         case 2:
1332           print_esc("vss");
1333           break;
1334         default:
1335           print_esc("vfilneg");
1336           break;
1337       }
1338       break;
1339     case 28:
1340       print_esc("mskip");
1341       break;
1342     case 29:
1343       print_esc("kern");
1344       break;
1345     case 30:
1346       print_esc("mkern");
1347       break;
1348     case 21:
1349       if (chrcode == 1)
1350         print_esc("moveleft");
1351       else print_esc("moveright");
1352       break;
1353     case 22:
1354       if (chrcode == 1)
1355         print_esc("raise");
1356       else print_esc("lower");
1357       break;
1358     case 20:
1359       switch (chrcode)
1360       {
1361         case 0:
1362           print_esc("box");
1363           break;
1364         case 1:
1365           print_esc("copy");
1366           break;
1367         case 2:
1368           print_esc("lastbox");
1369           break;
1370         case 3:
1371           print_esc("vsplit");
1372           break;
1373         case 4:
1374           print_esc("vtop");
1375           break;
1376         case 5:
1377           print_esc("vbox");
1378           break;
1379         default:
1380           print_esc("hbox");
1381           break;
1382       }
1383       break;
1384     case 31:
1385       if (chrcode == 100)
1386         print_esc("leaders");
1387       else if (chrcode == 101)
1388         print_esc("cleaders");
1389       else if (chrcode == 102)
1390         print_esc("xleaders");
1391       else print_esc("shipout");
1392       break;
1393     case 43:
1394       if (chrcode == 0)
1395         print_esc("noindent");
1396       else print_esc("indent");
1397       break;
1398     case 25:
1399       if (chrcode == 10)
1400         print_esc("unskip");
1401       else if (chrcode == 11)
1402         print_esc("unkern");
1403       else print_esc("unpenalty");
1404       break;
1405     case 23:
1406       if (chrcode == 1)
1407         print_esc("unhcopy");
1408       else print_esc("unhbox");
1409       break;
1410     case 24:
1411       if (chrcode == 1)
1412         print_esc("unvcopy");
1413       else print_esc("unvbox");
1414       break;
1415     case 47:
1416       if (chrcode == 1)
1417         print_esc("-");
1418       else
1419         print_esc("discretionary");
1420       break;
1421     case 48:
1422       if (chrcode == 1)
1423         print_esc("leqno");
1424       else print_esc("eqno");
1425       break;
1426     case 50:
1427       switch (chrcode)
1428       {
1429         case 16:
1430           print_esc("mathord");
1431           break;
1432         case 17:
1433           print_esc("mathop");
1434           break;
1435         case 18:
1436           print_esc("mathbin");
1437           break;
1438         case 19:
1439           print_esc("mathrel");
1440           break;
1441         case 20:
1442           print_esc("mathopen");
1443           break;
1444         case 21:
1445           print_esc("mathclose");
1446           break;
1447         case 22:
1448           print_esc("mathpunct");
1449           break;
1450         case 23:
1451           print_esc("mathinner");
1452           break;
1453         case 26:
1454           print_esc("underline");
1455           break;
1456         default:
1457           print_esc("overline");
1458           break;
1459       }
1460       break;
1461     case 51:
1462       if (chrcode == 1)
1463         print_esc("limits");
1464       else if (chrcode == 2)
1465         print_esc("nolimits");
1466       else print_esc("displaylimits");
1467       break;
1468     case 53:
1469       print_style(chrcode);
1470       break;
1471     case 52:
1472       switch (chrcode)
1473       {
1474         case 1:
1475           print_esc("over");
1476           break;
1477         case 2:
1478           print_esc("atop");
1479           break;
1480         case 3:
1481           print_esc("abovewithdelims");
1482           break;
1483         case 4:
1484           print_esc("overwithdelims");
1485           break;
1486         case 5:
1487           print_esc("atopwithdelims");
1488           break;
1489         default:
1490           print_esc("above");
1491           break;
1492       }
1493       break;
1494     case 49:
1495       if (chrcode == 30)
1496         print_esc("left");
1497       else print_esc("right");
1498       break;
1499     case 93:
1500       if (chrcode == 1)
1501         print_esc("long");
1502       else if (chrcode == 2)
1503         print_esc("outer");
1504       else print_esc("global");
1505       break;
1506     case 97:
1507       if (chrcode == 0)
1508         print_esc("def");
1509       else if (chrcode == 1)
1510         print_esc("gdef");
1511       else if (chrcode == 2)
1512         print_esc("edef");
1513       else print_esc("xdef");
1514       break;
1515     case 94:
1516       if (chrcode != 0)
1517         print_esc("futurelet");
1518       else print_esc("let");
1519       break;
1520     case 95:
1521       switch (chrcode)
1522       {
1523         case 0:
1524           print_esc("chardef");
1525           break;
1526         case 1:
1527           print_esc("mathchardef");
1528           break;
1529         case 2:
1530           print_esc("countdef");
1531           break;
1532         case 3:
1533           print_esc("dimendef");
1534           break;
1535         case 4:
1536           print_esc("skipdef");
1537           break;
1538         case 5:
1539           print_esc("muskipdef");
1540           break;
1541         default:
1542           print_esc("toksdef");
1543           break;
1544       }
1545       break;
1546     case 68:
1547       print_esc("char");
1548       print_hex(chrcode);
1549       break;
1550     case 69:
1551       print_esc("mathchar");
1552       print_hex(chrcode);
1553       break;
1554     case 85:
1555       if (chrcode == cat_code_base)
1556         print_esc("catcode");
1557       else if (chrcode == math_code_base)
1558         print_esc("mathcode");
1559       else if (chrcode == lc_code_base)
1560         print_esc("lccode");
1561       else if (chrcode == uc_code_base)
1562         print_esc("uccode");
1563       else if (chrcode == sf_code_base)
1564         print_esc("sfcode");
1565       else print_esc("delcode");
1566       break;
1567     case 86:
1568       print_size(chrcode - math_font_base);
1569       break;
1570     case 99:
1571       if (chrcode == 1)
1572         print_esc("patterns");
1573       else print_esc("hyphenation");
1574       break;
1575     case 78:
1576       if (chrcode == 0)
1577         print_esc("hyphenchar");
1578       else print_esc("skewchar");
1579       break;
1580     case 87:
1581       print_string("select font ");
1582       slow_print(font_name[chrcode]);
1583       if (font_size[chrcode] != font_dsize[chrcode])
1584       {
1585         print_string(" at ");
1586         print_scaled(font_size[chrcode]);
1587         print_string("pt");
1588       }
1589       break;
1590     case 100:
1591       switch (chrcode)
1592       {
1593         case 0:
1594           print_esc("batchmode");
1595           break;
1596         case 1:
1597           print_esc("nonstopmode");
1598           break;
1599         case 2:
1600           print_esc("scrollmode");
1601           break;
1602         default:
1603           print_esc("errorstopmode");
1604           break;
1605       }
1606       break;
1607     case 60:
1608       if (chrcode == 0)
1609         print_esc("closein");
1610       else print_esc("openin");
1611       break;
1612     case 58:
1613       if (chrcode == 0)
1614         print_esc("message");
1615       else print_esc("errmessage");
1616       break;
1617     case 57:
1618       if (chrcode == lc_code_base)
1619         print_esc("lowercase");
1620       else print_esc("uppercase");
1621       break;
1622     case 19:
1623       switch (chrcode)
1624       {
1625         case 1:
1626           print_esc("showbox");
1627           break;
1628         case 2:
1629           print_esc("showthe");
1630           break;
1631         case 3:
1632           print_esc("showlists");
1633           break;
1634         default:
1635           print_esc("show");
1636           break;
1637       }
1638       break;
1639     case 101:
1640       print_string("undefined");
1641       break;
1642     case 111:
1643       print_string("macro");
1644       break;
1645     case 112:
1646       print_esc("long macro");
1647       break;
1648     case 113:
1649       print_esc("outer macro");
1650       break;
1651     case 114:
1652       print_esc("long");
1653       print_esc("outer macro");
1654       break;
1655     case 115:
1656       print_esc("outer endtemplate");
1657       break;
1658     case 59:
1659       switch (chrcode)
1660       {
1661         case 0:
1662           print_esc("openout");
1663           break;
1664         case 1:
1665           print_esc("write");
1666           break;
1667         case 2:
1668           print_esc("closeout");
1669           break;
1670         case 3:
1671           print_esc("special");
1672           break;
1673         case 4:
1674           print_esc("immediate");
1675           break;
1676         case 5:
1677           print_esc("setlanguage");
1678           break;
1679         default:
1680           print_string("[unknown extension!]");
1681           break;
1682       }
1683       break;
1684     default:
1685       print_string("[unknown command code!]");
1686       break;
1687   }
1688 }
1689 #ifdef STAT
1690 /* sec 0252 */
1691 void show_eqtb_(halfword n)
1692 {
1693   if (n < active_base)
1694     print_char('?');
1695   else if (n < glue_base)
1696   {
1697     sprint_cs(n);
1698     print_char('=');
1699     print_cmd_chr(eq_type(n), equiv(n));
1700     if (eqtb[n].hh.b0 >= call)
1701     {
1702       print_char(':');
1703       show_token_list(link(equiv(n)), 0, 32);
1704     }
1705   }
1706   else if (n < local_base)
1707     if (n < skip_base)
1708     {
1709       print_skip_param(n - glue_base);
1710       print_char('=');
1711       if (n < glue_base + thin_mu_skip_code)
1712         print_spec(equiv(n), "pt");
1713       else
1714         print_spec(equiv(n), "mu");
1715     }
1716     else if (n < mu_skip_base)
1717     {
1718       print_esc("skip");
1719       print_int(n - skip_base);
1720       print_char('=');
1721       print_spec(equiv(n), "pt");
1722     }
1723     else
1724     {
1725       print_esc("muskip");
1726       print_int(n - mu_skip_base);
1727       print_char('=');
1728       print_spec(equiv(n), "mu");
1729     }
1730   else if (n < int_base)
1731     if (n == par_shape_loc)
1732     {
1733       print_esc("parshape");
1734       print_char('=');
1735       if (par_shape_ptr == 0)
1736         print_char('0');
1737       else
1738         print_int(info(par_shape_ptr));
1739     }
1740     else if (n < toks_base)
1741     {
1742       print_cmd_chr(assign_toks, n);
1743       print_char('=');
1744       if (equiv(n) != 0)
1745         show_token_list(link(equiv(n)), 0, 32);
1746     }
1747     else if (n < box_base)
1748     {
1749       print_esc("toks");
1750       print_int(n - toks_base);
1751       print_char('=');
1752       if (equiv(n) != 0)
1753         show_token_list(link(equiv(n)), 0, 32);
1754     }
1755     else if (n < cur_font_loc)
1756     {
1757       print_esc("box");
1758       print_int(n - box_base);
1759       print_char('=');
1760       if (equiv(n) == 0)
1761         print_string("void");
1762       else
1763       {
1764         depth_threshold = 0;
1765         breadth_max = 1;
1766         show_node_list(equiv(n));
1767       }
1768     }
1769     else if (n < cat_code_base)
1770     {
1771       if (n == cur_font_loc)
1772         print_string("current font");
1773       else if (n < math_font_base + 16)
1774       {
1775         print_esc("textfont");
1776         print_int(n - math_font_base);
1777       }
1778       else if (n < math_font_base + 32)
1779       {
1780         print_esc("scriptfont");
1781         print_int(n - math_font_base - 16);
1782       }
1783       else
1784       {
1785         print_esc("scriptscriptfont");
1786         print_int(n - math_font_base - 32);
1787       }
1788       print_char('=');
1789       print_esc(""); print(hash[(hash_size + hash_extra + 524) + equiv(n)].v.RH);
1790     }
1791     else if (n < math_code_base)
1792     {
1793       if (n < lc_code_base)
1794       {
1795         print_esc("catcode");
1796         print_int(n - cat_code_base);
1797       }
1798       else if (n < uc_code_base)
1799       {
1800         print_esc("lccode");
1801         print_int(n - lc_code_base);
1802       }
1803       else if (n < sf_code_base)
1804       {
1805         print_esc("uccode");
1806         print_int(n - uc_code_base);
1807       }
1808       else
1809       {
1810         print_esc("sfcode");
1811         print_int(n - sf_code_base);
1812       }
1813       print_char('=');
1814       print_int(equiv(n));
1815     }
1816     else
1817     {
1818       print_esc("mathcode");
1819       print_int(n - math_code_base);
1820       print_char('=');
1821       print_int(equiv(n));
1822     }
1823   else if (n < dimen_base)
1824   {
1825     if (n < count_base)
1826       print_param(n - int_base);
1827     else if (n < del_code_base)
1828     {
1829       print_esc("count");
1830       print_int(n - count_base);
1831     }
1832     else
1833     {
1834       print_esc("delcode");
1835       print_int(n - del_code_base);
1836     }
1837     print_char('=');
1838     print_int(eqtb[n].cint);
1839   }
1840   else if (n <= eqtb_size)
1841   {
1842     if (n < scaled_base)
1843       print_length_param(n - dimen_base);
1844     else
1845     {
1846       print_esc("dimen");
1847       print_int(n - scaled_base);
1848     }
1849     print_char('=');
1850     print_scaled(eqtb[n].cint);
1851     print_string("pt");
1852   }
1853   else print_char('?');
1854 }
1855 #endif /* STAT */
1856
1857 halfword id_lookup_(integer j, integer l)
1858 {
1859   register halfword Result;
1860   integer h;
1861   integer d;
1862   halfword p;
1863   halfword k;
1864
1865   h = buffer[j];
1866   for (k = j + 1; k <= j + l - 1; k++)
1867   {
1868     h = h + h + buffer[k];
1869     while (h >= hash_prime)
1870       h = h - hash_prime;
1871   }
1872   p = h + hash_base;
1873   while (true) {
1874     if (text(p) > 0)
1875       if (length(text(p)) == l)
1876         if (str_eq_buf(text(p), j))
1877           goto lab40;
1878     if (hash[p].v.LH == 0) {
1879       if (no_new_control_sequence)
1880         p = undefined_control_sequence;
1881       else
1882       {
1883         if (text(p) > 0)
1884         {
1885           do {
1886             if (hash_is_full)
1887             {
1888 /*        we can't expand the hash table ... */
1889 /*        overflow("hash size", hash_size); */ /* hash size - NOT DYNAMIC */
1890               overflow("hash size", hash_size + hash_extra); /* 96/Jan/10 */
1891               return 0;     // abort_flag set
1892             }
1893             decr(hash_used);
1894           } while (!(text(hash_used) == 0));
1895 #ifdef SHORTHASH
1896           if (hash_used > 65535L)
1897           {     /* debugging only 1996/Jan/20 */
1898             sprintf(log_line, "ERROR: %s too large %d\n", "hash entry", hash_used);
1899             show_line(log_line, 1);
1900           }
1901 #endif
1902           hash[p].v.LH = hash_used;
1903           p = hash_used;
1904         }
1905 #ifdef CHECKPOOL
1906         if (checkpool(NULL)) show_line("after hash_used\n", 0);
1907 #endif
1908         {
1909 #ifdef ALLOCATESTRING
1910           if (pool_ptr + l > current_pool_size)
1911             str_pool = realloc_str_pool(increment_pool_size + 1);
1912           if (pool_ptr + l > current_pool_size)
1913           { /* in case it failed 97/Mar/7 */
1914             overflow("pool size", current_pool_size - init_pool_ptr); /* pool size */
1915             return 0;     // abort_flag set
1916           }
1917 #else
1918           if (pool_ptr + l > pool_size)
1919           {
1920             overflow("pool size", pool_size - init_pool_ptr); /* pool size - not dynamic */
1921             return;     // abort_flag set
1922           }
1923 #endif
1924         }
1925         d = cur_length;
1926         while (pool_ptr > str_start[str_ptr]) {
1927           decr(pool_ptr);
1928           str_pool[pool_ptr + l] = str_pool[pool_ptr];
1929         }
1930 #ifdef CHECKPOOL
1931         if (checkpool(NULL)) show_line("after pool_ptr\n", 0);
1932 #endif
1933         for (k = j; k <= j + l - 1; k++) append_char(buffer[k]);
1934 #ifdef SHORTHASH
1935         {
1936           pool_pointer tempstring = make_string();
1937           if (tempstring > 65535L)
1938           {      /* cannot happen */
1939             sprintf(log_line, "ERROR: %s too large %d\n", "string ptr", tempstring);
1940             show_line(log_line, 1);
1941           }
1942           text(p) = tempstring;
1943         }
1944 #else
1945         text(p) = make_string();
1946 #endif
1947 #ifdef CHECKPOOL
1948         if (checkpool(NULL))
1949           show_line("after make_string\n", 0);
1950 #endif
1951         pool_ptr = pool_ptr + d;
1952 #ifdef STAT
1953         incr(cs_count);
1954         if (trace_flag)
1955         {
1956           str_pool[pool_ptr] = '\0';
1957           sprintf(log_line, " tex1 cs_count++ '%s' ", &str_pool[pool_ptr-l-d]);
1958           show_line(log_line, 0);      /* debugging */
1959         }
1960 #endif /* STAT */
1961       }
1962 #ifdef CHECKPOOL
1963       if (checkpool(NULL))
1964         show_line("after cs_count++\n", 0);
1965 #endif
1966       goto lab40;
1967     }
1968     p = hash[p].v.LH;
1969   }
1970 #ifdef CHECKPOOL
1971   if (checkpool(NULL)) show_line("before return\n", 0);
1972 #endif
1973 lab40:
1974   Result = p;
1975   return Result;
1976 }
1977 /* sec 0274 */
1978 void new_save_level_(group_code c)
1979 {
1980    if (save_ptr > max_save_stack)
1981    {
1982      max_save_stack = save_ptr;
1983 #ifdef ALLOCATESAVESTACK
1984      if (max_save_stack > current_save_size - 6)
1985        save_stack = realloc_save_stack(increment_save_size);
1986      if (max_save_stack > current_save_size - 6)
1987      { /* check again after allocation */
1988        overflow("save size", current_save_size);
1989        return;     // abort_flag set
1990      }
1991 #else
1992      if (max_save_stack > save_size - 6)
1993      { /* save size - not dynamic */
1994        overflow("save size", save_size);
1995        return;     // abort_flag set
1996      }
1997 #endif
1998   }
1999 /* save_type(save_ptr) <- level_boundary; */
2000   save_stack[save_ptr].hh.b0 = 3;
2001 /*  save_stack[save_ptr].hh.b1 = cur_group;  *//* keep compiler happy */
2002   save_stack[save_ptr].hh.b1 = (quarterword) cur_group;
2003 /* save_index(save_ptr):=cur_boundary; */
2004   save_stack[save_ptr].hh.v.RH = cur_boundary;
2005 /* if cur_level = max_quarterword then ... p.274 */
2006 /*  if (cur_level == 255)*/      /* 94/Apr/4 */
2007   if (cur_level == max_quarterword)
2008   {
2009 /* { quit if (cur_level + 1) is too large to store in eqtb } */
2010 /*  overflow("grouping levels", max_quarterword - min_quarterword); */
2011 /*  overflow("grouping levels", 255); */      /* grouping levels - not dynamic */
2012     overflow("grouping levels", max_quarterword - min_quarterword); /* 96/Oct/12 ??? */
2013     return;     // abort_flag set
2014   }
2015 /* cur_boundary <- save_ptr */
2016   cur_boundary = save_ptr;
2017   incr(cur_level);
2018   incr(save_ptr);
2019   cur_group = c;
2020 }
2021 /* sec 0275 */
2022 void eq_destroy_(memory_word w)
2023 {
2024   halfword q;
2025   switch (eq_type_field(w))
2026   {
2027     case call:
2028     case long_call:
2029     case outer_call:
2030     case long_outer_call:
2031       delete_token_ref(equiv_field(w));
2032       break;
2033     case glue_ref:
2034       delete_glue_ref(equiv_field(w));
2035       break;
2036     case shape_ref:
2037       q = equiv_field(w);
2038       if (q != 0)
2039         free_node(q, info(q) + info(q) + 1);
2040       break;
2041     case box_ref:
2042       flush_node_list(equiv_field(w));
2043       break;
2044     default:
2045       break;
2046   }
2047 }
2048 /* sec 0276 */
2049 void eq_save_(halfword p, quarterword l)
2050 {
2051   if (save_ptr > max_save_stack)
2052   {
2053     max_save_stack = save_ptr;
2054 #ifdef ALLOCATESAVESTACK
2055     if (max_save_stack > current_save_size - 6)
2056       save_stack = realloc_save_stack (increment_save_size);
2057     if (max_save_stack > current_save_size - 6)
2058     { /* check again after allocation */
2059       overflow("save size", current_save_size);
2060       return;     // abort_flag set
2061     }
2062 #else
2063     if (max_save_stack > save_size - 6)
2064     { /* save size not dynamic */
2065       overflow("save size", save_size);
2066       return;     // abort_flag set
2067     }
2068 #endif
2069   }
2070   if (l == level_zero)
2071     save_type(save_ptr) = restore_zero;
2072   else
2073   {
2074     save_stack[save_ptr] = eqtb[p];
2075     incr(save_ptr);
2076     save_type(save_ptr) = restore_old_value;
2077   }
2078   save_level(save_ptr) = l;
2079   save_index(save_ptr) = p;
2080   incr(save_ptr);
2081 }
2082 /* sec 0277 */
2083 void eq_define_(halfword p, quarterword t, halfword e)
2084 {
2085   if (eq_level(p) == cur_level)
2086     eq_destroy(eqtb[p]);
2087   else if (cur_level > level_one)
2088     eq_save(p, eq_level(p));
2089   eq_level(p) = (quarterword) cur_level; /* because cur_level padded out */
2090   eq_type(p) = t;
2091   equiv(p) = e;
2092 }
2093 /* sec 0278 */
2094 void eq_word_define_(halfword p, integer w)
2095 {
2096   if (xeq_level[p] != cur_level)
2097   {
2098     eq_save(p, xeq_level[p]);
2099     xeq_level[p] = (quarterword) cur_level; /* because cur_level padded out */
2100   }
2101   eqtb[p].cint = w;
2102 }
2103 /* sec 0279 */
2104 void geq_define_(halfword p, quarterword t, halfword e)
2105 {
2106   eq_destroy(eqtb[p]);
2107   eq_level(p) = level_one;
2108   eq_type(p) = t;
2109   equiv(p) = e;
2110 }
2111 /* sec 0279 */
2112 void geq_word_define_(halfword p, integer w)
2113 {
2114   eqtb[p].cint = w;
2115   xeq_level[p]= 1;
2116 }
2117 /* sec 0280 */
2118 void save_for_after_(halfword t)
2119 {
2120   if (cur_level > 1)
2121   {
2122     if (save_ptr > max_save_stack)
2123     {
2124       max_save_stack = save_ptr;
2125 #ifdef ALLOCATESAVESTACK
2126       if (max_save_stack > current_save_size - 6)
2127         save_stack = realloc_save_stack (increment_save_size);
2128       if (max_save_stack > current_save_size - 6)
2129       { /* check again after allocation */
2130         overflow("save size", current_save_size);
2131         return;     // abort_flag set
2132       }
2133 #else
2134       if (max_save_stack > save_size - 6)
2135       { /* save satck - not dynamic */
2136         overflow("save size", save_size);
2137         return;     // abort_flag set
2138       }
2139 #endif
2140     }
2141     save_type(save_ptr) = insert_token;
2142     save_level(save_ptr) = level_zero;
2143     save_index(save_ptr) = t;
2144     incr(save_ptr);
2145   }
2146 }
2147 /* restore_trace_, unsave followed in the old tex1.c */