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