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