src/texsourc/tex1.c

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