src/texsourc/tex5.c

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