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