home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / tex / tex31 / texsrc.lzh / TEXSRC.LZH / tex1.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-11-28  |  27.8 KB  |  1,338 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4. void zshowtokenlist ( p , q , l ) 
  5. integer p ; 
  6. integer q ; 
  7. integer l ; 
  8. {/* 10 */ showtokenlist_regmem 
  9.   integer m, c  ; 
  10.   ASCIIcode matchchr  ; 
  11.   ASCIIcode n  ; 
  12.   matchchr = 35 ; 
  13.   n = 48 ; 
  14.   tally = 0 ; 
  15.   while ( ( p != 0 ) && ( tally < l ) ) {
  16.       
  17.     if ( p == q ) 
  18.     {
  19.       firstcount = tally ; 
  20.       trickcount = tally + 1 + errorline - halferrorline ; 
  21.       if ( trickcount < errorline ) 
  22.       trickcount = errorline ; 
  23.     } 
  24.     if ( ( p < himemmin ) || ( p > memend ) ) 
  25.     {
  26.       printesc ( 307 ) ; 
  27.       return ; 
  28.     } 
  29.     if ( mem [ p ] .hh .v.LH >= 4095 ) 
  30.     printcs ( mem [ p ] .hh .v.LH - 4095 ) ; 
  31.     else {
  32.     
  33.       m = mem [ p ] .hh .v.LH / 256 ; 
  34.       c = mem [ p ] .hh .v.LH % 256 ; 
  35.       if ( mem [ p ] .hh .v.LH < 0 ) 
  36.       printesc ( 551 ) ; 
  37.       else switch ( m ) 
  38.       {case 1 : 
  39.       case 2 : 
  40.       case 3 : 
  41.       case 4 : 
  42.       case 7 : 
  43.       case 8 : 
  44.       case 10 : 
  45.       case 11 : 
  46.       case 12 : 
  47.     print ( c ) ; 
  48.     break ; 
  49.       case 6 : 
  50.     {
  51.       print ( c ) ; 
  52.       print ( c ) ; 
  53.     } 
  54.     break ; 
  55.       case 5 : 
  56.     {
  57.       print ( matchchr ) ; 
  58.       if ( c <= 9 ) 
  59.       printchar ( c + 48 ) ; 
  60.       else {
  61.           
  62.         printchar ( 33 ) ; 
  63.         return ; 
  64.       } 
  65.     } 
  66.     break ; 
  67.       case 13 : 
  68.     {
  69.       matchchr = c ; 
  70.       print ( c ) ; 
  71.       incr ( n ) ; 
  72.       printchar ( n ) ; 
  73.       if ( n > 57 ) 
  74.       return ; 
  75.     } 
  76.     break ; 
  77.       case 14 : 
  78.     print ( 552 ) ; 
  79.     break ; 
  80.     default: 
  81.     printesc ( 551 ) ; 
  82.     break ; 
  83.       } 
  84.     } 
  85.     p = mem [ p ] .hh .v.RH ; 
  86.   } 
  87.   if ( p != 0 ) 
  88.   printesc ( 550 ) ; 
  89. } 
  90. void runaway ( ) 
  91. {runaway_regmem 
  92.   halfword p  ; 
  93.   if ( scannerstatus > 1 ) 
  94.   {
  95.     printnl ( 565 ) ; 
  96.     switch ( scannerstatus ) 
  97.     {case 2 : 
  98.       {
  99.     print ( 566 ) ; 
  100.     p = defref ; 
  101.       } 
  102.       break ; 
  103.     case 3 : 
  104.       {
  105.     print ( 567 ) ; 
  106.     p = memtop - 3 ; 
  107.       } 
  108.       break ; 
  109.     case 4 : 
  110.       {
  111.     print ( 568 ) ; 
  112.     p = memtop - 4 ; 
  113.       } 
  114.       break ; 
  115.     case 5 : 
  116.       {
  117.     print ( 569 ) ; 
  118.     p = defref ; 
  119.       } 
  120.       break ; 
  121.     } 
  122.     printchar ( 63 ) ; 
  123.     println () ; 
  124.     showtokenlist ( mem [ p ] .hh .v.RH , 0 , errorline - 10 ) ; 
  125.   } 
  126. } 
  127. halfword getavail ( ) 
  128. {register halfword Result; getavail_regmem 
  129.   halfword p  ; 
  130.   p = avail ; 
  131.   if ( p != 0 ) 
  132.   avail = mem [ avail ] .hh .v.RH ; 
  133.   else if ( memend < memmax ) 
  134.   {
  135.     incr ( memend ) ; 
  136.     p = memend ; 
  137.   } 
  138.   else {
  139.       
  140.     decr ( himemmin ) ; 
  141.     p = himemmin ; 
  142.     if ( himemmin <= lomemmax ) 
  143.     {
  144.       runaway () ; 
  145.       overflow ( 298 , memmax + 1 - memmin ) ; 
  146.     } 
  147.   } 
  148.   mem [ p ] .hh .v.RH = 0 ; 
  149.     ;
  150. #ifdef STAT
  151.   incr ( dynused ) ; 
  152. #endif /* STAT */
  153.   Result = p ; 
  154.   return(Result) ; 
  155. } 
  156. void zflushlist ( p ) 
  157. halfword p ; 
  158. {flushlist_regmem 
  159.   halfword q, r  ; 
  160.   if ( p != 0 ) 
  161.   {
  162.     r = p ; 
  163.     do {
  164.     q = r ; 
  165.       r = mem [ r ] .hh .v.RH ; 
  166.     ;
  167. #ifdef STAT
  168.       decr ( dynused ) ; 
  169. #endif /* STAT */
  170.     } while ( ! ( r == 0 ) ) ; 
  171.     mem [ q ] .hh .v.RH = avail ; 
  172.     avail = p ; 
  173.   } 
  174. } 
  175. halfword zgetnode ( s ) 
  176. integer s ; 
  177. {/* 40 10 20 */ register halfword Result; getnode_regmem 
  178.   halfword p  ; 
  179.   halfword q  ; 
  180.   integer r  ; 
  181.   integer t  ; 
  182.   lab20: p = rover ; 
  183.   do {
  184.       q = p + mem [ p ] .hh .v.LH ; 
  185.     while ( ( mem [ q ] .hh .v.RH == 65535L ) ) {
  186.     
  187.       t = mem [ q + 1 ] .hh .v.RH ; 
  188.       if ( q == rover ) 
  189.       rover = t ; 
  190.       mem [ t + 1 ] .hh .v.LH = mem [ q + 1 ] .hh .v.LH ; 
  191.       mem [ mem [ q + 1 ] .hh .v.LH + 1 ] .hh .v.RH = t ; 
  192.       q = q + mem [ q ] .hh .v.LH ; 
  193.     } 
  194.     r = q - s ; 
  195.     if ( r > toint ( p + 1 ) ) 
  196.     {
  197.       mem [ p ] .hh .v.LH = r - p ; 
  198.       rover = p ; 
  199.       goto lab40 ; 
  200.     } 
  201.     if ( r == p ) 
  202.     if ( mem [ p + 1 ] .hh .v.RH != p ) 
  203.     {
  204.       rover = mem [ p + 1 ] .hh .v.RH ; 
  205.       t = mem [ p + 1 ] .hh .v.LH ; 
  206.       mem [ rover + 1 ] .hh .v.LH = t ; 
  207.       mem [ t + 1 ] .hh .v.RH = rover ; 
  208.       goto lab40 ; 
  209.     } 
  210.     mem [ p ] .hh .v.LH = q - p ; 
  211.     p = mem [ p + 1 ] .hh .v.RH ; 
  212.   } while ( ! ( p == rover ) ) ; 
  213.   if ( s == 1073741824L ) 
  214.   {
  215.     Result = 65535L ; 
  216.     return(Result) ; 
  217.   } 
  218.   if ( lomemmax + 2 < himemmin ) 
  219.   if ( lomemmax + 2 <= 65535L ) 
  220.   {
  221.     if ( himemmin - lomemmax >= 1998 ) 
  222.     t = lomemmax + 1000 ; 
  223.     else t = lomemmax + 1 + ( himemmin - lomemmax ) / 2 ; 
  224.     p = mem [ rover + 1 ] .hh .v.LH ; 
  225.     q = lomemmax ; 
  226.     mem [ p + 1 ] .hh .v.RH = q ; 
  227.     mem [ rover + 1 ] .hh .v.LH = q ; 
  228.     if ( t > 65535L ) 
  229.     t = 65535L ; 
  230.     mem [ q + 1 ] .hh .v.RH = rover ; 
  231.     mem [ q + 1 ] .hh .v.LH = p ; 
  232.     mem [ q ] .hh .v.RH = 65535L ; 
  233.     mem [ q ] .hh .v.LH = t - lomemmax ; 
  234.     lomemmax = t ; 
  235.     mem [ lomemmax ] .hh .v.RH = 0 ; 
  236.     mem [ lomemmax ] .hh .v.LH = 0 ; 
  237.     rover = q ; 
  238.     goto lab20 ; 
  239.   } 
  240.   overflow ( 298 , memmax + 1 - memmin ) ; 
  241.   lab40: mem [ r ] .hh .v.RH = 0 ; 
  242.     ;
  243. #ifdef STAT
  244.   varused = varused + s ; 
  245. #endif /* STAT */
  246.   Result = r ; 
  247.   return(Result) ; 
  248. } 
  249. void zfreenode ( p , s ) 
  250. halfword p ; 
  251. halfword s ; 
  252. {freenode_regmem 
  253.   halfword q  ; 
  254.   mem [ p ] .hh .v.LH = s ; 
  255.   mem [ p ] .hh .v.RH = 65535L ; 
  256.   q = mem [ rover + 1 ] .hh .v.LH ; 
  257.   mem [ p + 1 ] .hh .v.LH = q ; 
  258.   mem [ p + 1 ] .hh .v.RH = rover ; 
  259.   mem [ rover + 1 ] .hh .v.LH = p ; 
  260.   mem [ q + 1 ] .hh .v.RH = p ; 
  261.     ;
  262. #ifdef STAT
  263.   varused = varused - s ; 
  264. #endif /* STAT */
  265. } 
  266. halfword newnullbox ( ) 
  267. {register halfword Result; newnullbox_regmem 
  268.   halfword p  ; 
  269.   p = getnode ( 7 ) ; 
  270.   mem [ p ] .hh.b0 = 0 ; 
  271.   mem [ p ] .hh.b1 = 0 ; 
  272.   mem [ p + 1 ] .cint = 0 ; 
  273.   mem [ p + 2 ] .cint = 0 ; 
  274.   mem [ p + 3 ] .cint = 0 ; 
  275.   mem [ p + 4 ] .cint = 0 ; 
  276.   mem [ p + 5 ] .hh .v.RH = 0 ; 
  277.   mem [ p + 5 ] .hh.b0 = 0 ; 
  278.   mem [ p + 5 ] .hh.b1 = 0 ; 
  279.   mem [ p + 6 ] .gr = 0.0 ; 
  280.   Result = p ; 
  281.   return(Result) ; 
  282. } 
  283. halfword newrule ( ) 
  284. {register halfword Result; newrule_regmem 
  285.   halfword p  ; 
  286.   p = getnode ( 4 ) ; 
  287.   mem [ p ] .hh.b0 = 2 ; 
  288.   mem [ p ] .hh.b1 = 0 ; 
  289.   mem [ p + 1 ] .cint = -1073741824L ; 
  290.   mem [ p + 2 ] .cint = -1073741824L ; 
  291.   mem [ p + 3 ] .cint = -1073741824L ; 
  292.   Result = p ; 
  293.   return(Result) ; 
  294. } 
  295. halfword znewligature ( f , c , q ) 
  296. quarterword f ; 
  297. quarterword c ; 
  298. halfword q ; 
  299. {register halfword Result; newligature_regmem 
  300.   halfword p  ; 
  301.   p = getnode ( 2 ) ; 
  302.   mem [ p ] .hh.b0 = 6 ; 
  303.   mem [ p + 1 ] .hh.b0 = f ; 
  304.   mem [ p + 1 ] .hh.b1 = c ; 
  305.   mem [ p + 1 ] .hh .v.RH = q ; 
  306.   mem [ p ] .hh.b1 = 0 ; 
  307.   Result = p ; 
  308.   return(Result) ; 
  309. } 
  310. halfword znewligitem ( c ) 
  311. quarterword c ; 
  312. {register halfword Result; newligitem_regmem 
  313.   halfword p  ; 
  314.   p = getnode ( 2 ) ; 
  315.   mem [ p ] .hh.b1 = c ; 
  316.   mem [ p + 1 ] .hh .v.RH = 0 ; 
  317.   Result = p ; 
  318.   return(Result) ; 
  319. } 
  320. halfword newdisc ( ) 
  321. {register halfword Result; newdisc_regmem 
  322.   halfword p  ; 
  323.   p = getnode ( 2 ) ; 
  324.   mem [ p ] .hh.b0 = 7 ; 
  325.   mem [ p ] .hh.b1 = 0 ; 
  326.   mem [ p + 1 ] .hh .v.LH = 0 ; 
  327.   mem [ p + 1 ] .hh .v.RH = 0 ; 
  328.   Result = p ; 
  329.   return(Result) ; 
  330. } 
  331. halfword znewmath ( w , s ) 
  332. scaled w ; 
  333. smallnumber s ; 
  334. {register halfword Result; newmath_regmem 
  335.   halfword p  ; 
  336.   p = getnode ( 2 ) ; 
  337.   mem [ p ] .hh.b0 = 9 ; 
  338.   mem [ p ] .hh.b1 = s ; 
  339.   mem [ p + 1 ] .cint = w ; 
  340.   Result = p ; 
  341.   return(Result) ; 
  342. } 
  343. halfword znewspec ( p ) 
  344. halfword p ; 
  345. {register halfword Result; newspec_regmem 
  346.   halfword q  ; 
  347.   q = getnode ( 4 ) ; 
  348.   mem [ q ] = mem [ p ] ; 
  349.   mem [ q ] .hh .v.RH = 0 ; 
  350.   mem [ q + 1 ] .cint = mem [ p + 1 ] .cint ; 
  351.   mem [ q + 2 ] .cint = mem [ p + 2 ] .cint ; 
  352.   mem [ q + 3 ] .cint = mem [ p + 3 ] .cint ; 
  353.   Result = q ; 
  354.   return(Result) ; 
  355. } 
  356. halfword znewparamglue ( n ) 
  357. smallnumber n ; 
  358. {register halfword Result; newparamglue_regmem 
  359.   halfword p  ; 
  360.   halfword q  ; 
  361.   p = getnode ( 2 ) ; 
  362.   mem [ p ] .hh.b0 = 10 ; 
  363.   mem [ p ] .hh.b1 = n + 1 ; 
  364.   mem [ p + 1 ] .hh .v.RH = 0 ; 
  365.   q = eqtb [ 3782 + n ] .hh .v.RH ; 
  366.   mem [ p + 1 ] .hh .v.LH = q ; 
  367.   incr ( mem [ q ] .hh .v.RH ) ; 
  368.   Result = p ; 
  369.   return(Result) ; 
  370. } 
  371. halfword znewglue ( q ) 
  372. halfword q ; 
  373. {register halfword Result; newglue_regmem 
  374.   halfword p  ; 
  375.   p = getnode ( 2 ) ; 
  376.   mem [ p ] .hh.b0 = 10 ; 
  377.   mem [ p ] .hh.b1 = 0 ; 
  378.   mem [ p + 1 ] .hh .v.RH = 0 ; 
  379.   mem [ p + 1 ] .hh .v.LH = q ; 
  380.   incr ( mem [ q ] .hh .v.RH ) ; 
  381.   Result = p ; 
  382.   return(Result) ; 
  383. } 
  384. halfword znewskipparam ( n ) 
  385. smallnumber n ; 
  386. {register halfword Result; newskipparam_regmem 
  387.   halfword p  ; 
  388.   tempptr = newspec ( eqtb [ 3782 + n ] .hh .v.RH ) ; 
  389.   p = newglue ( tempptr ) ; 
  390.   mem [ tempptr ] .hh .v.RH = 0 ; 
  391.   mem [ p ] .hh.b1 = n + 1 ; 
  392.   Result = p ; 
  393.   return(Result) ; 
  394. } 
  395. halfword znewkern ( w ) 
  396. scaled w ; 
  397. {register halfword Result; newkern_regmem 
  398.   halfword p  ; 
  399.   p = getnode ( 2 ) ; 
  400.   mem [ p ] .hh.b0 = 11 ; 
  401.   mem [ p ] .hh.b1 = 0 ; 
  402.   mem [ p + 1 ] .cint = w ; 
  403.   Result = p ; 
  404.   return(Result) ; 
  405. } 
  406. halfword znewpenalty ( m ) 
  407. integer m ; 
  408. {register halfword Result; newpenalty_regmem 
  409.   halfword p  ; 
  410.   p = getnode ( 2 ) ; 
  411.   mem [ p ] .hh.b0 = 12 ; 
  412.   mem [ p ] .hh.b1 = 0 ; 
  413.   mem [ p + 1 ] .cint = m ; 
  414.   Result = p ; 
  415.   return(Result) ; 
  416. } 
  417. #ifdef DEBUG
  418. void zcheckmem ( printlocs ) 
  419. boolean printlocs ; 
  420. {/* 31 32 */ checkmem_regmem 
  421.   halfword p, q  ; 
  422.   boolean clobbered  ; 
  423.   {register integer for_end; p = memmin ; for_end = lomemmax ; if ( p <= 
  424.   for_end) do 
  425.     freearr [ p ] = false ; 
  426.   while ( p++ < for_end ) ; } 
  427.   {register integer for_end; p = himemmin ; for_end = memend ; if ( p <= 
  428.   for_end) do 
  429.     freearr [ p ] = false ; 
  430.   while ( p++ < for_end ) ; } 
  431.   p = avail ; 
  432.   q = 0 ; 
  433.   clobbered = false ; 
  434.   while ( p != 0 ) {
  435.       
  436.     if ( ( p > memend ) || ( p < himemmin ) ) 
  437.     clobbered = true ; 
  438.     else if ( freearr [ p ] ) 
  439.     clobbered = true ; 
  440.     if ( clobbered ) 
  441.     {
  442.       printnl ( 299 ) ; 
  443.       printint ( q ) ; 
  444.       goto lab31 ; 
  445.     } 
  446.     freearr [ p ] = true ; 
  447.     q = p ; 
  448.     p = mem [ q ] .hh .v.RH ; 
  449.   } 
  450.   lab31: ; 
  451.   p = rover ; 
  452.   q = 0 ; 
  453.   clobbered = false ; 
  454.   do {
  455.       if ( ( p >= lomemmax ) || ( p < memmin ) ) 
  456.     clobbered = true ; 
  457.     else if ( ( mem [ p + 1 ] .hh .v.RH >= lomemmax ) || ( mem [ p + 1 ] .hh 
  458.     .v.RH < memmin ) ) 
  459.     clobbered = true ; 
  460.     else if ( ! ( ( mem [ p ] .hh .v.RH == 65535L ) ) || ( mem [ p ] .hh .v.LH 
  461.     < 2 ) || ( p + mem [ p ] .hh .v.LH > lomemmax ) || ( mem [ mem [ p + 1 ] 
  462.     .hh .v.RH + 1 ] .hh .v.LH != p ) ) 
  463.     clobbered = true ; 
  464.     if ( clobbered ) 
  465.     {
  466.       printnl ( 300 ) ; 
  467.       printint ( q ) ; 
  468.       goto lab32 ; 
  469.     } 
  470.     {register integer for_end; q = p ; for_end = p + mem [ p ] .hh .v.LH - 1 
  471.     ; if ( q <= for_end) do 
  472.       {
  473.     if ( freearr [ q ] ) 
  474.     {
  475.       printnl ( 301 ) ; 
  476.       printint ( q ) ; 
  477.       goto lab32 ; 
  478.     } 
  479.     freearr [ q ] = true ; 
  480.       } 
  481.     while ( q++ < for_end ) ; } 
  482.     q = p ; 
  483.     p = mem [ p + 1 ] .hh .v.RH ; 
  484.   } while ( ! ( p == rover ) ) ; 
  485.   lab32: ; 
  486.   p = memmin ; 
  487.   while ( p <= lomemmax ) {
  488.       
  489.     if ( ( mem [ p ] .hh .v.RH == 65535L ) ) 
  490.     {
  491.       printnl ( 302 ) ; 
  492.       printint ( p ) ; 
  493.     } 
  494.     while ( ( p <= lomemmax ) && ! freearr [ p ] ) incr ( p ) ; 
  495.     while ( ( p <= lomemmax ) && freearr [ p ] ) incr ( p ) ; 
  496.   } 
  497.   if ( printlocs ) 
  498.   {
  499.     printnl ( 303 ) ; 
  500.     {register integer for_end; p = memmin ; for_end = lomemmax ; if ( p <= 
  501.     for_end) do 
  502.       if ( ! freearr [ p ] && ( ( p > waslomax ) || wasfree [ p ] ) ) 
  503.       {
  504.     printchar ( 32 ) ; 
  505.     printint ( p ) ; 
  506.       } 
  507.     while ( p++ < for_end ) ; } 
  508.     {register integer for_end; p = himemmin ; for_end = memend ; if ( p <= 
  509.     for_end) do 
  510.       if ( ! freearr [ p ] && ( ( p < washimin ) || ( p > wasmemend ) || 
  511.       wasfree [ p ] ) ) 
  512.       {
  513.     printchar ( 32 ) ; 
  514.     printint ( p ) ; 
  515.       } 
  516.     while ( p++ < for_end ) ; } 
  517.   } 
  518.   {register integer for_end; p = memmin ; for_end = lomemmax ; if ( p <= 
  519.   for_end) do 
  520.     wasfree [ p ] = freearr [ p ] ; 
  521.   while ( p++ < for_end ) ; } 
  522.   {register integer for_end; p = himemmin ; for_end = memend ; if ( p <= 
  523.   for_end) do 
  524.     wasfree [ p ] = freearr [ p ] ; 
  525.   while ( p++ < for_end ) ; } 
  526.   wasmemend = memend ; 
  527.   waslomax = lomemmax ; 
  528.   washimin = himemmin ; 
  529. } 
  530. #endif /* DEBUG */
  531. #ifdef DEBUG
  532. void zsearchmem ( p ) 
  533. halfword p ; 
  534. {searchmem_regmem 
  535.   integer q  ; 
  536.   {register integer for_end; q = memmin ; for_end = lomemmax ; if ( q <= 
  537.   for_end) do 
  538.     {
  539.       if ( mem [ q ] .hh .v.RH == p ) 
  540.       {
  541.     printnl ( 304 ) ; 
  542.     printint ( q ) ; 
  543.     printchar ( 41 ) ; 
  544.       } 
  545.       if ( mem [ q ] .hh .v.LH == p ) 
  546.       {
  547.     printnl ( 305 ) ; 
  548.     printint ( q ) ; 
  549.     printchar ( 41 ) ; 
  550.       } 
  551.     } 
  552.   while ( q++ < for_end ) ; } 
  553.   {register integer for_end; q = himemmin ; for_end = memend ; if ( q <= 
  554.   for_end) do 
  555.     {
  556.       if ( mem [ q ] .hh .v.RH == p ) 
  557.       {
  558.     printnl ( 304 ) ; 
  559.     printint ( q ) ; 
  560.     printchar ( 41 ) ; 
  561.       } 
  562.       if ( mem [ q ] .hh .v.LH == p ) 
  563.       {
  564.     printnl ( 305 ) ; 
  565.     printint ( q ) ; 
  566.     printchar ( 41 ) ; 
  567.       } 
  568.     } 
  569.   while ( q++ < for_end ) ; } 
  570.   {register integer for_end; q = 1 ; for_end = 4833 ; if ( q <= for_end) do 
  571.     {
  572.       if ( eqtb [ q ] .hh .v.RH == p ) 
  573.       {
  574.     printnl ( 497 ) ; 
  575.     printint ( q ) ; 
  576.     printchar ( 41 ) ; 
  577.       } 
  578.     } 
  579.   while ( q++ < for_end ) ; } 
  580.   if ( saveptr > 0 ) 
  581.   {register integer for_end; q = 0 ; for_end = saveptr - 1 ; if ( q <= 
  582.   for_end) do 
  583.     {
  584.       if ( savestack [ q ] .hh .v.RH == p ) 
  585.       {
  586.     printnl ( 542 ) ; 
  587.     printint ( q ) ; 
  588.     printchar ( 41 ) ; 
  589.       } 
  590.     } 
  591.   while ( q++ < for_end ) ; } 
  592.   {register integer for_end; q = 0 ; for_end = 307 ; if ( q <= for_end) do 
  593.     {
  594.       if ( hyphlist [ q ] == p ) 
  595.       {
  596.     printnl ( 933 ) ; 
  597.     printint ( q ) ; 
  598.     printchar ( 41 ) ; 
  599.       } 
  600.     } 
  601.   while ( q++ < for_end ) ; } 
  602. } 
  603. #endif /* DEBUG */
  604. void zshortdisplay ( p ) 
  605. integer p ; 
  606. {shortdisplay_regmem 
  607.   integer n  ; 
  608.   while ( p > memmin ) {
  609.       
  610.     if ( ( p >= himemmin ) ) 
  611.     {
  612.       if ( p <= memend ) 
  613.       {
  614.     if ( mem [ p ] .hh.b0 != fontinshortdisplay ) 
  615.     {
  616.       if ( ( mem [ p ] .hh.b0 > fontmax ) ) 
  617.       printchar ( 42 ) ; 
  618.       else printesc ( hash [ 3524 + mem [ p ] .hh.b0 ] .v.RH ) ; 
  619.       printchar ( 32 ) ; 
  620.       fontinshortdisplay = mem [ p ] .hh.b0 ; 
  621.     } 
  622.     print ( mem [ p ] .hh.b1 ) ; 
  623.       } 
  624.     } 
  625.     else switch ( mem [ p ] .hh.b0 ) 
  626.     {case 0 : 
  627.     case 1 : 
  628.     case 3 : 
  629.     case 8 : 
  630.     case 4 : 
  631.     case 5 : 
  632.     case 13 : 
  633.       print ( 306 ) ; 
  634.       break ; 
  635.     case 2 : 
  636.       printchar ( 124 ) ; 
  637.       break ; 
  638.     case 10 : 
  639.       if ( mem [ p + 1 ] .hh .v.LH != 0 ) 
  640.       printchar ( 32 ) ; 
  641.       break ; 
  642.     case 9 : 
  643.       printchar ( 36 ) ; 
  644.       break ; 
  645.     case 6 : 
  646.       shortdisplay ( mem [ p + 1 ] .hh .v.RH ) ; 
  647.       break ; 
  648.     case 7 : 
  649.       {
  650.     shortdisplay ( mem [ p + 1 ] .hh .v.LH ) ; 
  651.     shortdisplay ( mem [ p + 1 ] .hh .v.RH ) ; 
  652.     n = mem [ p ] .hh.b1 ; 
  653.     while ( n > 0 ) {
  654.         
  655.       if ( mem [ p ] .hh .v.RH != 0 ) 
  656.       p = mem [ p ] .hh .v.RH ; 
  657.       decr ( n ) ; 
  658.     } 
  659.       } 
  660.       break ; 
  661.       default: 
  662.       ; 
  663.       break ; 
  664.     } 
  665.     p = mem [ p ] .hh .v.RH ; 
  666.   } 
  667. } 
  668. void zprintfontandchar ( p ) 
  669. integer p ; 
  670. {printfontandchar_regmem 
  671.   if ( p > memend ) 
  672.   printesc ( 307 ) ; 
  673.   else {
  674.       
  675.     if ( ( mem [ p ] .hh.b0 > fontmax ) ) 
  676.     printchar ( 42 ) ; 
  677.     else printesc ( hash [ 3524 + mem [ p ] .hh.b0 ] .v.RH ) ; 
  678.     printchar ( 32 ) ; 
  679.     print ( mem [ p ] .hh.b1 ) ; 
  680.   } 
  681. } 
  682. void zprintmark ( p ) 
  683. integer p ; 
  684. {printmark_regmem 
  685.   printchar ( 123 ) ; 
  686.   if ( ( p < himemmin ) || ( p > memend ) ) 
  687.   printesc ( 307 ) ; 
  688.   else showtokenlist ( mem [ p ] .hh .v.RH , 0 , maxprintline - 10 ) ; 
  689.   printchar ( 125 ) ; 
  690. } 
  691. void zprintruledimen ( d ) 
  692. scaled d ; 
  693. {printruledimen_regmem 
  694.   if ( ( d == -1073741824L ) ) 
  695.   printchar ( 42 ) ; 
  696.   else printscaled ( d ) ; 
  697. } 
  698. void zprintglue ( d , order , s ) 
  699. scaled d ; 
  700. integer order ; 
  701. strnumber s ; 
  702. {printglue_regmem 
  703.   printscaled ( d ) ; 
  704.   if ( ( order < 0 ) || ( order > 3 ) ) 
  705.   print ( 308 ) ; 
  706.   else if ( order > 0 ) 
  707.   {
  708.     print ( 309 ) ; 
  709.     while ( order > 1 ) {
  710.     
  711.       printchar ( 108 ) ; 
  712.       decr ( order ) ; 
  713.     } 
  714.   } 
  715.   else if ( s != 0 ) 
  716.   print ( s ) ; 
  717. } 
  718. void zprintspec ( p , s ) 
  719. integer p ; 
  720. strnumber s ; 
  721. {printspec_regmem 
  722.   if ( ( p < memmin ) || ( p >= lomemmax ) ) 
  723.   printchar ( 42 ) ; 
  724.   else {
  725.       
  726.     printscaled ( mem [ p + 1 ] .cint ) ; 
  727.     if ( s != 0 ) 
  728.     print ( s ) ; 
  729.     if ( mem [ p + 2 ] .cint != 0 ) 
  730.     {
  731.       print ( 310 ) ; 
  732.       printglue ( mem [ p + 2 ] .cint , mem [ p ] .hh.b0 , s ) ; 
  733.     } 
  734.     if ( mem [ p + 3 ] .cint != 0 ) 
  735.     {
  736.       print ( 311 ) ; 
  737.       printglue ( mem [ p + 3 ] .cint , mem [ p ] .hh.b1 , s ) ; 
  738.     } 
  739.   } 
  740. } 
  741. void zprintfamandchar ( p ) 
  742. halfword p ; 
  743. {printfamandchar_regmem 
  744.   printesc ( 460 ) ; 
  745.   printint ( mem [ p ] .hh.b0 ) ; 
  746.   printchar ( 32 ) ; 
  747.   print ( mem [ p ] .hh.b1 ) ; 
  748. } 
  749. void zprintdelimiter ( p ) 
  750. halfword p ; 
  751. {printdelimiter_regmem 
  752.   integer a  ; 
  753.   a = mem [ p ] .qqqq .b0 * 256 + mem [ p ] .qqqq .b1 ; 
  754.   a = a * 4096 + mem [ p ] .qqqq .b2 * 256 + mem [ p ] .qqqq .b3 ; 
  755.   if ( a < 0 ) 
  756.   printint ( a ) ; 
  757.   else printhex ( a ) ; 
  758. } 
  759. void zprintsubsidiarydata ( p , c ) 
  760. halfword p ; 
  761. ASCIIcode c ; 
  762. {printsubsidiarydata_regmem 
  763.   if ( ( poolptr - strstart [ strptr ] ) >= depththreshold ) 
  764.   {
  765.     if ( mem [ p ] .hh .v.RH != 0 ) 
  766.     print ( 312 ) ; 
  767.   } 
  768.   else {
  769.       
  770.     {
  771.       strpool [ poolptr ] = c ; 
  772.       incr ( poolptr ) ; 
  773.     } 
  774.     tempptr = p ; 
  775.     switch ( mem [ p ] .hh .v.RH ) 
  776.     {case 1 : 
  777.       {
  778.     println () ; 
  779.     printcurrentstring () ; 
  780.     printfamandchar ( p ) ; 
  781.       } 
  782.       break ; 
  783.     case 2 : 
  784.       showinfo () ; 
  785.       break ; 
  786.     case 3 : 
  787.       if ( mem [ p ] .hh .v.LH == 0 ) 
  788.       {
  789.     println () ; 
  790.     printcurrentstring () ; 
  791.     print ( 853 ) ; 
  792.       } 
  793.       else showinfo () ; 
  794.       break ; 
  795.       default: 
  796.       ; 
  797.       break ; 
  798.     } 
  799.     decr ( poolptr ) ; 
  800.   } 
  801. } 
  802. void zprintstyle ( c ) 
  803. integer c ; 
  804. {printstyle_regmem 
  805.   switch ( c / 2 ) 
  806.   {case 0 : 
  807.     printesc ( 854 ) ; 
  808.     break ; 
  809.   case 1 : 
  810.     printesc ( 855 ) ; 
  811.     break ; 
  812.   case 2 : 
  813.     printesc ( 856 ) ; 
  814.     break ; 
  815.   case 3 : 
  816.     printesc ( 857 ) ; 
  817.     break ; 
  818.     default: 
  819.     print ( 858 ) ; 
  820.     break ; 
  821.   } 
  822. } 
  823. void zprintskipparam ( n ) 
  824. integer n ; 
  825. {printskipparam_regmem 
  826.   switch ( n ) 
  827.   {case 0 : 
  828.     printesc ( 372 ) ; 
  829.     break ; 
  830.   case 1 : 
  831.     printesc ( 373 ) ; 
  832.     break ; 
  833.   case 2 : 
  834.     printesc ( 374 ) ; 
  835.     break ; 
  836.   case 3 : 
  837.     printesc ( 375 ) ; 
  838.     break ; 
  839.   case 4 : 
  840.     printesc ( 376 ) ; 
  841.     break ; 
  842.   case 5 : 
  843.     printesc ( 377 ) ; 
  844.     break ; 
  845.   case 6 : 
  846.     printesc ( 378 ) ; 
  847.     break ; 
  848.   case 7 : 
  849.     printesc ( 379 ) ; 
  850.     break ; 
  851.   case 8 : 
  852.     printesc ( 380 ) ; 
  853.     break ; 
  854.   case 9 : 
  855.     printesc ( 381 ) ; 
  856.     break ; 
  857.   case 10 : 
  858.     printesc ( 382 ) ; 
  859.     break ; 
  860.   case 11 : 
  861.     printesc ( 383 ) ; 
  862.     break ; 
  863.   case 12 : 
  864.     printesc ( 384 ) ; 
  865.     break ; 
  866.   case 13 : 
  867.     printesc ( 385 ) ; 
  868.     break ; 
  869.   case 14 : 
  870.     printesc ( 386 ) ; 
  871.     break ; 
  872.   case 15 : 
  873.     printesc ( 387 ) ; 
  874.     break ; 
  875.   case 16 : 
  876.     printesc ( 388 ) ; 
  877.     break ; 
  878.   case 17 : 
  879.     printesc ( 389 ) ; 
  880.     break ; 
  881.     default: 
  882.     print ( 390 ) ; 
  883.     break ; 
  884.   } 
  885. } 
  886. void zshownodelist ( p ) 
  887. integer p ; 
  888. {/* 10 */ shownodelist_regmem 
  889.   integer n  ; 
  890.   real g  ; 
  891.   if ( ( poolptr - strstart [ strptr ] ) > depththreshold ) 
  892.   {
  893.     if ( p > 0 ) 
  894.     print ( 312 ) ; 
  895.     return ; 
  896.   } 
  897.   n = 0 ; 
  898.   while ( p > memmin ) {
  899.       
  900.     println () ; 
  901.     printcurrentstring () ; 
  902.     if ( p > memend ) 
  903.     {
  904.       print ( 313 ) ; 
  905.       return ; 
  906.     } 
  907.     incr ( n ) ; 
  908.     if ( n > breadthmax ) 
  909.     {
  910.       print ( 314 ) ; 
  911.       return ; 
  912.     } 
  913.     if ( ( p >= himemmin ) ) 
  914.     printfontandchar ( p ) ; 
  915.     else switch ( mem [ p ] .hh.b0 ) 
  916.     {case 0 : 
  917.     case 1 : 
  918.     case 13 : 
  919.       {
  920.     if ( mem [ p ] .hh.b0 == 0 ) 
  921.     printesc ( 104 ) ; 
  922.     else if ( mem [ p ] .hh.b0 == 1 ) 
  923.     printesc ( 118 ) ; 
  924.     else printesc ( 316 ) ; 
  925.     print ( 317 ) ; 
  926.     printscaled ( mem [ p + 3 ] .cint ) ; 
  927.     printchar ( 43 ) ; 
  928.     printscaled ( mem [ p + 2 ] .cint ) ; 
  929.     print ( 318 ) ; 
  930.     printscaled ( mem [ p + 1 ] .cint ) ; 
  931.     if ( mem [ p ] .hh.b0 == 13 ) 
  932.     {
  933.       if ( mem [ p ] .hh.b1 != 0 ) 
  934.       {
  935.         print ( 284 ) ; 
  936.         printint ( mem [ p ] .hh.b1 + 1 ) ; 
  937.         print ( 320 ) ; 
  938.       } 
  939.       if ( mem [ p + 6 ] .cint != 0 ) 
  940.       {
  941.         print ( 321 ) ; 
  942.         printglue ( mem [ p + 6 ] .cint , mem [ p + 5 ] .hh.b1 , 0 ) ; 
  943.       } 
  944.       if ( mem [ p + 4 ] .cint != 0 ) 
  945.       {
  946.         print ( 322 ) ; 
  947.         printglue ( mem [ p + 4 ] .cint , mem [ p + 5 ] .hh.b0 , 0 ) ; 
  948.       } 
  949.     } 
  950.     else {
  951.         
  952.       g = mem [ p + 6 ] .gr ; 
  953.       if ( ( g != 0.0 ) && ( mem [ p + 5 ] .hh.b0 != 0 ) ) 
  954.       {
  955.         print ( 323 ) ; 
  956.         if ( mem [ p + 5 ] .hh.b0 == 2 ) 
  957.         print ( 324 ) ; 
  958.         if ( fabs ( g ) > 20000.0 ) 
  959.         {
  960.           if ( g > 0.0 ) 
  961.           printchar ( 62 ) ; 
  962.           else print ( 325 ) ; 
  963.           printglue ( 20000 * 65536L , mem [ p + 5 ] .hh.b1 , 0 ) ; 
  964.         } 
  965.         else printglue ( round ( 65536L * g ) , mem [ p + 5 ] .hh.b1 , 0 ) 
  966.         ; 
  967.       } 
  968.       if ( mem [ p + 4 ] .cint != 0 ) 
  969.       {
  970.         print ( 319 ) ; 
  971.         printscaled ( mem [ p + 4 ] .cint ) ; 
  972.       } 
  973.     } 
  974.     {
  975.       {
  976.         strpool [ poolptr ] = 46 ; 
  977.         incr ( poolptr ) ; 
  978.       } 
  979.       shownodelist ( mem [ p + 5 ] .hh .v.RH ) ; 
  980.       decr ( poolptr ) ; 
  981.     } 
  982.       } 
  983.       break ; 
  984.     case 2 : 
  985.       {
  986.     printesc ( 326 ) ; 
  987.     printruledimen ( mem [ p + 3 ] .cint ) ; 
  988.     printchar ( 43 ) ; 
  989.     printruledimen ( mem [ p + 2 ] .cint ) ; 
  990.     print ( 318 ) ; 
  991.     printruledimen ( mem [ p + 1 ] .cint ) ; 
  992.       } 
  993.       break ; 
  994.     case 3 : 
  995.       {
  996.     printesc ( 327 ) ; 
  997.     printint ( mem [ p ] .hh.b1 ) ; 
  998.     print ( 328 ) ; 
  999.     printscaled ( mem [ p + 3 ] .cint ) ; 
  1000.     print ( 329 ) ; 
  1001.     printspec ( mem [ p + 4 ] .hh .v.RH , 0 ) ; 
  1002.     printchar ( 44 ) ; 
  1003.     printscaled ( mem [ p + 2 ] .cint ) ; 
  1004.     print ( 330 ) ; 
  1005.     printint ( mem [ p + 1 ] .cint ) ; 
  1006.     {
  1007.       {
  1008.         strpool [ poolptr ] = 46 ; 
  1009.         incr ( poolptr ) ; 
  1010.       } 
  1011.       shownodelist ( mem [ p + 4 ] .hh .v.LH ) ; 
  1012.       decr ( poolptr ) ; 
  1013.     } 
  1014.       } 
  1015.       break ; 
  1016.     case 8 : 
  1017.       switch ( mem [ p ] .hh.b1 ) 
  1018.       {case 0 : 
  1019.     {
  1020.       printwritewhatsit ( 1276 , p ) ; 
  1021.       printchar ( 61 ) ; 
  1022.       printfilename ( mem [ p + 1 ] .hh .v.RH , mem [ p + 2 ] .hh .v.LH , 
  1023.       mem [ p + 2 ] .hh .v.RH ) ; 
  1024.     } 
  1025.     break ; 
  1026.       case 1 : 
  1027.     {
  1028.       printwritewhatsit ( 590 , p ) ; 
  1029.       printmark ( mem [ p + 1 ] .hh .v.RH ) ; 
  1030.     } 
  1031.     break ; 
  1032.       case 2 : 
  1033.     printwritewhatsit ( 1277 , p ) ; 
  1034.     break ; 
  1035.       case 3 : 
  1036.     {
  1037.       printesc ( 1278 ) ; 
  1038.       printmark ( mem [ p + 1 ] .hh .v.RH ) ; 
  1039.     } 
  1040.     break ; 
  1041.       case 4 : 
  1042.     {
  1043.       printesc ( 1280 ) ; 
  1044.       printint ( mem [ p + 1 ] .hh .v.RH ) ; 
  1045.       print ( 362 ) ; 
  1046.       printint ( mem [ p + 1 ] .hh.b0 ) ; 
  1047.       printchar ( 44 ) ; 
  1048.       printint ( mem [ p + 1 ] .hh.b1 ) ; 
  1049.       printchar ( 41 ) ; 
  1050.     } 
  1051.     break ; 
  1052.     default: 
  1053.     print ( 1283 ) ; 
  1054.     break ; 
  1055.       } 
  1056.       break ; 
  1057.     case 10 : 
  1058.       if ( mem [ p ] .hh.b1 >= 100 ) 
  1059.       {
  1060.     printesc ( 335 ) ; 
  1061.     if ( mem [ p ] .hh.b1 == 101 ) 
  1062.     printchar ( 99 ) ; 
  1063.     else if ( mem [ p ] .hh.b1 == 102 ) 
  1064.     printchar ( 120 ) ; 
  1065.     print ( 336 ) ; 
  1066.     printspec ( mem [ p + 1 ] .hh .v.LH , 0 ) ; 
  1067.     {
  1068.       {
  1069.         strpool [ poolptr ] = 46 ; 
  1070.         incr ( poolptr ) ; 
  1071.       } 
  1072.       shownodelist ( mem [ p + 1 ] .hh .v.RH ) ; 
  1073.       decr ( poolptr ) ; 
  1074.     } 
  1075.       } 
  1076.       else {
  1077.       
  1078.     printesc ( 331 ) ; 
  1079.     if ( mem [ p ] .hh.b1 != 0 ) 
  1080.     {
  1081.       printchar ( 40 ) ; 
  1082.       if ( mem [ p ] .hh.b1 < 98 ) 
  1083.       printskipparam ( mem [ p ] .hh.b1 - 1 ) ; 
  1084.       else if ( mem [ p ] .hh.b1 == 98 ) 
  1085.       printesc ( 332 ) ; 
  1086.       else printesc ( 333 ) ; 
  1087.       printchar ( 41 ) ; 
  1088.     } 
  1089.     if ( mem [ p ] .hh.b1 != 98 ) 
  1090.     {
  1091.       printchar ( 32 ) ; 
  1092.       if ( mem [ p ] .hh.b1 < 98 ) 
  1093.       printspec ( mem [ p + 1 ] .hh .v.LH , 0 ) ; 
  1094.       else printspec ( mem [ p + 1 ] .hh .v.LH , 334 ) ; 
  1095.     } 
  1096.       } 
  1097.       break ; 
  1098.     case 11 : 
  1099.       if ( mem [ p ] .hh.b1 != 99 ) 
  1100.       {
  1101.     printesc ( 337 ) ; 
  1102.     if ( mem [ p ] .hh.b1 != 0 ) 
  1103.     printchar ( 32 ) ; 
  1104.     printscaled ( mem [ p + 1 ] .cint ) ; 
  1105.     if ( mem [ p ] .hh.b1 == 2 ) 
  1106.     print ( 338 ) ; 
  1107.       } 
  1108.       else {
  1109.       
  1110.     printesc ( 339 ) ; 
  1111.     printscaled ( mem [ p + 1 ] .cint ) ; 
  1112.     print ( 334 ) ; 
  1113.       } 
  1114.       break ; 
  1115.     case 9 : 
  1116.       {
  1117.     printesc ( 340 ) ; 
  1118.     if ( mem [ p ] .hh.b1 == 0 ) 
  1119.     print ( 341 ) ; 
  1120.     else print ( 342 ) ; 
  1121.     if ( mem [ p + 1 ] .cint != 0 ) 
  1122.     {
  1123.       print ( 343 ) ; 
  1124.       printscaled ( mem [ p + 1 ] .cint ) ; 
  1125.     } 
  1126.       } 
  1127.       break ; 
  1128.     case 6 : 
  1129.       {
  1130.     printfontandchar ( p + 1 ) ; 
  1131.     print ( 344 ) ; 
  1132.     if ( mem [ p ] .hh.b1 > 1 ) 
  1133.     printchar ( 124 ) ; 
  1134.     fontinshortdisplay = mem [ p + 1 ] .hh.b0 ; 
  1135.     shortdisplay ( mem [ p + 1 ] .hh .v.RH ) ; 
  1136.     if ( odd ( mem [ p ] .hh.b1 ) ) 
  1137.     printchar ( 124 ) ; 
  1138.     printchar ( 41 ) ; 
  1139.       } 
  1140.       break ; 
  1141.     case 12 : 
  1142.       {
  1143.     printesc ( 345 ) ; 
  1144.     printint ( mem [ p + 1 ] .cint ) ; 
  1145.       } 
  1146.       break ; 
  1147.     case 7 : 
  1148.       {
  1149.     printesc ( 346 ) ; 
  1150.     if ( mem [ p ] .hh.b1 > 0 ) 
  1151.     {
  1152.       print ( 347 ) ; 
  1153.       printint ( mem [ p ] .hh.b1 ) ; 
  1154.     } 
  1155.     {
  1156.       {
  1157.         strpool [ poolptr ] = 46 ; 
  1158.         incr ( poolptr ) ; 
  1159.       } 
  1160.       shownodelist ( mem [ p + 1 ] .hh .v.LH ) ; 
  1161.       decr ( poolptr ) ; 
  1162.     } 
  1163.     {
  1164.       strpool [ poolptr ] = 124 ; 
  1165.       incr ( poolptr ) ; 
  1166.     } 
  1167.     shownodelist ( mem [ p + 1 ] .hh .v.RH ) ; 
  1168.     decr ( poolptr ) ; 
  1169.       } 
  1170.       break ; 
  1171.     case 4 : 
  1172.       {
  1173.     printesc ( 348 ) ; 
  1174.     printmark ( mem [ p + 1 ] .cint ) ; 
  1175.       } 
  1176.       break ; 
  1177.     case 5 : 
  1178.       {
  1179.     printesc ( 349 ) ; 
  1180.     {
  1181.       {
  1182.         strpool [ poolptr ] = 46 ; 
  1183.         incr ( poolptr ) ; 
  1184.       } 
  1185.       shownodelist ( mem [ p + 1 ] .cint ) ; 
  1186.       decr ( poolptr ) ; 
  1187.     } 
  1188.       } 
  1189.       break ; 
  1190.     case 14 : 
  1191.       printstyle ( mem [ p ] .hh.b1 ) ; 
  1192.       break ; 
  1193.     case 15 : 
  1194.       {
  1195.     printesc ( 521 ) ; 
  1196.     {
  1197.       strpool [ poolptr ] = 68 ; 
  1198.       incr ( poolptr ) ; 
  1199.     } 
  1200.     shownodelist ( mem [ p + 1 ] .hh .v.LH ) ; 
  1201.     decr ( poolptr ) ; 
  1202.     {
  1203.       strpool [ poolptr ] = 84 ; 
  1204.       incr ( poolptr ) ; 
  1205.     } 
  1206.     shownodelist ( mem [ p + 1 ] .hh .v.RH ) ; 
  1207.     decr ( poolptr ) ; 
  1208.     {
  1209.       strpool [ poolptr ] = 83 ; 
  1210.       incr ( poolptr ) ; 
  1211.     } 
  1212.     shownodelist ( mem [ p + 2 ] .hh .v.LH ) ; 
  1213.     decr ( poolptr ) ; 
  1214.     {
  1215.       strpool [ poolptr ] = 115 ; 
  1216.       incr ( poolptr ) ; 
  1217.     } 
  1218.     shownodelist ( mem [ p + 2 ] .hh .v.RH ) ; 
  1219.     decr ( poolptr ) ; 
  1220.       } 
  1221.       break ; 
  1222.     case 16 : 
  1223.     case 17 : 
  1224.     case 18 : 
  1225.     case 19 : 
  1226.     case 20 : 
  1227.     case 21 : 
  1228.     case 22 : 
  1229.     case 23 : 
  1230.     case 24 : 
  1231.     case 27 : 
  1232.     case 26 : 
  1233.     case 29 : 
  1234.     case 28 : 
  1235.     case 30 : 
  1236.     case 31 : 
  1237.       {
  1238.     switch ( mem [ p ] .hh.b0 ) 
  1239.     {case 16 : 
  1240.       printesc ( 859 ) ; 
  1241.       break ; 
  1242.     case 17 : 
  1243.       printesc ( 860 ) ; 
  1244.       break ; 
  1245.     case 18 : 
  1246.       printesc ( 861 ) ; 
  1247.       break ; 
  1248.     case 19 : 
  1249.       printesc ( 862 ) ; 
  1250.       break ; 
  1251.     case 20 : 
  1252.       printesc ( 863 ) ; 
  1253.       break ; 
  1254.     case 21 : 
  1255.       printesc ( 864 ) ; 
  1256.       break ; 
  1257.     case 22 : 
  1258.       printesc ( 865 ) ; 
  1259.       break ; 
  1260.     case 23 : 
  1261.       printesc ( 866 ) ; 
  1262.       break ; 
  1263.     case 27 : 
  1264.       printesc ( 867 ) ; 
  1265.       break ; 
  1266.     case 26 : 
  1267.       printesc ( 868 ) ; 
  1268.       break ; 
  1269.     case 29 : 
  1270.       printesc ( 535 ) ; 
  1271.       break ; 
  1272.     case 24 : 
  1273.       {
  1274.         printesc ( 529 ) ; 
  1275.         printdelimiter ( p + 4 ) ; 
  1276.       } 
  1277.       break ; 
  1278.     case 28 : 
  1279.       {
  1280.         printesc ( 504 ) ; 
  1281.         printfamandchar ( p + 4 ) ; 
  1282.       } 
  1283.       break ; 
  1284.     case 30 : 
  1285.       {
  1286.         printesc ( 869 ) ; 
  1287.         printdelimiter ( p + 1 ) ; 
  1288.       } 
  1289.       break ; 
  1290.     case 31 : 
  1291.       {
  1292.         printesc ( 870 ) ; 
  1293.         printdelimiter ( p + 1 ) ; 
  1294.       } 
  1295.       break ; 
  1296.     } 
  1297.     if ( mem [ p ] .hh.b1 != 0 ) 
  1298.     if ( mem [ p ] .hh.b1 == 1 ) 
  1299.     printesc ( 871 ) ; 
  1300.     else printesc ( 872 ) ; 
  1301.     if ( mem [ p ] .hh.b0 < 30 ) 
  1302.     printsubsidiarydata ( p + 1 , 46 ) ; 
  1303.     printsubsidiarydata ( p + 2 , 94 ) ; 
  1304.     printsubsidiarydata ( p + 3 , 95 ) ; 
  1305.       } 
  1306.       break ; 
  1307.     case 25 : 
  1308.       {
  1309.     printesc ( 873 ) ; 
  1310.     if ( mem [ p + 1 ] .cint == 1073741824L ) 
  1311.     print ( 874 ) ; 
  1312.     else printscaled ( mem [ p + 1 ] .cint ) ; 
  1313.     if ( ( mem [ p + 4 ] .qqqq .b0 != 0 ) || ( mem [ p + 4 ] .qqqq .b1 != 
  1314.     0 ) || ( mem [ p + 4 ] .qqqq .b2 != 0 ) || ( mem [ p + 4 ] .qqqq .b3 
  1315.     != 0 ) ) 
  1316.     {
  1317.       print ( 875 ) ; 
  1318.       printdelimiter ( p + 4 ) ; 
  1319.     } 
  1320.     if ( ( mem [ p + 5 ] .qqqq .b0 != 0 ) || ( mem [ p + 5 ] .qqqq .b1 != 
  1321.     0 ) || ( mem [ p + 5 ] .qqqq .b2 != 0 ) || ( mem [ p + 5 ] .qqqq .b3 
  1322.     != 0 ) ) 
  1323.     {
  1324.       print ( 876 ) ; 
  1325.       printdelimiter ( p + 5 ) ; 
  1326.     } 
  1327.     printsubsidiarydata ( p + 2 , 92 ) ; 
  1328.     printsubsidiarydata ( p + 3 , 47 ) ; 
  1329.       } 
  1330.       break ; 
  1331.       default: 
  1332.       print ( 315 ) ; 
  1333.       break ; 
  1334.     } 
  1335.     p = mem [ p ] .hh .v.RH ; 
  1336.   } 
  1337. } 
  1338.