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