src/texsourc/tex5.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 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
  27
  28 /* rebox_ used to be in tex4.c */
  29
  30 halfword rebox_(halfword b, scaled w)
  31 {register halfword Result;
  32   halfword p;
  33   internal_font_number f;
  34   scaled v;
  35 /* begin if (width(b)<>w)and(list_ptr(b)<>null) then l.14010 */
  36   if((mem[b + 1].cint != w)&&(mem[b + 5].hh.v.RH != 0))
  37   {
  38     if(mem[b].hh.b0 == 1)
  39     b = hpack(b, 0, 1);
  40     p = mem[b + 5].hh.v.RH;
  41 /*  if (is_char_node(p))and(link(p)=null) then l.14013 */
  42     if(((p >= hi_mem_min)) &&(mem[p].hh.v.RH == 0))
  43     {
  44       f = mem[p].hh.b0;
  45       v = font_info[width_base[f]+ font_info[char_base[f]+ mem[p]
  46       .hh.b1].qqqq.b0].cint;
  47       if(v != mem[b + 1].cint)
  48       mem[p].hh.v.RH = new_kern(mem[b + 1].cint - v);
  49     }
  50     free_node(b, 7);
  51     b = new_glue(12);
  52     mem[b].hh.v.RH = p;
  53 /*   while link(p)<>null do p:=link(p); l.14019 */
  54     while(mem[p].hh.v.RH != 0)p = mem[p].hh.v.RH;
  55     mem[p].hh.v.RH = new_glue(12);
  56     Result = hpack(b, w, 0);
  57   }
  58   else {
  59
  60     mem[b + 1].cint = w;
  61     Result = b;
  62   }
  63   return Result;
  64 }
  65 /* This is to be the start of tex5.c */
  66 halfword math_glue_(halfword g, scaled m)
  67 {register halfword Result;
  68   halfword p;
  69   integer n;
  70   scaled f;
  71   n = x_over_n(m, 65536L);
  72   f = tex_remainder;
  73   if(f < 0)
  74   {
  75     decr(n);
  76     f = f + 65536L;
  77   }
  78   p = get_node(4);
  79   mem[p + 1].cint = mult_and_add(n, mem[g + 1].cint, xn_over_d(mem[
  80   g + 1].cint, f, 65536L), 1073741823L);  /* 2^30 - 1 */
  81   mem[p].hh.b0 = mem[g].hh.b0;
  82   if(mem[p].hh.b0 == 0)
  83   mem[p + 2].cint = mult_and_add(n, mem[g + 2].cint, xn_over_d(mem[
  84   g + 2].cint, f, 65536L), 1073741823L);  /* 2^30 - 1 */
  85   else mem[p + 2].cint = mem[g + 2].cint;
  86   mem[p].hh.b1 = mem[g].hh.b1;
  87   if(mem[p].hh.b1 == 0)
  88   mem[p + 3].cint = mult_and_add(n, mem[g + 3].cint, xn_over_d(mem[
  89   g + 3].cint, f, 65536L), 1073741823L);  /* 2^30 - 1 */
  90   else mem[p + 3].cint = mem[g + 3].cint;
  91   Result = p;
  92   return Result;
  93 }
  94 void math_kern_ (halfword p, scaled m)
  95 {
  96   integer n;
  97   scaled f;
  98   if(mem[p].hh.b1 == 99)
  99   {
 100     n = x_over_n(m, 65536L);
 101     f = tex_remainder;
 102     if(f < 0)
 103     {
 104       decr(n);
 105       f = f + 65536L;
 106     }
 107     mem[p + 1].cint = mult_and_add(n, mem[p + 1].cint, xn_over_d(mem
 108    [p + 1].cint, f, 65536L), 1073741823L);  /* 2^30 - 1 */
 109 /*    mem[p].hh.b1 = 0;  */
 110     mem[p].hh.b1 = 1; /* changed in 3.14159 */
 111   }
 112 }
 113 void flush_math (void)
 114 {
 115   flush_node_list(mem[head].hh.v.RH);
 116   flush_node_list(cur_list.aux_field.cint);
 117   mem[head].hh.v.RH = 0;
 118   tail = head;
 119   cur_list.aux_field.cint = 0;
 120 }
 121 halfword clean_box_(halfword p, small_number s)
 122 {/* 40 */ register halfword Result;
 123   halfword q;
 124   small_number savestyle;
 125   halfword x;
 126   halfword r;
 127   switch(mem[p].hh.v.RH)
 128   {case 1 :
 129     {
 130       cur_mlist = new_noad ();
 131       mem[cur_mlist + 1]= mem[p];
 132     }
 133     break;
 134   case 2 :
 135     {
 136       q = mem[p].hh.v.LH;
 137       goto lab40;
 138     }
 139     break;
 140   case 3 :
 141     cur_mlist = mem[p].hh.v.LH;
 142     break;
 143     default:
 144     {
 145       q = new_null_box ();
 146       goto lab40;
 147     }
 148     break;
 149   }
 150   savestyle = cur_style;
 151   cur_style = s;
 152   mlist_penalties = false;
 153   mlist_to_hlist ();
 154   q = mem[mem_top - 3].hh.v.RH;
 155   cur_style = savestyle;
 156   {
 157     if(cur_style < 4)
 158     cur_size = 0;
 159     else cur_size = 16 *((cur_style - 2)/ 2);
 160     cur_mu = x_over_n(font_info[6 +
 161     param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH]].cint, 18);
 162   }
 163   lab40: if((q >= hi_mem_min)||(q == 0))
 164   x = hpack(q, 0, 1);
 165   else if((mem[q].hh.v.RH == 0)&&(mem[q].hh.b0 <= 1)&&(mem
 166  [q + 4].cint == 0))
 167   x = q;
 168   else x = hpack(q, 0, 1);
 169   q = mem[x + 5].hh.v.RH;
 170   if((q >= hi_mem_min))
 171   {
 172     r = mem[q].hh.v.RH;
 173 /*   if r<>null then if link(r)=null then l.14140 */
 174     if(r != 0)
 175     if(mem[r].hh.v.RH == 0)
 176     if(!(r >= hi_mem_min))
 177     if(mem[r].hh.b0 == 11)
 178     {
 179       free_node(r, 2);
 180       mem[q].hh.v.RH = 0;   /* link(q):=null; */
 181     }
 182   }
 183   Result = x;
 184   return Result;
 185 }
 186 void fetch_(halfword a)
 187 {
 188   cur_c = mem[a].hh.b1;
 189   cur_f = eqtb[(hash_size + 1835) + mem[a].hh.b0 + cur_size].hh.v.RH;
 190   if(cur_f == 0)
 191   {
 192           print_err("");
 193     print_size(cur_size);
 194     print_char(32);   /*   */
 195     print_int(mem[a].hh.b0);
 196     print_string("is undefined (character ");
 197     print(cur_c);
 198     print_char(41);   /*)*/
 199         help4("Somewhere in the math formula just ended, you used the",
 200                 "stated character from an undefined font family. For example,",
 201                 "plain TeX doesn't allow \\it or \\sl in subscripts. Proceed,",
 202                 "and I'll try to forget that I needed that character.");
 203     error ();
 204     cur_i = null_character;
 205     mem[a].hh.v.RH = 0;
 206   }
 207   else {
 208
 209     if((cur_c >= font_bc[cur_f])&&(cur_c <= font_ec[cur_f]))
 210     cur_i = font_info[char_base[cur_f]+ cur_c].qqqq;
 211     else cur_i = null_character;
 212     if(!((cur_i.b0 > 0)))
 213     {
 214       char_warning(cur_f, cur_c);
 215       mem[a].hh.v.RH = 0;
 216     }
 217   }
 218 }
 219 void make_over_(halfword q)
 220 {
 221   mem[q + 1].hh.v.LH = overbar(clean_box(q + 1, 2 *(cur_style / 2)
 222   + 1), 3 * font_info[8 + param_base[eqtb[(hash_size + 1838) + cur_size].hh.v.RH]
 223 ].cint, font_info[8 + param_base[eqtb[(hash_size + 1838) + cur_size].hh.v.RH]]
 224  .cint);
 225   mem[q + 1].hh.v.RH = 2;
 226 }
 227 void make_under_(halfword q)
 228 {
 229   halfword p, x, y;
 230   scaled delta;
 231   x = clean_box(q + 1, cur_style);
 232   p = new_kern(3 * font_info[8 +
 233     param_base[eqtb[(hash_size + 1838) + cur_size].hh.v.RH]].cint);
 234   mem[x].hh.v.RH = p;
 235   mem[p].hh.v.RH = fraction_rule(font_info[8 +
 236     param_base[eqtb[(hash_size + 1838) + cur_size].hh.v.RH]].cint);
 237   y = vpackage(x, 0, 1, 1073741823L); /* 2^30 - 1 */
 238   delta = mem[y + 3].cint + mem[y + 2].cint + font_info[8 +
 239     param_base[eqtb[(hash_size + 1838) + cur_size].hh.v.RH]].cint;
 240   mem[y + 3].cint = mem[x + 3].cint;
 241   mem[y + 2].cint = delta - mem[y + 3].cint;
 242   mem[q + 1].hh.v.LH = y;
 243   mem[q + 1].hh.v.RH = 2;
 244 }
 245 void make_vcenter_(halfword q)
 246 {
 247   halfword v;
 248   scaled delta;
 249   v = mem[q + 1].hh.v.LH;
 250   if(mem[v].hh.b0 != 1){
 251     confusion(536);   /* vcenter */
 252     return;         // abort_flag set
 253   }
 254   delta = mem[v + 3].cint + mem[v + 2].cint;
 255   mem[v + 3].cint = font_info[22 +
 256     param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH]].cint + half(delta);
 257   mem[v + 2].cint = delta - mem[v + 3].cint;
 258 }
 259 void make_radical_(halfword q)
 260 {
 261   halfword x, y;
 262   scaled delta, clr;
 263   x = clean_box(q + 1, 2 *(cur_style / 2)+ 1);
 264   if(cur_style < 2)
 265   clr = font_info[8 +
 266   param_base[eqtb[(hash_size + 1838) + cur_size].hh.v.RH]].cint +
 267     (abs(font_info[5 + param_base[eqtb[(hash_size + 1837) +
 268         cur_size].hh.v.RH]].cint)/ 4);
 269   else {
 270
 271     clr = font_info[8 +
 272       param_base[eqtb[(hash_size + 1838) + cur_size].hh.v.RH]].cint;
 273     clr = clr +(abs(clr)/ 4);
 274   }
 275   y = var_delimiter(q + 4, cur_size, mem[x + 3].cint + mem[x + 2]
 276  .cint + clr + font_info[8 +
 277     param_base[eqtb[(hash_size + 1838) + cur_size].hh.v.RH]].cint);
 278   delta = mem[y + 2].cint -(mem[x + 3].cint + mem[x + 2].cint +
 279   clr);
 280   if(delta > 0)
 281   clr = clr + half(delta);
 282   mem[y + 4].cint = - (integer)(mem[x + 3].cint + clr);
 283   mem[y].hh.v.RH = overbar(x, clr, mem[y + 3].cint);
 284   mem[q + 1].hh.v.LH = hpack(y, 0, 1);
 285   mem[q + 1].hh.v.RH = 2;
 286 }
 287 void make_math_accent_(halfword q)
 288 {/* 30 31 */
 289   halfword p, x, y;
 290   integer a;
 291   quarterword c;
 292   internal_font_number f;
 293   ffourquarters i;
 294   scaled s;
 295   scaled h;
 296   scaled delta;
 297   scaled w;
 298   fetch(q + 4);
 299   if((cur_i.b0 > 0))
 300   {
 301     i = cur_i;
 302     c = cur_c;
 303     f = cur_f;
 304     s = 0;
 305     if(mem[q + 1].hh.v.RH == 1)
 306     {
 307       fetch(q + 1);
 308       if(((cur_i.b2)% 4)== 1)
 309       {
 310   a = lig_kern_base[cur_f]+ cur_i.b3;
 311   cur_i = font_info[a].qqqq;
 312   if(cur_i.b0 > 128)
 313   {
 314     a = lig_kern_base[cur_f]+ 256 * cur_i.b2 + cur_i.b3 + 32768L - 256
 315     *(128);
 316     cur_i = font_info[a].qqqq;
 317   }
 318   while(true){
 319     if(cur_i.b1 == skew_char[cur_f])
 320     {
 321       if(cur_i.b2 >= 128)
 322       if(cur_i.b0 <= 128)
 323       s = font_info[kern_base[cur_f]+ 256 * cur_i.b2 + cur_i.b3]
 324      .cint;
 325       goto lab31;
 326     }
 327     if(cur_i.b0 >= 128)
 328     goto lab31;
 329     a = a + cur_i.b0 + 1;
 330     cur_i = font_info[a].qqqq;
 331   }
 332       }
 333     }
 334     lab31:;
 335     x = clean_box(q + 1, 2 *(cur_style / 2)+ 1);
 336     w = mem[x + 1].cint;
 337     h = mem[x + 3].cint;
 338     while(true){
 339       if(((i.b2)% 4)!= 2)
 340       goto lab30;
 341       y = i.b3;
 342       i = font_info[char_base[f]+ y].qqqq;
 343       if(!(i.b0 > 0))
 344       goto lab30;
 345       if(font_info[width_base[f]+ i.b0].cint > w)
 346       goto lab30;
 347 /*    long to unsigned short ... */
 348       c = y;
 349     }
 350     lab30:;
 351     if(h < font_info[5 + param_base[f]].cint)
 352     delta = h;
 353     else delta = font_info[5 + param_base[f]].cint;
 354     if((mem[q + 2].hh.v.RH != 0)||(mem[q + 3].hh.v.RH != 0)
 355   )
 356     if(mem[q + 1].hh.v.RH == 1)
 357     {
 358       flush_node_list(x);
 359       x = new_noad ();
 360       mem[x + 1]= mem[q + 1];
 361       mem[x + 2]= mem[q + 2];
 362       mem[x + 3]= mem[q + 3];
 363       mem[q + 2].hh = empty_field;
 364       mem[q + 3].hh = empty_field;
 365       mem[q + 1].hh.v.RH = 3;
 366       mem[q + 1].hh.v.LH = x;
 367       x = clean_box(q + 1, cur_style);
 368       delta = delta + mem[x + 3].cint - h;
 369       h = mem[x + 3].cint;
 370     }
 371     y = char_box(f, c);
 372     mem[y + 4].cint = s + half(w - mem[y + 1].cint);
 373     mem[y + 1].cint = 0;
 374     p = new_kern(- (integer) delta);
 375     mem[p].hh.v.RH = x;
 376     mem[y].hh.v.RH = p;
 377     y = vpackage(y, 0, 1, 1073741823L);  /* 2^30 - 1 */
 378     mem[y + 1].cint = mem[x + 1].cint;
 379     if(mem[y + 3].cint < h)
 380     {
 381       p = new_kern(h - mem[y + 3].cint);
 382       mem[p].hh.v.RH = mem[y + 5].hh.v.RH;
 383       mem[y + 5].hh.v.RH = p;
 384       mem[y + 3].cint = h;
 385     }
 386     mem[q + 1].hh.v.LH = y;
 387     mem[q + 1].hh.v.RH = 2;
 388   }
 389 }
 390 void make_fraction_(halfword q)
 391 {
 392   halfword p, v, x, y, z;
 393   scaled delta, delta1, delta2, shiftup, shiftdown, clr;
 394   if(mem[q + 1].cint == 1073741824L) /* 2^30 */
 395   mem[q + 1].cint = font_info[8 +
 396     param_base[eqtb[(hash_size + 1838) + cur_size].hh.v.RH]].cint;
 397   x = clean_box(q + 2, cur_style + 2 - 2 *(cur_style / 6));
 398   z = clean_box(q + 3, 2 *(cur_style / 2)+ 3 - 2 *(cur_style / 6));
 399   if(mem[x + 1].cint < mem[z + 1].cint)
 400   x = rebox(x, mem[z + 1].cint);
 401   else z = rebox(z, mem[x + 1].cint);
 402   if(cur_style < 2)
 403   {
 404     shiftup = font_info[8 +
 405       param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH]].cint;
 406     shiftdown = font_info[11 +
 407     param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH]].cint;
 408   }
 409   else {
 410
 411     shiftdown = font_info[12 +
 412     param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH]].cint;
 413     if(mem[q + 1].cint != 0)
 414     shiftup = font_info[9 +
 415     param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH]].cint;
 416     else shiftup = font_info[10 +
 417     param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH]].cint;
 418   }
 419   if(mem[q + 1].cint == 0)
 420   {
 421     if(cur_style < 2)
 422     clr = 7 * font_info[8 + param_base[eqtb[(hash_size + 1838) + cur_size].hh.v.RH]
 423   ].cint;
 424     else clr = 3 * font_info[8 + param_base[eqtb[(hash_size + 1838) + cur_size].hh
 425    .v.RH]].cint;
 426     delta = half(clr -((shiftup - mem[x + 2].cint)-(mem[z + 3]
 427    .cint - shiftdown)));
 428     if(delta > 0)
 429     {
 430       shiftup = shiftup + delta;
 431       shiftdown = shiftdown + delta;
 432     }
 433   }
 434   else {
 435
 436     if(cur_style < 2)
 437     clr = 3 * mem[q + 1].cint;
 438     else clr = mem[q + 1].cint;
 439     delta = half(mem[q + 1].cint);
 440     delta1 = clr -((shiftup - mem[x + 2].cint)-(font_info[22 +
 441     param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH]].cint + delta));
 442     delta2 = clr -((font_info[22 + param_base[eqtb[(hash_size + 1837) + cur_size]
 443    .hh.v.RH]].cint - delta)-(mem[z + 3].cint - shiftdown));
 444     if(delta1 > 0)
 445     shiftup = shiftup + delta1;
 446     if(delta2 > 0)
 447     shiftdown = shiftdown + delta2;
 448   }
 449   v = new_null_box ();
 450   mem[v].hh.b0 = 1;
 451   mem[v + 3].cint = shiftup + mem[x + 3].cint;
 452   mem[v + 2].cint = mem[z + 2].cint + shiftdown;
 453   mem[v + 1].cint = mem[x + 1].cint;
 454   if(mem[q + 1].cint == 0)
 455   {
 456     p = new_kern((shiftup - mem[x + 2].cint)-(mem[z + 3].cint -
 457     shiftdown));
 458     mem[p].hh.v.RH = z;
 459   }
 460   else {
 461
 462     y = fraction_rule(mem[q + 1].cint);
 463     p = new_kern((font_info[22 + param_base[eqtb[(hash_size + 1837) + cur_size].hh
 464    .v.RH]].cint - delta)-(mem[z + 3].cint - shiftdown));
 465     mem[y].hh.v.RH = p;
 466     mem[p].hh.v.RH = z;
 467     p = new_kern((shiftup - mem[x + 2].cint)-(font_info[22 +
 468     param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH]].cint + delta));
 469     mem[p].hh.v.RH = y;
 470   }
 471   mem[x].hh.v.RH = p;
 472   mem[v + 5].hh.v.RH = x;
 473   if(cur_style < 2)
 474   delta = font_info[20 + param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH]]
 475  .cint;
 476   else delta = font_info[21 + param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH
 477 ]].cint;
 478   x = var_delimiter(q + 4, cur_size, delta);
 479   mem[x].hh.v.RH = v;
 480   z = var_delimiter(q + 5, cur_size, delta);
 481   mem[v].hh.v.RH = z;
 482   mem[q + 1].cint = hpack(x, 0, 1);
 483 }
 484 /***************************************************************************/
 485 /* moved to end to avoid questions about pragma optimize 96/Sep/12 */
 486 scaled make_op_ (halfword);
 487 /***************************************************************************/
 488 void make_ord_(halfword q)
 489 {/* 20 10 */
 490   integer a;
 491   halfword p, r;
 492   lab20: if(mem[q + 3].hh.v.RH == 0)
 493   if(mem[q + 2].hh.v.RH == 0)
 494   if(mem[q + 1].hh.v.RH == 1)
 495   {
 496     p = mem[q].hh.v.RH;
 497     if(p != 0)
 498     if((mem[p].hh.b0 >= 16)&&(mem[p].hh.b0 <= 22))
 499     if(mem[p + 1].hh.v.RH == 1)
 500     if(mem[p + 1].hh.b0 == mem[q + 1].hh.b0)
 501     {
 502       mem[q + 1].hh.v.RH = 4;
 503       fetch(q + 1);
 504       if(((cur_i.b2)% 4)== 1)
 505       {
 506   a = lig_kern_base[cur_f]+ cur_i.b3;
 507   cur_c = mem[p + 1].hh.b1;
 508   cur_i = font_info[a].qqqq;
 509   if(cur_i.b0 > 128)
 510   {
 511     a = lig_kern_base[cur_f]+ 256 * cur_i.b2 + cur_i.b3 + 32768L - 256
 512     *(128);
 513     cur_i = font_info[a].qqqq;
 514   }
 515   while(true){
 516     if(cur_i.b1 == cur_c)
 517     if(cur_i.b0 <= 128)
 518     if(cur_i.b2 >= 128)
 519     {
 520       p = new_kern(font_info[kern_base[cur_f]+ 256 * cur_i.b2 + cur_i
 521      .b3].cint);
 522       mem[p].hh.v.RH = mem[q].hh.v.RH;
 523       mem[q].hh.v.RH = p;
 524       return;
 525     }
 526     else {
 527
 528       {
 529         if(interrupt != 0){
 530         pause_for_instructions ();
 531       }
 532       }
 533       switch(cur_i.b2)
 534       {case 1 :
 535       case 5 :
 536         mem[q + 1].hh.b1 = cur_i.b3;
 537         break;
 538       case 2 :
 539       case 6 :
 540         mem[p + 1].hh.b1 = cur_i.b3;
 541         break;
 542       case 3 :
 543       case 7 :
 544       case 11 :
 545         {
 546     r = new_noad ();
 547     mem[r + 1].hh.b1 = cur_i.b3;
 548     mem[r + 1].hh.b0 = mem[q + 1].hh.b0;
 549     mem[q].hh.v.RH = r;
 550     mem[r].hh.v.RH = p;
 551     if(cur_i.b2 < 11)
 552     mem[r + 1].hh.v.RH = 1;
 553     else mem[r + 1].hh.v.RH = 4;
 554         }
 555         break;
 556         default:
 557         {
 558     mem[q].hh.v.RH = mem[p].hh.v.RH;
 559     mem[q + 1].hh.b1 = cur_i.b3;
 560     mem[q + 3]= mem[p + 3];
 561     mem[q + 2]= mem[p + 2];
 562     free_node(p, 4);
 563         }
 564         break;
 565       }
 566       if(cur_i.b2 > 3)
 567       return;
 568       mem[q + 1].hh.v.RH = 1;
 569       goto lab20;
 570     }
 571     if(cur_i.b0 >= 128)
 572     return;
 573     a = a + cur_i.b0 + 1;
 574     cur_i = font_info[a].qqqq;
 575   }
 576       }
 577     }
 578   }
 579 }
 580 /***************************************************************************/
 581 /* moved to end to avoid questions about pragma optimize 96/Sep/12 */
 582 void make_scripts_ (halfword, scaled);
 583 /***************************************************************************/
 584 small_number make_left_right_(halfword q, small_number style, scaled maxd, scaled max_h)
 585 {register small_number Result;
 586   scaled delta, delta1, delta2;
 587   if(style < 4)
 588   cur_size = 0;
 589   else cur_size = 16 *((style - 2)/ 2);
 590   delta2 = maxd + font_info[22 + param_base[eqtb[(hash_size + 1837) + cur_size].hh
 591  .v.RH]].cint;
 592   delta1 = max_h + maxd - delta2;
 593   if(delta2 > delta1)
 594   delta1 = delta2;
 595   delta =(delta1 / 500)* eqtb[(hash_size + 3181)].cint;
 596   delta2 = delta1 + delta1 - eqtb[(hash_size + 3740)].cint;
 597   if(delta < delta2)
 598   delta = delta2;
 599   mem[q + 1].cint = var_delimiter(q + 1, cur_size, delta);
 600   Result = mem[q].hh.b0 -(10);
 601   return Result;
 602 }
 603 void mlist_to_hlist (void)
 604 {/* 21 82 80 81 83 30 */
 605   halfword mlist;
 606   bool penalties;
 607   small_number style;
 608   small_number savestyle;
 609   halfword q;
 610   halfword r;
 611 /*  small_number rtype;  */
 612   int rtype;            /* 95/Jan/7 */
 613 /*  small_number t; */
 614   int t;              /* 95/Jan/7 */
 615   halfword p, x, y, z;
 616   integer pen;
 617   small_number s;
 618   scaled max_h, maxd;
 619   scaled delta;
 620   mlist = cur_mlist;
 621   penalties = mlist_penalties;
 622   style = cur_style;
 623   q = mlist;
 624   r = 0;
 625   rtype = 17;
 626   max_h = 0;
 627   maxd = 0;
 628   {
 629     if(cur_style < 4)
 630     cur_size = 0;
 631     else cur_size = 16 *((cur_style - 2)/ 2);
 632     cur_mu = x_over_n(font_info[6 + param_base[eqtb[(hash_size + 1837) + cur_size].hh
 633    .v.RH]].cint, 18);
 634   }
 635   while(q != 0){
 636
 637     lab21: delta = 0;
 638     switch(mem[q].hh.b0){
 639     case 18 :
 640       switch(rtype)
 641       {case 18 :
 642       case 17 :
 643       case 19 :
 644       case 20 :
 645       case 22 :
 646       case 30 :
 647   {
 648     mem[q].hh.b0 = 16;
 649     goto lab21;
 650   }
 651   break;
 652   default:
 653   ;
 654   break;
 655       }
 656       break;
 657     case 19 :
 658     case 21 :
 659     case 22 :
 660     case 31 :
 661       {
 662   if(rtype == 18) mem[r].hh.b0 = 16;
 663   if(mem[q].hh.b0 == 31)  goto lab80;
 664       }
 665       break;
 666     case 30 :
 667       goto lab80;
 668       break;
 669     case 25 :
 670       {
 671   make_fraction(q);
 672   goto lab82;
 673       }
 674       break;
 675     case 17 :
 676       {
 677   delta = make_op(q);
 678   if(mem[q].hh.b1 == 1)
 679   goto lab82;
 680       }
 681       break;
 682     case 16 :
 683       make_ord(q);
 684       break;
 685     case 20 :
 686     case 23 :
 687    ;
 688       break;
 689     case 24 :
 690       make_radical(q);
 691       break;
 692     case 27 :
 693       make_over(q);
 694       break;
 695     case 26 :
 696       make_under(q);
 697       break;
 698     case 28 :
 699       make_math_accent(q);
 700       break;
 701     case 29 :
 702       make_vcenter(q);
 703       break;
 704     case 14 :
 705       {
 706   cur_style = mem[q].hh.b1;
 707   {
 708     if(cur_style < 4)
 709     cur_size = 0;
 710     else cur_size = 16 *((cur_style - 2)/ 2);
 711     cur_mu = x_over_n(font_info[6 + param_base[eqtb[(hash_size + 1837) + cur_size]
 712    .hh.v.RH]].cint, 18);
 713   }
 714   goto lab81;
 715       }
 716       break;
 717     case 15 :
 718       {
 719   switch(cur_style / 2)
 720   {case 0 :
 721     {
 722       p = mem[q + 1].hh.v.LH;
 723       mem[q + 1].hh.v.LH = 0;
 724     }
 725     break;
 726   case 1 :
 727     {
 728       p = mem[q + 1].hh.v.RH;
 729       mem[q + 1].hh.v.RH = 0;
 730     }
 731     break;
 732   case 2 :
 733     {
 734       p = mem[q + 2].hh.v.LH;
 735       mem[q + 2].hh.v.LH = 0;
 736     }
 737     break;
 738   case 3 :
 739     {
 740       p = mem[q + 2].hh.v.RH;
 741       mem[q + 2].hh.v.RH = 0;
 742     }
 743     break;
 744   }
 745   flush_node_list(mem[q + 1].hh.v.LH);
 746   flush_node_list(mem[q + 1].hh.v.RH);
 747   flush_node_list(mem[q + 2].hh.v.LH);
 748   flush_node_list(mem[q + 2].hh.v.RH);
 749   mem[q].hh.b0 = 14;
 750   mem[q].hh.b1 = cur_style;
 751   mem[q + 1].cint = 0;
 752   mem[q + 2].cint = 0;
 753   if(p != 0)/* if p<>null then l.14317 */
 754   {
 755     z = mem[q].hh.v.RH;
 756     mem[q].hh.v.RH = p;
 757 /*   while link(p)<>null do p:=link(p); */
 758     while(mem[p].hh.v.RH != 0)p = mem[p].hh.v.RH;
 759     mem[p].hh.v.RH = z;
 760   }
 761   goto lab81;
 762       }
 763       break;
 764     case 3 :
 765     case 4 :
 766     case 5 :
 767     case 8 :
 768     case 12 :
 769     case 7 :
 770       goto lab81;
 771       break;
 772     case 2 :
 773       {
 774   if(mem[q + 3].cint > max_h)
 775   max_h = mem[q + 3].cint;
 776   if(mem[q + 2].cint > maxd)
 777   maxd = mem[q + 2].cint;
 778   goto lab81;
 779       }
 780       break;
 781     case 10 :
 782       {
 783   if(mem[q].hh.b1 == 99)
 784   {
 785     x = mem[q + 1].hh.v.LH;
 786     y = math_glue(x, cur_mu);
 787     delete_glue_ref(x);
 788     mem[q + 1].hh.v.LH = y;
 789     mem[q].hh.b1 = 0;
 790   }
 791   else if((cur_size != 0)&&(mem[q].hh.b1 == 98))
 792   {
 793     p = mem[q].hh.v.RH;
 794 /*   if p<>null then if (type(p)=glue_node)or(type(p)=kern_node) then */
 795     if(p != 0)
 796     if((mem[p].hh.b0 == 10)||(mem[p].hh.b0 == 11))
 797     {
 798       mem[q].hh.v.RH = mem[p].hh.v.RH;
 799       mem[p].hh.v.RH = 0;
 800       flush_node_list(p);
 801     }
 802   }
 803   goto lab81;
 804       }
 805       break;
 806     case 11 :
 807       {
 808   math_kern(q, cur_mu);
 809   goto lab81;
 810       }
 811       break;
 812       default:
 813       {
 814         confusion(883); /* mlist1 */
 815         return;       // abort_flag set
 816       }
 817       break;
 818   } /* end of switch */
 819
 820     switch(mem[q + 1].hh.v.RH){
 821   case 1 :
 822     case 4 :
 823       {
 824   fetch(q + 1);
 825   if((cur_i.b0 > 0))
 826   {
 827     delta = font_info[italic_base[cur_f]+(cur_i.b2)/ 4].cint;
 828     p = new_character(cur_f, cur_c);
 829     if((mem[q + 1].hh.v.RH == 4)&&(font_info[2 + param_base
 830    [cur_f]].cint != 0))
 831     delta = 0;
 832     if((mem[q + 3].hh.v.RH == 0)&&(delta != 0))
 833     {
 834       mem[p].hh.v.RH = new_kern(delta);
 835       delta = 0;
 836     }
 837   }
 838   else p = 0;
 839       }
 840       break;
 841     case 0 :
 842       p = 0;
 843       break;
 844     case 2 :
 845       p = mem[q + 1].hh.v.LH;
 846       break;
 847     case 3 :
 848       {
 849   cur_mlist = mem[q + 1].hh.v.LH;
 850   savestyle = cur_style;
 851   mlist_penalties = false;
 852   mlist_to_hlist ();
 853   cur_style = savestyle;
 854   {
 855     if(cur_style < 4)
 856     cur_size = 0;
 857     else cur_size = 16 *((cur_style - 2)/ 2);
 858     cur_mu = x_over_n(font_info[6 + param_base[eqtb[(hash_size + 1837) + cur_size]
 859    .hh.v.RH]].cint, 18);
 860   }
 861   p = hpack(mem[mem_top - 3].hh.v.RH, 0, 1);
 862       }
 863       break;
 864       default:
 865       {
 866         confusion(884); /* mlist2 */
 867         return;       // abort_flag set
 868       }
 869       break;
 870   } /* end of switch */
 871
 872     mem[q + 1].cint = p;  /* p may be used without ... */
 873     if((mem[q + 3].hh.v.RH == 0)&&(mem[q + 2].hh.v.RH == 0)
 874   )
 875     goto lab82;
 876     make_scripts(q, delta);
 877     lab82: z = hpack(mem[q + 1].cint, 0, 1);
 878     if(mem[z + 3].cint > max_h)
 879     max_h = mem[z + 3].cint;
 880     if(mem[z + 2].cint > maxd)
 881     maxd = mem[z + 2].cint;
 882     free_node(z, 7);
 883     lab80: r = q;
 884     rtype = mem[r].hh.b0;
 885     lab81: q = mem[q].hh.v.RH;
 886   }
 887   if(rtype == 18)
 888   mem[r].hh.b0 = 16;
 889   p = mem_top - 3;
 890   mem[p].hh.v.RH = 0;
 891   q = mlist;
 892   rtype = 0;
 893   cur_style = style;
 894   {
 895     if(cur_style < 4)
 896     cur_size = 0;
 897     else cur_size = 16 *((cur_style - 2)/ 2);
 898     cur_mu = x_over_n(font_info[6 + param_base[eqtb[(hash_size + 1837) + cur_size].hh
 899    .v.RH]].cint, 18);
 900   }
 901   while(q != 0){
 902
 903     t = 16;
 904     s = 4;
 905     pen = 10000;
 906     switch(mem[q].hh.b0)
 907     {case 17 :
 908     case 20 :
 909     case 21 :
 910     case 22 :
 911     case 23 :
 912       t = mem[q].hh.b0;
 913       break;
 914     case 18 :
 915       {
 916   t = 18;
 917   pen = eqtb[(hash_size + 3172)].cint;
 918       }
 919       break;
 920     case 19 :
 921       {
 922   t = 19;
 923   pen = eqtb[(hash_size + 3173)].cint;
 924       }
 925       break;
 926     case 16 :
 927     case 29 :
 928     case 27 :
 929     case 26 :
 930    ;
 931       break;
 932     case 24 :
 933       s = 5;
 934       break;
 935     case 28 :
 936       s = 5;
 937       break;
 938     case 25 :
 939       {
 940   t = 23;
 941   s = 6;
 942       }
 943       break;
 944     case 30 :
 945     case 31 :
 946       t = make_left_right(q, style, maxd, max_h);
 947       break;
 948     case 14 :
 949       {
 950   cur_style = mem[q].hh.b1;
 951   s = 3;
 952   {
 953     if(cur_style < 4)
 954     cur_size = 0;
 955     else cur_size = 16 *((cur_style - 2)/ 2);
 956     cur_mu = x_over_n(font_info[6 + param_base[eqtb[(hash_size + 1837) + cur_size]
 957    .hh.v.RH]].cint, 18);
 958   }
 959   goto lab83;
 960       }
 961       break;
 962     case 8 :
 963     case 12 :
 964     case 2 :
 965     case 7 :
 966     case 5 :
 967     case 3 :
 968     case 4 :
 969     case 10 :
 970     case 11 :
 971       {
 972   mem[p].hh.v.RH = q;
 973   p = q;
 974   q = mem[q].hh.v.RH;
 975   mem[p].hh.v.RH = 0;
 976   goto lab30;
 977       }
 978       break;
 979       default:
 980       {
 981         confusion(885); /* mlist3 */
 982         return;       // abort_flag set
 983       }
 984       break;
 985     }
 986     if(rtype > 0)
 987     {
 988       switch(str_pool[rtype * 8 + t + magic_offset])
 989       {case 48 :
 990   x = 0;
 991   break;
 992       case 49 :
 993   if(cur_style < 4)
 994   x = 15;
 995   else x = 0;
 996   break;
 997       case 50 :
 998   x = 15;
 999   break;
1000       case 51 :
1001   if(cur_style < 4)
1002   x = 16;
1003   else x = 0;
1004   break;
1005       case 52 :
1006   if(cur_style < 4)
1007   x = 17;
1008   else x = 0;
1009   break;
1010   default:
1011     {
1012       confusion(887);   /* mlist4 */
1013       return;       // abort_flag set
1014     }
1015     break;
1016       }
1017       if(x != 0)
1018       {
1019   y = math_glue(eqtb[(hash_size + 782) + x].hh.v.RH, cur_mu); /* gluebase + x */
1020   z = new_glue(y);
1021   mem[y].hh.v.RH = 0;
1022   mem[p].hh.v.RH = z;
1023   p = z;
1024   mem[z].hh.b1 = x + 1;   /* x may be used without ... */
1025       }
1026     }
1027     if(mem[q + 1].cint != 0)
1028     {
1029       mem[p].hh.v.RH = mem[q + 1].cint;
1030       do {
1031     p = mem[p].hh.v.RH;
1032       } while(!(mem[p].hh.v.RH == 0));
1033     }
1034     if(penalties)
1035     if(mem[q].hh.v.RH != 0)
1036     if(pen < 10000)
1037     {
1038       rtype = mem[mem[q].hh.v.RH].hh.b0;
1039       if(rtype != 12)
1040       if(rtype != 19)
1041       {
1042   z = new_penalty(pen);
1043   mem[p].hh.v.RH = z;
1044   p = z;
1045       }
1046     }
1047     rtype = t;
1048     lab83: r = q;
1049     q = mem[q].hh.v.RH;
1050     free_node(r, s);
1051     lab30:;
1052   }
1053 }
1054 void push_alignment (void)
1055 {
1056   halfword p;
1057   p = get_node(5);
1058   mem[p].hh.v.RH = align_ptr;
1059   mem[p].hh.v.LH = cur_align;
1060   mem[p + 1].hh.v.LH = mem[mem_top - 8].hh.v.RH;
1061   mem[p + 1].hh.v.RH = cur_span;
1062   mem[p + 2].cint = cur_loop;
1063   mem[p + 3].cint = align_state;
1064   mem[p + 4].hh.v.LH = cur_head;
1065   mem[p + 4].hh.v.RH = cur_tail;
1066   align_ptr = p;
1067   cur_head = get_avail ();
1068 }
1069 void pop_alignment (void)
1070 {
1071   halfword p;
1072   {
1073     mem[cur_head].hh.v.RH = avail;
1074     avail = cur_head;
1075   ;
1076 #ifdef STAT
1077     decr(dyn_used);
1078 #endif /* STAT */
1079   }
1080   p = align_ptr;
1081   cur_tail = mem[p + 4].hh.v.RH;
1082   cur_head = mem[p + 4].hh.v.LH;
1083   align_state = mem[p + 3].cint;
1084   cur_loop = mem[p + 2].cint;
1085   cur_span = mem[p + 1].hh.v.RH;
1086   mem[mem_top - 8].hh.v.RH = mem[p + 1].hh.v.LH;
1087   cur_align = mem[p].hh.v.LH;
1088   align_ptr = mem[p].hh.v.RH;
1089   free_node(p, 5);
1090 }
1091 void get_preamble_token (void)
1092 {/* 20 */
1093   lab20: get_token ();
1094   while((cur_chr == 256)&&(cur_cmd == 4)) {
1095
1096     get_token ();
1097     if(cur_cmd > 100)
1098     {
1099       expand ();
1100       get_token ();
1101     }
1102   }
1103   if(cur_cmd == 9){
1104     fatal_error("(interwoven alignment preambles are not allowed)"); /*  */
1105     return;     // abort_flag set
1106   }
1107   if((cur_cmd == 75)&&(cur_chr == (hash_size + 793)))
1108   {
1109     scan_optional_equals ();
1110     scan_glue(2);
1111     if(eqtb[(hash_size + 3206)].cint > 0)
1112     geq_define((hash_size + 793), 117, cur_val);
1113     else eq_define((hash_size + 793), 117, cur_val);
1114     goto lab20;
1115   }
1116 }
1117 void init_align (void)
1118 {/* 30 31 32 22 */
1119   halfword savecsptr;
1120   halfword p;
1121   savecsptr = cur_cs;
1122   push_alignment ();
1123   align_state = -1000000L;
1124   if((mode == 203)&&((tail != cur_list
1125  .head_field)||(cur_list.aux_field.cint != 0)))
1126   {
1127           print_err("Improper ");
1128     print_esc("halign");
1129     print_string("inside $$");
1130         help3("Displays can use special alignments (like \\eqalignno)",
1131                 "only if nothing but the alignment itself is between $$'s.",
1132                 "So I've deleted the formulas that preceded this alignment.");
1133     error ();
1134     flush_math ();
1135   }
1136   push_nest ();
1137   if(mode == 203)
1138   {
1139     mode = -1;
1140     cur_list.aux_field.cint = nest[nest_ptr - 2].aux_field.cint;
1141   }
1142   else if(mode > 0)
1143 /*    long to short ... */
1144   mode = - (integer) mode;
1145   scan_spec(6, false);
1146   mem[mem_top - 8].hh.v.RH = 0;
1147   cur_align = mem_top - 8;
1148   cur_loop = 0;
1149   scanner_status = 4;
1150   warning_index = savecsptr;
1151   align_state = -1000000L;
1152   while(true){
1153     mem[cur_align].hh.v.RH = new_param_glue(11);
1154     cur_align = mem[cur_align].hh.v.RH;
1155     if(cur_cmd == 5)
1156     goto lab30;
1157     p = mem_top - 4;
1158     mem[p].hh.v.RH = 0;
1159     while(true){
1160       get_preamble_token();
1161       if(cur_cmd == 6)
1162       goto lab31;
1163       if((cur_cmd <= 5)&&(cur_cmd >= 4)&&(align_state == -1000000L))
1164       if((p == mem_top - 4)&&(cur_loop == 0)&&(cur_cmd == 4))
1165       cur_loop = cur_align;
1166       else {
1167     print_err("Missing # inserted in alignment preamble");
1168         help3("There should be exactly one # between &'s, when an",
1169                 "\\halign or \\valign is being set up. In this case you had",
1170                 "none, so I've put one in; maybe that will work.");
1171   back_error ();
1172   goto lab31;
1173       }
1174       else if((cur_cmd != 10)||(p != mem_top - 4))
1175       {
1176   mem[p].hh.v.RH = get_avail ();
1177   p = mem[p].hh.v.RH;
1178   mem[p].hh.v.LH = cur_tok;
1179       }
1180     }
1181     lab31:;
1182     mem[cur_align].hh.v.RH = new_null_box ();
1183     cur_align = mem[cur_align].hh.v.RH;
1184     mem[cur_align].hh.v.LH = mem_top - 9;
1185     mem[cur_align + 1].cint = -1073741824L;  /* - 2^30 */
1186     mem[cur_align + 3].cint = mem[mem_top - 4].hh.v.RH;
1187     p = mem_top - 4;
1188     mem[p].hh.v.RH = 0;
1189     while(true){
1190 lab22:
1191     get_preamble_token();
1192       if((cur_cmd <= 5)&&(cur_cmd >= 4)&&(align_state == -1000000L))
1193       goto lab32;
1194       if(cur_cmd == 6)
1195       {
1196                   print_err("Only one # is allowed per tab");
1197                   help3("There should be exactly one # between &'s, when an",
1198                           "\\halign or \\valign is being set up. In this case you had",
1199                           "more than one, so I'm ignoring all but the first.");
1200   error ();
1201   goto lab22;
1202       }
1203       mem[p].hh.v.RH = get_avail ();
1204       p = mem[p].hh.v.RH;
1205       mem[p].hh.v.LH = cur_tok;
1206     }
1207     lab32: mem[p].hh.v.RH = get_avail ();
1208     p = mem[p].hh.v.RH;
1209 /*    mem[p].hh.v.LH = (hash_size + 4614);  */
1210 /*    mem[p].hh.v.LH = (hash_size + 4095 + 519);  */
1211     mem[p].hh.v.LH = (hash_size + hash_extra + 4095 + 519); /* 96/Jan/10 */
1212     mem[cur_align + 2].cint = mem[mem_top - 4].hh.v.RH;
1213   }
1214   lab30: scanner_status = 0;
1215   new_save_level(6);
1216 /* if every_cr<>null then begin_token_list(every_cr,every_cr_text); l.15665 */
1217   if(eqtb[(hash_size + 1320)].hh.v.RH != 0)/* everycr */
1218     begin_token_list(eqtb[(hash_size + 1320)].hh.v.RH, 13);
1219   align_peek ();
1220 }
1221 void init_span_ (halfword p)
1222 {
1223   push_nest ();
1224   if(mode == -102)
1225   space_factor = 1000;
1226   else {
1227
1228     cur_list.aux_field.cint = ignore_depth;
1229     normal_paragraph ();
1230   }
1231   cur_span = p;
1232 }
1233 void init_row (void)
1234 {
1235   push_nest ();
1236   mode =(-103)- mode;
1237   if(mode == -102)
1238   space_factor = 0;
1239   else cur_list.aux_field.cint = 0;
1240   {
1241     mem[tail].hh.v.RH = new_glue(mem[mem[mem_top - 8]
1242    .hh.v.RH + 1].hh.v.LH);
1243     tail = mem[tail].hh.v.RH;
1244   }
1245   mem[tail].hh.b1 = 12;
1246   cur_align = mem[mem[mem_top - 8].hh.v.RH].hh.v.RH;
1247   cur_tail = cur_head;
1248   init_span(cur_align);
1249 }
1250 void init_col (void)
1251 {
1252   mem[cur_align + 5].hh.v.LH = cur_cmd;
1253   if(cur_cmd == 63)
1254   align_state = 0;
1255   else {
1256
1257     back_input ();
1258     begin_token_list(mem[cur_align + 3].cint, 1);
1259   }
1260 }
1261 /* fin_col() moved to end to hide in pragma (g, "off") */
1262 /* may need to move more ? everything calling new_null_box() ? */
1263 void fin_row (void)
1264 {
1265   halfword p;
1266   if(mode == -102)
1267   {
1268     p = hpack(mem[head].hh.v.RH, 0, 1);
1269     pop_nest ();
1270     append_to_vlist(p);
1271     if(cur_head != cur_tail)
1272     {
1273       mem[tail].hh.v.RH = mem[cur_head].hh.v.RH;
1274       tail = cur_tail;
1275     }
1276   }
1277   else {
1278
1279     p = vpackage(mem[head].hh.v.RH, 0, 1,
1280     1073741823L);   /* 2^30 - 1 */
1281     pop_nest ();
1282     mem[tail].hh.v.RH = p;
1283     tail = p;
1284     space_factor = 1000;
1285   }
1286   mem[p].hh.b0 = 13;
1287   mem[p + 6].cint = 0;
1288   if(eqtb[(hash_size + 1320)].hh.v.RH != 0)/* everycr */
1289     begin_token_list(eqtb[(hash_size + 1320)].hh.v.RH, 13);
1290   align_peek ();
1291 }
1292 void fin_align (void)
1293 {
1294   halfword p, q, r, s, u, v;
1295   scaled t, w;
1296   scaled o;
1297   halfword n;
1298   scaled rulesave;
1299   memory_word auxsave;
1300
1301   if(cur_group != 6){
1302     confusion(909); /* align1 */
1303     return;       // abort_flag set
1304   }
1305   unsave ();
1306   if(cur_group != 6){
1307     confusion(910); /* align0 */
1308     return;       // abort_flag set
1309   }
1310   unsave ();
1311   if(nest[nest_ptr - 1].mode_field == 203)
1312   o = eqtb[(hash_size + 3745)].cint;
1313   else o = 0;
1314   q = mem[mem[mem_top - 8].hh.v.RH].hh.v.RH;
1315   do {
1316       flush_list(mem[q + 3].cint);
1317     flush_list(mem[q + 2].cint);
1318     p = mem[mem[q].hh.v.RH].hh.v.RH;
1319     if(mem[q + 1].cint == -1073741824L) /* - 2^30 */
1320     {
1321       mem[q + 1].cint = 0;
1322       r = mem[q].hh.v.RH;
1323       s = mem[r + 1].hh.v.LH;
1324       if(s != 0)
1325       {
1326   incr(mem[0].hh.v.RH); /* mem[mem_bot]? mem[null]? */
1327   delete_glue_ref(s);
1328   mem[r + 1].hh.v.LH = 0;
1329       }
1330     }
1331     if(mem[q].hh.v.LH != mem_top - 9)
1332     {
1333       t = mem[q + 1].cint + mem[mem[mem[q].hh.v.RH + 1].hh
1334      .v.LH + 1].cint;
1335       r = mem[q].hh.v.LH;
1336       s = mem_top - 9;
1337       mem[s].hh.v.LH = p;
1338       n = 1;
1339       do {
1340     mem[r + 1].cint = mem[r + 1].cint - t;
1341   u = mem[r].hh.v.LH;
1342   while(mem[r].hh.v.RH > n){
1343
1344     s = mem[s].hh.v.LH;
1345     n = mem[mem[s].hh.v.LH].hh.v.RH + 1;
1346   }
1347   if(mem[r].hh.v.RH < n)
1348   {
1349     mem[r].hh.v.LH = mem[s].hh.v.LH;
1350     mem[s].hh.v.LH = r;
1351     decr(mem[r].hh.v.RH);
1352     s = r;
1353   }
1354   else {
1355
1356     if(mem[r + 1].cint > mem[mem[s].hh.v.LH + 1].cint)
1357     mem[mem[s].hh.v.LH + 1].cint = mem[r + 1].cint;
1358     free_node(r, 2);
1359   }
1360   r = u;
1361       } while(!(r == mem_top - 9));
1362     }
1363     mem[q].hh.b0 = 13;
1364     mem[q].hh.b1 = 0;
1365     mem[q + 3].cint = 0;
1366     mem[q + 2].cint = 0;
1367     mem[q + 5].hh.b1 = 0;
1368     mem[q + 5].hh.b0 = 0;
1369     mem[q + 6].cint = 0;
1370     mem[q + 4].cint = 0;
1371     q = p;
1372   } while(!(q == 0));
1373   save_ptr = save_ptr - 2;
1374   pack_begin_line = - (integer) mode_line;
1375   if(mode == -1)
1376   {
1377     rulesave = eqtb[(hash_size + 3746)].cint;
1378     eqtb[(hash_size + 3746)].cint = 0;
1379     p = hpack(mem[mem_top - 8].hh.v.RH, save_stack[save_ptr + 1].cint
1380    , save_stack[save_ptr + 0].cint);
1381     eqtb[(hash_size + 3746)].cint = rulesave;
1382   }
1383   else {
1384
1385     q = mem[mem[mem_top - 8].hh.v.RH].hh.v.RH;
1386     do {
1387   mem[q + 3].cint = mem[q + 1].cint;
1388       mem[q + 1].cint = 0;
1389       q = mem[mem[q].hh.v.RH].hh.v.RH;
1390     } while(!(q == 0));
1391     p = vpackage(mem[mem_top - 8].hh.v.RH, save_stack[save_ptr + 1]
1392    .cint, save_stack[save_ptr + 0].cint, 1073741823L);  /* 2^30 - 1 */
1393     q = mem[mem[mem_top - 8].hh.v.RH].hh.v.RH;
1394     do {
1395   mem[q + 1].cint = mem[q + 3].cint;
1396       mem[q + 3].cint = 0;
1397       q = mem[mem[q].hh.v.RH].hh.v.RH;
1398     } while(!(q == 0));
1399   }
1400   pack_begin_line = 0;
1401   q = mem[head].hh.v.RH;
1402   s = head;
1403   while(q != 0){    /* while q<>null l.15794 OK */
1404
1405     if(!(q >= hi_mem_min))  /*   begin if not is_char_node(q) then */
1406     if(mem[q].hh.b0 == 13)
1407     {
1408       if(mode == -1)
1409       {
1410   mem[q].hh.b0 = 0;
1411   mem[q + 1].cint = mem[p + 1].cint;
1412       }
1413       else {
1414
1415   mem[q].hh.b0 = 1;
1416   mem[q + 3].cint = mem[p + 3].cint;
1417       }
1418       mem[q + 5].hh.b1 = mem[p + 5].hh.b1;
1419       mem[q + 5].hh.b0 = mem[p + 5].hh.b0;
1420       mem[q + 6].gr = mem[p + 6].gr;
1421       mem[q + 4].cint = o;
1422       r = mem[mem[q + 5].hh.v.RH].hh.v.RH;
1423       s = mem[mem[p + 5].hh.v.RH].hh.v.RH;
1424       do {
1425     n = mem[r].hh.b1;
1426   t = mem[s + 1].cint;
1427   w = t;
1428   u = mem_top - 4;
1429   while(n > 0){
1430
1431     decr(n);
1432     s = mem[s].hh.v.RH;
1433     v = mem[s + 1].hh.v.LH;
1434     mem[u].hh.v.RH = new_glue(v);
1435     u = mem[u].hh.v.RH;
1436     mem[u].hh.b1 = 12;
1437     t = t + mem[v + 1].cint;
1438     if(mem[p + 5].hh.b0 == 1)
1439     {
1440       if(mem[v].hh.b0 == mem[p + 5].hh.b1)
1441       t = t + round(mem[p + 6].gr * mem[v + 2].cint);
1442     }
1443     else if(mem[p + 5].hh.b0 == 2)
1444     {
1445       if(mem[v].hh.b1 == mem[p + 5].hh.b1)
1446       t = t - round(mem[p + 6].gr * mem[v + 3].cint);
1447     }
1448     s = mem[s].hh.v.RH;
1449     mem[u].hh.v.RH = new_null_box ();
1450     u = mem[u].hh.v.RH;
1451     t = t + mem[s + 1].cint;
1452     if(mode == -1)
1453     mem[u + 1].cint = mem[s + 1].cint;
1454     else {
1455
1456       mem[u].hh.b0 = 1;
1457       mem[u + 3].cint = mem[s + 1].cint;
1458     }
1459   }
1460   if(mode == -1)
1461   {
1462     mem[r + 3].cint = mem[q + 3].cint;
1463     mem[r + 2].cint = mem[q + 2].cint;
1464     if(t == mem[r + 1].cint)
1465     {
1466       mem[r + 5].hh.b0 = 0;
1467       mem[r + 5].hh.b1 = 0;
1468       mem[r + 6].gr = 0.0;
1469     }
1470     else if(t > mem[r + 1].cint)
1471     {
1472       mem[r + 5].hh.b0 = 1;
1473       if(mem[r + 6].cint == 0)
1474       mem[r + 6].gr = 0.0;
1475       else mem[r + 6].gr =(t - mem[r + 1].cint)/ ((double)
1476       mem[r + 6].cint);
1477     }
1478     else {
1479
1480       mem[r + 5].hh.b1 = mem[r + 5].hh.b0;
1481       mem[r + 5].hh.b0 = 2;
1482       if(mem[r + 4].cint == 0)
1483       mem[r + 6].gr = 0.0;
1484       else if((mem[r + 5].hh.b1 == 0)&&(mem[r + 1].cint -
1485       t > mem[r + 4].cint))
1486       mem[r + 6].gr = 1.0;
1487       else mem[r + 6].gr =(mem[r + 1].cint - t)/ ((double)
1488       mem[r + 4].cint);
1489     }
1490     mem[r + 1].cint = w;
1491     mem[r].hh.b0 = 0;
1492   }
1493   else {
1494
1495     mem[r + 1].cint = mem[q + 1].cint;
1496     if(t == mem[r + 3].cint)
1497     {
1498       mem[r + 5].hh.b0 = 0;
1499       mem[r + 5].hh.b1 = 0;
1500       mem[r + 6].gr = 0.0;
1501     }
1502     else if(t > mem[r + 3].cint)
1503     {
1504       mem[r + 5].hh.b0 = 1;
1505       if(mem[r + 6].cint == 0)
1506       mem[r + 6].gr = 0.0;
1507       else mem[r + 6].gr =(t - mem[r + 3].cint)/ ((double)
1508       mem[r + 6].cint);
1509     }
1510     else {
1511
1512       mem[r + 5].hh.b1 = mem[r + 5].hh.b0;
1513       mem[r + 5].hh.b0 = 2;
1514       if(mem[r + 4].cint == 0)
1515       mem[r + 6].gr = 0.0;
1516       else if((mem[r + 5].hh.b1 == 0)&&(mem[r + 3].cint -
1517       t > mem[r + 4].cint))
1518       mem[r + 6].gr = 1.0;
1519       else mem[r + 6].gr =(mem[r + 3].cint - t)/ ((double)
1520       mem[r + 4].cint);
1521     }
1522     mem[r + 3].cint = w;
1523     mem[r].hh.b0 = 1;
1524   }
1525   mem[r + 4].cint = 0;
1526   if(u != mem_top - 4)
1527   {
1528     mem[u].hh.v.RH = mem[r].hh.v.RH;
1529     mem[r].hh.v.RH = mem[mem_top - 4].hh.v.RH;
1530     r = u;
1531   }
1532   r = mem[mem[r].hh.v.RH].hh.v.RH;
1533   s = mem[mem[s].hh.v.RH].hh.v.RH;
1534       } while(!(r == 0));
1535     }
1536     else if(mem[q].hh.b0 == 2)
1537     {
1538       if((mem[q + 1].cint == -1073741824L))  /* 2^30  */
1539       mem[q + 1].cint = mem[p + 1].cint;
1540       if((mem[q + 3].cint == -1073741824L))  /* 2^30  */
1541       mem[q + 3].cint = mem[p + 3].cint;
1542       if((mem[q + 2].cint == -1073741824L))  /* 2^30  */
1543       mem[q + 2].cint = mem[p + 2].cint;
1544       if(o != 0)
1545       {
1546   r = mem[q].hh.v.RH;
1547   mem[q].hh.v.RH = 0;
1548   q = hpack(q, 0, 1);
1549   mem[q + 4].cint = o;
1550   mem[q].hh.v.RH = r;
1551   mem[s].hh.v.RH = q;
1552       }
1553     }
1554     s = q;
1555     q = mem[q].hh.v.RH;
1556   }
1557   flush_node_list(p);
1558   pop_alignment ();
1559   auxsave = cur_list.aux_field;
1560   p = mem[head].hh.v.RH;
1561   q = tail;
1562   pop_nest ();
1563   if(mode == 203)
1564   {
1565     do_assignments ();
1566     if(cur_cmd != 3) {
1567                 print_err("Missing $$ inserted");
1568                 help2("Displays can use special alignments (like \\eqalignno)",
1569                         "only if nothing but the alignment itself is between $$'s.");
1570       back_error ();
1571     }
1572     else {
1573
1574       get_x_token ();
1575       if(cur_cmd != 3)
1576       {
1577                   print_err("Display math should end with $$");
1578                   help2("The `$' that I just saw supposedly matches a previous `$$'.",
1579                           "So I shall assume that you typed `$$' both times.");
1580   back_error ();
1581       }
1582   }
1583     pop_nest ();
1584     {
1585       mem[tail].hh.v.RH = new_penalty(eqtb[(hash_size + 3174)].cint
1586     );
1587       tail = mem[tail].hh.v.RH;
1588     }
1589     {
1590       mem[tail].hh.v.RH = new_param_glue(3);
1591       tail = mem[tail].hh.v.RH;
1592     }
1593     mem[tail].hh.v.RH = p;
1594     if(p != 0)
1595     tail = q;
1596     {
1597       mem[tail].hh.v.RH = new_penalty(eqtb[(hash_size + 3175)].cint
1598     );
1599       tail = mem[tail].hh.v.RH;
1600     }
1601     {
1602       mem[tail].hh.v.RH = new_param_glue(4);
1603       tail = mem[tail].hh.v.RH;
1604     }
1605     cur_list.aux_field.cint = auxsave.cint;
1606     resume_after_display ();
1607   }
1608   else {
1609
1610     cur_list.aux_field = auxsave;
1611     mem[tail].hh.v.RH = p;
1612     if(p != 0)    /*   if p<>null then tail:=q; l.15926 */
1613     tail = q;
1614     if(mode == 1){
1615     build_page ();
1616   }
1617   }
1618 }
1619 /* used to be align_peek, zfintieshrink, etc in old tex5.c */
1620 /************************************************************************/
1621 /* moved down here to avoid questions about pragma optimize */
1622 #pragma optimize("g", off)          /* for MC VS compiler */
1623 /*  Moved down here 96/Oct/12 in response to problem with texerror.tex */
1624 /*  pragma optimize("a", off) not strong enough - this may slow things */
1625 bool fin_col (void)
1626 {/* 10 */ register bool Result;
1627   halfword p;
1628   halfword q, r;
1629   halfword s;
1630   halfword u;
1631   scaled w;
1632   glue_ord o;
1633   halfword n;
1634   if(cur_align == 0){
1635     confusion(903); /* endv */
1636     return 0;       // abort_flag set
1637   }
1638   q = mem[cur_align].hh.v.RH;
1639   if(q == 0){
1640     confusion(903); /* endv */
1641     return 0;       // abort_flag set
1642   }
1643   if(align_state < 500000L) {     /* ??? */
1644     fatal_error("(interwoven alignment preambles are not allowed)"); /*  */
1645     return 0;     // abort_flag set
1646   }
1647   p = mem[q].hh.v.RH;         /* p <- link(q) p.791 */
1648 /* if (p = null) ^ (extra_info(cur_align) < cr_code) then p.792 */
1649   if((p == 0)&&(mem[cur_align + 5].hh.v.LH < 257))
1650   if(cur_loop != 0)
1651   {
1652 /*  potential problem here if new_null_box causes memory reallocation ??? */
1653 /*  compiler optimization does not refresh `mem' loaded in registers ? */
1654     mem[q].hh.v.RH = new_null_box ();
1655     p = mem[q].hh.v.RH;
1656     mem[p].hh.v.LH = mem_top - 9;
1657     mem[p + 1].cint = -1073741824L;  /* - 2^30 */
1658     cur_loop = mem[cur_loop].hh.v.RH;
1659     q = mem_top - 4;
1660     r = mem[cur_loop + 3].cint;
1661     while(r != 0){
1662
1663       mem[q].hh.v.RH = get_avail ();
1664       q = mem[q].hh.v.RH;
1665       mem[q].hh.v.LH = mem[r].hh.v.LH;
1666       r = mem[r].hh.v.RH;
1667     }
1668     mem[q].hh.v.RH = 0;
1669     mem[p + 3].cint = mem[mem_top - 4].hh.v.RH;
1670     q = mem_top - 4;
1671     r = mem[cur_loop + 2].cint;
1672     while(r != 0){
1673
1674       mem[q].hh.v.RH = get_avail ();
1675       q = mem[q].hh.v.RH;
1676       mem[q].hh.v.LH = mem[r].hh.v.LH;
1677       r = mem[r].hh.v.RH;
1678     }
1679     mem[q].hh.v.RH = 0;
1680     mem[p + 2].cint = mem[mem_top - 4].hh.v.RH;
1681     cur_loop = mem[cur_loop].hh.v.RH;
1682     mem[p].hh.v.RH = new_glue(mem[cur_loop + 1].hh.v.LH);
1683   }
1684   else {
1685       print_err("Extra alignment tab has been changed to ");
1686     print_esc("cr");
1687         help3("You have given more \\span or & marks than there were",
1688                 "in the preamble to the \\halign or \\valign now in progress.",
1689                 "So I'll assume that you meant to type \\cr instead.");
1690 /* extra_info(cur_align) < cr_code) ? */
1691     mem[cur_align + 5].hh.v.LH = 257;
1692     error ();
1693   }
1694   if(mem[cur_align + 5].hh.v.LH != 256)
1695   {
1696     unsave ();
1697     new_save_level(6);
1698     {
1699       if(mode == -102)
1700       {
1701   adjust_tail = cur_tail;
1702   u = hpack(mem[head].hh.v.RH, 0, 1);
1703   w = mem[u + 1].cint;
1704   cur_tail = adjust_tail;
1705   adjust_tail = 0;
1706       }
1707       else {
1708
1709   u = vpackage(mem[head].hh.v.RH, 0, 1, 0);
1710   w = mem[u + 3].cint;
1711       }
1712       n = 0;
1713       if(cur_span != cur_align)
1714       {
1715   q = cur_span;
1716   do {
1717       incr(n);
1718     q = mem[mem[q].hh.v.RH].hh.v.RH;
1719   } while(!(q == cur_align));
1720 /*  if n > max_quarterword then confusion("256 spans"); p.798 */
1721 /*  if(n > 255) */            /* 94/Apr/4 ? */
1722   if(n > max_quarterword) {       /* 96/Oct/12 ??? */
1723     confusion(908);   /* 256 spans --- message wrong now, but ... */
1724     return 0;       // abort_flag set
1725   }
1726   q = cur_span;
1727   while(mem[mem[q].hh.v.LH].hh.v.RH < n)q = mem[q].hh
1728   .v.LH;
1729   if(mem[mem[q].hh.v.LH].hh.v.RH > n)
1730   {
1731     s = get_node(2);
1732     mem[s].hh.v.LH = mem[q].hh.v.LH;
1733     mem[s].hh.v.RH = n;
1734     mem[q].hh.v.LH = s;
1735     mem[s + 1].cint = w;
1736   }
1737   else if(mem[mem[q].hh.v.LH + 1].cint < w)
1738   mem[mem[q].hh.v.LH + 1].cint = w;
1739       }
1740       else if(w > mem[cur_align + 1].cint)
1741       mem[cur_align + 1].cint = w;
1742       mem[u].hh.b0 = 13;
1743       mem[u].hh.b1 = n;
1744       if(totalstretch[3]!= 0)
1745       o = 3;
1746       else if(totalstretch[2]!= 0)
1747       o = 2;
1748       else if(totalstretch[1]!= 0)
1749       o = 1;
1750       else o = 0;
1751       mem[u + 5].hh.b1 = o;
1752       mem[u + 6].cint = totalstretch[o];
1753       if(totalshrink[3]!= 0)
1754       o = 3;
1755       else if(totalshrink[2]!= 0)
1756       o = 2;
1757       else if(totalshrink[1]!= 0)
1758       o = 1;
1759       else o = 0;
1760       mem[u + 5].hh.b0 = o;
1761       mem[u + 4].cint = totalshrink[o];
1762       pop_nest ();
1763       mem[tail].hh.v.RH = u;
1764       tail = u;
1765     }
1766     {
1767       mem[tail].hh.v.RH = new_glue(mem[mem[cur_align]
1768      .hh.v.RH + 1].hh.v.LH);
1769       tail = mem[tail].hh.v.RH;
1770     }
1771     mem[tail].hh.b1 = 12;
1772 /* if (extra_info(cur_align) >= cr_code) then p.792 */
1773     if(mem[cur_align + 5].hh.v.LH >= 257)
1774     {
1775       Result = true;
1776       return(Result);
1777     }
1778     init_span(p);
1779   }
1780   align_state = 1000000L;
1781   do {
1782       get_x_token ();
1783   } while(!(cur_cmd != 10));
1784   cur_align = p;
1785   init_col ();
1786   Result = false;
1787   return Result;
1788 }
1789 /* #pragma optimize ("g", on) */        /* for MC VS compiler */
1790 /* #pragma optimize ("g",) */         /* 94/Jan/25 */
1791 /* #pragma optimize ("", on) */           /* 96/Sep/12 */
1792 /* #pragma optimize("g", off) */          /* for MC VS compiler */
1793
1794 scaled make_op_(halfword q)
1795 {register scaled Result;
1796   scaled delta;
1797   halfword p, v, x, y, z;
1798   quarterword c;
1799   ffourquarters i;
1800   scaled shiftup, shiftdown;
1801   if((mem[q].hh.b1 == 0)&&(cur_style < 2))
1802   mem[q].hh.b1 = 1;
1803   if(mem[q + 1].hh.v.RH == 1)
1804   {
1805     fetch(q + 1);
1806     if((cur_style < 2)&&(((cur_i.b2)% 4)== 2))
1807     {
1808       c = cur_i.b3;
1809       i = font_info[char_base[cur_f]+ c].qqqq;
1810       if((i.b0 > 0))
1811       {
1812   cur_c = c;
1813   cur_i = i;
1814   mem[q + 1].hh.b1 = c;
1815       }
1816     }
1817     delta = font_info[italic_base[cur_f]+(cur_i.b2)/ 4].cint;
1818     x = clean_box(q + 1, cur_style);
1819     if((mem[q + 3].hh.v.RH != 0)&&(mem[q].hh.b1 != 1))
1820     mem[x + 1].cint = mem[x + 1].cint - delta;
1821     mem[x + 4].cint = half(mem[x + 3].cint - mem[x + 2].cint)-
1822     font_info[22 + param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH]].cint;
1823     mem[q + 1].hh.v.RH = 2;
1824     mem[q + 1].hh.v.LH = x;
1825   }
1826   else delta = 0;
1827   if(mem[q].hh.b1 == 1)
1828   {
1829     x = clean_box(q + 2, 2 *(cur_style / 4)+ 4 +(cur_style % 2));
1830     y = clean_box(q + 1, cur_style);
1831     z = clean_box(q + 3, 2 *(cur_style / 4)+ 5);
1832     v = new_null_box ();
1833     mem[v].hh.b0 = 1;
1834     mem[v + 1].cint = mem[y + 1].cint;
1835     if(mem[x + 1].cint > mem[v + 1].cint)
1836     mem[v + 1].cint = mem[x + 1].cint;
1837     if(mem[z + 1].cint > mem[v + 1].cint)
1838     mem[v + 1].cint = mem[z + 1].cint;
1839     x = rebox(x, mem[v + 1].cint);
1840     y = rebox(y, mem[v + 1].cint);
1841     z = rebox(z, mem[v + 1].cint);
1842     mem[x + 4].cint = half(delta);
1843     mem[z + 4].cint = - (integer) mem[x + 4].cint;
1844     mem[v + 3].cint = mem[y + 3].cint;
1845     mem[v + 2].cint = mem[y + 2].cint;
1846     if(mem[q + 2].hh.v.RH == 0)
1847     {
1848       free_node(x, 7);
1849       mem[v + 5].hh.v.RH = y;
1850     }
1851     else {
1852
1853       shiftup = font_info[11 + param_base[eqtb[(hash_size + 1838) + cur_size].hh.v.RH
1854     ]].cint - mem[x + 2].cint;
1855       if(shiftup < font_info[9 + param_base[eqtb[(hash_size + 1838) + cur_size].hh
1856      .v.RH]].cint)
1857       shiftup = font_info[9 + param_base[eqtb[(hash_size + 1838) + cur_size].hh.v.RH
1858     ]].cint;
1859       p = new_kern(shiftup);
1860       mem[p].hh.v.RH = y;
1861       mem[x].hh.v.RH = p;
1862       p = new_kern(font_info[13 + param_base[eqtb[(hash_size + 1838) + cur_size].hh
1863      .v.RH]].cint);
1864       mem[p].hh.v.RH = x;
1865       mem[v + 5].hh.v.RH = p;
1866       mem[v + 3].cint = mem[v + 3].cint + font_info[13 + param_base[
1867       eqtb[(hash_size + 1838) + cur_size].hh.v.RH]].cint + mem[x + 3].cint + mem
1868      [x + 2].cint + shiftup;
1869     }
1870     if(mem[q + 3].hh.v.RH == 0)
1871     free_node(z, 7);
1872     else {
1873
1874       shiftdown = font_info[12 + param_base[eqtb[(hash_size + 1838) + cur_size].hh
1875      .v.RH]].cint - mem[z + 3].cint;
1876       if(shiftdown < font_info[10 + param_base[eqtb[(hash_size + 1838) + cur_size]
1877      .hh.v.RH]].cint)
1878       shiftdown = font_info[10 + param_base[eqtb[(hash_size + 1838) + cur_size].hh
1879      .v.RH]].cint;
1880       p = new_kern(shiftdown);
1881       mem[y].hh.v.RH = p;
1882       mem[p].hh.v.RH = z;
1883       p = new_kern(font_info[13 + param_base[eqtb[(hash_size + 1838) + cur_size].hh
1884      .v.RH]].cint);
1885       mem[z].hh.v.RH = p;
1886       mem[v + 2].cint = mem[v + 2].cint + font_info[13 + param_base[
1887       eqtb[(hash_size + 1838) + cur_size].hh.v.RH]].cint + mem[z + 3].cint + mem
1888      [z + 2].cint + shiftdown;
1889     }
1890     mem[q + 1].cint = v;
1891   }
1892   Result = delta;
1893   return Result;
1894 }
1895 /* #pragma optimize ("g", on) */        /* for MC VS compiler */
1896 /* #pragma optimize ("g",) */         /* 94/Jan/25 */
1897 /* #pragma optimize ("", on) */           /* 96/Sep/12 */
1898 /* #pragma optimize ("g", off) */
1899
1900 void make_scripts_(halfword q, scaled delta)
1901 {
1902   halfword p, x, y, z;
1903   scaled shiftup, shiftdown, clr;
1904   small_number t;
1905   p = mem[q + 1].cint;
1906   if((p >= hi_mem_min))
1907   {
1908     shiftup = 0;
1909     shiftdown = 0;
1910   }
1911   else {
1912
1913     z = hpack(p, 0, 1);
1914     if(cur_style < 4)
1915     t = 16;
1916     else t = 32;
1917     shiftup = mem[z + 3].cint - font_info[18 + param_base[eqtb[(hash_size + 1837) +
1918     t].hh.v.RH]].cint;
1919     shiftdown = mem[z + 2].cint + font_info[19 + param_base[eqtb[(hash_size + 1837)
1920     + t].hh.v.RH]].cint;
1921     free_node(z, 7);
1922   }
1923   if(mem[q + 2].hh.v.RH == 0)
1924   {
1925     x = clean_box(q + 3, 2 *(cur_style / 4)+ 5);
1926     mem[x + 1].cint = mem[x + 1].cint + eqtb[(hash_size + 3742)].cint;
1927     if(shiftdown < font_info[16 + param_base[eqtb[(hash_size + 1837) + cur_size].hh
1928    .v.RH]].cint)
1929     shiftdown = font_info[16 + param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH
1930   ]].cint;
1931     clr = mem[x + 3].cint -(abs(font_info[5 + param_base[eqtb[
1932     (hash_size + 1837) + cur_size].hh.v.RH]].cint * 4)/ 5);
1933     if(shiftdown < clr)
1934     shiftdown = clr;
1935     mem[x + 4].cint = shiftdown;
1936   }
1937   else {
1938
1939     {
1940       x = clean_box(q + 2, 2 *(cur_style / 4)+ 4 +(cur_style % 2));
1941       mem[x + 1].cint = mem[x + 1].cint + eqtb[(hash_size + 3742)].cint;
1942       if(odd(cur_style))
1943       clr = font_info[15 + param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH]]
1944      .cint;
1945       else if(cur_style < 2)
1946       clr = font_info[13 + param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH]]
1947      .cint;
1948       else clr = font_info[14 + param_base[eqtb[(hash_size + 1837) + cur_size].hh
1949      .v.RH]].cint;
1950       if(shiftup < clr)
1951       shiftup = clr;
1952       clr = mem[x + 2].cint +(abs(font_info[5 +
1953     param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH]].cint)/ 4);
1954       if(shiftup < clr)
1955       shiftup = clr;
1956     }
1957     if(mem[q + 3].hh.v.RH == 0)
1958     mem[x + 4].cint = - (integer) shiftup;
1959     else {
1960
1961       y = clean_box(q + 3, 2 *(cur_style / 4)+ 5);
1962       mem[y + 1].cint = mem[y + 1].cint + eqtb[(hash_size + 3742)].cint;
1963       if(shiftdown < font_info[17 + param_base[eqtb[(hash_size + 1837) + cur_size]
1964      .hh.v.RH]].cint)
1965       shiftdown = font_info[17 + param_base[eqtb[(hash_size + 1837) + cur_size].hh
1966      .v.RH]].cint;
1967       clr = 4 * font_info[8 + param_base[eqtb[(hash_size + 1838) + cur_size].hh.v.RH
1968     ]].cint -((shiftup - mem[x + 2].cint)-(mem[y + 3].cint
1969       - shiftdown));
1970       if(clr > 0)
1971       {
1972   shiftdown = shiftdown + clr;
1973   clr =(abs(font_info[5 + param_base[eqtb[(hash_size + 1837) + cur_size].hh
1974   .v.RH]].cint * 4)/ 5)-(shiftup - mem[x + 2].cint);
1975   if(clr > 0)
1976   {
1977     shiftup = shiftup + clr;
1978     shiftdown = shiftdown - clr;
1979   }
1980       }
1981       mem[x + 4].cint = delta;
1982       p = new_kern((shiftup - mem[x + 2].cint)-(mem[y + 3].cint
1983       - shiftdown));
1984       mem[x].hh.v.RH = p;
1985       mem[p].hh.v.RH = y;
1986       x = vpackage(x, 0, 1, 1073741823L);  /* 2^30 - 1 */
1987       mem[x + 4].cint = shiftdown;
1988     }
1989   }
1990   if(mem[q + 1].cint == 0)
1991   mem[q + 1].cint = x;
1992   else {
1993
1994     p = mem[q + 1].cint;
1995     while(mem[p].hh.v.RH != 0)p = mem[p].hh.v.RH;
1996     mem[p].hh.v.RH = x;
1997   }
1998 }
1999 /* #pragma optimize ("g", on) */        /* 96/Sep/12 */
2000 /* #pragma optimize ("g") */          /* 94/Jan/25 */
2001 #pragma optimize ("", on)           /* 96/Sep/12 */
2002 /***************************************************************************/