home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / tex / tex31 / texsrc.lzh / TEXSRC.LZH / tex6.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-01-09  |  28.4 KB  |  1,259 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4. void passtext ( ) 
  5. {/* 30 */ passtext_regmem 
  6.   integer l  ; 
  7.   smallnumber savescannerstatus  ; 
  8.   savescannerstatus = scannerstatus ; 
  9.   scannerstatus = 1 ; 
  10.   l = 0 ; 
  11.   skipline = line ; 
  12.   while ( true ) {
  13.       
  14.     getnext () ; 
  15.     if ( curcmd == 106 ) 
  16.     {
  17.       if ( l == 0 ) 
  18.       goto lab30 ; 
  19.       if ( curchr == 2 ) 
  20.       decr ( l ) ; 
  21.     } 
  22.     else if ( curcmd == 105 ) 
  23.     incr ( l ) ; 
  24.   } 
  25.   lab30: scannerstatus = savescannerstatus ; 
  26. } 
  27. void zchangeiflimit ( l , p ) 
  28. smallnumber l ; 
  29. halfword p ; 
  30. {/* 10 */ changeiflimit_regmem 
  31.   halfword q  ; 
  32.   if ( p == condptr ) 
  33.   iflimit = l ; 
  34.   else {
  35.       
  36.     q = condptr ; 
  37.     while ( true ) {
  38.     
  39.       if ( q == 0 ) 
  40.       confusion ( 752 ) ; 
  41.       if ( mem [ q ] .hh .v.RH == p ) 
  42.       {
  43.     mem [ q ] .hh.b0 = l ; 
  44.     return ; 
  45.       } 
  46.       q = mem [ q ] .hh .v.RH ; 
  47.     } 
  48.   } 
  49. } 
  50. void conditional ( ) 
  51. {/* 10 50 */ conditional_regmem 
  52.   boolean b  ; 
  53.   schar r  ; 
  54.   integer m, n  ; 
  55.   halfword p, q  ; 
  56.   smallnumber savescannerstatus  ; 
  57.   halfword savecondptr  ; 
  58.   smallnumber thisif  ; 
  59.   {
  60.     p = getnode ( 2 ) ; 
  61.     mem [ p ] .hh .v.RH = condptr ; 
  62.     mem [ p ] .hh.b0 = iflimit ; 
  63.     mem [ p ] .hh.b1 = curif ; 
  64.     mem [ p + 1 ] .cint = ifline ; 
  65.     condptr = p ; 
  66.     curif = curchr ; 
  67.     iflimit = 1 ; 
  68.     ifline = line ; 
  69.   } 
  70.   savecondptr = condptr ; 
  71.   thisif = curchr ; 
  72.   switch ( thisif ) 
  73.   {case 0 : 
  74.   case 1 : 
  75.     {
  76.       {
  77.     getxtoken () ; 
  78.     if ( curcmd == 0 ) 
  79.     if ( curchr == 257 ) 
  80.     {
  81.       curcmd = 13 ; 
  82.       curchr = curtok - 4096 ; 
  83.     } 
  84.       } 
  85.       if ( ( curcmd > 13 ) || ( curchr > 255 ) ) 
  86.       {
  87.     m = 0 ; 
  88.     n = 256 ; 
  89.       } 
  90.       else {
  91.       
  92.     m = curcmd ; 
  93.     n = curchr ; 
  94.       } 
  95.       {
  96.     getxtoken () ; 
  97.     if ( curcmd == 0 ) 
  98.     if ( curchr == 257 ) 
  99.     {
  100.       curcmd = 13 ; 
  101.       curchr = curtok - 4096 ; 
  102.     } 
  103.       } 
  104.       if ( ( curcmd > 13 ) || ( curchr > 255 ) ) 
  105.       {
  106.     curcmd = 0 ; 
  107.     curchr = 256 ; 
  108.       } 
  109.       if ( thisif == 0 ) 
  110.       b = ( n == curchr ) ; 
  111.       else b = ( m == curcmd ) ; 
  112.     } 
  113.     break ; 
  114.   case 2 : 
  115.   case 3 : 
  116.     {
  117.       if ( thisif == 2 ) 
  118.       scanint () ; 
  119.       else scandimen ( false , false , false ) ; 
  120.       n = curval ; 
  121.       do {
  122.       getxtoken () ; 
  123.       } while ( ! ( curcmd != 10 ) ) ; 
  124.       if ( ( curtok >= 3132 ) && ( curtok <= 3134 ) ) 
  125.       r = curtok - 3072 ; 
  126.       else {
  127.       
  128.     {
  129.       if ( interaction == 3 ) 
  130.       wakeupterminal () ; 
  131.       printnl ( 262 ) ; 
  132.       print ( 776 ) ; 
  133.     } 
  134.     printcmdchr ( 105 , thisif ) ; 
  135.     {
  136.       helpptr = 1 ; 
  137.       helpline [ 0 ] = 777 ; 
  138.     } 
  139.     backerror () ; 
  140.     r = 61 ; 
  141.       } 
  142.       if ( thisif == 2 ) 
  143.       scanint () ; 
  144.       else scandimen ( false , false , false ) ; 
  145.       switch ( r ) 
  146.       {case 60 : 
  147.     b = ( n < curval ) ; 
  148.     break ; 
  149.       case 61 : 
  150.     b = ( n == curval ) ; 
  151.     break ; 
  152.       case 62 : 
  153.     b = ( n > curval ) ; 
  154.     break ; 
  155.       } 
  156.     } 
  157.     break ; 
  158.   case 4 : 
  159.     {
  160.       scanint () ; 
  161.       b = odd ( curval ) ; 
  162.     } 
  163.     break ; 
  164.   case 5 : 
  165.     b = ( abs ( curlist .modefield ) == 1 ) ; 
  166.     break ; 
  167.   case 6 : 
  168.     b = ( abs ( curlist .modefield ) == 102 ) ; 
  169.     break ; 
  170.   case 7 : 
  171.     b = ( abs ( curlist .modefield ) == 203 ) ; 
  172.     break ; 
  173.   case 8 : 
  174.     b = ( curlist .modefield < 0 ) ; 
  175.     break ; 
  176.   case 9 : 
  177.   case 10 : 
  178.   case 11 : 
  179.     {
  180.       scaneightbitint () ; 
  181.       p = eqtb [ 4578 + curval ] .hh .v.RH ; 
  182.       if ( thisif == 9 ) 
  183.       b = ( p == 0 ) ; 
  184.       else if ( p == 0 ) 
  185.       b = false ; 
  186.       else if ( thisif == 10 ) 
  187.       b = ( mem [ p ] .hh.b0 == 0 ) ; 
  188.       else b = ( mem [ p ] .hh.b0 == 1 ) ; 
  189.     } 
  190.     break ; 
  191.   case 12 : 
  192.     {
  193.       savescannerstatus = scannerstatus ; 
  194.       scannerstatus = 0 ; 
  195.       getnext () ; 
  196.       n = curcs ; 
  197.       p = curcmd ; 
  198.       q = curchr ; 
  199.       getnext () ; 
  200.       if ( curcmd != p ) 
  201.       b = false ; 
  202.       else if ( curcmd < 111 ) 
  203.       b = ( curchr == q ) ; 
  204.       else {
  205.       
  206.     p = mem [ curchr ] .hh .v.RH ; 
  207.     q = mem [ eqtb [ n ] .hh .v.RH ] .hh .v.RH ; 
  208.     if ( p == q ) 
  209.     b = true ; 
  210.     else {
  211.         
  212.       while ( ( p != 0 ) && ( q != 0 ) ) if ( mem [ p ] .hh .v.LH != mem [ 
  213.       q ] .hh .v.LH ) 
  214.       p = 0 ; 
  215.       else {
  216.           
  217.         p = mem [ p ] .hh .v.RH ; 
  218.         q = mem [ q ] .hh .v.RH ; 
  219.       } 
  220.       b = ( ( p == 0 ) && ( q == 0 ) ) ; 
  221.     } 
  222.       } 
  223.       scannerstatus = savescannerstatus ; 
  224.     } 
  225.     break ; 
  226.   case 13 : 
  227.     {
  228.       scanfourbitint () ; 
  229.       b = ( readopen [ curval ] == 2 ) ; 
  230.     } 
  231.     break ; 
  232.   case 14 : 
  233.     b = true ; 
  234.     break ; 
  235.   case 15 : 
  236.     b = false ; 
  237.     break ; 
  238.   case 16 : 
  239.     {
  240.       scanint () ; 
  241.       n = curval ; 
  242.       if ( eqtb [ 6199 ] .cint > 1 ) 
  243.       {
  244.     begindiagnostic () ; 
  245.     print ( 778 ) ; 
  246.     printint ( n ) ; 
  247.     printchar ( 125 ) ; 
  248.     enddiagnostic ( false ) ; 
  249.       } 
  250.       while ( n != 0 ) {
  251.       
  252.     passtext () ; 
  253.     if ( condptr == savecondptr ) 
  254.     if ( curchr == 4 ) 
  255.     decr ( n ) ; 
  256.     else goto lab50 ; 
  257.     else if ( curchr == 2 ) 
  258.     {
  259.       p = condptr ; 
  260.       ifline = mem [ p + 1 ] .cint ; 
  261.       curif = mem [ p ] .hh.b1 ; 
  262.       iflimit = mem [ p ] .hh.b0 ; 
  263.       condptr = mem [ p ] .hh .v.RH ; 
  264.       freenode ( p , 2 ) ; 
  265.     } 
  266.       } 
  267.       changeiflimit ( 4 , savecondptr ) ; 
  268.       return ; 
  269.     } 
  270.     break ; 
  271.   } 
  272.   if ( eqtb [ 6199 ] .cint > 1 ) 
  273.   {
  274.     begindiagnostic () ; 
  275.     if ( b ) 
  276.     print ( 774 ) ; 
  277.     else print ( 775 ) ; 
  278.     enddiagnostic ( false ) ; 
  279.   } 
  280.   if ( b ) 
  281.   {
  282.     changeiflimit ( 3 , savecondptr ) ; 
  283.     return ; 
  284.   } 
  285.   while ( true ) {
  286.       
  287.     passtext () ; 
  288.     if ( condptr == savecondptr ) 
  289.     {
  290.       if ( curchr != 4 ) 
  291.       goto lab50 ; 
  292.       {
  293.     if ( interaction == 3 ) 
  294.     wakeupterminal () ; 
  295.     printnl ( 262 ) ; 
  296.     print ( 772 ) ; 
  297.       } 
  298.       printesc ( 770 ) ; 
  299.       {
  300.     helpptr = 1 ; 
  301.     helpline [ 0 ] = 773 ; 
  302.       } 
  303.       error () ; 
  304.     } 
  305.     else if ( curchr == 2 ) 
  306.     {
  307.       p = condptr ; 
  308.       ifline = mem [ p + 1 ] .cint ; 
  309.       curif = mem [ p ] .hh.b1 ; 
  310.       iflimit = mem [ p ] .hh.b0 ; 
  311.       condptr = mem [ p ] .hh .v.RH ; 
  312.       freenode ( p , 2 ) ; 
  313.     } 
  314.   } 
  315.   lab50: if ( curchr == 2 ) 
  316.   {
  317.     p = condptr ; 
  318.     ifline = mem [ p + 1 ] .cint ; 
  319.     curif = mem [ p ] .hh.b1 ; 
  320.     iflimit = mem [ p ] .hh.b0 ; 
  321.     condptr = mem [ p ] .hh .v.RH ; 
  322.     freenode ( p , 2 ) ; 
  323.   } 
  324.   else iflimit = 2 ; 
  325. } 
  326. void beginname ( ) 
  327. {beginname_regmem 
  328.   areadelimiter = 0 ; 
  329.   extdelimiter = 0 ; 
  330. } 
  331. boolean zmorename ( c ) 
  332. ASCIIcode c ; 
  333. {register boolean Result; morename_regmem 
  334.   if ( c == 32 ) 
  335.   Result = false ; 
  336.   else {
  337.       
  338.     {
  339.       if ( poolptr + 1 > poolsize ) 
  340.       overflow ( 257 , poolsize - initpoolptr ) ; 
  341.     } 
  342.     {
  343.       strpool [ poolptr ] = c ; 
  344.       incr ( poolptr ) ; 
  345.     } 
  346.     if ( ( c == 47 ) ) 
  347.     {
  348.       areadelimiter = ( poolptr - strstart [ strptr ] ) ; 
  349.       extdelimiter = 0 ; 
  350.     } 
  351.     else if ( c == 46 ) 
  352.     extdelimiter = ( poolptr - strstart [ strptr ] ) ; 
  353.     Result = true ; 
  354.   } 
  355.   return(Result) ; 
  356. } 
  357. void endname ( ) 
  358. {endname_regmem 
  359.   if ( strptr + 3 > maxstrings ) 
  360.   overflow ( 258 , maxstrings - initstrptr ) ; 
  361.   if ( areadelimiter == 0 ) 
  362.   curarea = 335 ; 
  363.   else {
  364.       
  365.     curarea = strptr ; 
  366.     strstart [ strptr + 1 ] = strstart [ strptr ] + areadelimiter ; 
  367.     incr ( strptr ) ; 
  368.   } 
  369.   if ( extdelimiter == 0 ) 
  370.   {
  371.     curext = 335 ; 
  372.     curname = makestring () ; 
  373.   } 
  374.   else {
  375.       
  376.     curname = strptr ; 
  377.     strstart [ strptr + 1 ] = strstart [ strptr ] + extdelimiter - 
  378.     areadelimiter - 1 ; 
  379.     incr ( strptr ) ; 
  380.     curext = makestring () ; 
  381.   } 
  382. } 
  383. void zpackfilename ( n , a , e ) 
  384. strnumber n ; 
  385. strnumber a ; 
  386. strnumber e ; 
  387. {packfilename_regmem 
  388.   integer k  ; 
  389.   ASCIIcode c  ; 
  390.   poolpointer j  ; 
  391.   k = 0 ; 
  392.   {register integer for_end; j = strstart [ a ] ; for_end = strstart [ a + 1 
  393.   ] - 1 ; if ( j <= for_end) do 
  394.     {
  395.       c = strpool [ j ] ; 
  396.       incr ( k ) ; 
  397.       if ( k <= FILENAMESIZE ) 
  398.       nameoffile [ k ] = xchr [ c ] ; 
  399.     } 
  400.   while ( j++ < for_end ) ; } 
  401.   {register integer for_end; j = strstart [ n ] ; for_end = strstart [ n + 1 
  402.   ] - 1 ; if ( j <= for_end) do 
  403.     {
  404.       c = strpool [ j ] ; 
  405.       incr ( k ) ; 
  406.       if ( k <= FILENAMESIZE ) 
  407.       nameoffile [ k ] = xchr [ c ] ; 
  408.     } 
  409.   while ( j++ < for_end ) ; } 
  410.   {register integer for_end; j = strstart [ e ] ; for_end = strstart [ e + 1 
  411.   ] - 1 ; if ( j <= for_end) do 
  412.     {
  413.       c = strpool [ j ] ; 
  414.       incr ( k ) ; 
  415.       if ( k <= FILENAMESIZE ) 
  416.       nameoffile [ k ] = xchr [ c ] ; 
  417.     } 
  418.   while ( j++ < for_end ) ; } 
  419.   if ( k <= FILENAMESIZE ) 
  420.   namelength = k ; 
  421.   else namelength = FILENAMESIZE ; 
  422.   {register integer for_end; k = namelength + 1 ; for_end = FILENAMESIZE 
  423.   ; if ( k <= for_end) do 
  424.     nameoffile [ k ] = ' ' ; 
  425.   while ( k++ < for_end ) ; } 
  426. } 
  427. void zpackbufferedname ( n , a , b ) 
  428. smallnumber n ; 
  429. integer a ; 
  430. integer b ; 
  431. {packbufferedname_regmem 
  432.   integer k  ; 
  433.   ASCIIcode c  ; 
  434.   integer j  ; 
  435.   if ( n + b - a + 5 > FILENAMESIZE ) 
  436.   b = a + FILENAMESIZE - n - 5 ; 
  437.   k = 0 ; 
  438.   {register integer for_end; j = 1 ; for_end = n ; if ( j <= for_end) do 
  439.     {
  440.       c = xord [ TEXformatdefault [ j ] ] ; 
  441.       incr ( k ) ; 
  442.       if ( k <= FILENAMESIZE ) 
  443.       nameoffile [ k ] = xchr [ c ] ; 
  444.     } 
  445.   while ( j++ < for_end ) ; } 
  446.   {register integer for_end; j = a ; for_end = b ; if ( j <= for_end) do 
  447.     {
  448.       c = buffer [ j ] ; 
  449.       incr ( k ) ; 
  450.       if ( k <= FILENAMESIZE ) 
  451.       nameoffile [ k ] = xchr [ c ] ; 
  452.     } 
  453.   while ( j++ < for_end ) ; } 
  454.   {register integer for_end; j = formatdefaultlength - 3 ; for_end = 
  455.   formatdefaultlength ; if ( j <= for_end) do 
  456.     {
  457.       c = xord [ TEXformatdefault [ j ] ] ; 
  458.       incr ( k ) ; 
  459.       if ( k <= FILENAMESIZE ) 
  460.       nameoffile [ k ] = xchr [ c ] ; 
  461.     } 
  462.   while ( j++ < for_end ) ; } 
  463.   if ( k <= FILENAMESIZE ) 
  464.   namelength = k ; 
  465.   else namelength = FILENAMESIZE ; 
  466.   {register integer for_end; k = namelength + 1 ; for_end = FILENAMESIZE 
  467.   ; if ( k <= for_end) do 
  468.     nameoffile [ k ] = ' ' ; 
  469.   while ( k++ < for_end ) ; } 
  470. } 
  471. strnumber makenamestring ( ) 
  472. {register strnumber Result; makenamestring_regmem 
  473.   integer k  ; 
  474.   if ( ( poolptr + namelength > poolsize ) || ( strptr == maxstrings ) || ( ( 
  475.   poolptr - strstart [ strptr ] ) > 0 ) ) 
  476.   Result = 63 ; 
  477.   else {
  478.       
  479.     {register integer for_end; k = 1 ; for_end = namelength ; if ( k <= 
  480.     for_end) do 
  481.       {
  482.     strpool [ poolptr ] = xord [ nameoffile [ k ] ] ; 
  483.     incr ( poolptr ) ; 
  484.       } 
  485.     while ( k++ < for_end ) ; } 
  486.     Result = makestring () ; 
  487.   } 
  488.   return(Result) ; 
  489. } 
  490. strnumber zamakenamestring ( f ) 
  491. alphafile * f ; 
  492. {register strnumber Result; amakenamestring_regmem 
  493.   Result = makenamestring () ; 
  494.   return(Result) ; 
  495. } 
  496. strnumber zbmakenamestring ( f ) 
  497. bytefile * f ; 
  498. {register strnumber Result; bmakenamestring_regmem 
  499.   Result = makenamestring () ; 
  500.   return(Result) ; 
  501. } 
  502. strnumber zwmakenamestring ( f ) 
  503. wordfile * f ; 
  504. {register strnumber Result; wmakenamestring_regmem 
  505.   Result = makenamestring () ; 
  506.   return(Result) ; 
  507. } 
  508. void scanfilename ( ) 
  509. {/* 30 */ scanfilename_regmem 
  510.   nameinprogress = true ; 
  511.   beginname () ; 
  512.   do {
  513.       getxtoken () ; 
  514.   } while ( ! ( curcmd != 10 ) ) ; 
  515.   while ( true ) {
  516.       
  517.     if ( ( curcmd > 12 ) || ( curchr > 255 ) ) 
  518.     {
  519.       backinput () ; 
  520.       goto lab30 ; 
  521.     } 
  522.     if ( ! morename ( curchr ) ) 
  523.     goto lab30 ; 
  524.     getxtoken () ; 
  525.   } 
  526.   lab30: endname () ; 
  527.   nameinprogress = false ; 
  528. } 
  529. void zpackjobname ( s ) 
  530. strnumber s ; 
  531. {packjobname_regmem 
  532.   curarea = 335 ; 
  533.   curext = s ; 
  534.   curname = jobname ; 
  535.   packfilename ( curname , curarea , curext ) ; 
  536. } 
  537. void zpromptfilename ( s , e ) 
  538. strnumber s ; 
  539. strnumber e ; 
  540. {/* 30 */ promptfilename_regmem 
  541.   integer k  ; 
  542.   if ( interaction == 2 ) 
  543.   wakeupterminal () ; 
  544.   if ( s == 780 ) 
  545.   {
  546.     if ( interaction == 3 ) 
  547.     wakeupterminal () ; 
  548.     printnl ( 262 ) ; 
  549.     print ( 781 ) ; 
  550.   } 
  551.   else {
  552.       
  553.     if ( interaction == 3 ) 
  554.     wakeupterminal () ; 
  555.     printnl ( 262 ) ; 
  556.     print ( 782 ) ; 
  557.   } 
  558.   printfilename ( curname , curarea , curext ) ; 
  559.   print ( 783 ) ; 
  560.   if ( e == 784 ) 
  561.   showcontext () ; 
  562.   printnl ( 785 ) ; 
  563.   print ( s ) ; 
  564.   if ( interaction < 2 ) 
  565.   fatalerror ( 786 ) ; 
  566.   clearterminal () ; 
  567.   {
  568.     wakeupterminal () ; 
  569.     print ( 564 ) ; 
  570.     terminput () ; 
  571.   } 
  572.   {
  573.     beginname () ; 
  574.     k = first ; 
  575.     while ( ( buffer [ k ] == 32 ) && ( k < last ) ) incr ( k ) ; 
  576.     while ( true ) {
  577.     
  578.       if ( k == last ) 
  579.       goto lab30 ; 
  580.       if ( ! morename ( buffer [ k ] ) ) 
  581.       goto lab30 ; 
  582.       incr ( k ) ; 
  583.     } 
  584.     lab30: endname () ; 
  585.   } 
  586.   if ( curext == 335 ) 
  587.   curext = e ; 
  588.   packfilename ( curname , curarea , curext ) ; 
  589. } 
  590. void openlogfile ( ) 
  591. {openlogfile_regmem 
  592.   schar oldsetting  ; 
  593.   integer k  ; 
  594.   integer l  ; 
  595.   ccharpointer months  ; 
  596.   oldsetting = selector ; 
  597.   if ( jobname == 0 ) 
  598.   jobname = 789 ; 
  599.   packjobname ( 790 ) ; 
  600.   while ( ! aopenout ( logfile ) ) {
  601.       
  602.     selector = 17 ; 
  603.     promptfilename ( 792 , 790 ) ; 
  604.   } 
  605.   logname = amakenamestring ( logfile ) ; 
  606.   selector = 18 ; 
  607.   logopened = true ; 
  608.   {
  609.     (void) Fputs( logfile ,  "This is TeX, C Version 3.1t2" ) ; 
  610.     print ( formatident ) ; 
  611.     print ( 793 ) ; 
  612.     printint ( eqtb [ 6184 ] .cint ) ; 
  613.     printchar ( 32 ) ; 
  614.     months = " JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC" ; 
  615.     {register integer for_end; k = 3 * eqtb [ 6185 ] .cint - 2 ; for_end = 3 
  616.     * eqtb [ 6185 ] .cint ; if ( k <= for_end) do 
  617.       (void) putc( months [ k ] ,  logfile );
  618.     while ( k++ < for_end ) ; } 
  619.     printchar ( 32 ) ; 
  620.     printint ( eqtb [ 6186 ] .cint ) ; 
  621.     printchar ( 32 ) ; 
  622.     printtwo ( eqtb [ 6183 ] .cint / 60 ) ; 
  623.     printchar ( 58 ) ; 
  624.     printtwo ( eqtb [ 6183 ] .cint % 60 ) ; 
  625.   } 
  626.   (void) Fputs( logfile ,  "\nCompiled for the Atari ST with GNU-C " __VERSION__ " by fgth (" __DATE__ ")" ) ; 
  627.   inputstack [ inputptr ] = curinput ; 
  628.   printnl ( 791 ) ; 
  629.   l = inputstack [ 0 ] .limitfield ; 
  630.   if ( buffer [ l ] == eqtb [ 6211 ] .cint ) 
  631.   decr ( l ) ; 
  632.   {register integer for_end; k = 1 ; for_end = l ; if ( k <= for_end) do 
  633.     print ( buffer [ k ] ) ; 
  634.   while ( k++ < for_end ) ; } 
  635.   println () ; 
  636.   selector = oldsetting + 2 ; 
  637. } 
  638. void startinput ( ) 
  639. {/* 30 */ startinput_regmem 
  640.   scanfilename () ; 
  641.   if ( curext == 335 ) 
  642.   packfilename ( curname , curarea , 784 ) ; 
  643.   else packfilename ( curname , curarea , curext ) ; 
  644.   while ( true ) {
  645.       
  646.     beginfilereading () ; 
  647.     if ( aopenin ( inputfile [ curinput .indexfield ] , TEXINPUTPATH ) ) 
  648.     goto lab30 ; 
  649.     if ( curext == 335 ) 
  650.     {
  651.       packfilename ( curname , curarea , curext ) ; 
  652.       if ( aopenin ( inputfile [ curinput .indexfield ] , TEXINPUTPATH ) ) 
  653.       goto lab30 ; 
  654.     } 
  655.     endfilereading () ; 
  656.     promptfilename ( 780 , 784 ) ; 
  657.   } 
  658.   lab30: curinput .namefield = amakenamestring ( inputfile [ curinput 
  659.   .indexfield ] ) ; 
  660.   if ( jobname == 0 ) 
  661.   {
  662.     jobname = curname ; 
  663.     openlogfile () ; 
  664.   } 
  665.   if ( termoffset + ( strstart [ curinput .namefield + 1 ] - strstart [ 
  666.   curinput .namefield ] ) > maxprintline - 3 ) 
  667.   println () ; 
  668.   else if ( ( termoffset > 0 ) || ( fileoffset > 0 ) ) 
  669.   printchar ( 32 ) ; 
  670.   printchar ( 40 ) ; 
  671.   incr ( openparens ) ; 
  672.   print ( curinput .namefield ) ; 
  673.   flush ( stdout ) ; 
  674.   curinput .statefield = 33 ; 
  675.   {
  676.     line = 1 ; 
  677.     if ( inputln ( inputfile [ curinput .indexfield ] , false ) ) 
  678.     ; 
  679.     firmuptheline () ; 
  680.     if ( ( eqtb [ 6211 ] .cint < 0 ) || ( eqtb [ 6211 ] .cint > 255 ) ) 
  681.     decr ( curinput .limitfield ) ; 
  682.     else buffer [ curinput .limitfield ] = eqtb [ 6211 ] .cint ; 
  683.     first = curinput .limitfield + 1 ; 
  684.     curinput .locfield = curinput .startfield ; 
  685.   } 
  686. } 
  687. internalfontnumber zreadfontinfo ( u , nom , aire , s ) 
  688. halfword u ; 
  689. strnumber nom ; 
  690. strnumber aire ; 
  691. scaled s ; 
  692. {/* 30 11 45 */ register internalfontnumber Result; readfontinfo_regmem 
  693.   fontindex k  ; 
  694.   boolean fileopened  ; 
  695.   halfword lf, lh, bc, ec, nw, nh, nd, ni, nl, nk, ne, np  ; 
  696.   internalfontnumber f  ; 
  697.   internalfontnumber g  ; 
  698.   eightbits a, b, c, d  ; 
  699.   fourquarters qw  ; 
  700.   scaled sw  ; 
  701.   integer bchlabel  ; 
  702.   short bchar  ; 
  703.   scaled z  ; 
  704.   integer alpha  ; 
  705.   schar beta  ; 
  706.   g = 0 ; 
  707.   fileopened = false ; 
  708.   packfilename ( nom , aire , 804 ) ; 
  709.   if ( ! bopenin ( tfmfile ) ) 
  710.   goto lab11 ; 
  711.   fileopened = true ; 
  712.   {
  713.     {
  714.       lf = tfmtemp ; 
  715.       if ( lf > 127 ) 
  716.       goto lab11 ; 
  717.       tfmtemp = getc ( tfmfile ) ; 
  718.       lf = lf * 256 + tfmtemp ; 
  719.     } 
  720.     tfmtemp = getc ( tfmfile ) ; 
  721.     {
  722.       lh = tfmtemp ; 
  723.       if ( lh > 127 ) 
  724.       goto lab11 ; 
  725.       tfmtemp = getc ( tfmfile ) ; 
  726.       lh = lh * 256 + tfmtemp ; 
  727.     } 
  728.     tfmtemp = getc ( tfmfile ) ; 
  729.     {
  730.       bc = tfmtemp ; 
  731.       if ( bc > 127 ) 
  732.       goto lab11 ; 
  733.       tfmtemp = getc ( tfmfile ) ; 
  734.       bc = bc * 256 + tfmtemp ; 
  735.     } 
  736.     tfmtemp = getc ( tfmfile ) ; 
  737.     {
  738.       ec = tfmtemp ; 
  739.       if ( ec > 127 ) 
  740.       goto lab11 ; 
  741.       tfmtemp = getc ( tfmfile ) ; 
  742.       ec = ec * 256 + tfmtemp ; 
  743.     } 
  744.     if ( ( bc > ec + 1 ) || ( ec > 255 ) ) 
  745.     goto lab11 ; 
  746.     if ( bc > 255 ) 
  747.     {
  748.       bc = 1 ; 
  749.       ec = 0 ; 
  750.     } 
  751.     tfmtemp = getc ( tfmfile ) ; 
  752.     {
  753.       nw = tfmtemp ; 
  754.       if ( nw > 127 ) 
  755.       goto lab11 ; 
  756.       tfmtemp = getc ( tfmfile ) ; 
  757.       nw = nw * 256 + tfmtemp ; 
  758.     } 
  759.     tfmtemp = getc ( tfmfile ) ; 
  760.     {
  761.       nh = tfmtemp ; 
  762.       if ( nh > 127 ) 
  763.       goto lab11 ; 
  764.       tfmtemp = getc ( tfmfile ) ; 
  765.       nh = nh * 256 + tfmtemp ; 
  766.     } 
  767.     tfmtemp = getc ( tfmfile ) ; 
  768.     {
  769.       nd = tfmtemp ; 
  770.       if ( nd > 127 ) 
  771.       goto lab11 ; 
  772.       tfmtemp = getc ( tfmfile ) ; 
  773.       nd = nd * 256 + tfmtemp ; 
  774.     } 
  775.     tfmtemp = getc ( tfmfile ) ; 
  776.     {
  777.       ni = tfmtemp ; 
  778.       if ( ni > 127 ) 
  779.       goto lab11 ; 
  780.       tfmtemp = getc ( tfmfile ) ; 
  781.       ni = ni * 256 + tfmtemp ; 
  782.     } 
  783.     tfmtemp = getc ( tfmfile ) ; 
  784.     {
  785.       nl = tfmtemp ; 
  786.       if ( nl > 127 ) 
  787.       goto lab11 ; 
  788.       tfmtemp = getc ( tfmfile ) ; 
  789.       nl = nl * 256 + tfmtemp ; 
  790.     } 
  791.     tfmtemp = getc ( tfmfile ) ; 
  792.     {
  793.       nk = tfmtemp ; 
  794.       if ( nk > 127 ) 
  795.       goto lab11 ; 
  796.       tfmtemp = getc ( tfmfile ) ; 
  797.       nk = nk * 256 + tfmtemp ; 
  798.     } 
  799.     tfmtemp = getc ( tfmfile ) ; 
  800.     {
  801.       ne = tfmtemp ; 
  802.       if ( ne > 127 ) 
  803.       goto lab11 ; 
  804.       tfmtemp = getc ( tfmfile ) ; 
  805.       ne = ne * 256 + tfmtemp ; 
  806.     } 
  807.     tfmtemp = getc ( tfmfile ) ; 
  808.     {
  809.       np = tfmtemp ; 
  810.       if ( np > 127 ) 
  811.       goto lab11 ; 
  812.       tfmtemp = getc ( tfmfile ) ; 
  813.       np = np * 256 + tfmtemp ; 
  814.     } 
  815.     if ( lf != 6 + lh + ( ec - bc + 1 ) + nw + nh + nd + ni + nl + nk + ne + 
  816.     np ) 
  817.     goto lab11 ; 
  818.   } 
  819.   lf = lf - 6 - lh ; 
  820.   if ( np < 7 ) 
  821.   lf = lf + 7 - np ; 
  822.   if ( ( fontptr == fontmax ) || ( fmemptr + lf > fontmemsize ) ) 
  823.   {
  824.     {
  825.       if ( interaction == 3 ) 
  826.       wakeupterminal () ; 
  827.       printnl ( 262 ) ; 
  828.       print ( 795 ) ; 
  829.     } 
  830.     sprintcs ( u ) ; 
  831.     printchar ( 61 ) ; 
  832.     printfilename ( nom , aire , 335 ) ; 
  833.     if ( s >= 0 ) 
  834.     {
  835.       print ( 737 ) ; 
  836.       printscaled ( s ) ; 
  837.       print ( 393 ) ; 
  838.     } 
  839.     else if ( s != -1000 ) 
  840.     {
  841.       print ( 796 ) ; 
  842.       printint ( - (integer) s ) ; 
  843.     } 
  844.     print ( 805 ) ; 
  845.     {
  846.       helpptr = 4 ; 
  847.       helpline [ 3 ] = 806 ; 
  848.       helpline [ 2 ] = 807 ; 
  849.       helpline [ 1 ] = 808 ; 
  850.       helpline [ 0 ] = 809 ; 
  851.     } 
  852.     error () ; 
  853.     goto lab30 ; 
  854.   } 
  855.   f = fontptr + 1 ; 
  856.   charbase [ f ] = fmemptr - bc ; 
  857.   widthbase [ f ] = charbase [ f ] + ec + 1 ; 
  858.   heightbase [ f ] = widthbase [ f ] + nw ; 
  859.   depthbase [ f ] = heightbase [ f ] + nh ; 
  860.   italicbase [ f ] = depthbase [ f ] + nd ; 
  861.   ligkernbase [ f ] = italicbase [ f ] + ni ; 
  862.   kernbase [ f ] = ligkernbase [ f ] + nl - 256 * ( 128 ) ; 
  863.   extenbase [ f ] = kernbase [ f ] + 256 * ( 128 ) + nk ; 
  864.   parambase [ f ] = extenbase [ f ] + ne ; 
  865.   {
  866.     if ( lh < 2 ) 
  867.     goto lab11 ; 
  868.     {
  869.       tfmtemp = getc ( tfmfile ) ; 
  870.       a = tfmtemp ; 
  871.       qw .b0 = a ; 
  872.       tfmtemp = getc ( tfmfile ) ; 
  873.       b = tfmtemp ; 
  874.       qw .b1 = b ; 
  875.       tfmtemp = getc ( tfmfile ) ; 
  876.       c = tfmtemp ; 
  877.       qw .b2 = c ; 
  878.       tfmtemp = getc ( tfmfile ) ; 
  879.       d = tfmtemp ; 
  880.       qw .b3 = d ; 
  881.       fontcheck [ f ] = qw ; 
  882.     } 
  883.     tfmtemp = getc ( tfmfile ) ; 
  884.     {
  885.       z = tfmtemp ; 
  886.       if ( z > 127 ) 
  887.       goto lab11 ; 
  888.       tfmtemp = getc ( tfmfile ) ; 
  889.       z = z * 256 + tfmtemp ; 
  890.     } 
  891.     tfmtemp = getc ( tfmfile ) ; 
  892.     z = z * 256 + tfmtemp ; 
  893.     tfmtemp = getc ( tfmfile ) ; 
  894.     z = ( z * 16 ) + ( tfmtemp / 16 ) ; 
  895.     if ( z < 65536L ) 
  896.     goto lab11 ; 
  897.     while ( lh > 2 ) {
  898.     
  899.       tfmtemp = getc ( tfmfile ) ; 
  900.       tfmtemp = getc ( tfmfile ) ; 
  901.       tfmtemp = getc ( tfmfile ) ; 
  902.       tfmtemp = getc ( tfmfile ) ; 
  903.       decr ( lh ) ; 
  904.     } 
  905.     fontdsize [ f ] = z ; 
  906.     if ( s != -1000 ) 
  907.     if ( s >= 0 ) 
  908.     z = s ; 
  909.     else z = xnoverd ( z , - (integer) s , 1000 ) ; 
  910.     fontsize [ f ] = z ; 
  911.   } 
  912.   {register integer for_end; k = fmemptr ; for_end = widthbase [ f ] - 1 
  913.   ; if ( k <= for_end) do 
  914.     {
  915.       {
  916.     tfmtemp = getc ( tfmfile ) ; 
  917.     a = tfmtemp ; 
  918.     qw .b0 = a ; 
  919.     tfmtemp = getc ( tfmfile ) ; 
  920.     b = tfmtemp ; 
  921.     qw .b1 = b ; 
  922.     tfmtemp = getc ( tfmfile ) ; 
  923.     c = tfmtemp ; 
  924.     qw .b2 = c ; 
  925.     tfmtemp = getc ( tfmfile ) ; 
  926.     d = tfmtemp ; 
  927.     qw .b3 = d ; 
  928.     fontinfo [ k ] .qqqq = qw ; 
  929.       } 
  930.       if ( ( a >= nw ) || ( b / 16 >= nh ) || ( b % 16 >= nd ) || ( c / 4 >= 
  931.       ni ) ) 
  932.       goto lab11 ; 
  933.       switch ( c % 4 ) 
  934.       {case 1 : 
  935.     if ( d >= nl ) 
  936.     goto lab11 ; 
  937.     break ; 
  938.       case 3 : 
  939.     if ( d >= ne ) 
  940.     goto lab11 ; 
  941.     break ; 
  942.       case 2 : 
  943.     {
  944.       {
  945.         if ( ( d < bc ) || ( d > ec ) ) 
  946.         goto lab11 ; 
  947.       } 
  948.       while ( d < k + bc - fmemptr ) {
  949.           
  950.         qw = fontinfo [ charbase [ f ] + d ] .qqqq ; 
  951.         if ( ( ( qw .b2 ) % 4 ) != 2 ) 
  952.         goto lab45 ; 
  953.         d = qw .b3 ; 
  954.       } 
  955.       if ( d == k + bc - fmemptr ) 
  956.       goto lab11 ; 
  957.       lab45: ; 
  958.     } 
  959.     break ; 
  960.     default: 
  961.     ; 
  962.     break ; 
  963.       } 
  964.     } 
  965.   while ( k++ < for_end ) ; } 
  966.   {
  967.     {
  968.       alpha = 16 ; 
  969.       while ( z >= 8388608L ) {
  970.       
  971.     z = z / 2 ; 
  972.     alpha = alpha + alpha ; 
  973.       } 
  974.       beta = 256 / alpha ; 
  975.       alpha = alpha * z ; 
  976.     } 
  977.     {register integer for_end; k = widthbase [ f ] ; for_end = ligkernbase [ 
  978.     f ] - 1 ; if ( k <= for_end) do 
  979.       {
  980.     tfmtemp = getc ( tfmfile ) ; 
  981.     a = tfmtemp ; 
  982.     tfmtemp = getc ( tfmfile ) ; 
  983.     b = tfmtemp ; 
  984.     tfmtemp = getc ( tfmfile ) ; 
  985.     c = tfmtemp ; 
  986.     tfmtemp = getc ( tfmfile ) ; 
  987.     d = tfmtemp ; 
  988.     sw = ( ( ( ( ( d * z ) / 256 ) + ( c * z ) ) / 256 ) + ( b * z ) ) / 
  989.     beta ; 
  990.     if ( a == 0 ) 
  991.     fontinfo [ k ] .cint = sw ; 
  992.     else if ( a == 255 ) 
  993.     fontinfo [ k ] .cint = sw - alpha ; 
  994.     else goto lab11 ; 
  995.       } 
  996.     while ( k++ < for_end ) ; } 
  997.     if ( fontinfo [ widthbase [ f ] ] .cint != 0 ) 
  998.     goto lab11 ; 
  999.     if ( fontinfo [ heightbase [ f ] ] .cint != 0 ) 
  1000.     goto lab11 ; 
  1001.     if ( fontinfo [ depthbase [ f ] ] .cint != 0 ) 
  1002.     goto lab11 ; 
  1003.     if ( fontinfo [ italicbase [ f ] ] .cint != 0 ) 
  1004.     goto lab11 ; 
  1005.   } 
  1006.   bchlabel = 32767 ; 
  1007.   bchar = 256 ; 
  1008.   if ( nl > 0 ) 
  1009.   {
  1010.     {register integer for_end; k = ligkernbase [ f ] ; for_end = kernbase [ f 
  1011.     ] + 256 * ( 128 ) - 1 ; if ( k <= for_end) do 
  1012.       {
  1013.     {
  1014.       tfmtemp = getc ( tfmfile ) ; 
  1015.       a = tfmtemp ; 
  1016.       qw .b0 = a ; 
  1017.       tfmtemp = getc ( tfmfile ) ; 
  1018.       b = tfmtemp ; 
  1019.       qw .b1 = b ; 
  1020.       tfmtemp = getc ( tfmfile ) ; 
  1021.       c = tfmtemp ; 
  1022.       qw .b2 = c ; 
  1023.       tfmtemp = getc ( tfmfile ) ; 
  1024.       d = tfmtemp ; 
  1025.       qw .b3 = d ; 
  1026.       fontinfo [ k ] .qqqq = qw ; 
  1027.     } 
  1028.     if ( a > 128 ) 
  1029.     {
  1030.       if ( 256 * c + d >= nl ) 
  1031.       goto lab11 ; 
  1032.       if ( a == 255 ) 
  1033.       if ( k == ligkernbase [ f ] ) 
  1034.       bchar = b ; 
  1035.     } 
  1036.     else {
  1037.         
  1038.       if ( b != bchar ) 
  1039.       {
  1040.         {
  1041.           if ( ( b < bc ) || ( b > ec ) ) 
  1042.           goto lab11 ; 
  1043.         } 
  1044.         qw = fontinfo [ charbase [ f ] + b ] .qqqq ; 
  1045.         if ( ! ( qw .b0 > 0 ) ) 
  1046.         goto lab11 ; 
  1047.       } 
  1048.       if ( c < 128 ) 
  1049.       {
  1050.         {
  1051.           if ( ( d < bc ) || ( d > ec ) ) 
  1052.           goto lab11 ; 
  1053.         } 
  1054.         qw = fontinfo [ charbase [ f ] + d ] .qqqq ; 
  1055.         if ( ! ( qw .b0 > 0 ) ) 
  1056.         goto lab11 ; 
  1057.       } 
  1058.       else if ( 256 * ( c - 128 ) + d >= nk ) 
  1059.       goto lab11 ; 
  1060.       if ( a < 128 ) 
  1061.       if ( k - ligkernbase [ f ] + a + 1 >= nl ) 
  1062.       goto lab11 ; 
  1063.     } 
  1064.       } 
  1065.     while ( k++ < for_end ) ; } 
  1066.     if ( a == 255 ) 
  1067.     bchlabel = 256 * c + d ; 
  1068.   } 
  1069.   {register integer for_end; k = kernbase [ f ] + 256 * ( 128 ) ; for_end = 
  1070.   extenbase [ f ] - 1 ; if ( k <= for_end) do 
  1071.     {
  1072.       tfmtemp = getc ( tfmfile ) ; 
  1073.       a = tfmtemp ; 
  1074.       tfmtemp = getc ( tfmfile ) ; 
  1075.       b = tfmtemp ; 
  1076.       tfmtemp = getc ( tfmfile ) ; 
  1077.       c = tfmtemp ; 
  1078.       tfmtemp = getc ( tfmfile ) ; 
  1079.       d = tfmtemp ; 
  1080.       sw = ( ( ( ( ( d * z ) / 256 ) + ( c * z ) ) / 256 ) + ( b * z ) ) / 
  1081.       beta ; 
  1082.       if ( a == 0 ) 
  1083.       fontinfo [ k ] .cint = sw ; 
  1084.       else if ( a == 255 ) 
  1085.       fontinfo [ k ] .cint = sw - alpha ; 
  1086.       else goto lab11 ; 
  1087.     } 
  1088.   while ( k++ < for_end ) ; } 
  1089.   {register integer for_end; k = extenbase [ f ] ; for_end = parambase [ f ] 
  1090.   - 1 ; if ( k <= for_end) do 
  1091.     {
  1092.       {
  1093.     tfmtemp = getc ( tfmfile ) ; 
  1094.     a = tfmtemp ; 
  1095.     qw .b0 = a ; 
  1096.     tfmtemp = getc ( tfmfile ) ; 
  1097.     b = tfmtemp ; 
  1098.     qw .b1 = b ; 
  1099.     tfmtemp = getc ( tfmfile ) ; 
  1100.     c = tfmtemp ; 
  1101.     qw .b2 = c ; 
  1102.     tfmtemp = getc ( tfmfile ) ; 
  1103.     d = tfmtemp ; 
  1104.     qw .b3 = d ; 
  1105.     fontinfo [ k ] .qqqq = qw ; 
  1106.       } 
  1107.       if ( a != 0 ) 
  1108.       {
  1109.     {
  1110.       if ( ( a < bc ) || ( a > ec ) ) 
  1111.       goto lab11 ; 
  1112.     } 
  1113.     qw = fontinfo [ charbase [ f ] + a ] .qqqq ; 
  1114.     if ( ! ( qw .b0 > 0 ) ) 
  1115.     goto lab11 ; 
  1116.       } 
  1117.       if ( b != 0 ) 
  1118.       {
  1119.     {
  1120.       if ( ( b < bc ) || ( b > ec ) ) 
  1121.       goto lab11 ; 
  1122.     } 
  1123.     qw = fontinfo [ charbase [ f ] + b ] .qqqq ; 
  1124.     if ( ! ( qw .b0 > 0 ) ) 
  1125.     goto lab11 ; 
  1126.       } 
  1127.       if ( c != 0 ) 
  1128.       {
  1129.     {
  1130.       if ( ( c < bc ) || ( c > ec ) ) 
  1131.       goto lab11 ; 
  1132.     } 
  1133.     qw = fontinfo [ charbase [ f ] + c ] .qqqq ; 
  1134.     if ( ! ( qw .b0 > 0 ) ) 
  1135.     goto lab11 ; 
  1136.       } 
  1137.       {
  1138.     {
  1139.       if ( ( d < bc ) || ( d > ec ) ) 
  1140.       goto lab11 ; 
  1141.     } 
  1142.     qw = fontinfo [ charbase [ f ] + d ] .qqqq ; 
  1143.     if ( ! ( qw .b0 > 0 ) ) 
  1144.     goto lab11 ; 
  1145.       } 
  1146.     } 
  1147.   while ( k++ < for_end ) ; } 
  1148.   {
  1149.     {register integer for_end; k = 1 ; for_end = np ; if ( k <= for_end) do 
  1150.       if ( k == 1 ) 
  1151.       {
  1152.     tfmtemp = getc ( tfmfile ) ; 
  1153.     sw = tfmtemp ; 
  1154.     if ( sw > 127 ) 
  1155.     sw = sw - 256 ; 
  1156.     tfmtemp = getc ( tfmfile ) ; 
  1157.     sw = sw * 256 + tfmtemp ; 
  1158.     tfmtemp = getc ( tfmfile ) ; 
  1159.     sw = sw * 256 + tfmtemp ; 
  1160.     tfmtemp = getc ( tfmfile ) ; 
  1161.     fontinfo [ parambase [ f ] ] .cint = ( sw * 16 ) + ( tfmtemp / 16 ) ; 
  1162.       } 
  1163.       else {
  1164.       
  1165.     tfmtemp = getc ( tfmfile ) ; 
  1166.     a = tfmtemp ; 
  1167.     tfmtemp = getc ( tfmfile ) ; 
  1168.     b = tfmtemp ; 
  1169.     tfmtemp = getc ( tfmfile ) ; 
  1170.     c = tfmtemp ; 
  1171.     tfmtemp = getc ( tfmfile ) ; 
  1172.     d = tfmtemp ; 
  1173.     sw = ( ( ( ( ( d * z ) / 256 ) + ( c * z ) ) / 256 ) + ( b * z ) ) / 
  1174.     beta ; 
  1175.     if ( a == 0 ) 
  1176.     fontinfo [ parambase [ f ] + k - 1 ] .cint = sw ; 
  1177.     else if ( a == 255 ) 
  1178.     fontinfo [ parambase [ f ] + k - 1 ] .cint = sw - alpha ; 
  1179.     else goto lab11 ; 
  1180.       } 
  1181.     while ( k++ < for_end ) ; } 
  1182.     if ( feof ( tfmfile ) ) 
  1183.     goto lab11 ; 
  1184.     {register integer for_end; k = np + 1 ; for_end = 7 ; if ( k <= for_end) 
  1185.     do 
  1186.       fontinfo [ parambase [ f ] + k - 1 ] .cint = 0 ; 
  1187.     while ( k++ < for_end ) ; } 
  1188.   } 
  1189.   if ( np >= 7 ) 
  1190.   fontparams [ f ] = np ; 
  1191.   else fontparams [ f ] = 7 ; 
  1192.   hyphenchar [ f ] = eqtb [ 6209 ] .cint ; 
  1193.   skewchar [ f ] = eqtb [ 6210 ] .cint ; 
  1194.   if ( bchlabel < nl ) 
  1195.   bcharlabel [ f ] = bchlabel + ligkernbase [ f ] ; 
  1196.   else bcharlabel [ f ] = fontmemsize ; 
  1197.   fontbchar [ f ] = bchar ; 
  1198.   fontfalsebchar [ f ] = bchar ; 
  1199.   if ( bchar <= ec ) 
  1200.   if ( bchar >= bc ) 
  1201.   {
  1202.     qw = fontinfo [ charbase [ f ] + bchar ] .qqqq ; 
  1203.     if ( ( qw .b0 > 0 ) ) 
  1204.     fontfalsebchar [ f ] = 256 ; 
  1205.   } 
  1206.   fontname [ f ] = nom ; 
  1207.   fontarea [ f ] = aire ; 
  1208.   fontbc [ f ] = bc ; 
  1209.   fontec [ f ] = ec ; 
  1210.   fontglue [ f ] = 0 ; 
  1211.   charbase [ f ] = charbase [ f ] ; 
  1212.   widthbase [ f ] = widthbase [ f ] ; 
  1213.   ligkernbase [ f ] = ligkernbase [ f ] ; 
  1214.   kernbase [ f ] = kernbase [ f ] ; 
  1215.   extenbase [ f ] = extenbase [ f ] ; 
  1216.   decr ( parambase [ f ] ) ; 
  1217.   fmemptr = fmemptr + lf ; 
  1218.   fontptr = f ; 
  1219.   g = f ; 
  1220.   goto lab30 ; 
  1221.   lab11: {
  1222.       
  1223.     if ( interaction == 3 ) 
  1224.     wakeupterminal () ; 
  1225.     printnl ( 262 ) ; 
  1226.     print ( 795 ) ; 
  1227.   } 
  1228.   sprintcs ( u ) ; 
  1229.   printchar ( 61 ) ; 
  1230.   printfilename ( nom , aire , 335 ) ; 
  1231.   if ( s >= 0 ) 
  1232.   {
  1233.     print ( 737 ) ; 
  1234.     printscaled ( s ) ; 
  1235.     print ( 393 ) ; 
  1236.   } 
  1237.   else if ( s != -1000 ) 
  1238.   {
  1239.     print ( 796 ) ; 
  1240.     printint ( - (integer) s ) ; 
  1241.   } 
  1242.   if ( fileopened ) 
  1243.   print ( 797 ) ; 
  1244.   else print ( 798 ) ; 
  1245.   {
  1246.     helpptr = 5 ; 
  1247.     helpline [ 4 ] = 799 ; 
  1248.     helpline [ 3 ] = 800 ; 
  1249.     helpline [ 2 ] = 801 ; 
  1250.     helpline [ 1 ] = 802 ; 
  1251.     helpline [ 0 ] = 803 ; 
  1252.   } 
  1253.   error () ; 
  1254.   lab30: if ( fileopened ) 
  1255.   bclose ( tfmfile ) ; 
  1256.   Result = g ; 
  1257.   return(Result) ; 
  1258. } 
  1259.