src/texsourc/tex7.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:4131) // old style declarator
  14 #pragma warning(disable:4135) // conversion between different integral types
  15 #pragma warning(disable:4127) // conditional expression is constant
  16
  17 #include <setjmp.h>
  18
  19 #define EXTERN extern
  20
  21 #include "texd.h"
  22
  23 #pragma warning(disable:4244)       /* 96/Jan/10 */
  24
  25 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
  26 /* sec 0944 */
  27 void build_page (void)
  28 {/* 10 30 31 22 80 90 */
  29   halfword p;
  30   halfword q, r;
  31   integer b, c;
  32   integer pi;
  33 /*  unsigned char n;  */
  34   unsigned int n;             /* 95/Jan/7 */
  35   scaled delta, h, w;
  36
  37 /* begin if (link(contrib_head)=null)or output_active then return; l.19351 */
  38   if((mem[contrib_head].hh.v.RH == 0)|| output_active)
  39     return;
  40   do {
  41       lab22: p = mem[contrib_head].hh.v.RH;
  42 /*    if(last_glue != 262143L) */
  43     if(last_glue != empty_flag)
  44       delete_glue_ref(last_glue);
  45     last_penalty = 0;
  46     last_kern = 0;
  47     if(mem[p].hh.b0 == 10)
  48     {
  49       last_glue = mem[p + 1].hh.v.LH;
  50       incr(mem[last_glue].hh.v.RH);
  51     }
  52     else {
  53
  54 /*      last_glue = 262143L;  */
  55       last_glue = empty_flag;
  56       if(mem[p].hh.b0 == 12)
  57         last_penalty = mem[p + 1].cint;
  58       else if(mem[p].hh.b0 == 11)
  59         last_kern = mem[p + 1].cint;
  60     }
  61     switch(mem[p].hh.b0)
  62     {
  63       case 0 :
  64       case 1 :
  65       case 2 :
  66         if(page_contents < 2)
  67         {
  68           if(page_contents == 0)
  69             freeze_page_specs(2);
  70           else
  71             page_contents = 2;
  72           q = new_skip_param(9);
  73           if(mem[temp_ptr + 1].cint > mem[p + 3].cint)
  74             mem[temp_ptr + 1].cint = mem[temp_ptr + 1].cint - mem[p + 3].cint;
  75           else
  76             mem[temp_ptr + 1].cint = 0;
  77           mem[q].hh.v.RH = p;
  78           mem[contrib_head].hh.v.RH = q;
  79           goto lab22;
  80       }
  81       else {
  82         page_so_far[1]= page_so_far[1]+ page_so_far[7]+ mem[p + 3].cint;
  83         page_so_far[7]= mem[p + 2].cint;
  84         goto lab80;
  85       }
  86       break;
  87     case 8 :
  88       goto lab80;
  89       break;
  90     case 10 :
  91       if(page_contents < 2)
  92         goto lab31;
  93       else if((mem[page_tail].hh.b0 < 9))
  94         pi = 0;
  95       else
  96         goto lab90;
  97       break;
  98     case 11 :
  99       if(page_contents < 2)
 100         goto lab31;
 101       else if(mem[p].hh.v.RH == 0)
 102         return;
 103       else if(mem[mem[p].hh.v.RH].hh.b0 == 10)
 104         pi = 0;
 105       else
 106         goto lab90;
 107       break;
 108     case 12 :
 109       if(page_contents < 2)
 110         goto lab31;
 111       else
 112         pi = mem[p + 1].cint;
 113       break;
 114     case 4 :
 115       goto lab80;
 116       break;
 117     case 3 :
 118       {
 119         if(page_contents == 0)
 120           freeze_page_specs(1);
 121         n = mem[p].hh.b1;
 122         r = mem_top;
 123         while(n >= mem[mem[r].hh.v.RH].hh.b1)
 124           r = mem[r].hh.v.RH;
 125         n = n;
 126         if(mem[r].hh.b1 != n)
 127         {
 128           q = get_node(4);
 129           mem[q].hh.v.RH = mem[r].hh.v.RH;
 130           mem[r].hh.v.RH = q;
 131           r = q;
 132           mem[r].hh.b1 = n;
 133           mem[r].hh.b0 = 0;
 134           ensure_vbox(n);
 135           if(eqtb[(hash_size + 1578) + n].hh.v.RH == 0)
 136             mem[r + 3].cint = 0;
 137           else
 138             mem[r + 3].cint = mem[eqtb[(hash_size + 1578) + n].hh.v.RH + 3].cint + mem[eqtb[(hash_size + 1578) + n].hh.v.RH + 2].cint;
 139           mem[r + 2].hh.v.LH = 0;
 140           q = eqtb[(hash_size + 800) + n].hh.v.RH;
 141           if(eqtb[(hash_size + 3218) + n].cint == 1000)
 142             h = mem[r + 3].cint;
 143           else
 144             h = x_over_n(mem[r + 3].cint, 1000)* eqtb[(hash_size + 3218) + n].cint;
 145           page_so_far[0]= page_so_far[0]- h - mem[q + 1].cint;
 146           page_so_far[2 + mem[q].hh.b0]= page_so_far[2 + mem[q].hh.b0]+ mem[q + 2].cint;
 147           page_so_far[6]= page_so_far[6]+ mem[q + 3].cint;
 148           if((mem[q].hh.b1 != 0)&&(mem[q + 3].cint != 0))
 149           {
 150                           print_err("Infinite glue shrinkage inserted from");
 151             print_esc("skip");
 152             print_int(n);
 153                         help3("The correction glue for page breaking with insertions",
 154                                 "must have finite shrinkability. But you may proceed,",
 155                                 "since the offensive shrinkability has been made finite.");
 156             error ();
 157           }
 158         }
 159         if(mem[r].hh.b0 == 1)
 160           insert_penalties = insert_penalties + mem[p + 1].cint;
 161         else {
 162           mem[r + 2].hh.v.RH = p;
 163           delta = page_so_far[0]- page_so_far[1]- page_so_far[7] + page_so_far[6];
 164           if(eqtb[(hash_size + 3218) + n].cint == 1000)
 165             h = mem[p + 3].cint;
 166           else
 167             h = x_over_n(mem[p + 3].cint, 1000)* eqtb[(hash_size + 3218) + n].cint;
 168           if(((h <= 0)||(h <= delta)) &&(mem[p + 3].cint + mem[r + 3].cint <= eqtb[(hash_size + 3751) + n].cint))
 169           {
 170             page_so_far[0]= page_so_far[0]- h;
 171             mem[r + 3].cint = mem[r + 3].cint + mem[p + 3].cint;
 172           }
 173           else {
 174             if(eqtb[(hash_size + 3218) + n].cint <= 0)
 175               w = 1073741823L;  /* 2^30 - 1 */
 176             else {
 177               w = page_so_far[0]- page_so_far[1]- page_so_far[7];
 178               if(eqtb[(hash_size + 3218) + n].cint != 1000)
 179                 w = x_over_n(w, eqtb[(hash_size + 3218) + n].cint)* 1000;
 180             }
 181             if(w > eqtb[(hash_size + 3751) + n].cint - mem[r + 3].cint)
 182               w = eqtb[(hash_size + 3751) + n].cint - mem[r + 3].cint;
 183             q = vert_break(mem[p + 4].hh.v.LH, w, mem[p + 2].cint);
 184             mem[r + 3].cint = mem[r + 3].cint + best_height_plus_depth;
 185             ;
 186 #ifdef STAT
 187             if(eqtb[(hash_size + 3196)].cint > 0)
 188             {
 189               begin_diagnostic ();
 190               print_nl("% split");   /*  */
 191               print_int(n);
 192               print_string(" to");
 193               print_scaled(w);
 194               print_char(44);  /*, */
 195               print_scaled(best_height_plus_depth);
 196               print_string(" p=");
 197               if(q == 0)    /* if q=null l.19614 */
 198                 print_int(-10000);
 199               else if(mem[q].hh.b0 == 12)
 200                 print_int(mem[q + 1].cint);
 201               else print_char(48); /* 0 */
 202               end_diagnostic(false);
 203             }
 204 #endif /* STAT */
 205             if(eqtb[(hash_size + 3218) + n].cint != 1000)
 206               best_height_plus_depth = x_over_n(best_height_plus_depth, 1000) * eqtb[(hash_size + 3218) + n].cint;
 207             page_so_far[0]= page_so_far[0]- best_height_plus_depth;
 208             mem[r].hh.b0 = 1;
 209             mem[r + 1].hh.v.RH = q;
 210             mem[r + 1].hh.v.LH = p;
 211             if(q == 0)
 212               insert_penalties = insert_penalties - 10000;
 213             else if(mem[q].hh.b0 == 12)
 214               insert_penalties = insert_penalties + mem[q + 1].cint;
 215           }
 216         }
 217         goto lab80;
 218       }
 219       break;
 220     default:
 221       {
 222         confusion(987); /* page */
 223         return;       // abort_flag set
 224       }
 225       break;
 226     }
 227     if(pi < 10000)/* pi may be used ... */
 228     {
 229       if(page_so_far[1]< page_so_far[0])
 230         if((page_so_far[3]!= 0)||(page_so_far[4]!= 0)||(page_so_far[5]!= 0))
 231           b = 0;
 232         else
 233           b = badness(page_so_far[0]- page_so_far[1], page_so_far[2]);
 234       else if(page_so_far[1]- page_so_far[0]> page_so_far[6])
 235         b = 1073741823L;  /* 2^30 - 1 */
 236       else
 237         b = badness(page_so_far[1]- page_so_far[0], page_so_far[6]);
 238       if(b < 1073741823L) /* 2^30 - 1 */
 239         if(pi <= -10000)
 240           c = pi;
 241         else if(b < 10000)
 242           c = b + pi + insert_penalties;
 243         else
 244           c = 100000L;
 245       else
 246         c = b;
 247       if (insert_penalties >= 10000)
 248         c = 1073741823L;  /* 2^30 - 1 */
 249       ;
 250 #ifdef STAT
 251       if(eqtb[(hash_size + 3196)].cint > 0)
 252       {
 253         begin_diagnostic ();
 254         print_nl("%");  /* % */
 255         print_string(" t=");
 256         print_totals ();
 257         print_string(" g=");
 258         print_scaled(page_so_far[0]);
 259         print_string(" b=");
 260         if(b == 1073741823L) /* 2^30 - 1 */
 261           print_char(42);  /* * */
 262         else
 263           print_int(b);
 264         print_string(" p=");
 265         print_int(pi);
 266         print_string(" c=");
 267         if(c == 1073741823L) /* 2^30 - 1 */
 268           print_char(42);  /* * */
 269         else print_int(c);
 270         if(c <= least_page_cost)
 271           print_char(35);  /* # */
 272         end_diagnostic(false);
 273       }
 274 #endif /* STAT */
 275       if(c <= least_page_cost)
 276       {
 277   best_page_break = p;
 278   best_size = page_so_far[0];
 279   least_page_cost = c;
 280   r = mem[mem_top].hh.v.RH;
 281   while(r != mem_top){
 282
 283     mem[r + 2].hh.v.LH = mem[r + 2].hh.v.RH;
 284     r = mem[r].hh.v.RH;
 285   }
 286       }
 287       if((c == 1073741823L)||(pi <= -10000))  /* 2^30 - 1 */
 288       {
 289   fire_up(p);
 290   if(output_active)return;
 291   goto lab30;
 292       }
 293     }
 294     if((mem[p].hh.b0 < 10)||(mem[p].hh.b0 > 11))
 295     goto lab80;
 296     lab90: if(mem[p].hh.b0 == 11)
 297     q = p;
 298     else {
 299
 300       q = mem[p + 1].hh.v.LH;
 301       page_so_far[2 + mem[q].hh.b0]= page_so_far[2 + mem[q].hh.b0]
 302       + mem[q + 2].cint;
 303       page_so_far[6]= page_so_far[6]+ mem[q + 3].cint;
 304       if((mem[q].hh.b1 != 0)&&(mem[q + 3].cint != 0))
 305       {
 306                   print_err("Infinite glue shrinkage found on current page");
 307                   help4("The page about to be output contains some infinitely",
 308                           "shrinkable glue, e.g., `\\vss' or `\\vskip 0pt minus 1fil'.",
 309                           "Such glue doesn't belong there; but you can safely proceed,",
 310                           "since the offensive shrinkability has been made finite.");
 311   error ();
 312   r = new_spec(q);
 313   mem[r].hh.b1 = 0;
 314   delete_glue_ref(q);
 315   mem[p + 1].hh.v.LH = r;
 316   q = r;
 317       }
 318     }
 319     page_so_far[1]= page_so_far[1]+ page_so_far[7]+ mem[q + 1].cint
 320  ;
 321     page_so_far[7]= 0;
 322     lab80: if(page_so_far[7]> page_max_depth)
 323     {
 324       page_so_far[1]= page_so_far[1]+ page_so_far[7]- page_max_depth;
 325       page_so_far[7]= page_max_depth;
 326     }
 327     mem[page_tail].hh.v.RH = p;
 328     page_tail = p;
 329     mem[contrib_head].hh.v.RH = mem[p].hh.v.RH;
 330     mem[p].hh.v.RH = 0;
 331     goto lab30;
 332     lab31: mem[contrib_head].hh.v.RH = mem[p].hh.v.RH;
 333     mem[p].hh.v.RH = 0;
 334     flush_node_list(p);
 335     lab30:;
 336   } while(!(mem[contrib_head].hh.v.RH == 0));
 337   if(nest_ptr == 0)
 338   tail = contrib_head;
 339   else nest[0].tail_field = contrib_head;
 340 }
 341 /* sec 1043 */
 342 void app_space (void)
 343 {
 344   halfword q;
 345   if((space_factor >= 2000) && (eqtb[(hash_size + 795)].hh.v.RH != 0))
 346   q = new_param_glue(13);
 347   else {
 348     if(eqtb[(hash_size + 794)].hh.v.RH != 0)
 349     main_p = eqtb[(hash_size + 794)].hh.v.RH;
 350     else {
 351       main_p = font_glue[eqtb[(hash_size + 1834)].hh.v.RH];
 352       if(main_p == 0)
 353       {
 354   main_p = new_spec(0);
 355   main_k = param_base[eqtb[(hash_size + 1834)].hh.v.RH]+ 2;
 356   mem[main_p + 1].cint = font_info[main_k].cint;
 357   mem[main_p + 2].cint = font_info[main_k + 1].cint;
 358   mem[main_p + 3].cint = font_info[main_k + 2].cint;
 359   font_glue[eqtb[(hash_size + 1834)].hh.v.RH]= main_p;
 360       }
 361     }
 362     main_p = new_spec(main_p);
 363     if(space_factor >= 2000)
 364     mem[main_p + 1].cint = mem[main_p + 1].cint + font_info[7 + param_base[eqtb[(hash_size + 1834)].hh.v.RH]].cint;
 365     mem[main_p + 2].cint = xn_over_d(mem[main_p + 2].cint, cur_list.aux_field.hh.v.LH, 1000);
 366     mem[main_p + 3].cint = xn_over_d(mem[main_p + 3].cint, 1000, space_factor);
 367     q = new_glue(main_p);
 368     mem[main_p].hh.v.RH = 0;
 369   }
 370   mem[tail].hh.v.RH = q;
 371   tail = q;
 372 }
 373 /* called from tex8.c only */
 374 /* sec 1047 */
 375 void insert_dollar_sign (void)
 376 {
 377   back_input ();
 378   cur_tok = 804;
 379   print_err("Proceed; I'll discard its present contents.");
 380   help2("I've inserted a begin-math/end-math symbol since I think",
 381           "you left one out. Proceed, with fingers crossed.");
 382   ins_error ();
 383 }
 384 /* sec 1049 */
 385 void you_cant (void)
 386 {
 387   print_err("You can't use `");
 388   print_cmd_chr(cur_cmd, cur_chr);
 389   print_string("' in ");
 390   print_mode(mode);
 391 }
 392 /* sec 1050 */
 393 void report_illegal_case (void)
 394 {
 395   you_cant ();
 396   help4("Sorry, but I'm not programmed to handle this case;",
 397           "I'll just pretend that you didn't ask for it.",
 398           "If you're in the wrong mode, you might be able to",
 399           "return to the right one by typing `I}' or `I$' or `I\\par'.");
 400   error ();
 401 }
 402 /* sec 1051 */
 403 bool privileged (void)
 404 {
 405   register bool Result;
 406   if(mode > 0)Result = true;
 407   else {
 408     report_illegal_case ();
 409     Result = false;
 410   }
 411   return Result;
 412 }
 413 /* sec 1054 */
 414 bool its_all_over (void)
 415 {/* 10 */
 416   register bool Result;
 417   if(privileged ())
 418   {
 419     if((page_head == page_tail) && (head == cur_list.tail_field) && (dead_cycles == 0))
 420     {
 421       Result = true;
 422       return(Result);
 423     }
 424     back_input ();
 425     {
 426       mem[tail].hh.v.RH = new_null_box ();
 427       tail = mem[tail].hh.v.RH;
 428     }
 429     mem[tail + 1].cint = eqtb[(hash_size + 3733)].cint;
 430     {
 431       mem[tail].hh.v.RH = new_glue(8);
 432       tail = mem[tail].hh.v.RH;
 433     }
 434     {
 435       mem[tail].hh.v.RH = new_penalty(-1073741824L);
 436     /* - 2^30  */
 437       tail = mem[tail].hh.v.RH;
 438     }
 439     build_page ();
 440   }
 441   Result = false;
 442   return Result;
 443 }
 444 /* sec 1060 */
 445 void append_glue (void)
 446 {
 447   small_number s;
 448   s = cur_chr;
 449   switch(s)
 450   {case 0 :
 451       cur_val = 4;
 452   break;
 453   case 1 :
 454     cur_val = 8;
 455     break;
 456   case 2 :
 457     cur_val = 12;
 458     break;
 459   case 3 :
 460     cur_val = 16;
 461     break;
 462   case 4 :
 463     scan_glue(2);
 464         break;
 465   case 5 :
 466     scan_glue(3);
 467         break;
 468   }
 469   {
 470     mem[tail].hh.v.RH = new_glue(cur_val);
 471     tail = mem[tail].hh.v.RH;
 472   }
 473   if(s >= 4)
 474   {
 475     decr(mem[cur_val].hh.v.RH);
 476     if(s > 4)
 477       mem[tail].hh.b1 = 99;
 478   }
 479 }
 480 /* sec 1161 */
 481 void append_kern (void)
 482 {
 483   quarterword s;
 484   s = cur_chr;
 485   scan_dimen(s == 99, false, false);
 486   {
 487     mem[tail].hh.v.RH = new_kern(cur_val);
 488     tail = mem[tail].hh.v.RH;
 489   }
 490   mem[tail].hh.b1 = s;
 491 }
 492 /* sec 1054 */
 493 void off_save (void)
 494 {
 495   halfword p;
 496   if(cur_group == 0)
 497   {
 498         print_err("Extra ");
 499     print_cmd_chr(cur_cmd, cur_chr);
 500         help1("Things are pretty mixed up, but I think the worst is over.");
 501     error ();
 502   }
 503   else {
 504
 505     back_input ();
 506     p = get_avail ();
 507     mem[temp_head].hh.v.RH = p;
 508         print_err("Missing ");
 509     switch(cur_group)
 510     {case 14 :
 511       {
 512 /*  mem[p].hh.v.LH = (hash_size + 4611);  */
 513 /*  mem[p].hh.v.LH = (hash_size + 4095 + 516);  */
 514   mem[p].hh.v.LH = (hash_size + hash_extra + 4095 + 516); /* 96/Jan/10 */
 515   print_esc("endgroup");
 516       }
 517       break;
 518     case 15 :
 519       {
 520   mem[p].hh.v.LH = 804;
 521   print_char(36);
 522       }
 523       break;
 524     case 16 :
 525       {
 526 /*  mem[p].hh.v.LH = (hash_size + 4612);  */
 527 /*  mem[p].hh.v.LH = (hash_size + 4095 + 517);  */
 528   mem[p].hh.v.LH = (hash_size + hash_extra + 4095 + 517); /* 96/Jan/10 */
 529   mem[p].hh.v.RH = get_avail ();
 530   p = mem[p].hh.v.RH;
 531   mem[p].hh.v.LH = 3118;
 532   print_esc("right.");
 533       }
 534       break;
 535       default:
 536       {
 537   mem[p].hh.v.LH = 637;
 538   print_char(125);   /* } */
 539       }
 540       break;
 541     }
 542     print_string(" inserted");
 543     begin_token_list(mem[temp_head].hh.v.RH, 4);
 544         help5("I've inserted something that you may have forgotten.",
 545                 "(See the <inserted text> above.)",
 546                 "With luck, this will get me unwedged. But if you",
 547                 "really didn't forget anything, try typing `2' now; then",
 548                 "my insertion and my current dilemma will both disappear.");
 549     error ();
 550   }
 551 }
 552 /* only called from tex8.c */
 553 /* sec 1069 */
 554 void extra_right_brace (void)
 555 {
 556   print_err("Extra }, or forgotten");
 557   switch(cur_group)
 558   {case 14 :
 559     print_esc("endgroup");
 560     break;
 561   case 15 :
 562     print_char(36); /* $ */
 563     break;
 564   case 16 :
 565     print_esc("right");
 566     break;
 567   }
 568   help5("I've deleted a group-closing symbol because it seems to be",
 569           "spurious, as in `$x}$'. But perhaps the } is legitimate and",
 570           "you forgot something else, as in `\\hbox{$x}'. In such cases",
 571           "the way to recover is to insert both the forgotten and the",
 572           "deleted material, e.g., by typing `I$}'.");
 573   error ();
 574   incr(align_state);
 575 }
 576 /* sec 1070 */
 577 void normal_paragraph (void)
 578 {
 579 /* if looseness<>0 then eq_word_define(int_base+looseness_code,0); */
 580   if(eqtb[(hash_size + 3182)].cint != 0)
 581   eq_word_define((hash_size + 3182), 0);
 582   if(eqtb[(hash_size + 3747)].cint != 0)
 583   eq_word_define((hash_size + 3747), 0);
 584   if(eqtb[(hash_size + 3204)].cint != 1)
 585   eq_word_define((hash_size + 3204), 1);
 586   if(eqtb[(hash_size + 1312)].hh.v.RH != 0)
 587   eq_define((hash_size + 1312), 118, 0);
 588 }
 589 /* sec 1075 */
 590 void box_end_(integer boxcontext)
 591 {
 592   halfword p;
 593 /* if box_context<box_flag then ... 1073741824 2^30 */
 594   if(boxcontext < 1073741824L)
 595   {
 596     if(cur_box != 0)
 597     {
 598       mem[cur_box + 4].cint = boxcontext;
 599       if(abs(mode)== 1)
 600       {
 601   append_to_vlist(cur_box);
 602   if(adjust_tail != 0)
 603   {
 604     if(adjust_head != adjust_tail)
 605     {
 606       mem[tail].hh.v.RH = mem[adjust_head].hh
 607      .v.RH;
 608       tail = adjust_tail;
 609     }
 610     adjust_tail = 0;
 611   }
 612   if(mode > 0){
 613     build_page ();
 614   }
 615       }
 616       else {
 617   if(abs(mode)== 102)
 618   space_factor = 1000;
 619   else {
 620
 621     p = new_noad ();
 622     mem[p + 1].hh.v.RH = 2;
 623     mem[p + 1].hh.v.LH = cur_box;
 624     cur_box = p;
 625   }
 626   mem[tail].hh.v.RH = cur_box;
 627   tail = cur_box;
 628       }
 629     }
 630   }
 631
 632 /* following fixed 1994/Apr/5 1 day anno Yang --- moby sigh ... */
 633
 634 /* else if box_context<box_flag+512 then ... */
 635 /*  else if(boxcontext < 1073742336L)*/   /* 2^30 + 512 */
 636   else if(boxcontext < (1073741824L + 512))   /* 2^30 + 512 */
 637 /* else if box_context<box_flag+256 then ... */
 638 /*  if(boxcontext < 1073742080L)*/ /* 2^30 + 256 */
 639   if(boxcontext < (1073741824L + 256))/* 2^30 + 256 */
 640 /* eq_define(box_base-box_flag+box_context,box_ref,cur_box) */
 641 /* eq_define((hash_size - 1073740246L) + boxcontext, 119, cur_box); */
 642   eq_define((hash_size + 1578 - 1073741824L) + boxcontext, 119, cur_box);
 643 /* else geq_define(box_base-box_flag-256+box_context,box_ref,cur_box) */
 644 /* else geq_define((hash_size - 1073740502L) + boxcontext, 119, cur_box); */
 645   else geq_define((hash_size + 1322 - 1073741824L) + boxcontext, 119, cur_box);
 646   else if(cur_box != 0)
 647 /*  if(boxcontext > 1073742336L)*/  /* 2^30 + 512 */
 648   if(boxcontext > (1073741824L + 512)) /* 2^30 + 512 */
 649   {
 650     do {
 651     get_x_token ();
 652     } while(!((cur_cmd != 10)&&(cur_cmd != 0)));
 653 /* 424 in tex82.bug */
 654     if(((cur_cmd == 26) && (abs(mode)!= 1)) ||
 655                 ((cur_cmd == 27) && (abs(mode)== 1)))
 656     {
 657 /*   begin append_glue; subtype(tail):=box_context-(leader_flag-a_leaders); */
 658       append_glue ();
 659 /*      -(2^30 + 513 - 100)  */
 660       mem[tail].hh.b1 = boxcontext -(1073742237L);
 661       mem[tail + 1].hh.v.RH = cur_box;
 662     }
 663     else {
 664     print_err("Leaders not followed by proper glue");
 665         help3("You should say `\\leaders <box or rule><hskip or vskip>'.",
 666                 "I found the <box or rule>, but there's no suitable",
 667                 "<hskip or vskip>, so I'm ignoring these leaders.");
 668       back_error ();
 669       flush_node_list(cur_box);
 670   }
 671   }
 672   else ship_out(cur_box);
 673 }
 674 /* called only from tex8.c */
 675 /* sec 1079 */
 676 void begin_box_(integer boxcontext)
 677 {/* 10 30 */
 678   halfword p, q;
 679   quarterword m;
 680   halfword k;
 681   eight_bits n;
 682   switch(cur_chr){
 683   case 0 :
 684     {
 685       scan_eight_bit_int ();
 686       cur_box = eqtb[(hash_size + 1578) + cur_val].hh.v.RH;
 687       eqtb[(hash_size + 1578) + cur_val].hh.v.RH = 0;
 688     }
 689     break;
 690   case 1 :
 691     {
 692       scan_eight_bit_int ();
 693       cur_box = copy_node_list(eqtb[(hash_size + 1578) + cur_val].hh.v.RH);
 694     }
 695     break;
 696   case 2 :
 697     {
 698       cur_box = 0;
 699       if(abs(mode)== 203)
 700       {
 701   you_cant ();
 702   help1("Sorry; this \\lastbox will be void.");
 703   error ();
 704       }
 705       else if((mode == 1)&&(head == cur_list
 706      .tail_field))
 707       {
 708   you_cant ();
 709   help2("Sorry...I usually can't take things from the current page.",
 710           "This \\lastbox will therefore be void.");
 711   error ();
 712       }
 713       else {
 714   if(!(tail >= hi_mem_min))
 715   if((mem[tail].hh.b0 == 0)||(mem[cur_list
 716  .tail_field].hh.b0 == 1))
 717   {
 718     q = head;
 719     do {
 720         p = q;
 721       if(!(q >= hi_mem_min))
 722       if(mem[q].hh.b0 == 7)
 723       {
 724         {
 725         register integer for_end;
 726         m = 1;
 727         for_end = mem[q].hh.b1;
 728         if(m <= for_end) do
 729           p = mem[p].hh.v.RH;
 730         while(m++ < for_end);
 731       }
 732         if(p == tail)
 733         goto lab30;
 734       }
 735       q = mem[p].hh.v.RH;
 736     } while(!(q == tail));
 737     cur_box = tail;
 738     mem[cur_box + 4].cint = 0;
 739     tail = p;
 740     mem[p].hh.v.RH = 0;
 741     lab30:;
 742   }
 743       }
 744     }
 745     break;
 746   case 3 :
 747     {
 748       scan_eight_bit_int ();
 749       n = cur_val;
 750       if(! scan_keyword(836))  /* to */
 751       {
 752                   print_err("Missing `to' inserted");
 753                   help2("I'm working on `\\vsplit<box number> to <dimen>';",
 754                           "will look for the <dimen> next.");
 755   error ();
 756       }
 757       scan_dimen(false, false, false);
 758       cur_box = vsplit(n, cur_val);
 759     }
 760     break;
 761     default:
 762     {
 763       k = cur_chr - 4;
 764       save_stack[save_ptr + 0].cint = boxcontext;
 765       if(k == 102)
 766       if((boxcontext < 1073741824L)&& /* 2^30 */
 767       (abs(mode)== 1)
 768     )
 769       scan_spec(3, true);
 770       else scan_spec(2, true);
 771       else {
 772
 773   if(k == 1)
 774   scan_spec(4, true);
 775   else {
 776
 777     scan_spec(5, true);
 778     k = 1;
 779   }
 780   normal_paragraph ();
 781       }
 782       push_nest ();
 783       mode = - (integer) k;
 784       if(k == 1)
 785       {
 786   cur_list.aux_field.cint = ignore_depth;
 787   if(eqtb[(hash_size + 1318)].hh.v.RH != 0)/* everyhbox */
 788   begin_token_list(eqtb[(hash_size + 1318)].hh.v.RH, 11);
 789       }
 790       else {
 791
 792   space_factor = 1000;
 793   if(eqtb[(hash_size + 1317)].hh.v.RH != 0)/* everyhbox */
 794     begin_token_list(eqtb[(hash_size + 1317)].hh.v.RH, 10);
 795       }
 796       return;
 797     }
 798     break;
 799   }
 800   box_end(boxcontext);
 801 }
 802 /* sec 1084 */
 803 void scan_box_(integer boxcontext)
 804 {
 805   do {
 806       get_x_token ();
 807   } while(!((cur_cmd != 10)&&(cur_cmd != 0)));
 808   if(cur_cmd == 20){
 809     begin_box(boxcontext);
 810   }
 811   else if((boxcontext >= 1073742337L)&& /* (2^30 + 512 + 1)  */
 812      ((cur_cmd == 36)||(cur_cmd == 35)))
 813   {
 814     cur_box = scan_rule_spec ();
 815     box_end(boxcontext);
 816   }
 817   else {
 818       print_err("A <box> was supposed to be here");
 819           help3("I was expecting to see \\hbox or \\vbox or \\copy or \\box or",
 820                   "something like that. So you might find something missing in",
 821                   "your output. But keep trying; you can fix this later.");
 822     back_error ();
 823   }
 824 }
 825 /****************************************************************************/
 826 void package_ (small_number);
 827 /****************************************************************************/
 828 /* sec 1091 */
 829 small_number norm_min_ (integer h)
 830 {register
 831 /*  small_number Result; */
 832   int Result;               /* 95/Jan/7 */
 833   if(h <= 0)
 834     Result = 1;
 835   else if(h >= 63)
 836     Result = 63;
 837   else Result = h;
 838   return Result;
 839 }
 840 /* sec 1091 */
 841 void new_graf_(bool indented)
 842 {
 843   prev_graf = 0;
 844   if((mode == 1)||(head != cur_list
 845  .tail_field))
 846   {
 847     mem[tail].hh.v.RH = new_param_glue(2);
 848     tail = mem[tail].hh.v.RH;
 849   }
 850 /* used to be followingin 3.141 */
 851 /*  cur_list .lhmfield = norm_min(eqtb[(hash_size + 3214)].cint); */
 852 /*  cur_list .rhmfield = norm_min(eqtb[(hash_size + 3215)].cint); */
 853   push_nest ();
 854   mode = 102;
 855   space_factor = 1000;
 856 /* changes here since 3.141 */
 857   if(eqtb[(hash_size + 3213)].cint <= 0)
 858   cur_lang = 0;
 859   else if(eqtb[(hash_size + 3213)].cint > 255)
 860   cur_lang = 0;
 861   else cur_lang = eqtb[(hash_size + 3213)].cint;
 862   clang = cur_lang;
 863   prev_graf =(norm_min(eqtb[(hash_size + 3214)].cint)* 64 +
 864      norm_min(eqtb[(hash_size + 3215)].cint)) * 65536L + cur_lang;
 865 /* eqtb ??? hash_size ? hash_size + hash_extra ? norm_min etc */
 866 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
 867   if(indented)
 868   {
 869     tail = new_null_box ();
 870     mem[head].hh.v.RH = tail;
 871     mem[tail + 1].cint = eqtb[(hash_size + 3730)].cint;
 872   }
 873   if(eqtb[(hash_size + 1314)].hh.v.RH != 0)  /* everypar */
 874     begin_token_list(eqtb[(hash_size + 1314)].hh.v.RH, 7);
 875   if(nest_ptr == 1){
 876     build_page ();
 877   }
 878 }
 879 /* procedure indent_in_hmode; l.21058 */
 880 /* sec 1093 */
 881 void indent_in_hmode (void)
 882 {
 883   halfword p, q;
 884   if(cur_chr > 0)
 885   {
 886     p = new_null_box ();
 887     mem[p + 1].cint = eqtb[(hash_size + 3730)].cint;
 888     if(abs(mode)== 102)
 889     space_factor = 1000;
 890     else {
 891
 892       q = new_noad ();
 893       mem[q + 1].hh.v.RH = 2;
 894       mem[q + 1].hh.v.LH = p;
 895       p = q;
 896     }
 897     {
 898       mem[tail].hh.v.RH = p;
 899       tail = mem[tail].hh.v.RH;
 900     }
 901   }
 902 }
 903 /* only called from tex8.c */
 904 /* sec 1095 */
 905 void head_for_vmode (void)
 906 {
 907   if(mode < 0)
 908   if(cur_cmd != 36){
 909     off_save ();
 910   }
 911   else {
 912           print_err("You can't use `");
 913     print_esc("hrule");
 914     print_string("' here except with leaders");
 915         help2("To put a horizontal rule in an hbox or an alignment,",
 916                 "you should use \\leaders or \\hrulefill (see The TeXbook).");
 917     error ();
 918   }
 919   else {
 920
 921     back_input ();
 922     cur_tok = par_token;
 923     back_input ();
 924     cur_input.index_field = 4;
 925   }
 926 }
 927 /* sec 1096 */
 928 void end_graf (void)
 929 {
 930   if(mode == 102)
 931   {
 932     if(head == tail)
 933     pop_nest ();
 934     else line_break(eqtb[(hash_size + 3169)].cint);
 935     normal_paragraph ();
 936     error_count = 0;
 937   }
 938 }
 939 /* only called form tex8.c */
 940 /* sec 1099 */
 941 void begin_insert_or_adjust (void)
 942 {
 943   if(cur_cmd == 38)
 944   cur_val = 255;
 945   else {
 946
 947     scan_eight_bit_int ();
 948     if(cur_val == 255)
 949     {
 950                 print_err("You can't ");
 951       print_esc("insert");
 952       print_int(255);
 953           help1("I'm changing to \\insert0; box 255 is special.");
 954       error ();
 955       cur_val = 0;
 956     }
 957   }
 958   save_stack[save_ptr + 0].cint = cur_val;
 959   incr(save_ptr);
 960   new_save_level(11);
 961   scan_left_brace ();
 962   normal_paragraph ();
 963   push_nest ();
 964   mode = -1;
 965   cur_list.aux_field.cint = ignore_depth;
 966 }
 967 /* sec 1101 */
 968 void make_mark (void)
 969 {
 970   halfword p;
 971   p = scan_toks(false, true);
 972   p = get_node(2);
 973   mem[p].hh.b0 = 4;
 974   mem[p].hh.b1 = 0;
 975   mem[p + 1].cint = def_ref;
 976   mem[tail].hh.v.RH = p;
 977   tail = p;
 978 }
 979 /* sec 1103 */
 980 void append_penalty (void)
 981 {
 982     scan_int ();
 983   {
 984     mem[tail].hh.v.RH = new_penalty(cur_val);
 985     tail = mem[tail].hh.v.RH;
 986   }
 987   if(mode == 1){
 988     build_page ();
 989   }
 990 }
 991 /* only called from tex8.c */
 992 /* sec 1105 */
 993 void delete_last (void)
 994 {/* 10 */
 995   halfword p, q;
 996   quarterword m;
 997   if((mode == 1)&&(tail == cur_list
 998  .head_field))
 999   {
1000 /*    if((cur_chr != 10)||(last_glue != 262143L)) */
1001     if((cur_chr != 10)||(last_glue != empty_flag))
1002     {
1003       you_cant ();
1004           help2("Sorry...I usually can't take things from the current page.",
1005                   "Try `I\\vskip-\\lastskip' instead.");
1006       if(cur_chr == 11)
1007       help_line[0] = "Try `I\\kern-\\last_kern' instead.";
1008       else if(cur_chr != 10)
1009       help_line[0] = "Perhaps you can make the output routine do it.";
1010       error ();
1011     }
1012   }
1013   else {
1014
1015     if(!(tail >= hi_mem_min))
1016     if(mem[tail].hh.b0 == cur_chr)
1017     {
1018       q = head;
1019       do {
1020     p = q;
1021   if(!(q >= hi_mem_min))
1022   if(mem[q].hh.b0 == 7)
1023   {
1024     {
1025       register integer for_end;
1026       m = 1;
1027       for_end = mem[q].hh.b1;
1028       if(m <= for_end) do
1029         p = mem[p].hh.v.RH;
1030       while(m++ < for_end);
1031     }
1032     if(p == tail)
1033     return;
1034   }
1035   q = mem[p].hh.v.RH;
1036       } while(!(q == tail));
1037       mem[p].hh.v.RH = 0;
1038       flush_node_list(tail);
1039       tail = p;
1040     }
1041   }
1042 }
1043 /* only called from tex8.c */
1044 /* procedure unpackage; l.21256 */
1045 /* sec 1110 */
1046 void unpackage (void)
1047 {/* 10 */
1048   halfword p;
1049   char c;
1050   c = cur_chr;
1051   scan_eight_bit_int ();
1052   p = eqtb[(hash_size + 1578) + cur_val].hh.v.RH;
1053   if(p == 0)/* if p=null then return; l.21261 */
1054   return;
1055   if((abs(mode)== 203)||((abs(mode)
1056   == 1)&&(mem[p].hh.b0 != 1)) ||((abs(mode)==
1057   102)&&(mem[p].hh.b0 != 0)))
1058   {
1059           print_err("Incompatible list can't be unboxed");
1060           help3("Sorry, Pandora. (You sneaky devil.)",
1061                   "I refuse to unbox an \\hbox in vertical mode or vice versa.",
1062                   "And I can't open any boxes in math mode.");
1063     error ();
1064     return;
1065   }
1066   if(c == 1)
1067   mem[tail].hh.v.RH = copy_node_list(mem[p + 5].hh
1068  .v.RH);
1069   else {
1070
1071     mem[tail].hh.v.RH = mem[p + 5].hh.v.RH;
1072     eqtb[(hash_size + 1578) + cur_val].hh.v.RH = 0;
1073     free_node(p, 7);
1074   }
1075   while(mem[tail].hh.v.RH != 0)tail = mem
1076  [tail].hh.v.RH;
1077 }
1078 /* sec 1113 */
1079 void append_italic_correction (void)
1080 {/* 10 */
1081   halfword p;
1082   internal_font_number f;
1083   if(tail != head)
1084   {
1085     if((tail >= hi_mem_min))
1086     p = tail;
1087     else if(mem[tail].hh.b0 == 6)
1088     p = tail + 1;
1089     else return;
1090     f = mem[p].hh.b0;
1091     {
1092       mem[tail].hh.v.RH = new_kern(font_info[italic_base[
1093       f]+(font_info[char_base[f]+ mem[p].hh.b1].qqqq.b2)/ 4]
1094      .cint);
1095       tail = mem[tail].hh.v.RH;
1096     }
1097     mem[tail].hh.b1 = 1;
1098   }
1099 }
1100 /* sec 1117 */
1101 void append_discretionary (void)
1102 {
1103   integer c;
1104   {
1105     mem[tail].hh.v.RH = new_disc ();
1106     tail = mem[tail].hh.v.RH;
1107   }
1108   if(cur_chr == 1)
1109   {
1110     c = hyphen_char[eqtb[(hash_size + 1834)].hh.v.RH];
1111     if(c >= 0)
1112     if(c < 256)
1113     mem[tail + 1].hh.v.LH = new_character(eqtb[(hash_size + 1834)]
1114    .hh.v.RH, c);
1115   }
1116   else {
1117
1118     incr(save_ptr);
1119     save_stack[save_ptr - 1].cint = 0;
1120     new_save_level(10);
1121     scan_left_brace ();
1122     push_nest ();
1123     mode = -102;
1124     space_factor = 1000;
1125   }
1126 }
1127 /* only called form tex8.c */
1128 /* sec 1119 */
1129 void build_discretionary (void)
1130 {/* 30 10 */
1131   halfword p, q;
1132   integer n;
1133   unsave ();
1134   q = head;
1135   p = mem[q].hh.v.RH;
1136   n = 0;
1137   while(p != 0){
1138
1139     if(!(p >= hi_mem_min))
1140     if(mem[p].hh.b0 > 2)
1141     if(mem[p].hh.b0 != 11)
1142     if(mem[p].hh.b0 != 6)
1143     {
1144                 print_err("Improper discretionary list");
1145                 help1("Discretionary lists must contain only boxes and kerns.");
1146       error ();
1147       begin_diagnostic ();
1148       print_nl("The following discretionary sublist has been deleted:");  /*  */
1149       show_box(p);
1150       end_diagnostic(true);
1151       flush_node_list(p);
1152       mem[q].hh.v.RH = 0;
1153       goto lab30;
1154     }
1155     q = p;
1156     p = mem[q].hh.v.RH;
1157     incr(n);
1158   }
1159   lab30:;
1160   p = mem[head].hh.v.RH;
1161   pop_nest ();
1162   switch(save_stack[save_ptr - 1].cint)
1163   {case 0 :
1164     mem[tail + 1].hh.v.LH = p;
1165     break;
1166   case 1 :
1167     mem[tail + 1].hh.v.RH = p;
1168     break;
1169   case 2 :
1170     {
1171       if((n > 0)&&(abs(mode)== 203))
1172       {
1173                   print_err("Illegal math ");
1174   print_esc("discretionary");
1175   help2("Sorry: The third part of a discretionary break must be",
1176           "empty, in math formulas. I had to delete your third part.");
1177   flush_node_list(p);
1178   n = 0;
1179   error ();
1180       }
1181       else mem[tail].hh.v.RH = p;
1182 /* if n <= max_quarterword then replace_count(tail) <- n; p.1120 */
1183 /*      if(n <= 255) */       /* 94/Apr/4 ? */
1184       if(n <= max_quarterword)     /* 96/Oct/12 ??? */
1185       mem[tail].hh.b1 = n;
1186       else {
1187     print_err("Discretionary list is too long");
1188         help2("Wow---I never thought anybody would tweak me here.",
1189                 "You can't seriously need such a huge discretionary list?");
1190   error ();
1191       }
1192       if(n > 0)
1193       tail = q;
1194       decr(save_ptr);
1195       return;
1196     }
1197     break;
1198   }
1199   incr(save_stack[save_ptr - 1].cint);
1200   new_save_level(10);
1201   scan_left_brace ();
1202   push_nest ();
1203   mode = -102;
1204   space_factor = 1000;
1205 }
1206 /* called only from tex8.c */
1207 /* sec 1123 */
1208 void make_accent (void)
1209 {
1210   real s, t;
1211   halfword p, q, r;
1212   internal_font_number f;
1213   scaled a, h, x, w, delta;
1214   ffourquarters i;
1215   scan_char_num ();
1216   f = eqtb[(hash_size + 1834)].hh.v.RH;
1217   p = new_character(f, cur_val);
1218   if(p != 0)
1219   {
1220     x = font_info[5 + param_base[f]].cint;
1221     s = font_info[1 + param_base[f]].cint / ((double) 65536.0);
1222     a = font_info[width_base[f]+ font_info[char_base[f]+ mem[p]
1223     .hh.b1].qqqq.b0].cint;
1224     do_assignments ();
1225     q = 0;
1226     f = eqtb[(hash_size + 1834)].hh.v.RH;
1227     if((cur_cmd == 11)||(cur_cmd == 12)||(cur_cmd == 68))
1228     q = new_character(f, cur_chr);
1229     else if(cur_cmd == 16)
1230     {
1231       scan_char_num ();
1232       q = new_character(f, cur_val);
1233     }
1234     else back_input ();
1235     if(q != 0)
1236     {
1237       t = font_info[1 + param_base[f]].cint / ((double) 65536.0);
1238       i = font_info[char_base[f]+ mem[q].hh.b1].qqqq;
1239       w = font_info[width_base[f]+ i.b0].cint;
1240       h = font_info[height_base[f]+(i.b1)/ 16].cint;
1241       if(h != x)
1242       {
1243   p = hpack(p, 0, 1);
1244   mem[p + 4].cint = x - h;
1245       }
1246       delta = round((w - a)/ ((double) 2.0)+ h * t - x * s);
1247       r = new_kern(delta);
1248       mem[r].hh.b1 = 2;
1249       mem[tail].hh.v.RH = r;
1250       mem[r].hh.v.RH = p;
1251       tail = new_kern(- (integer) a - delta);
1252       mem[tail].hh.b1 = 2;
1253       mem[p].hh.v.RH = tail;
1254       p = q;
1255     }
1256     mem[tail].hh.v.RH = p;
1257     tail = p;
1258     space_factor = 1000;
1259   }
1260 }
1261 /* sec 1127 */
1262 void align_error (void)
1263 {
1264   if(abs(align_state)> 2){
1265           print_err("Misplaced ");
1266     print_cmd_chr(cur_cmd, cur_chr);
1267     if(cur_tok == 1062) {
1268                 help6("I can't figure out why you would want to use a tab mark",
1269                         "here. If you just want an ampersand, the remedy is",
1270                         "simple: Just type `I\\&' now. But if some right brace",
1271                         "up above has ended a previous alignment prematurely,",
1272                         "you're probably due for more error messages, and you",
1273                         "might try typing `S' now just to see what is salvageable.");
1274     }
1275     else {
1276                 help5("I can't figure out why you would want to use a tab mark",
1277                         "or \\cr or \\span just now. If something like a right brace",
1278                         "up above has ended a previous alignment prematurely,",
1279                         "you're probably due for more error messages, and you",
1280                         "might try typing `S' now just to see what is salvageable.");
1281     }
1282     error ();
1283   }
1284   else {
1285     back_input ();
1286     if(align_state < 0) {
1287                 print_err("Missing { inserted");
1288       incr(align_state);
1289       cur_tok = 379;    /* belowdisplayshortskip ? */
1290     }
1291     else {
1292                 print_err("Missing } inserted");
1293       decr(align_state);
1294       cur_tok = 637;
1295     }
1296         help3("I've put in what seems to be necessary to fix",
1297                 "the current column of the current alignment.",
1298                 "Try to go on, since this might almost work.");
1299     ins_error ();
1300   }
1301 }
1302 /* sec 1129 */
1303 void noalign_error (void)
1304 {
1305   print_err("Misplaced ");
1306   print_esc("noalign");
1307   help2("I expect to see \\noalign only after the \\cr of",
1308           "an alignment. Proceed, and I'll ignore this case.");
1309   error ();
1310 }
1311 /* only called from tex8.c */
1312 /* sec 1129 */
1313 void omit_error (void)
1314 {
1315   print_err("Misplaced ");
1316   print_esc("omit");
1317   help2("I expect to see \\omit only after tab marks or the \\cr of",
1318           "an alignment. Proceed, and I'll ignore this case.");
1319   error ();
1320 }
1321 /* sec 1131 */
1322 void do_endv (void)
1323 {
1324   if(cur_group == 6) {
1325     end_graf ();
1326     if(fin_col ())fin_row ();
1327   }
1328   else off_save ();
1329 }
1330 /* only called form tex8.c */
1331 /* sec 1135 */
1332 void cs_error (void)
1333 {
1334   print_err("Extra ");
1335   print_esc("endcsname");
1336   help1("I'm ignoring this, since I wasn't doing a \\csname.");
1337   error ();
1338 }
1339 /* sec 1136 */
1340 void push_math_(group_code c)
1341 {
1342   push_nest ();
1343   mode = -203;
1344   cur_list.aux_field.cint = 0;
1345   new_save_level(c);
1346 }
1347 /* sec 1138 */
1348 void init_math (void)
1349 {/* 21 40 45 30 */
1350   scaled w;
1351   scaled l;
1352   scaled s;
1353   halfword p;
1354   halfword q;
1355   internal_font_number f;
1356   integer n;
1357   scaled v;
1358   scaled d;
1359   get_token ();
1360   if((cur_cmd == 3)&&(mode > 0))
1361   {
1362     if(head == tail)
1363     {
1364       pop_nest ();
1365       w = -1073741823L; /* - (2^30 - 1) */
1366     }
1367     else {
1368
1369       line_break(eqtb[(hash_size + 3170)].cint);
1370       v = mem[just_box + 4].cint + 2 * font_info[6 +
1371       param_base[eqtb[(hash_size + 1834)].hh.v.RH]].cint;
1372       w = -1073741823L;  /* - (2^30 - 1) */
1373       p = mem[just_box + 5].hh.v.RH;
1374       while(p != 0){
1375
1376   lab21: if((p >= hi_mem_min))
1377   {
1378     f = mem[p].hh.b0;
1379     d = font_info[width_base[f]+ font_info[char_base[f]+ mem[p
1380   ].hh.b1].qqqq.b0].cint;
1381     goto lab40;
1382   }
1383   switch(mem[p].hh.b0)
1384   {case 0 :
1385   case 1 :
1386   case 2 :
1387     {
1388       d = mem[p + 1].cint;
1389       goto lab40;
1390     }
1391     break;
1392   case 6 :
1393     {
1394       mem[lig_trick]= mem[p + 1];
1395       mem[lig_trick].hh.v.RH = mem[p].hh.v.RH;
1396       p = lig_trick;
1397       goto lab21;
1398     }
1399     break;
1400   case 11 :
1401   case 9 :
1402     d = mem[p + 1].cint;
1403     break;
1404   case 10 :
1405     {
1406       q = mem[p + 1].hh.v.LH;
1407       d = mem[q + 1].cint;
1408       if(mem[just_box + 5].hh.b0 == 1)
1409       {
1410         if((mem[just_box + 5].hh.b1 == mem[q].hh.b0)&&(mem
1411        [q + 2].cint != 0))
1412         v = 1073741823L;  /* - (2^30 - 1) */
1413       }
1414       else if(mem[just_box + 5].hh.b0 == 2)
1415       {
1416         if((mem[just_box + 5].hh.b1 == mem[q].hh.b1)&&(mem
1417        [q + 3].cint != 0))
1418         v = 1073741823L;  /* - (2^30 - 1) */
1419       }
1420       if(mem[p].hh.b1 >= 100)
1421       goto lab40;
1422     }
1423     break;
1424   case 8 :
1425     d = 0;
1426     break;
1427     default:
1428     d = 0;
1429     break;
1430   }
1431   if(v < 1073741823L) /* - (2^30 - 1) */
1432   v = v + d;
1433   goto lab45;
1434   lab40: if(v < 1073741823L) /* - (2^30 - 1) */
1435   {
1436     v = v + d;
1437     w = v;
1438   }
1439   else {
1440
1441     w = 1073741823L;  /* - (2^30 - 1) */
1442     goto lab30;
1443   }
1444   lab45: p = mem[p].hh.v.RH;
1445       }
1446       lab30:;
1447     }
1448     if(eqtb[(hash_size + 1312)].hh.v.RH == 0)
1449     if((eqtb[(hash_size + 3747)].cint != 0)&&(((eqtb[(hash_size + 3204)].cint >= 0)&&
1450    (prev_graf + 2 > eqtb[(hash_size + 3204)].cint)) ||(prev_graf +
1451     1 < - (integer) eqtb[(hash_size + 3204)].cint)))
1452     {
1453       l = eqtb[(hash_size + 3733)].cint - abs(eqtb[(hash_size + 3747)].cint);
1454       if(eqtb[(hash_size + 3747)].cint > 0)
1455       s = eqtb[(hash_size + 3747)].cint;
1456       else s = 0;
1457     }
1458     else {
1459
1460       l = eqtb[(hash_size + 3733)].cint;
1461       s = 0;
1462     }
1463     else {
1464
1465       n = mem[eqtb[(hash_size + 1312)].hh.v.RH].hh.v.LH;
1466       if(prev_graf + 2 >= n)
1467       p = eqtb[(hash_size + 1312)].hh.v.RH + 2 * n;
1468       else p = eqtb[(hash_size + 1312)].hh.v.RH + 2 *(prev_graf + 2);
1469       s = mem[p - 1].cint;
1470       l = mem[p].cint;
1471     }
1472     push_math(15);
1473     mode = 203;
1474     eq_word_define((hash_size + 3207), -1);
1475     eq_word_define((hash_size + 3743), w);
1476     eq_word_define((hash_size + 3744), l);
1477     eq_word_define((hash_size + 3745), s);
1478     if(eqtb[(hash_size + 1316)].hh.v.RH != 0)/* everydisplay */
1479     begin_token_list(eqtb[(hash_size + 1316)].hh.v.RH, 9);
1480     if(nest_ptr == 1){
1481     build_page ();
1482   }
1483   }
1484   else {
1485
1486     back_input ();
1487     {
1488       push_math(15);
1489       eq_word_define((hash_size + 3207), -1);
1490       if(eqtb[(hash_size + 1315)].hh.v.RH != 0)/* everymath */
1491       begin_token_list(eqtb[(hash_size + 1315)].hh.v.RH, 8);
1492     }
1493   }
1494 }
1495 /* sec 1142 */
1496 void start_eq_no (void)
1497 {
1498   save_stack[save_ptr + 0].cint = cur_chr;
1499   incr(save_ptr);
1500   {
1501     push_math(15);
1502     eq_word_define((hash_size + 3207), -1);
1503     if(eqtb[(hash_size + 1315)].hh.v.RH != 0)/* everymath */
1504     begin_token_list(eqtb[(hash_size + 1315)].hh.v.RH, 8);
1505   }
1506 }
1507 /* sec 1151 */
1508 void scan_math_(halfword p)
1509 {/* 20 21 10 */
1510   integer c;
1511   lab20: do {
1512       get_x_token ();
1513   } while(!((cur_cmd != 10)&&(cur_cmd != 0)));
1514   lab21: switch(cur_cmd)
1515   {case 11 :
1516   case 12 :
1517   case 68 :
1518     {
1519       c = eqtb[(hash_size + 2907) + cur_chr].hh.v.RH;
1520       if(c == 32768L)
1521       {
1522   {
1523     cur_cs = cur_chr + 1;
1524     cur_cmd = eqtb[cur_cs].hh.b0;
1525     cur_chr = eqtb[cur_cs].hh.v.RH;
1526     x_token ();
1527     back_input ();
1528   }
1529   goto lab20;
1530       }
1531     }
1532     break;
1533   case 16 :
1534     {
1535       scan_char_num ();
1536       cur_chr = cur_val;
1537       cur_cmd = 68;
1538       goto lab21;
1539     }
1540     break;
1541   case 17 :
1542     {
1543       scan_fifteen_bit_int ();
1544       c = cur_val;
1545     }
1546     break;
1547   case 69 :
1548     c = cur_chr;
1549     break;
1550   case 15 :
1551     {
1552       scan_twenty_seven_bit_int ();
1553       c = cur_val / 4096;
1554 /*      c = cur_val >> 12; */
1555     }
1556     break;
1557     default:
1558     {
1559       back_input ();
1560       scan_left_brace ();
1561       save_stack[save_ptr + 0].cint = p;
1562       incr(save_ptr);
1563       push_math(9);
1564       return;
1565     }
1566     break;
1567   }
1568   mem[p].hh.v.RH = 1;
1569   mem[p].hh.b1 = c % 256;
1570 /*  mem[p].hh.b1 = c & 255; */ /* last 8 bits */
1571   if((c >= 28672)&& /* 32768 - 4096 ??? if (c>=var_code) and ... */
1572     ((eqtb[(hash_size + 3207)].cint >= 0)&&
1573     (eqtb[(hash_size + 3207)].cint < 16)))
1574   mem[p].hh.b0 = eqtb[(hash_size + 3207)].cint;
1575   else mem[p].hh.b0 =(c / 256)% 16;
1576 /*  else mem[p].hh.b0 =(c >> 8)& 15; */ /* 4 bits to left */
1577 }
1578 /* sec 1155 */
1579 void set_math_char_(integer c)
1580 {
1581   halfword p;
1582   if(c >= 32768L)
1583   {
1584     cur_cs = cur_chr + 1;          /* ??? */
1585 /*    cur_cmd = eqtb[eqtbextra + cur_cs].hh.b0;  */ /* was wrong ??? */
1586     cur_cmd = eqtb[cur_cs].hh.b0;
1587 /*    cur_chr = eqtb[cur_cs].hh.v.RH; */ /* should have been eqtbextra ? */
1588     cur_chr = eqtb[cur_cs].hh.v.RH;
1589     x_token ();
1590     back_input ();
1591   }
1592   else {
1593
1594     p = new_noad ();
1595     mem[p + 1].hh.v.RH = 1;
1596     mem[p + 1].hh.b1 = c % 256;
1597 /*    mem[p + 1].hh.b1 = c & 255;  */ /* last 8 bits */
1598     mem[p + 1].hh.b0 =(c / 256)% 16;
1599 /*    mem[p + 1].hh.b0 =(c >> 8)& 15;  */ /* 4 bits to left */
1600     if(c >= 28672)  /* 32768 - 4096 ? */
1601     {
1602       if(((eqtb[(hash_size + 3207)].cint >= 0)&&(eqtb[(hash_size + 3207)].cint < 16))
1603     )
1604       mem[p + 1].hh.b0 = eqtb[(hash_size + 3207)].cint;
1605       mem[p].hh.b0 = 16;
1606     }
1607     else mem[p].hh.b0 = 16 +(c / 4096);
1608 /*    else mem[p].hh.b0 = 16 +(c >> 12);  */
1609     mem[tail].hh.v.RH = p;
1610     tail = p;
1611   }
1612 }
1613 /* sec 1159 */
1614 void math_limit_switch (void)
1615 {/* 10 */
1616   if(head != tail)
1617   if(mem[tail].hh.b0 == 17)
1618   {
1619     mem[tail].hh.b1 = cur_chr;
1620     return;
1621   }
1622   print_err("Limit controls must follow a math operator");
1623   help1("I'm ignoring this misplaced \\limits or \\nolimits command.");
1624   error ();
1625 }
1626 /* sec 1160 */
1627 void scan_delimiter_(halfword p, bool r)
1628 {
1629    if(r){
1630    scan_twenty_seven_bit_int ();
1631   }
1632   else {
1633
1634     do {
1635   get_x_token ();
1636     } while(!((cur_cmd != 10)&&(cur_cmd != 0)));
1637     switch(cur_cmd)
1638     {case 11 :
1639     case 12 :
1640       cur_val = eqtb[(hash_size + 3474) + cur_chr].cint;
1641       break;
1642     case 15 :
1643       scan_twenty_seven_bit_int ();
1644       break;
1645       default:
1646       cur_val = -1;
1647       break;
1648     }
1649   }
1650   if(cur_val < 0)
1651   {
1652           print_err("Missing delimiter (. inserted)");
1653           help6("I was expecting to see something like `(' or `\\{' or",
1654                   "`\\}' here. If you typed, e.g., `{' instead of `\\{', you",
1655                   "should probably delete the `{' by typing `1' now, so that",
1656                   "braces don't get unbalanced. Otherwise just proceed.",
1657                   "Acceptable delimiters are characters whose \\delcode is",
1658                   "nonnegative, or you can use `\\delimiter <delimiter code>'.");
1659     back_error ();
1660     cur_val = 0;
1661   }
1662 /* attempt to speed up - bkph */  /* is compiler smart enough already ? */
1663   mem[p].qqqq.b0 =(cur_val / 1048576L)% 16;   /* 2^20 */
1664 /*  mem[p].qqqq.b0 =(cur_val >> 20)& 15;  */
1665   mem[p].qqqq.b1 =(cur_val / 4096)% 256;
1666 /*  mem[p].qqqq.b1 =(cur_val >> 12)& 255; */
1667   mem[p].qqqq.b2 =(cur_val / 256)% 16;
1668 /*  mem[p].qqqq.b2 =(cur_val >> 8)& 15; */
1669   mem[p].qqqq.b3 = cur_val % 256;
1670 /*  mem[p].qqqq.b3 = cur_val & 255;  */
1671 }
1672 /* sec 1163 */
1673 void math_radical (void)
1674 {
1675   {
1676     mem[tail].hh.v.RH = get_node(5);
1677     tail = mem[tail].hh.v.RH;
1678   }
1679   mem[tail].hh.b0 = 24;
1680   mem[tail].hh.b1 = 0;
1681   mem[tail + 1].hh = empty_field;
1682   mem[tail + 3].hh = empty_field;
1683   mem[tail + 2].hh = empty_field;
1684   scan_delimiter(tail + 4, true);
1685   scan_math(tail + 1);
1686 }
1687 /* sec 1165 */
1688 void math_ac (void)
1689 {
1690   if(cur_cmd == 45)
1691   {
1692     print_err("Please use ");
1693     print_esc("mathaccent");
1694     print_string(" for accents in math mode");
1695         help2("I'm changing \\accent to \\mathaccent here; wish me luck.",
1696                 "(Accents are not the same in formulas as they are in text.)");
1697     error ();
1698   }
1699   {
1700     mem[tail].hh.v.RH = get_node(5);
1701     tail = mem[tail].hh.v.RH;
1702   }
1703   mem[tail].hh.b0 = 28;
1704   mem[tail].hh.b1 = 0;
1705   mem[tail + 1].hh = empty_field;
1706   mem[tail + 3].hh = empty_field;
1707   mem[tail + 2].hh = empty_field;
1708   mem[tail + 4].hh.v.RH = 1;
1709   scan_fifteen_bit_int ();
1710   mem[tail + 4].hh.b1 = cur_val % 256;
1711 /*  mem[tail + 4].hh.b1 = cur_val & 255; */
1712   if((cur_val >= 28672)&& /* 32768 - 4096 ? */
1713     ((eqtb[(hash_size + 3207)].cint >= 0)&&
1714     (eqtb[(hash_size + 3207)].cint < 16)))
1715   mem[tail + 4].hh.b0 = eqtb[(hash_size + 3207)].cint;
1716   else mem[tail + 4].hh.b0 =(cur_val / 256)% 16;
1717 /*  else mem[tail + 4].hh.b0 =(cur_val >> 8)& 15; */
1718   scan_math(tail + 1);
1719 }
1720 /* sec 1172 */
1721 void append_choices (void)
1722 {
1723   {
1724     mem[tail].hh.v.RH = new_choice ();
1725     tail = mem[tail].hh.v.RH;
1726   }
1727   incr(save_ptr);
1728   save_stack[save_ptr - 1].cint = 0;
1729   push_math(13);
1730   scan_left_brace ();
1731 }
1732 /* sec 1184 */
1733 halfword fin_mlist_(halfword p)
1734 {register halfword Result;
1735   halfword q;
1736   if(cur_list.aux_field.cint != 0)
1737   {
1738     mem[cur_list.aux_field.cint + 3].hh.v.RH = 3;
1739     mem[cur_list.aux_field.cint + 3].hh.v.LH = mem[head]
1740    .hh.v.RH;
1741     if(p == 0)
1742     q = cur_list.aux_field.cint;
1743     else {
1744
1745       q = mem[cur_list.aux_field.cint + 2].hh.v.LH;
1746       if(mem[q].hh.b0 != 30){
1747       confusion(871); /* right */
1748       return 0;       // abort_flag set
1749     }
1750       mem[cur_list.aux_field.cint + 2].hh.v.LH = mem[q].hh.v.RH;
1751       mem[q].hh.v.RH = cur_list.aux_field.cint;
1752       mem[cur_list.aux_field.cint].hh.v.RH = p;
1753     }
1754   }
1755   else {
1756
1757     mem[tail].hh.v.RH = p;
1758     q = mem[head].hh.v.RH;
1759   }
1760   pop_nest ();
1761   Result = q;
1762   return Result;
1763 }
1764 /* sec 1174 */
1765 void build_choices (void)
1766 {/* 10 */
1767   halfword p;
1768   unsave ();
1769   p = fin_mlist(0);
1770   switch(save_stack[save_ptr - 1].cint)
1771   {case 0 :
1772     mem[tail + 1].hh.v.LH = p;
1773     break;
1774   case 1 :
1775     mem[tail + 1].hh.v.RH = p;
1776     break;
1777   case 2 :
1778     mem[tail + 2].hh.v.LH = p;
1779     break;
1780   case 3 :
1781     {
1782       mem[tail + 2].hh.v.RH = p;
1783       decr(save_ptr);
1784       return;
1785     }
1786     break;
1787   }
1788   incr(save_stack[save_ptr - 1].cint);
1789   push_math(13);
1790   scan_left_brace ();
1791 }
1792 /* sec 1176 */
1793 void sub_sup (void)
1794 {
1795 /*  small_number t; */
1796   int t;              /* 95/Jan/7 */
1797   halfword p;
1798   t = 0;
1799   p = 0;
1800   if(tail != head)
1801   if((mem[tail].hh.b0 >= 16)&&
1802     (mem[tail].hh.b0 < 30))
1803   {
1804     p = tail + 2 + cur_cmd - 7;
1805     t = mem[p].hh.v.RH;
1806   }
1807   if((p == 0)||(t != 0))
1808   {
1809     {
1810       mem[tail].hh.v.RH = new_noad ();
1811       tail = mem[tail].hh.v.RH;
1812     }
1813     p = tail + 2 + cur_cmd - 7;
1814     if(t != 0)
1815     {
1816       if(cur_cmd == 7)
1817       {
1818                   print_err("Double superscript");
1819                   help1("I treat `x^1^2' essentially like `x^1{}^2'.");
1820       }
1821       else {
1822     print_err("Double subscript");
1823         help1("I treat `x_1_2' essentially like `x_1{}_2'.");
1824       }
1825       error ();
1826     }
1827   }
1828   scan_math(p);
1829 }
1830 /* used to continue here with math_fraction etc in tex7.c */
1831 /*****************************************************************************/
1832 /* moved down here to avoid pragma optimize questions 96/Sep/12 */
1833 /* #pragma optimize("g", off) */          /* for MC VS compiler */
1834 /* #pragma optimize("a", off) */          /* for MC VS compiler */
1835 /* sec 1086 */
1836 void package_(small_number c)
1837 {
1838   scaled h;
1839   halfword p;
1840   scaled d;
1841   d = eqtb[(hash_size + 3737)].cint;
1842   unsave ();
1843   save_ptr = save_ptr - 3;
1844   if(mode == -102)
1845   cur_box = hpack(mem[head].hh.v.RH, save_stack[save_ptr
1846   + 2].cint, save_stack[save_ptr + 1].cint);
1847   else {
1848
1849     cur_box = vpackage(mem[head].hh.v.RH, save_stack[
1850     save_ptr + 2].cint, save_stack[save_ptr + 1].cint, d);
1851     if(c == 4)
1852     {
1853       h = 0;
1854       p = mem[cur_box + 5].hh.v.RH;
1855       if(p != 0)
1856       if(mem[p].hh.b0 <= 2)
1857       h = mem[p + 3].cint;
1858       mem[cur_box + 2].cint = mem[cur_box + 2].cint - h + mem[cur_box +
1859       3].cint;
1860       mem[cur_box + 3].cint = h;
1861     }
1862   }
1863   pop_nest ();
1864   box_end(save_stack[save_ptr + 0].cint);
1865 }
1866 /* #pragma optimize("g", on) */         /* for MC VS compiler */
1867 /* #pragma optimize("a", on) */         /* for MC VS compiler */
1868 /* #pragma optimize("a",) */          /* 94/Jan/25 */
1869 #pragma optimize ("", on)           /* 96/Sep/12 */
1870 /****************************************************************************/