src/texsourc/tex0.c

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