src/texsourc/tex0.c

   1 /*\r
   2    Copyright 2014 Clerk Ma\r
   3 \r
   4    This program is free software; you can redistribute it and/or modify\r
   5    it under the terms of the GNU General Public License as published by\r
   6    the Free Software Foundation; either version 2 of the License, or\r
   7    (at your option) any later version.\r
   8 \r
   9    This program is distributed in the hope that it will be useful, but\r
  10    WITHOUT ANY WARRANTY; without even the implied warranty of\r
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\r
  12    General Public License for more details.\r
  13 \r
  14    You should have received a copy of the GNU General Public License\r
  15    along with this program; if not, write to the Free Software\r
  16    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA\r
  17    02110-1301 USA.\r
  18 */\r
  19 \r
  20 #define EXTERN extern\r
  21 #include "yandytex.h"\r
  22 \r
  23 /* sec 0058 */\r
  24 void print_ln (void)\r
  25 {\r
  26   switch (selector)\r
  27   {\r
  28     case term_and_log:\r
  29       wterm_cr();\r
  30       term_offset = 0;\r
  31       wlog_cr();\r
  32       file_offset = 0;\r
  33       break;\r
  34 \r
  35     case log_only:\r
  36       wlog_cr();\r
  37       file_offset = 0;\r
  38       break;\r
  39 \r
  40     case term_only:\r
  41       wterm_cr();\r
  42       term_offset = 0;\r
  43       break;\r
  44 \r
  45     case no_print:\r
  46     case pseudo:\r
  47     case new_string:\r
  48       do_nothing();\r
  49       break;\r
  50 \r
  51     default:\r
  52       putc('\n', write_file[selector]);\r
  53       break;\r
  54   }\r
  55 }\r
  56 /* sec 0058 */\r
  57 void print_char_ (ASCII_code s)\r
  58 {\r
  59   if (s == new_line_char)\r
  60     if (selector < pseudo)\r
  61     {\r
  62       print_ln();\r
  63       return;\r
  64     }\r
  65 \r
  66   switch (selector)\r
  67   {\r
  68     case term_and_log:\r
  69       wterm(xchr[s]);\r
  70       incr(term_offset);\r
  71       wlog(xchr[s]);\r
  72       incr(file_offset);\r
  73 \r
  74       if (term_offset == max_print_line)\r
  75       {\r
  76         wterm_cr();\r
  77         term_offset = 0;\r
  78       }\r
  79       \r
  80       if (file_offset == max_print_line)\r
  81       {\r
  82         wlog_cr();\r
  83         file_offset = 0;\r
  84       }\r
  85 \r
  86       break;\r
  87 \r
  88     case log_only:\r
  89       wlog(xchr[s]);\r
  90       incr(file_offset);\r
  91 \r
  92       if (file_offset == max_print_line)\r
  93         print_ln();\r
  94 \r
  95       break;\r
  96 \r
  97     case term_only:\r
  98       wterm(xchr[s]);\r
  99       incr(term_offset);\r
 100 \r
 101       if (term_offset == max_print_line)\r
 102         print_ln();\r
 103 \r
 104       break;\r
 105 \r
 106     case no_print:\r
 107       do_nothing();\r
 108       break;\r
 109 \r
 110     case pseudo:\r
 111       if (tally < trick_count)\r
 112         trick_buf[tally % error_line] = s;\r
 113 \r
 114       break;\r
 115 \r
 116     case new_string:\r
 117 #ifdef ALLOCATESTRING\r
 118       if (pool_ptr + 1 > current_pool_size)\r
 119         str_pool = realloc_str_pool(increment_pool_size);\r
 120       \r
 121       if (pool_ptr < current_pool_size)\r
 122         append_char(s);\r
 123 #else\r
 124       if (pool_ptr < pool_size)\r
 125         append_char(s);\r
 126 #endif\r
 127       break;\r
 128 \r
 129     default:\r
 130       putc(xchr[s], write_file[selector]);\r
 131       break;\r
 132   }\r
 133 \r
 134   incr(tally);\r
 135 }\r
 136 /* sec 0059 */\r
 137 void print_ (integer s)\r
 138 {\r
 139   pool_pointer j;\r
 140   integer nl;\r
 141 \r
 142   if (s >= str_ptr)\r
 143     s = 259; /* ??? */\r
 144   else\r
 145   {\r
 146     if (s < 256)\r
 147     {\r
 148       if (s < 0)\r
 149         s = 259; /* ??? */\r
 150       else\r
 151       {\r
 152         if (selector > pseudo)\r
 153         {\r
 154           print_char(s);\r
 155           return;\r
 156         }\r
 157 \r
 158         if (s == new_line_char)\r
 159           if (selector < pseudo)\r
 160           {\r
 161             print_ln();\r
 162             return;\r
 163           }\r
 164           \r
 165         nl = new_line_char;\r
 166         new_line_char = -1;\r
 167 \r
 168         if (!show_in_hex && s < 256 && s >= 32)\r
 169         {\r
 170           print_char(s);       /* don't translate to hex */\r
 171         }\r
 172         else\r
 173         {                       /* not just a character */\r
 174           j = str_start[s];\r
 175 \r
 176           while (j < str_start[s + 1])\r
 177           {\r
 178             print_char(str_pool[j]);\r
 179             incr(j);\r
 180           }\r
 181         }\r
 182 \r
 183         new_line_char = nl;\r
 184         return;\r
 185       }\r
 186     }\r
 187   }\r
 188 \r
 189   j = str_start[s];\r
 190 \r
 191   while (j < str_start[s + 1])\r
 192   {\r
 193     print_char(str_pool[j]);\r
 194     incr(j);\r
 195   }\r
 196 }\r
 197 /* string version print. */\r
 198 void prints_ (const char * s)\r
 199 {\r
 200   while (*s)\r
 201     print_char(*s++);\r
 202 }\r
 203 /* sec 0060 */\r
 204 void slow_print_ (integer s)\r
 205 {\r
 206   pool_pointer j;\r
 207 \r
 208   if ((s >= str_ptr) || (s < 256))\r
 209     print(s);\r
 210   else\r
 211   {\r
 212     j = str_start[s];\r
 213 \r
 214     while (j < str_start[s + 1])\r
 215     {\r
 216       print(str_pool[j]);\r
 217       incr(j);\r
 218     }\r
 219   }\r
 220 }\r
 221 /* sec 0062 */\r
 222 void print_nl (const char * s)\r
 223 {\r
 224   if (((term_offset > 0) && (odd(selector))) ||\r
 225       ((file_offset > 0) && (selector >= log_only)))\r
 226     print_ln();\r
 227 \r
 228   prints(s);\r
 229 }\r
 230 /* sec 0063 */\r
 231 void print_esc (const char * s)\r
 232 {\r
 233   integer c;\r
 234 \r
 235   c = escape_char;\r
 236 \r
 237   if (c >= 0)\r
 238     if (c < 256)\r
 239       print(c);\r
 240 \r
 241   prints(s);\r
 242 }\r
 243 /* sec 0064 */\r
 244 void print_the_digs (eight_bits k)\r
 245 {\r
 246   while (k > 0)\r
 247   {\r
 248     decr(k);\r
 249 \r
 250     if (dig[k] < 10)\r
 251       print_char('0' + dig[k]);\r
 252     else\r
 253       print_char('A' + dig[k]);\r
 254   }\r
 255 }\r
 256 /* sec 0065 */\r
 257 void print_int_ (integer n)\r
 258 {\r
 259   char k;\r
 260   integer m;\r
 261 \r
 262   k = 0;\r
 263 \r
 264   if (n < 0)\r
 265   {\r
 266     print_char('-');\r
 267 \r
 268     if (n > -100000000L)\r
 269       n = - (integer) n;\r
 270     else\r
 271     {\r
 272       m = -1 - n;\r
 273       n = m / 10;\r
 274       m = (m % 10) + 1;\r
 275       k = 1;\r
 276 \r
 277       if (m < 10)\r
 278         dig[0] = (char) m;\r
 279       else\r
 280       {\r
 281         dig[0] = 0;\r
 282         incr(n);\r
 283       }\r
 284     }\r
 285   }\r
 286 \r
 287   do\r
 288     {\r
 289       dig[k] = (char) (n % 10);\r
 290       n = n / 10;\r
 291       incr(k);\r
 292     }\r
 293   while (!(n == 0));\r
 294 \r
 295   print_the_digs(k);\r
 296 }\r
 297 /* sec 0262 */\r
 298 void print_cs_ (integer p)\r
 299 {\r
 300   if (p < hash_base)\r
 301     if (p >= single_base)\r
 302       if (p == null_cs)\r
 303       {\r
 304         print_esc("csname");\r
 305         print_esc("endcsname");\r
 306         print_char(' ');\r
 307       }\r
 308       else\r
 309       {\r
 310         print_esc(""); print(p - single_base);\r
 311 \r
 312         if (cat_code(p - single_base) == letter)\r
 313           print_char(' ');\r
 314       }\r
 315     else if (p < active_base)\r
 316       print_esc("IMPOSSIBLE.");\r
 317     else\r
 318       print(p - active_base);\r
 319   else if (p >= undefined_control_sequence)\r
 320     print_esc("IMPOSSIBLE.");\r
 321   else if ((text(p) >= str_ptr))\r
 322     print_esc("NONEXISTENT.");\r
 323   else\r
 324   {\r
 325     print_esc("");\r
 326     print(text(p));\r
 327     print_char(' ');\r
 328   }\r
 329 }\r
 330 /* sec 0263 */\r
 331 void sprint_cs (pointer p)\r
 332 { \r
 333   if (p < hash_base)\r
 334     if (p < single_base)\r
 335       print(p - active_base);\r
 336     else if (p < null_cs)\r
 337     {\r
 338       print_esc("");\r
 339       print(p - single_base);\r
 340     }\r
 341     else\r
 342     {\r
 343       print_esc("csname");\r
 344       print_esc("endcsname");\r
 345     }\r
 346   else\r
 347   {\r
 348     print_esc(""); print(text(p));\r
 349   }\r
 350 }\r
 351 /* sec 0518 */\r
 352 void print_file_name (integer n, integer a, integer e)\r
 353 {\r
 354   slow_print(a);\r
 355   slow_print(n);\r
 356   slow_print(e);\r
 357 }\r
 358 /* sec 0699 */\r
 359 void print_size (integer s)\r
 360 { \r
 361   if (s == 0)\r
 362     print_esc("textfont");\r
 363   else if (s == 16)\r
 364     print_esc("scriptfont");\r
 365   else\r
 366     print_esc("scriptscriptfont");\r
 367 } \r
 368 /* sec 1355 */\r
 369 void print_write_whatsit_(const char * s, pointer p)\r
 370 {\r
 371   print_esc(s);\r
 372 \r
 373   if (write_stream(p) < 16)\r
 374     print_int(write_stream(p)); \r
 375   else if (write_stream(p) == 16)\r
 376     print_char('*');\r
 377   else\r
 378     print_char('-');\r
 379 }\r
 380 /* sec 0081 */\r
 381 void jump_out (void) \r
 382 {\r
 383   close_files_and_terminate();\r
 384 \r
 385   {\r
 386     int code;\r
 387 \r
 388     fflush(stdout); \r
 389     ready_already = 0;\r
 390 \r
 391     if (trace_flag)\r
 392       puts("EXITING at JUMPOUT");\r
 393 \r
 394     if ((history != spotless) && (history != warning_issued))\r
 395       code = 1;\r
 396     else\r
 397       code = 0;\r
 398 \r
 399     uexit(code);\r
 400   }\r
 401 }\r
 402 /* sec 0082 */\r
 403 void error (void)\r
 404 {\r
 405   ASCII_code c;\r
 406   integer s1, s2, s3, s4;\r
 407 \r
 408   if (history < error_message_issued)\r
 409     history = error_message_issued;\r
 410 \r
 411   print_char('.');\r
 412   show_context();\r
 413 \r
 414   if (interaction == error_stop_mode)\r
 415     while (true)\r
 416     {\r
 417 continu:\r
 418       clear_for_error_prompt();\r
 419       prompt_input("? ");\r
 420 \r
 421       if (last == first)\r
 422         return; // no input\r
 423 \r
 424       c = buffer[first];\r
 425 \r
 426       if (c >= 'a')\r
 427         c = (c + 'A' - 'a'); \r
 428 \r
 429       switch (c)\r
 430       {\r
 431         case '0':\r
 432         case '1':\r
 433         case '2':\r
 434         case '3':\r
 435         case '4':\r
 436         case '5':\r
 437         case '6':\r
 438         case '7':\r
 439         case '8':\r
 440         case '9':\r
 441           if (deletions_allowed)\r
 442           {\r
 443             s1 = cur_tok;\r
 444             s2 = cur_cmd;\r
 445             s3 = cur_chr;\r
 446             s4 = align_state;\r
 447             align_state = 1000000L;\r
 448             OK_to_interrupt = false;\r
 449 \r
 450             if ((last > first + 1) && (buffer[first + 1] >= '0') && (buffer[first + 1] <= '9'))\r
 451               c = (c * 10 + buffer[first + 1] - '0' * 11);\r
 452             else\r
 453               c = (c - 48);\r
 454             \r
 455             while (c > 0)\r
 456             {\r
 457               get_token();\r
 458               decr(c);\r
 459             }\r
 460 \r
 461             cur_tok = s1;\r
 462             cur_cmd = s2;\r
 463             cur_chr = s3;\r
 464             align_state = s4;\r
 465             OK_to_interrupt = true;\r
 466             help2("I have just deleted some text, as you asked.",\r
 467                 "You can now delete more, or insert, or whatever.");\r
 468             show_context();\r
 469             goto continu;\r
 470           }\r
 471           break;\r
 472 \r
 473 #ifdef DEBUG\r
 474         case 'D':\r
 475           {\r
 476             debug_help();\r
 477             goto continu;\r
 478           }\r
 479           break;\r
 480 #endif\r
 481 \r
 482         case 'E':\r
 483           if (base_ptr > 0)\r
 484           {\r
 485             edit_name_start = str_start[input_stack[base_ptr].name_field];\r
 486             edit_name_length = length(input_stack[base_ptr].name_field);\r
 487             edit_line = line;\r
 488             jump_out();\r
 489           }\r
 490           break;\r
 491 \r
 492         case 'H':\r
 493           {\r
 494             if (use_err_help)\r
 495             {\r
 496               give_err_help();\r
 497               use_err_help = false;\r
 498             }\r
 499             else\r
 500             {\r
 501               if (help_ptr == 0)\r
 502                 help2("Sorry, I don't know how to help in this situation.",\r
 503                     "Maybe you should try asking a human?");\r
 504               do\r
 505                 {\r
 506                   decr(help_ptr);\r
 507                   prints(help_line[help_ptr]);\r
 508                   print_ln();\r
 509                 }\r
 510               while (!(help_ptr == 0));\r
 511             }\r
 512 \r
 513             help4("Sorry, I already gave what help I could...",\r
 514                 "Maybe you should try asking a human?",\r
 515                 "An error might have occurred before I noticed any problems.",\r
 516                 "``If all else fails, read the instructions.''");\r
 517             goto continu;\r
 518           }\r
 519           break;\r
 520 \r
 521         case 'I':\r
 522           {\r
 523             begin_file_reading();\r
 524 \r
 525             if (last > first + 1)\r
 526             {\r
 527               loc = first + 1;\r
 528               buffer[first] = ' ';\r
 529             }\r
 530             else\r
 531             {\r
 532               prompt_input("insert>");\r
 533               loc = first;\r
 534             }\r
 535 \r
 536             first = last;\r
 537             limit = last - 1;\r
 538 \r
 539             return;\r
 540           }\r
 541           break;\r
 542 \r
 543         case 'Q':\r
 544         case 'R':\r
 545         case 'S':\r
 546           {\r
 547             error_count = 0; \r
 548             interaction = 0 + c - 'Q';\r
 549             prints("OK, entering ");\r
 550 \r
 551             switch (c)\r
 552             {\r
 553               case 'Q':\r
 554                 print_esc("batchmode");\r
 555                 decr(selector);\r
 556                 break;\r
 557 \r
 558               case 'R':\r
 559                 print_esc("nonstopmode");\r
 560                 break;\r
 561 \r
 562               case 'S':\r
 563                 print_esc("scrollmode");\r
 564                 break;\r
 565             }\r
 566 \r
 567             prints("...");\r
 568             print_ln();\r
 569             update_terminal();\r
 570             return;\r
 571           }\r
 572           break;\r
 573 \r
 574         case 'X':\r
 575           {\r
 576             interaction = scroll_mode;\r
 577             jump_out();\r
 578           }\r
 579           break;\r
 580 \r
 581         default:\r
 582           break;\r
 583       }\r
 584 \r
 585       {\r
 586         prints("Type <return> to proceed, S to scroll future error messages,");\r
 587         print_nl("R to run without stopping, Q to run quietly,");\r
 588         print_nl("I to insert something, ");\r
 589 \r
 590         if (base_ptr > 0)\r
 591           prints("E to edit your file,");\r
 592 \r
 593         if (deletions_allowed)\r
 594           print_nl("1 or ... or 9 to ignore the next 1 to 9 tokens of input,");\r
 595 \r
 596         print_nl("H for help, X to quit.");\r
 597       }\r
 598     }\r
 599 \r
 600   incr(error_count);\r
 601 \r
 602   if (error_count == 100)\r
 603   {\r
 604     print_nl("(That makes 100 errors; please try again.)");\r
 605     history = fatal_error_stop;\r
 606     jump_out();\r
 607   }\r
 608 \r
 609   if (interaction > batch_mode)\r
 610     decr(selector);\r
 611 \r
 612   if (use_err_help)\r
 613   {\r
 614     print_ln();\r
 615     give_err_help();\r
 616   }\r
 617   else while (help_ptr > 0)\r
 618   {\r
 619     decr(help_ptr);\r
 620     print_nl(help_line[help_ptr]);\r
 621   }\r
 622 \r
 623   print_ln();\r
 624 \r
 625   if (interaction > batch_mode)\r
 626     incr(selector);\r
 627   \r
 628   print_ln();\r
 629 }\r
 630 /* sec 0093 */\r
 631 void fatal_error (const char * s)\r
 632 {\r
 633   normalize_selector();\r
 634   print_err("Emergency stop");\r
 635   help1(s);\r
 636   succumb();\r
 637 }\r
 638 /* sec 0094 */\r
 639 void overflow_(const char * s, integer n)\r
 640 {\r
 641   normalize_selector();\r
 642   print_err("TeX capacity exceeded, sorry [");\r
 643   prints(s);\r
 644   print_char('=');\r
 645   print_int(n);\r
 646   print_char(']');\r
 647   help2("If you really absolutely need more capacity,",\r
 648       "you can ask a wizard to enlarge me.");\r
 649 \r
 650   if (!knuth_flag)\r
 651   {\r
 652     if (!strcmp(s, "pattern memory") && (n == trie_size))\r
 653       printf("\n  (Maybe use -h=... on command line in initex)\n");\r
 654     else if (!strcmp(s, "exception dictionary") && (n == hyphen_prime))\r
 655       printf("\n  (Maybe use -e=... on command line in initex)\n");\r
 656   }\r
 657 \r
 658   succumb();\r
 659 }\r
 660 /* sec 0095 */\r
 661 void confusion (const char * s)\r
 662 {\r
 663   normalize_selector();\r
 664 \r
 665   if (history < error_message_issued)\r
 666   {\r
 667     print_err("This can't happen (");\r
 668     prints(s);\r
 669     print_char(')');\r
 670     help1("I'm broken. Please show this to someone who can fix can fix");\r
 671   }\r
 672   else\r
 673   {\r
 674     print_err("I can't go on meeting you like this");\r
 675     help2("One of your faux pas seems to have wounded me deeply...",\r
 676         "in fact, I'm barely conscious. Please fix it and try again.");\r
 677   }\r
 678 \r
 679   succumb();\r
 680 }\r
 681 /* sec 0037 */\r
 682 boolean init_terminal (void)\r
 683 {\r
 684   boolean flag;\r
 685 \r
 686   t_open_in();\r
 687 \r
 688   if (last > first)\r
 689   {\r
 690     loc = first;\r
 691 \r
 692     while ((loc < last) && (buffer[loc]== ' '))\r
 693       incr(loc);\r
 694 \r
 695     if (loc < last)\r
 696       return true;\r
 697   }\r
 698 \r
 699 // failed to find input file name\r
 700   while (true)\r
 701   {\r
 702     wake_up_terminal();\r
 703     fputs("**", stdout);\r
 704     update_terminal();\r
 705     flag = input_ln(stdin, true);\r
 706 \r
 707     if (!flag)\r
 708     {\r
 709       wterm_cr();\r
 710       puts("! End of file on the terminal... why?\n");\r
 711       return false;\r
 712     }\r
 713 \r
 714     loc = first;\r
 715 \r
 716     while ((loc < last) && (buffer[loc]== ' '))\r
 717       incr(loc);    // step over intial white space\r
 718 \r
 719     if (loc < last)\r
 720       return true;\r
 721 \r
 722     printf("%s\n", "Please type the name of your input file.");\r
 723   }\r
 724 }\r
 725 /* sec 0043 */\r
 726 str_number make_string (void)\r
 727 {\r
 728 #ifdef ALLOCATESTRING\r
 729   if (str_ptr == current_max_strings)\r
 730     str_start = realloc_str_start(increment_max_strings);\r
 731 \r
 732   if (str_ptr == current_max_strings)\r
 733   {\r
 734     overflow("number of strings", current_max_strings - init_str_ptr);\r
 735     return 0;\r
 736   }\r
 737 #else\r
 738   if (str_ptr == max_strings)\r
 739   {\r
 740     overflow("number of strings", max_strings - init_str_ptr);\r
 741     return 0;\r
 742   }\r
 743 #endif\r
 744 \r
 745   incr(str_ptr);\r
 746   str_start[str_ptr] = pool_ptr;\r
 747 \r
 748   return (str_ptr - 1);\r
 749 }\r
 750 /* sec 0044 */\r
 751 boolean str_eq_buf_ (str_number s, integer k)\r
 752 {\r
 753   pool_pointer j;\r
 754   boolean result;\r
 755 \r
 756   j = str_start[s];\r
 757 \r
 758   while (j < str_start[s + 1])\r
 759   {\r
 760     if (str_pool[j] != buffer[k])\r
 761     {\r
 762       result = false;\r
 763       goto not_found;\r
 764     }\r
 765 \r
 766     incr(j);\r
 767     incr(k);\r
 768   }\r
 769 \r
 770   result = true;\r
 771 \r
 772 not_found:\r
 773   return result;\r
 774 }\r
 775 /* sec 0045 */\r
 776 boolean str_eq_str_ (str_number s, str_number t)\r
 777 {\r
 778   pool_pointer j, k;\r
 779   boolean result;\r
 780 \r
 781   result = false;\r
 782 \r
 783   if (length(s) != length(t))\r
 784     goto not_found;\r
 785 \r
 786   j = str_start[s];\r
 787   k = str_start[t];\r
 788 \r
 789   while (j < str_start[s + 1])\r
 790   {\r
 791     if (str_pool[j] != str_pool[k])\r
 792       goto not_found;\r
 793 \r
 794     incr(j);\r
 795     incr(k);\r
 796   }\r
 797 \r
 798   result = true;\r
 799 \r
 800 not_found:\r
 801   return result;\r
 802 }\r
 803 /* sec 0066 */\r
 804 void print_two_(integer n)\r
 805 { \r
 806   n = abs(n) % 100;\r
 807   print_char('0' + (n / 10));\r
 808   print_char('0' + (n % 10));\r
 809 } \r
 810 /* sec 0067 */\r
 811 void print_hex_(integer n)\r
 812 {\r
 813   char k;\r
 814 \r
 815   k = 0;\r
 816   print_char('"');\r
 817 \r
 818   do\r
 819     {\r
 820       dig[k] = (unsigned char) (n % 16);\r
 821       n = n / 16;\r
 822       incr(k);\r
 823     }\r
 824   while (!(n == 0));\r
 825 \r
 826   print_the_digs(k);\r
 827 }\r
 828 /* sec 0069 */\r
 829 void print_roman_int_(integer n)\r
 830 {\r
 831   pool_pointer j, k;\r
 832   nonnegative_integer u, v;\r
 833 \r
 834   j = str_start[260]; /* m2d5c2l5x2v5i */\r
 835   v = 1000;\r
 836 \r
 837   while (true)\r
 838   {\r
 839     while (n >= v)\r
 840     {\r
 841       print_char(str_pool[j]);\r
 842       n = n - v;\r
 843     }\r
 844 \r
 845     if (n <= 0)\r
 846       return;\r
 847 \r
 848     k = j + 2;\r
 849     u = v / (str_pool[k - 1] - '0');\r
 850 \r
 851     if (str_pool[k - 1] == 50)\r
 852     {\r
 853       k = k + 2;\r
 854       u = u / (str_pool[k - 1] - '0');\r
 855     }\r
 856 \r
 857     if (n + u >= v)\r
 858     {\r
 859       print_char(str_pool[k]);\r
 860       n = n + u;\r
 861     }\r
 862     else\r
 863     {\r
 864       j = j + 2;\r
 865       v = v / (str_pool[j - 1] - '0');\r
 866     }\r
 867   }\r
 868 }\r
 869 /* sec 0070 */\r
 870 void print_current_string (void)\r
 871 {\r
 872   pool_pointer j;\r
 873 \r
 874   j = str_start[str_ptr];\r
 875 \r
 876   while (j < pool_ptr)\r
 877   {\r
 878     print_char(str_pool[j]);\r
 879     incr(j);\r
 880   }\r
 881 }\r
 882 \r
 883 /* sec 0071 */\r
 884 void term_input (void)\r
 885 { \r
 886   integer k;\r
 887   \r
 888   if (!knuth_flag)\r
 889     show_line("\n", 0);\r
 890 \r
 891   update_terminal();\r
 892 \r
 893   if (!input_ln(stdin, true))\r
 894   {\r
 895     fatal_error("End of file on the terminal!");\r
 896     return;\r
 897   }\r
 898 \r
 899   term_offset = 0;\r
 900   decr(selector);\r
 901 \r
 902   if (last != first)\r
 903     for (k = first; k <= last - 1; k++)\r
 904       print(buffer[k]);\r
 905 \r
 906   print_ln();\r
 907   incr(selector);\r
 908 }\r
 909 /* sec 0091 */\r
 910 void int_error_ (integer n)\r
 911 {\r
 912   prints(" (");\r
 913   print_int(n);\r
 914   print_char(')');\r
 915   error();\r
 916 }\r
 917 /* sec 0092 */\r
 918 void normalize_selector (void)\r
 919 {\r
 920   if (log_opened)\r
 921     selector = term_and_log;\r
 922   else\r
 923     selector = term_only;\r
 924 \r
 925   if (job_name == 0)\r
 926     open_log_file();\r
 927 \r
 928   if (interaction == batch_mode)\r
 929     decr(selector);\r
 930 }\r
 931 /* sec 0098 */\r
 932 void pause_for_instructions (void)\r
 933 {\r
 934   if (OK_to_interrupt)\r
 935   {\r
 936     interaction = error_stop_mode;\r
 937 \r
 938     if ((selector == log_only) || (selector == no_print))\r
 939       incr(selector);\r
 940 \r
 941     print_err("Interruption");\r
 942     help3("You rang?",\r
 943         "Try to insert some instructions for me (e.g.,`I\\showlists'),",\r
 944         "unless you just want to quit by typing `X'.");\r
 945     deletions_allowed = false;\r
 946     error();\r
 947     deletions_allowed = true;\r
 948     interrupt = 0;\r
 949   }\r
 950 }\r
 951 /* sec 0100 */\r
 952 integer half_(integer x)\r
 953 {\r
 954   if (odd(x))\r
 955     return ((x + 1) / 2);\r
 956   else\r
 957     return (x / 2);\r
 958 }\r
 959 /* sec 0102 */\r
 960 scaled round_decimals_(small_number k)\r
 961 {\r
 962   integer a;\r
 963 \r
 964   a = 0;\r
 965 \r
 966   while (k > 0)\r
 967   {\r
 968     decr(k);\r
 969     a = (a + dig[k] * 131072L) / 10; /* 2^17 */\r
 970   }\r
 971   \r
 972   return ((a + 1) / 2);\r
 973 }\r
 974 /* sec 0103 */\r
 975 void print_scaled_(scaled s)\r
 976 {\r
 977   scaled delta;\r
 978 \r
 979   if (s < 0)\r
 980   {\r
 981     print_char('-');\r
 982     s = - (integer) s;\r
 983   }\r
 984 \r
 985   print_int(s / 65536L);\r
 986   print_char('.');\r
 987   s = 10 * (s % 65536L) + 5;\r
 988   delta = 10;\r
 989 \r
 990   do\r
 991     {\r
 992       if (delta > 65536L)\r
 993         s = s - 17232; /* 2^15 - 50000 - rounding */\r
 994 \r
 995       print_char('0' + (s / 65536L));\r
 996       s = 10 * (s % 65536L);\r
 997       delta = delta * 10;\r
 998     }\r
 999   while (!(s <= delta));\r
1000 }\r
1001 /* sec 0105 */\r
1002 scaled mult_and_add_(integer n, scaled x, scaled y, scaled max_answer)\r
1003 {\r
1004   if (n < 0)\r
1005   {\r
1006     x = - (integer) x;\r
1007     n = - (integer) n;\r
1008   }\r
1009 \r
1010   if (n == 0)\r
1011     return y;\r
1012   else if (((x <= (max_answer - y) / n) && (- (integer) x <= (max_answer + y) / n)))\r
1013     return (n * x + y); \r
1014   else\r
1015   {\r
1016     arith_error = true;\r
1017     return 0;\r
1018   }\r
1019 }\r
1020 /* sec 0106 */\r
1021 scaled x_over_n_(scaled x, integer n)\r
1022 {\r
1023   register scaled Result;\r
1024   boolean negative;\r
1025 \r
1026   negative = false;\r
1027 \r
1028   if (n == 0)\r
1029   {\r
1030     arith_error = true;\r
1031     Result = 0;\r
1032     tex_remainder = x;\r
1033   }\r
1034   else\r
1035   {\r
1036     if (n < 0)\r
1037     {\r
1038       x = - (integer) x;\r
1039       n = - (integer) n;\r
1040       negative = true;\r
1041     }\r
1042 \r
1043     if (x >= 0)\r
1044     {\r
1045       Result = x / n;\r
1046       tex_remainder = x % n;\r
1047     }\r
1048     else\r
1049     {\r
1050       Result = - (integer) ((- (integer) x) / n);\r
1051       tex_remainder = - (integer) ((- (integer) x) % n);\r
1052     }\r
1053   }\r
1054 \r
1055   if (negative)\r
1056     tex_remainder = - (integer) tex_remainder;\r
1057 \r
1058   return Result;\r
1059 }\r
1060 /* sec 0107 */\r
1061 scaled xn_over_d_(scaled x, integer n, integer d)\r
1062 {\r
1063   register scaled Result;\r
1064   boolean positive;\r
1065   nonnegative_integer t, u, v;\r
1066 \r
1067   if (x >= 0)\r
1068     positive = true; \r
1069   else\r
1070   {\r
1071     x = - (integer) x;\r
1072     positive = false;\r
1073   }\r
1074 \r
1075   t = (x % 32767L) * n;\r
1076   u = (x / 32768L) * n + (t / 32768L);\r
1077   v = (u % d) * 32768L + (t % 32768L); \r
1078 \r
1079   if (u / d >= 32768L)\r
1080     arith_error = true; \r
1081   else\r
1082     u = 32768L * (u / d) + (v / d);\r
1083 \r
1084   if (positive)\r
1085   {\r
1086     Result = u;\r
1087     tex_remainder = v % d;\r
1088   }\r
1089   else\r
1090   {\r
1091     Result = - (integer) u;\r
1092     tex_remainder = - (integer)(v % d);\r
1093   }\r
1094 \r
1095   return Result;\r
1096 }\r
1097 /* sec 0108 */\r
1098 halfword badness_(scaled t, scaled s)\r
1099 {\r
1100   integer r;\r
1101 \r
1102   if (t == 0)\r
1103     return 0;\r
1104   else if (s <= 0)\r
1105     return 10000;\r
1106   else\r
1107   {\r
1108     if (t <= 7230584L)\r
1109       r = (t * 297) / s;\r
1110     else if (s >= 1663497L)\r
1111       r = t / (s / 297);\r
1112     else\r
1113       r = t;\r
1114 \r
1115     if (r > 1290)\r
1116       return 10000; \r
1117     else\r
1118       return (r * r * r + 131072L) / 262144L;  /* 2^17 */\r
1119   }\r
1120 }\r
1121 /* sec 0114 */\r
1122 #ifdef DEBUG\r
1123 void print_word (memory_word w)\r
1124 { \r
1125   print_int(w.cint); \r
1126   print_char(' ');\r
1127   print_scaled(w.cint); \r
1128   print_char(' ');\r
1129   print_scaled(round(unity * w.gr));\r
1130   print_ln();\r
1131   print_int(w.hh.lh);\r
1132   print_char('=');\r
1133   print_int(w.hh.b0);\r
1134   print_char(':');\r
1135   print_int(w.hh.b1);\r
1136   print_char(';');\r
1137   print_int(w.hh.rh);\r
1138   print_char(' ');\r
1139   print_int(w.qqqq.b0); \r
1140   print_char(':');\r
1141   print_int(w.qqqq.b1); \r
1142   print_char(':');\r
1143   print_int(w.qqqq.b2); \r
1144   print_char(':');\r
1145   print_int(w.qqqq.b3);\r
1146 }\r
1147 #endif\r
1148 /* sec 0292 */\r
1149 void show_token_list_(integer p, integer q, integer l)\r
1150 {\r
1151   integer m, c;\r
1152   ASCII_code match_chr;\r
1153   ASCII_code n;\r
1154 \r
1155   match_chr = '#';\r
1156   n = '0';\r
1157   tally = 0;\r
1158 \r
1159   while ((p != 0) && (tally < l))\r
1160   {\r
1161     if (p == q)\r
1162     {\r
1163       first_count = tally;\r
1164       trick_count = tally + 1 + error_line - half_error_line;\r
1165 \r
1166       if (trick_count < error_line)\r
1167         trick_count = error_line;\r
1168     }\r
1169 \r
1170     if ((p < hi_mem_min) || (p > mem_end))\r
1171     {\r
1172       print_esc("CLOBBERED.");\r
1173       return;\r
1174     }\r
1175 \r
1176     if (info(p) >= cs_token_flag)\r
1177       print_cs(info(p) - cs_token_flag);\r
1178     else\r
1179     {\r
1180       m = info(p) / 256;\r
1181       c = info(p) % 256;\r
1182 \r
1183       if (info(p) < 0)\r
1184         print_esc("BAD.");\r
1185       else switch (m)\r
1186       {\r
1187         case left_brace:\r
1188         case right_brace:\r
1189         case math_shift:\r
1190         case tab_mark:\r
1191         case sup_mark:\r
1192         case sub_mark:\r
1193         case spacer:\r
1194         case letter:\r
1195         case other_char:\r
1196           print(c);\r
1197           break;\r
1198         \r
1199         case mac_param:\r
1200           print(c);\r
1201           print(c);\r
1202           break;\r
1203         \r
1204         case out_param:\r
1205           print(match_chr);\r
1206           \r
1207           if (c <= 9)\r
1208             print_char(c + '0');\r
1209           else\r
1210           {\r
1211             print_char('!');\r
1212             return;\r
1213           }\r
1214           break;\r
1215         \r
1216         case match:\r
1217           match_chr = (ASCII_code) c;\r
1218           print(c);\r
1219           incr(n);\r
1220           print_char(n);\r
1221           \r
1222           if (n > '9')\r
1223             return;\r
1224           break;\r
1225         \r
1226         case end_match:\r
1227           prints("->");\r
1228           break;\r
1229         \r
1230         default:\r
1231           print_esc("BAD.");\r
1232           break;\r
1233       }\r
1234     }\r
1235 \r
1236     p = link(p);\r
1237   }\r
1238 \r
1239   if (p != 0)\r
1240     print_esc("ETC.");\r
1241 }\r
1242 /* sec 0306 */\r
1243 void runaway (void)\r
1244 {\r
1245   pointer p;\r
1246 \r
1247   if (scanner_status > skipping)\r
1248   {\r
1249     print_nl("Runaway ");\r
1250 \r
1251     switch (scanner_status)\r
1252     {\r
1253       case defining:\r
1254         prints("definition");\r
1255         p = def_ref;\r
1256         break;\r
1257 \r
1258       case matching:\r
1259         prints("argument");\r
1260         p = temp_head;\r
1261         break;\r
1262 \r
1263       case aligning:\r
1264         prints("preamble");\r
1265         p = hold_head;\r
1266         break;\r
1267 \r
1268       case absorbing:\r
1269         prints("text");\r
1270         p = def_ref;\r
1271         break;\r
1272     }\r
1273 \r
1274     print_char('?');\r
1275     print_ln();\r
1276     show_token_list(link(p), 0, error_line - 10); \r
1277   }\r
1278 }\r
1279 /* sec 0120 */\r
1280 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */\r
1281 /* first try list of available nodes (avail != NULL)                   */\r
1282 /* then see if can go upwards (mem_end < mem_max)                      */\r
1283 /* then see if can go downwards (hi_mem_min > lo_mem_max)              */\r
1284 /* if not, extend memory at the top and grab from there --- new        */\r
1285 /* else fail ! paragraph 120                                           */\r
1286 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */\r
1287 pointer get_avail (void)\r
1288 {\r
1289   pointer p;\r
1290 \r
1291   p = avail;\r
1292 \r
1293   if (p != 0)\r
1294     avail = link(avail);\r
1295   else if (mem_end < mem_max)\r
1296   {\r
1297     incr(mem_end);\r
1298     p = mem_end;\r
1299   }\r
1300   else\r
1301   {\r
1302     decr(hi_mem_min);\r
1303     p = hi_mem_min;\r
1304 \r
1305     if (hi_mem_min <= lo_mem_max) /* have we run out in middle ? */\r
1306     {\r
1307       incr(hi_mem_min);\r
1308       mem = realloc_main (0, mem_top / 2);  /* zzzaa = zmem = mem */\r
1309 \r
1310       if (mem == NULL)\r
1311         return 0;\r
1312 \r
1313       if (mem_end >= mem_max)\r
1314       {\r
1315         runaway();\r
1316         overflow("main memory size", mem_max + 1 - mem_min);\r
1317         return 0;\r
1318       }\r
1319 \r
1320       incr(mem_end);        /* then grab from new area */\r
1321       p = mem_end;          /* 1993/Dec/14 */\r
1322     }\r
1323   }\r
1324 \r
1325   link(p) = 0;       /* link(p) = null !!! */\r
1326 \r
1327 #ifdef STAT\r
1328   incr(dyn_used); \r
1329 #endif\r
1330 \r
1331   return p; \r
1332 } \r
1333 /* sec 0123 */\r
1334 void flush_list_(pointer p)\r
1335 { \r
1336   pointer q, r;\r
1337 \r
1338   if (p != 0)\r
1339   {\r
1340     r = p;\r
1341 \r
1342     do\r
1343       {\r
1344         q = r;\r
1345         r = link(r);\r
1346 #ifdef STAT\r
1347         decr(dyn_used);\r
1348 #endif\r
1349       }\r
1350     while (!(r == 0));\r
1351 \r
1352     link(q) = avail;\r
1353     avail = p;\r
1354   }\r
1355 }\r
1356 /* sec 0125 */\r
1357 pointer get_node (integer s)\r
1358 {\r
1359   pointer p;\r
1360   pointer q;\r
1361   integer r;\r
1362   integer t;\r
1363 \r
1364 restart:\r
1365   p = rover;\r
1366 \r
1367   do\r
1368     {\r
1369       q = p + node_size(p);\r
1370 \r
1371       while (is_empty(q))\r
1372       {\r
1373         t = rlink(q);\r
1374 \r
1375         if (q == rover)\r
1376           rover = t;\r
1377 \r
1378         llink(t) = llink(q);\r
1379         rlink(llink(q)) = t;\r
1380         q = q + node_size(q);\r
1381       }\r
1382 \r
1383       r = q - s;\r
1384 \r
1385       if (r > toint(p + 1)) \r
1386       {\r
1387         node_size(p) = r - p;\r
1388         rover = p;\r
1389         goto found;\r
1390       }\r
1391 \r
1392       if (r == p)\r
1393         if (rlink(p) != p)\r
1394         {\r
1395           rover = rlink(p);\r
1396           t = llink(p);\r
1397           llink(rover) = t;\r
1398           rlink(t) = rover;\r
1399           goto found;\r
1400         }\r
1401 \r
1402       node_size(p) = q - p;\r
1403       p = rlink(p);\r
1404     }\r
1405   while (!(p == rover));\r
1406 \r
1407   if (s == 1073741824L)    /* 2^30 - special case - merge adjacent */\r
1408   {\r
1409     if (trace_flag)\r
1410       puts("Merged adjacent multi-word nodes");\r
1411 \r
1412     return max_halfword;\r
1413   }\r
1414 \r
1415 /*  maybe try downward epxansion first instead ? */\r
1416   if (lo_mem_max + 2 < hi_mem_min)\r
1417     if (lo_mem_max + 2 <= mem_bot + max_halfword)  /* silly ? flush 93/Dec/16 */\r
1418     {\r
1419       if (hi_mem_min - lo_mem_max >= (block_size + block_size - 2))\r
1420         t = lo_mem_max + block_size;\r
1421       else\r
1422         t = lo_mem_max + 1 + (hi_mem_min - lo_mem_max) / 2;\r
1423 \r
1424       p = llink(rover);\r
1425       q = lo_mem_max;\r
1426       rlink(p) = q;\r
1427       llink(rover) = q;\r
1428 \r
1429       if (t > mem_bot + max_halfword)\r
1430         t = mem_bot + max_halfword;     /* silly ? flush 93/Dec/16 */\r
1431 \r
1432       rlink(q) = rover;\r
1433       llink(q) = p;\r
1434       link(q) = empty_flag;\r
1435       node_size(q) = t - lo_mem_max; /* block size */\r
1436       lo_mem_max = t;\r
1437       link(lo_mem_max) = 0;\r
1438       info(lo_mem_max) = 0;\r
1439       rover = q;\r
1440       goto restart;\r
1441     }\r
1442 \r
1443 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */\r
1444 /* we've run out of space in the middle for variable length blocks */\r
1445 /* try and add new block from below mem_bot *//* first check if space ! */\r
1446   if (mem_min - (block_size + 1) <= mem_start) /* extend lower memory downwards */\r
1447   {\r
1448     mem = realloc_main (mem_top / 2 + block_size, 0);  /* zzzaa = zmem = mem */\r
1449 \r
1450     if (mem == NULL)\r
1451     {\r
1452       return 0;\r
1453     }\r
1454   }\r
1455 \r
1456   if (mem_min - (block_size + 1) <= mem_start) /* check again */\r
1457   {\r
1458     if (trace_flag)\r
1459       printf("mem_min %lld, mem_start %d, block_size %d\n", mem_min, mem_start, block_size);\r
1460 \r
1461     overflow("main memory size", mem_max + 1 - mem_min); /* darn: allocation failed ! */\r
1462     return 0;\r
1463   }\r
1464 \r
1465   add_variable_space(block_size);\r
1466   goto restart; /* go try get_node again */\r
1467 \r
1468 found:\r
1469   link(r) = 0;\r
1470 \r
1471 #ifdef STAT\r
1472   var_used = var_used + s; \r
1473 #endif\r
1474 \r
1475   return r; \r
1476 } \r
1477 /* sec 0130 */\r
1478 void free_node (pointer p, halfword s)\r
1479 { \r
1480   pointer q;\r
1481 \r
1482   node_size(p) = s;\r
1483   link(p) = empty_flag;\r
1484   q = llink(rover);\r
1485   llink(p) = q;\r
1486   rlink(p) = rover;\r
1487   llink(rover) = p;\r
1488   rlink(q) = p;\r
1489 \r
1490 #ifdef STAT\r
1491   var_used = var_used - s; \r
1492 #endif\r
1493 }\r
1494 /* sec 0136 */\r
1495 pointer new_null_box (void) \r
1496 {\r
1497   pointer p;\r
1498 \r
1499   p = get_node(box_node_size);\r
1500   type(p) = hlist_node;\r
1501   subtype(p) = min_quarterword;\r
1502   width(p) = 0;\r
1503   depth(p) = 0;\r
1504   height(p) = 0;\r
1505   shift_amount(p) = 0;\r
1506   list_ptr(p) = 0;\r
1507   glue_sign(p) = normal;\r
1508   glue_order(p) = normal;\r
1509   glue_set(p) = 0.0;\r
1510 \r
1511   return p;\r
1512 }\r
1513 /* sec 0139 */\r
1514 pointer new_rule (void) \r
1515 {\r
1516   pointer p;\r
1517 \r
1518   p = get_node(rule_node_size);\r
1519   type(p) = rule_node;\r
1520   subtype(p) = 0;\r
1521   width(p) = null_flag;\r
1522   depth(p) = null_flag;\r
1523   height(p) = null_flag;\r
1524 \r
1525   return p;\r
1526 }\r
1527 /* sec 0144 */\r
1528 pointer new_ligature_(quarterword f, quarterword c, pointer q)\r
1529 {\r
1530   pointer p;\r
1531 \r
1532   p = get_node(small_node_size);\r
1533   type(p) = ligature_node;\r
1534   font(lig_char(p)) = f;\r
1535   character(lig_char(p)) = c;\r
1536   lig_ptr(p) = q;\r
1537   subtype(p) = 0;\r
1538 \r
1539   return p;\r
1540 }\r
1541 /* sec 0144 */\r
1542 pointer new_lig_item_(quarterword c)\r
1543 {\r
1544   pointer p;\r
1545 \r
1546   p = get_node(small_node_size);\r
1547   character(p) = c;\r
1548   lig_ptr(p) = 0;\r
1549 \r
1550   return p;\r
1551 }\r
1552 /* sec 0145 */\r
1553 pointer new_disc (void) \r
1554 {\r
1555   pointer p;\r
1556 \r
1557   p = get_node(small_node_size);\r
1558   type(p) = disc_node;\r
1559   replace_count(p) = 0;\r
1560   pre_break(p) = 0;\r
1561   post_break(p) = 0;\r
1562 \r
1563   return p;\r
1564 }\r
1565 /* sec 0147 */\r
1566 pointer new_math (scaled w, small_number s)\r
1567 {\r
1568   pointer p;\r
1569 \r
1570   p = get_node(small_node_size);\r
1571   type(p) = math_node;\r
1572   subtype(p) = s;\r
1573   width(p) = w;\r
1574 \r
1575   return p;\r
1576 }\r
1577 /* sec 0151 */\r
1578 pointer new_spec_(pointer p)\r
1579 {\r
1580   pointer q;\r
1581 \r
1582   q = get_node(glue_spec_size);\r
1583   mem[q] = mem[p];\r
1584   glue_ref_count(q) = 0;\r
1585   width(q) = width(p);\r
1586   stretch(q) = stretch(p);\r
1587   shrink(q) = shrink(p);\r
1588 \r
1589   return q;\r
1590 }\r
1591 /* se 0152 */\r
1592 pointer new_param_glue (small_number n)\r
1593 {\r
1594   pointer p;\r
1595   pointer q;\r
1596 \r
1597   p = get_node(small_node_size);\r
1598   type(p) = glue_node;\r
1599   subtype(p) = n + 1;\r
1600   leader_ptr(p) = 0;\r
1601   q = glue_par(n);\r
1602   glue_ptr(p) = q;\r
1603   incr(glue_ref_count(q));\r
1604 \r
1605   return p;\r
1606 }\r
1607 /* sec 0153 */\r
1608 pointer new_glue (pointer q)\r
1609 {\r
1610   pointer p;\r
1611 \r
1612   p = get_node(small_node_size);\r
1613   type(p) = glue_node;\r
1614   subtype(p) = normal;\r
1615   leader_ptr(p) = 0; \r
1616   glue_ptr(p) = q;\r
1617   incr(glue_ref_count(q));\r
1618 \r
1619   return p;\r
1620 }\r
1621 /* sec 0154 */\r
1622 pointer new_skip_param (small_number n)\r
1623 {\r
1624   pointer p;\r
1625 \r
1626   temp_ptr = new_spec(glue_par(n));\r
1627   p = new_glue(temp_ptr);\r
1628   glue_ref_count(temp_ptr) = 0;\r
1629   subtype(p) = n + 1;\r
1630 \r
1631   return p;\r
1632 }\r
1633 /* sec 0155 */\r
1634 pointer new_kern(scaled w)\r
1635 {\r
1636   pointer p;\r
1637 \r
1638   p = get_node(small_node_size);\r
1639   type(p) = kern_node;\r
1640   subtype(p) = normal;\r
1641   width(p) = w;\r
1642 \r
1643   return p;\r
1644 }\r
1645 /* sec 0158 */\r
1646 pointer new_penalty(integer m)\r
1647 {\r
1648   pointer p;\r
1649 \r
1650   p = get_node(small_node_size);\r
1651   type(p) = penalty_node;\r
1652   subtype(p) = 0;\r
1653   penalty(p) = m;\r
1654 \r
1655   return p;\r
1656 }\r
1657 \r
1658 #ifdef DEBUG\r
1659 /* sec 0167 */\r
1660 void check_mem (boolean print_locs)\r
1661 {\r
1662   pointer p, q;\r
1663   boolean clobbered;\r
1664 \r
1665   for (p = mem_min; p <= lo_mem_max; p++)\r
1666     freearr[p] = false;\r
1667 \r
1668   for (p = hi_mem_min; p <= mem_end; p++)\r
1669     freearr[p] = false;\r
1670 \r
1671   p = avail;\r
1672   q = 0;\r
1673   clobbered = false;\r
1674 \r
1675   while (p != 0)\r
1676   {\r
1677     if ((p > mem_end) || (p < hi_mem_min))\r
1678       clobbered = true;\r
1679     else if (freearr[p])\r
1680       clobbered = true;\r
1681 \r
1682     if (clobbered)\r
1683     {\r
1684       print_nl("AVAIL list clobbered at ");\r
1685       print_int(q);\r
1686       goto done1;\r
1687     }\r
1688 \r
1689     freearr[p] = true;\r
1690     q = p;\r
1691     p = link(q);\r
1692   }\r
1693 \r
1694 done1:\r
1695   p = rover;\r
1696   q = 0;\r
1697   clobbered = false;\r
1698 \r
1699   do\r
1700     {\r
1701       if ((p >= lo_mem_max) || (p < mem_min))\r
1702         clobbered = true;\r
1703       else if ((rlink(p) >= lo_mem_max) || (rlink(p) < mem_min))\r
1704         clobbered = true;\r
1705       else if (!(is_empty(p)) || (node_size(p) < 2) ||\r
1706           (p + node_size(p) > lo_mem_max) || (llink(rlink(p)) != p))\r
1707         clobbered = true;\r
1708       \r
1709       if (clobbered)\r
1710       {\r
1711         print_nl("Double-AVAIL list clobbered at ");\r
1712         print_int(q);\r
1713         goto done2;\r
1714       }\r
1715 \r
1716       for (q = p; q <= p + node_size(p) - 1; q++)\r
1717       {\r
1718         if (freearr[q])\r
1719         {\r
1720           print_nl("Doubly free location at ");\r
1721           print_int(q);\r
1722           goto done2;\r
1723         }\r
1724 \r
1725         freearr[q] = true;\r
1726       }\r
1727 \r
1728       q = p;\r
1729       p = rlink(p);\r
1730     }\r
1731   while (!(p == rover));\r
1732 \r
1733 done2:\r
1734   p = mem_min;\r
1735 \r
1736   while (p <= lo_mem_max)\r
1737   {\r
1738     if (is_empty(p))\r
1739     {\r
1740       print_nl("Bad flag at ");\r
1741       print_int(p);\r
1742     }\r
1743 \r
1744     while ((p <= lo_mem_max) && !freearr[p])\r
1745       incr(p);\r
1746 \r
1747     while ((p <= lo_mem_max) && freearr[p])\r
1748       incr(p);\r
1749   }\r
1750 \r
1751   if (print_locs)\r
1752   {\r
1753     print_nl("New busy locs:");\r
1754 \r
1755     for (p = mem_min; p <= lo_mem_max; p++)\r
1756       if (!freearr[p] && ((p > was_lo_max) || wasfree[p]))\r
1757       {\r
1758         print_char(' ');\r
1759         print_int(p);\r
1760       }\r
1761 \r
1762     for (p = hi_mem_min; p <= mem_end; p++)\r
1763       if (!freearr[p] && ((p < was_hi_min) || (p > was_mem_end) || wasfree[p]))\r
1764       {\r
1765         print_char(' ');\r
1766         print_int(p);\r
1767       }\r
1768   }\r
1769 \r
1770   for (p = mem_min; p <= lo_mem_max; p++)\r
1771     wasfree[p] = freearr[p];\r
1772 \r
1773   for (p = hi_mem_min; p <= mem_end; p++)\r
1774     wasfree[p] = freearr[p];\r
1775 \r
1776   was_mem_end = mem_end;\r
1777   was_lo_max = lo_mem_max;\r
1778   was_hi_min = hi_mem_min;\r
1779 }\r
1780 /* sec 0172 */\r
1781 void search_mem_(pointer p)\r
1782 {\r
1783   integer q;\r
1784 \r
1785   for (q = mem_min; q <= lo_mem_max; q++)\r
1786   {\r
1787     if (link(q) == p)\r
1788     {\r
1789       print_nl("LINK(");\r
1790       print_int(q);\r
1791       print_char(')');\r
1792     }\r
1793 \r
1794     if (info(q) == p)\r
1795     {\r
1796       print_nl("INFO(");\r
1797       print_int(q);\r
1798       print_char(')');\r
1799     }\r
1800   }\r
1801 \r
1802   for (q = hi_mem_min; q <= mem_end; q++)\r
1803   {\r
1804     if (link(q) == p)\r
1805     {\r
1806       print_nl("LINK(");\r
1807       print_int(q);\r
1808       print_char(')');\r
1809     }\r
1810 \r
1811     if (info(q) == p)\r
1812     {\r
1813       print_nl("INFO(");\r
1814       print_int(q);\r
1815       print_char(')');\r
1816     }\r
1817   }\r
1818 \r
1819   for (q = active_base; q <= box_base + 255; q++)\r
1820     if (equiv(q) == p)\r
1821     {\r
1822       print_nl("EQUIV(");\r
1823       print_int(q);\r
1824       print_char(')');\r
1825     }\r
1826 \r
1827   if (save_ptr > 0)\r
1828     for (q = 0; q <= save_ptr - 1; q++)\r
1829     {\r
1830       if (equiv_field(save_stack[q]) == p)\r
1831       {\r
1832         print_nl("SAVE(");\r
1833         print_int(q);\r
1834         print_char(')');\r
1835       }\r
1836     }\r
1837 \r
1838   for (q = 0; q <= hyphen_prime; q++)\r
1839     if (hyph_list[q] == p)\r
1840     {\r
1841       print_nl("HYPH(");\r
1842       print_int(q);\r
1843       print_char(')');\r
1844     }\r
1845 }\r
1846 #endif\r
1847 /* sec 0174 */\r
1848 void short_display_(integer p)\r
1849 {\r
1850   integer n; \r
1851 \r
1852   while (p != 0) /* want p != null here ! */\r
1853   {\r
1854     if (is_char_node(p))\r
1855     {\r
1856       if (p <= mem_end)\r
1857       {\r
1858         if (font(p) != font_in_short_display)\r
1859         {\r
1860           if ((font(p) > font_max))\r
1861             print_char('*');\r
1862           else\r
1863           {\r
1864             print_esc("");\r
1865             print(font_id_text(font(p)));\r
1866           }\r
1867           \r
1868           print_char(' ');\r
1869           font_in_short_display = font(p);\r
1870         }\r
1871         \r
1872         print(character(p));\r
1873       }\r
1874     }\r
1875     else switch (type(p))\r
1876     {\r
1877       case hlist_node:\r
1878       case vlist_node:\r
1879       case ins_node:\r
1880       case whatsit_node:\r
1881       case mark_node:\r
1882       case adjust_node:\r
1883       case unset_node:\r
1884         prints("[]");\r
1885         break;\r
1886 \r
1887       case rule_node:\r
1888         print_char('|');\r
1889         break;\r
1890 \r
1891       case glue_node:\r
1892         if (glue_ptr(p) != 0)\r
1893           print_char(' ');\r
1894         break;\r
1895 \r
1896       case math_node:\r
1897         print_char('$');\r
1898         break;\r
1899 \r
1900       case ligature_node:\r
1901         short_display(lig_ptr(p));\r
1902         break;\r
1903 \r
1904       case disc_node:\r
1905         short_display(pre_break(p));\r
1906         short_display(post_break(p));\r
1907         n = replace_count(p);\r
1908 \r
1909         while (n > 0)\r
1910         {\r
1911           if (link(p) != 0)\r
1912             p = link(p);\r
1913 \r
1914           decr(n);\r
1915         }\r
1916         break;\r
1917 \r
1918       default:\r
1919         break;\r
1920     }\r
1921     \r
1922     p = link(p);\r
1923   }\r
1924 }\r
1925 /* sec 0176 */\r
1926 void print_font_and_char (integer p)\r
1927 {\r
1928   if (p > mem_end)\r
1929     print_esc("CLOBBERED.");\r
1930   else\r
1931   {\r
1932     if ((font(p) > font_max))\r
1933       print_char('*');\r
1934     else\r
1935     {\r
1936       print_esc("");\r
1937       print(font_id_text(font(p)));\r
1938     }\r
1939 \r
1940     print_char(' ');\r
1941     print(character(p));\r
1942   }\r
1943 }\r
1944 /* sec 0176 */\r
1945 void print_mark (integer p)\r
1946 { \r
1947   print_char('{');\r
1948 \r
1949   if ((p < hi_mem_min) || (p > mem_end))\r
1950     print_esc("CLOBBERED.");\r
1951   else\r
1952     show_token_list(link(p), 0, max_print_line - 10);\r
1953 \r
1954   print_char('}');\r
1955 }\r
1956 /* sec 0176 */\r
1957 void print_rule_dimen(scaled d)\r
1958 {\r
1959   if (is_running(d))\r
1960     print_char('*');\r
1961   else\r
1962     print_scaled(d);\r
1963 }\r
1964 /* sec 0177 */\r
1965 void print_glue_(scaled d, integer order, const char * s)\r
1966 {\r
1967   print_scaled(d); \r
1968 \r
1969   if ((order < normal) || (order > filll))\r
1970     prints("foul");\r
1971   else if (order > normal)\r
1972   {\r
1973     prints("fil");\r
1974 \r
1975     while (order > fil)\r
1976     {\r
1977       print_char('l');\r
1978       decr(order);\r
1979     }\r
1980   }\r
1981   else if (*s != '\0')\r
1982     prints(s);\r
1983 }\r
1984 /* sec 0178 */\r
1985 void print_spec_(integer p, const char * s)\r
1986 {\r
1987   if ((p < mem_min) || (p >= lo_mem_max)) \r
1988     print_char('*');\r
1989   else\r
1990   {\r
1991     print_scaled(width(p));\r
1992 \r
1993     if (*s != '\0')\r
1994       prints(s);\r
1995 \r
1996     if (stretch(p) != 0)\r
1997     {\r
1998       prints("plus");\r
1999       print_glue(stretch(p), stretch_order(p), s);\r
2000     }\r
2001 \r
2002     if (shrink(p) != 0)\r
2003     {\r
2004       prints("minus");\r
2005       print_glue(shrink(p), shrink_order(p), s);\r
2006     }\r
2007   }\r
2008 }\r
2009 /* sec 0691 */\r
2010 void print_fam_and_char_(pointer p)\r
2011 {\r
2012   print_esc("fam");\r
2013   print_int(fam(p));\r
2014   print_char(' ');\r
2015   print(character(p));\r
2016 }\r
2017 /* sec 0691 */\r
2018 void print_delimiter_(pointer p)\r
2019 {\r
2020   integer a;\r
2021 \r
2022   a = small_fam(p) * 256 + small_char(p);\r
2023   a = a * 0x1000 + large_fam(p) * 256 + large_char(p);\r
2024 \r
2025   if (a < 0)\r
2026     print_int(a);\r
2027   else\r
2028     print_hex(a);\r
2029 }\r
2030 /* sec 0692 */\r
2031 void print_subsidiary_data_(pointer p, ASCII_code c)\r
2032 {\r
2033   if ((pool_ptr - str_start[str_ptr]) >= depth_threshold)\r
2034   {\r
2035     if (math_type(p) != 0)\r
2036       prints(" []");\r
2037   }\r
2038   else\r
2039   {\r
2040     append_char(c);\r
2041     temp_ptr = p;\r
2042 \r
2043     switch (math_type(p))\r
2044     {\r
2045       case math_char:\r
2046         print_ln();\r
2047         print_current_string();\r
2048         print_fam_and_char(p);\r
2049         break;\r
2050 \r
2051       case sub_box:\r
2052         show_info();\r
2053         break;\r
2054 \r
2055       case sub_mlist:\r
2056         if (info(p) == 0)\r
2057         {\r
2058           print_ln();\r
2059           print_current_string();\r
2060           prints("{}");\r
2061         }\r
2062         else\r
2063           show_info();\r
2064         break;\r
2065 \r
2066       default:\r
2067         break;\r
2068     }\r
2069 \r
2070     decr(pool_ptr);\r
2071   }\r
2072 }\r
2073 /* sec 0694 */\r
2074 void print_style_(integer c)\r
2075 {\r
2076   switch (c / 2)\r
2077   {\r
2078     case 0:\r
2079       print_esc("displaystyle");\r
2080       break;\r
2081     case 1:\r
2082       print_esc("textstyle");\r
2083       break;\r
2084     case 2:\r
2085       print_esc("scriptstyle");\r
2086       break;\r
2087     case 3:\r
2088       print_esc("scriptscriptstyle");\r
2089       break;\r
2090     default:\r
2091       prints("Unknown style!");\r
2092       break;\r
2093   }\r
2094 }\r
2095 /* sec 0225 */\r
2096 void print_skip_param_(integer n)\r
2097 {\r
2098   switch (n)\r
2099   {\r
2100     case line_skip_code:\r
2101       print_esc("lineskip");\r
2102       break;\r
2103 \r
2104     case baseline_skip_code:\r
2105       print_esc("baselineskip");\r
2106       break; \r
2107 \r
2108     case par_skip_code:\r
2109       print_esc("parskip");\r
2110       break;\r
2111 \r
2112     case above_display_skip_code:\r
2113       print_esc("abovedisplayskip");\r
2114       break;\r
2115 \r
2116     case below_display_skip_code:\r
2117       print_esc("belowdisplayskip");\r
2118       break;\r
2119 \r
2120     case above_display_short_skip_code:\r
2121       print_esc("abovedisplayshortskip");\r
2122       break;\r
2123 \r
2124     case below_display_short_skip_code:\r
2125       print_esc("belowdisplayshortskip");\r
2126       break;\r
2127 \r
2128     case left_skip_code:\r
2129       print_esc("leftskip");\r
2130       break;\r
2131 \r
2132     case right_skip_code:\r
2133       print_esc("rightskip");\r
2134       break;\r
2135 \r
2136     case top_skip_code:\r
2137       print_esc("topskip");\r
2138       break;\r
2139 \r
2140     case split_top_skip_code:\r
2141       print_esc("splittopskip");\r
2142       break;\r
2143 \r
2144     case tab_skip_code:\r
2145       print_esc("tabskip");\r
2146       break;\r
2147 \r
2148     case space_skip_code:\r
2149       print_esc("spaceskip");\r
2150       break;\r
2151 \r
2152     case xspace_skip_code:\r
2153       print_esc("xspaceskip");\r
2154       break;\r
2155 \r
2156     case par_fill_skip_code:\r
2157       print_esc("parfillskip");\r
2158       break;\r
2159 \r
2160     case thin_mu_skip_code:\r
2161       print_esc("thinmuskip");\r
2162       break;\r
2163 \r
2164     case med_mu_skip_code:\r
2165       print_esc("medmuskip");\r
2166       break; \r
2167 \r
2168     case thick_mu_skip_code:\r
2169       print_esc("thickmuskip");\r
2170       break;\r
2171 \r
2172     default:\r
2173       prints("[unknown glue parameter!]");\r
2174       break;\r
2175   }\r
2176 }\r
2177 /* sec 0182 */\r
2178 void show_node_list_(integer p)\r
2179 {\r
2180   integer n;\r
2181   real g;\r
2182 \r
2183   if (cur_length > depth_threshold)\r
2184   {\r
2185     if (p != 0)\r
2186       prints(" []");\r
2187 \r
2188     return; \r
2189   }\r
2190 \r
2191   n = 0;\r
2192 \r
2193   while (p != 0)\r
2194   {\r
2195     print_ln(); \r
2196     print_current_string(); \r
2197 \r
2198     if (p > mem_end)\r
2199     {\r
2200       prints("Bad link, display aborted.");\r
2201       return;\r
2202     }\r
2203 \r
2204     incr(n);\r
2205 \r
2206     if (n > breadth_max)\r
2207     {\r
2208       prints("etc.");\r
2209       return;\r
2210     }\r
2211 \r
2212     if (is_char_node(p))\r
2213       print_font_and_char(p);\r
2214     else switch (type(p))\r
2215     {\r
2216       case hlist_node:\r
2217       case vlist_node:\r
2218       case unset_node:\r
2219         {\r
2220           if (type(p) == hlist_node)\r
2221             print_esc("h");\r
2222           else if (type(p) == vlist_node)\r
2223             print_esc("v");\r
2224           else\r
2225             print_esc("unset");\r
2226 \r
2227           prints("box(");\r
2228           print_scaled(height(p));\r
2229           print_char('+');\r
2230           print_scaled(depth(p));\r
2231           prints(")x");\r
2232           print_scaled(width(p));\r
2233 \r
2234           if (type(p) == unset_node)\r
2235           {\r
2236             if (span_count(p) != 0)\r
2237             {\r
2238               prints(" (");\r
2239               print_int(span_count(p) + 1);\r
2240               prints(" columns)");\r
2241             }\r
2242 \r
2243             if (glue_stretch(p) != 0)\r
2244             {\r
2245               prints(", stretch ");\r
2246               print_glue(glue_stretch(p), glue_order(p), "");\r
2247             }\r
2248 \r
2249             if (glue_shrink(p) != 0)\r
2250             {\r
2251               prints(", shrink ");\r
2252               print_glue(glue_shrink(p), glue_sign(p), "");\r
2253             }\r
2254           }\r
2255           else\r
2256           {\r
2257             g = glue_set(p);\r
2258 \r
2259             if ((g != 0.0) && (glue_sign(p) != 0))\r
2260             {\r
2261               prints(", glue set ");\r
2262 \r
2263               if (glue_sign(p) == shrinking)\r
2264                 prints("- ");\r
2265 \r
2266               if (fabs(g) > 20000.0)\r
2267               {\r
2268                 if (g > 0.0)\r
2269                   print_char('>');\r
2270                 else\r
2271                   prints("< -");\r
2272 \r
2273                 print_glue(20000 * unity, glue_order(p), "");\r
2274               }\r
2275               else\r
2276                 print_glue(round(unity * g), glue_order(p), "");\r
2277             }\r
2278 \r
2279             if (shift_amount(p) != 0)\r
2280             {\r
2281               prints(", shifted ");\r
2282               print_scaled(shift_amount(p));\r
2283             }\r
2284           }\r
2285 \r
2286           node_list_display(list_ptr(p));\r
2287         }\r
2288         break;\r
2289 \r
2290       case rule_node:\r
2291         {\r
2292           print_esc("rule(");\r
2293           print_rule_dimen(height(p));\r
2294           print_char('+');\r
2295           print_rule_dimen(depth(p));\r
2296           prints(")x");\r
2297           print_rule_dimen(width(p));\r
2298         }\r
2299         break;\r
2300 \r
2301       case ins_node:\r
2302         {\r
2303           print_esc("insert");\r
2304           print_int(subtype(p));\r
2305           prints(", natural size ");\r
2306           print_scaled(height(p));\r
2307           prints("; split(");\r
2308           print_spec(split_top_ptr(p), "");\r
2309           print_char(',');\r
2310           print_scaled(depth(p));\r
2311           prints("); float cost ");\r
2312           print_int(float_cost(p));\r
2313           node_list_display(ins_ptr(p));\r
2314         }\r
2315         break;\r
2316 \r
2317       case whatsit_node:\r
2318         switch (subtype(p))\r
2319         {\r
2320           case open_node:\r
2321             {\r
2322               print_write_whatsit("openout", p);\r
2323               print_char('=');\r
2324               print_file_name(open_name(p), open_area(p), open_ext(p));\r
2325             }\r
2326             break;\r
2327 \r
2328           case write_node:\r
2329             {\r
2330               print_write_whatsit("write", p);\r
2331               print_mark(write_tokens(p));\r
2332             }\r
2333             break;\r
2334 \r
2335           case close_node:\r
2336             print_write_whatsit("closeout", p);\r
2337             break;\r
2338 \r
2339           case special_node:\r
2340             {\r
2341               print_esc("special");\r
2342               print_mark(write_tokens(p));\r
2343             }\r
2344             break;\r
2345 \r
2346           case language_node:\r
2347             {\r
2348               print_esc("setlanguage");\r
2349               print_int(what_lang(p));\r
2350               prints(" (hyphenmin ");\r
2351               print_int(what_lhm(p));\r
2352               print_char(',');\r
2353               print_int(what_rhm(p));\r
2354               print_char(')');\r
2355             }\r
2356             break;\r
2357 \r
2358           default:\r
2359             prints("whatsit?");\r
2360             break;\r
2361         }\r
2362         break;\r
2363 \r
2364       case glue_node:\r
2365         if (subtype(p) >= a_leaders)\r
2366         {\r
2367           print_esc("");\r
2368 \r
2369           if (subtype(p) == c_leaders)\r
2370             print_char('c');\r
2371           else if (subtype(p) == x_leaders)\r
2372             print_char('x');\r
2373 \r
2374           prints("leaders ");\r
2375           print_spec(glue_ptr(p), "");\r
2376           node_list_display(leader_ptr(p));\r
2377         }\r
2378         else\r
2379         {\r
2380           print_esc("glue");\r
2381 \r
2382           if (subtype(p) != normal)\r
2383           {\r
2384             print_char('(');\r
2385 \r
2386             if (subtype(p) < cond_math_glue)\r
2387               print_skip_param(subtype(p) - 1);\r
2388             else if (subtype(p) == cond_math_glue)\r
2389               print_esc("nonscript");\r
2390             else print_esc("mskip");\r
2391 \r
2392             print_char(')');\r
2393           }\r
2394 \r
2395           if (subtype(p) != cond_math_glue)\r
2396           {\r
2397             print_char(' ');\r
2398 \r
2399             if (subtype(p) < cond_math_glue)\r
2400               print_spec(glue_ptr(p), "");\r
2401             else\r
2402               print_spec(glue_ptr(p), "mu");\r
2403           }\r
2404         }\r
2405         break;\r
2406 \r
2407       case kern_node:\r
2408         if (subtype(p) != mu_glue)\r
2409         {\r
2410           print_esc("kern");\r
2411 \r
2412           if (subtype(p) != normal)\r
2413             print_char(' ');\r
2414 \r
2415           print_scaled(width(p));\r
2416 \r
2417           if (subtype(p) == acc_kern)\r
2418             prints(" (for accent)");\r
2419         }\r
2420         else\r
2421         {\r
2422           print_esc("mkern");\r
2423           print_scaled(width(p));\r
2424           prints("mu");\r
2425         }\r
2426         break;\r
2427 \r
2428       case math_node:\r
2429         {\r
2430           print_esc("math");\r
2431 \r
2432           if (subtype(p) == before)\r
2433             prints("on");\r
2434           else\r
2435             prints("off");\r
2436 \r
2437           if (width(p) != 0)\r
2438           {\r
2439             prints(", surrounded ");\r
2440             print_scaled(width(p));\r
2441           }\r
2442         }\r
2443         break;\r
2444 \r
2445       case ligature_node:\r
2446         {\r
2447           print_font_and_char(lig_char(p));\r
2448           prints("(ligature ");\r
2449 \r
2450           if (subtype(p) > 1)\r
2451             print_char('|');\r
2452 \r
2453           font_in_short_display = font(lig_char(p)); \r
2454           short_display(lig_ptr(p));\r
2455 \r
2456           if (odd(subtype(p)))\r
2457             print_char('|');\r
2458 \r
2459           print_char(')');\r
2460         }\r
2461         break;\r
2462 \r
2463       case penalty_node:\r
2464         {\r
2465           print_esc("penalty ");\r
2466           print_int(penalty(p));\r
2467         }\r
2468         break;\r
2469 \r
2470       case disc_node:\r
2471         {\r
2472           print_esc("discretionary");\r
2473 \r
2474           if (replace_count(p) > 0)\r
2475           {\r
2476             prints(" replacing ");\r
2477             print_int(replace_count(p));\r
2478           }\r
2479 \r
2480           node_list_display(pre_break(p));\r
2481           append_char('|');\r
2482           show_node_list(post_break(p));\r
2483           decr(pool_ptr);\r
2484         }\r
2485         break;\r
2486 \r
2487       case mark_node:\r
2488         {\r
2489           print_esc("mark");\r
2490           print_mark(mark_ptr(p));\r
2491         }\r
2492         break;\r
2493 \r
2494       case adjust_node:\r
2495         {\r
2496           print_esc("vadjust");\r
2497           node_list_display(adjust_ptr(p));\r
2498         }\r
2499         break;\r
2500 \r
2501       case style_node:\r
2502         print_style(subtype(p));\r
2503         break;\r
2504 \r
2505       case choice_node:\r
2506         {\r
2507           print_esc("mathchoice");\r
2508           append_char('D');\r
2509           show_node_list(display_mlist(p));\r
2510           decr(pool_ptr);\r
2511           append_char('T');\r
2512           show_node_list(text_mlist(p));\r
2513           decr(pool_ptr);\r
2514           append_char('S');\r
2515           show_node_list(script_mlist(p));\r
2516           decr(pool_ptr);\r
2517           append_char('s');\r
2518           show_node_list(script_script_mlist(p)); \r
2519           decr(pool_ptr); \r
2520         } \r
2521         break;\r
2522 \r
2523       case ord_noad:\r
2524       case op_noad:\r
2525       case bin_noad:\r
2526       case rel_noad:\r
2527       case open_noad:\r
2528       case close_noad:\r
2529       case punct_noad:\r
2530       case inner_noad:\r
2531       case radical_noad:\r
2532       case over_noad:\r
2533       case under_noad:\r
2534       case vcenter_noad:\r
2535       case accent_noad:\r
2536       case left_noad:\r
2537       case right_noad:\r
2538         {\r
2539           switch (type(p))\r
2540           {\r
2541             case ord_noad:\r
2542               print_esc("mathord");\r
2543               break;\r
2544 \r
2545             case op_noad:\r
2546               print_esc("mathop");\r
2547               break;\r
2548 \r
2549             case bin_noad:\r
2550               print_esc("mathbin");\r
2551               break;\r
2552 \r
2553             case rel_noad:\r
2554               print_esc("mathrel");\r
2555               break;\r
2556 \r
2557             case open_noad:\r
2558               print_esc("mathopen");\r
2559               break;\r
2560 \r
2561             case close_noad:\r
2562               print_esc("mathclose");\r
2563               break;\r
2564 \r
2565             case punct_noad:\r
2566               print_esc("mathpunct");\r
2567               break;\r
2568 \r
2569             case inner_noad:\r
2570               print_esc("mathinner");\r
2571               break;\r
2572 \r
2573             case over_noad:\r
2574               print_esc("overline");\r
2575               break;\r
2576 \r
2577             case under_noad:\r
2578               print_esc("underline");\r
2579               break;\r
2580 \r
2581             case vcenter_noad:\r
2582               print_esc("vcenter");\r
2583               break;\r
2584 \r
2585             case radical_noad:\r
2586               {\r
2587                 print_esc("radical");\r
2588                 print_delimiter(left_delimiter(p));\r
2589               }\r
2590               break;\r
2591 \r
2592             case accent_noad:\r
2593               {\r
2594                 print_esc("accent");\r
2595                 print_fam_and_char(accent_chr(p));\r
2596               }\r
2597               break;\r
2598 \r
2599             case left_noad:\r
2600               {\r
2601                 print_esc("left");\r
2602                 print_delimiter(delimiter(p));\r
2603               }\r
2604               break;\r
2605 \r
2606             case right_noad:\r
2607               {\r
2608                 print_esc("right");\r
2609                 print_delimiter(delimiter(p));\r
2610               }\r
2611               break;\r
2612           }\r
2613 \r
2614           if (subtype(p) != normal)\r
2615             if (subtype(p) == limits)\r
2616               print_esc("limits");\r
2617             else\r
2618               print_esc("nolimits");\r
2619 \r
2620           if (type(p) < left_noad)\r
2621             print_subsidiary_data(nucleus(p), '.');\r
2622 \r
2623           print_subsidiary_data(supscr(p), '^');\r
2624           print_subsidiary_data(subscr(p), '_');\r
2625         }\r
2626         break;\r
2627 \r
2628       case fraction_noad:\r
2629         {\r
2630           print_esc("fraction, thickness ");\r
2631 \r
2632           if (thickness(p) == 1073741824L)  /* 2^30 */\r
2633             prints("= default");\r
2634           else\r
2635             print_scaled(thickness(p));\r
2636 \r
2637           if ((small_fam(left_delimiter(p)) != 0) || (small_char(left_delimiter(p)) != 0) ||\r
2638               (large_fam(left_delimiter(p)) != 0) || (large_char(left_delimiter(p)) != 0))\r
2639           {\r
2640             prints(", left-delimiter ");\r
2641             print_delimiter(left_delimiter(p));\r
2642           }\r
2643 \r
2644           if ((small_fam(right_delimiter(p)) != 0) || (small_char(right_delimiter(p)) != 0) ||\r
2645               (large_fam(right_delimiter(p)) != 0) || (large_char(right_delimiter(p)) != 0))\r
2646           {\r
2647             prints(", right-delimiter ");\r
2648             print_delimiter(right_delimiter(p));\r
2649           }\r
2650 \r
2651           print_subsidiary_data(numerator(p), '\\');\r
2652           print_subsidiary_data(denominator(p), '/');\r
2653         }\r
2654         break;\r
2655 \r
2656       default:\r
2657         prints("Unknown node type!");\r
2658         break;\r
2659     }\r
2660 \r
2661     p = link(p);\r
2662   }\r
2663 }