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