home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 3 / Meeting_Pearls_III.iso / Pearls / texmf / source / TeX / tex / tex3.c < prev    next >
C/C++ Source or Header  |  1992-11-08  |  25KB  |  1,153 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4.  
  5. long_halfword strtoks ( poolpointer b )
  6. { strtoks_regmem 
  7.   register long_halfword p;
  8.   register halfword t;
  9.   register poolpointer k;
  10.  
  11.   strroom ( 1 ) ; 
  12.   p = temphead ; 
  13.   link ( p ) = 0 ; 
  14.   k = b;
  15.   while ( k < poolptr ) {
  16.     t = strpool[k];
  17.     if ( t == 32 ) 
  18.       t = spacetoken ; 
  19.     else
  20.       t = othertoken + t ; 
  21.     faststorenewtoken ( t ) ; 
  22.     incr ( k );
  23.   }
  24.   poolptr = b;
  25.   return(p);
  26. }
  27.  
  28.  
  29. long_halfword thetoks ( void )
  30. { register integer r_curval;
  31.  
  32.   getxtoken ();
  33.   r_curval = scansomethinginternal( tokval, false );
  34.  { thetoks_regmem
  35.  
  36.   if ( curvallevel >= identval ) {
  37.     long_halfword p;
  38.  
  39.     p = temphead;
  40.     link ( p ) = 0;
  41.     if ( curvallevel == identval )
  42.       storenewtoken ( cstokenflag + r_curval );
  43.     else if ( r_curval != 0 ) {
  44.       register halfword r;
  45.  
  46.       r = link ( r_curval );
  47.       while ( r != 0 ) {
  48.     faststorenewtoken ( info ( r ) );
  49.     r = link ( r );
  50.       }
  51.     }
  52.     return(p);
  53.   } else {
  54.     poolpointer b;
  55.     integer oldsetting;
  56.  
  57.     oldsetting = selector ; 
  58.     selector = newstring ; 
  59.     b = poolptr;
  60.     switch ( curvallevel ) {
  61.     case intval : 
  62.       printint ( r_curval );
  63.       break;
  64.     case dimenval : 
  65.     printscaled ( r_curval );
  66.     print( STR_PT );
  67.       break;
  68.     case glueval : 
  69.     printspec( r_curval, STR_PT );
  70.     deleteglueref ( r_curval ) ; 
  71.       break ; 
  72.     case muval : 
  73.     printspec ( r_curval, STR_MU );
  74.     deleteglueref ( r_curval );
  75.       break ; 
  76.     } 
  77.     selector = oldsetting ; 
  78.     return( strtoks ( b ) );
  79.   }
  80.  }
  81. }
  82.  
  83.  
  84. void insthetoks ( void )
  85. { insthetoks_regmem 
  86.  
  87.   link ( garbage ) = thetoks();
  88.   begintokenlist( link(temphead), inserted );
  89. }
  90.  
  91.  
  92. void convtoks ( void )
  93. { convtoks_regmem
  94.   register integer c;
  95.   integer oldsetting;
  96.   poolpointer b;
  97.  
  98.   c = curchr ; 
  99.   switch ( c ) {
  100.   case numbercode : 
  101.   case romannumeralcode : 
  102.     scanint ();
  103.     break;
  104.   case stringcode :
  105.   case meaningcode :
  106.     { register smallnumber savescannerstatus;
  107.  
  108.       savescannerstatus = scannerstatus;
  109.       scannerstatus = normal;
  110.       gettoken();
  111.       scannerstatus = savescannerstatus;
  112.     }
  113.     break;
  114.   case fontnamecode : 
  115.     scanfontident ();
  116.     break;
  117.   case jobnamecode : 
  118.     if ( jobname == 0 )
  119.       openlogfile();
  120.     break;
  121.   }
  122.  
  123.   oldsetting = selector ; 
  124.   selector = newstring ; 
  125.   b = poolptr ; 
  126.   switch ( c ) {
  127.   case numbercode : 
  128.     printint ( curval ) ; 
  129.     break ; 
  130.   case romannumeralcode : 
  131.     printromanint ( curval ) ; 
  132.     break ; 
  133.   case stringcode : 
  134.     if ( curcs != 0 ) 
  135.       sprintcs ( curcs );
  136.     else
  137.       printchar ( curchr );
  138.     break;
  139.   case meaningcode : 
  140.     printmeaning ();
  141.     break;
  142.   case fontnamecode : 
  143.     { register integer r_curval = curval;
  144.  
  145.       print ( fontname(r_curval) );
  146.       if ( fontsize(r_curval) != fontdsize(r_curval) ) {
  147.     print( STR_AT_ );
  148.     printscaled ( fontsize(r_curval) );
  149.     print( STR_PT );
  150.       }
  151.     }
  152.     break;
  153.   case jobnamecode:
  154.     print( jobname );
  155.     break;
  156.   }
  157.   selector = oldsetting;
  158.   link ( garbage ) = strtoks ( b );
  159.   begintokenlist( link(temphead), inserted );
  160. }
  161.  
  162.  
  163. long_halfword scantoks ( boolean macrodef, boolean xpand )
  164. { scantoks_regmem
  165.   register halfword t, s;
  166.   register long_halfword p;
  167.   register halfword unbalance, hashbrace;
  168.  
  169.   if ( macrodef )
  170.     scannerstatus = defining ; 
  171.   else
  172.     scannerstatus = absorbing ; 
  173.   warningindex = curcs ; 
  174. #if 0
  175.   defref = getavail () ; 
  176.   tokenrefcount ( defref ) = 0 ; 
  177.  
  178.   p = defref;
  179. #else
  180.   p = getavail();
  181.   tokenrefcount( p ) = 0 ; 
  182.  
  183.   defref = p;
  184. #endif
  185.   hashbrace = 0;
  186.   t = zerotoken;
  187.  
  188.   if ( macrodef ) {
  189.     while ( true ) {
  190.       gettoken () ; 
  191.       if ( curtok < rightbracelimit )
  192.     goto lab31;
  193.       if ( curcmd == 6 ) {
  194.     s = matchtoken + curchr ; 
  195.     if( (eightbits)gettoken() == 1 ) {
  196.       hashbrace = curtok;
  197.       storenewtoken ( curtok );
  198.       storenewtoken ( endmatchtoken );
  199.       goto lab30;
  200.     }
  201.     if ( t == zerotoken + 9 ) {
  202.       print_err("You already have nine parameters");
  203.       zhelp1( STR_H_IMGOING_TABSIGN );
  204.       error();
  205.     } else {
  206.       incr ( t ) ; 
  207.       if ( curtok != t ) {
  208.         print_err("Parameters must be numbered consecutively");
  209.         zhelp1( STR_H_IVEINSERTED_DIGIT );
  210.         backerror () ; 
  211.       }
  212.       curtok = s;
  213.     }
  214.       }
  215.       storenewtoken( curtok );
  216.     }            /* while ( true ) */
  217.  
  218. lab31:
  219.     storenewtoken ( endmatchtoken );
  220.     if ( curcmd == 2 ) {
  221.       p_print_err( STR_H_MISSING_LEFTBRACE );
  222.       incr ( alignstate );
  223.       zhelp1( STR_H_WHEREWAS_LEFTBRACE );
  224.       error();
  225.       goto lab40;
  226.     }
  227. lab30: ; 
  228.  
  229.   } else
  230.  
  231.     scanleftbrace();
  232.  
  233.   unbalance = 1;
  234.   while ( true ) {
  235.     if ( xpand ) {
  236.       while ( true ) {
  237.     if( (eightbits)getnext() <= maxcommand )
  238.       goto lab32 ; 
  239.     if ( curcmd != the ) 
  240.       expand();
  241.     else {
  242.       register long_halfword q;
  243.  
  244.       q = thetoks();
  245.       if ( link ( temphead ) != 0 ) {
  246.         link ( p ) = link ( temphead ) ; 
  247.         p = q;
  248.       }
  249.     }
  250.       }     /* while ( true ) */
  251. lab32:
  252.       xtoken();
  253.     } else
  254.       gettoken();
  255.  
  256.     if ( curtok < rightbracelimit ) {
  257.       if ( curcmd < 2 ) 
  258.     incr ( unbalance ) ; 
  259.       else {
  260.     decr ( unbalance ) ; 
  261.     if ( unbalance == 0 ) 
  262.       goto lab40 ; 
  263.       }
  264.     } else if ( curcmd == 6 ) 
  265.       if ( macrodef ) {
  266.     s = curtok ; 
  267.     if( (eightbits)( (xpand) ? getxtoken() : gettoken() ) != 6 ) {
  268.       if ( ( curtok <= zerotoken ) || ( curtok > t ) ) {
  269.         print_err("Illegal parameter number in definition of ");
  270.         sprintcs ( warningindex );
  271.         zhelp1( STR_H_YOUMEANT_TAB );
  272.         backerror();
  273.         curtok = s;
  274.       } else
  275.         curtok = outparamtoken - 48 + curchr;
  276.     }
  277.       }
  278.     storenewtoken ( curtok ) ; 
  279.   }        /* while (true) */
  280.  
  281. lab40:
  282.   scannerstatus = normal ; 
  283.   if ( hashbrace != 0 ) 
  284.     storenewtoken ( hashbrace );
  285.  
  286.   return(p);
  287. }
  288.  
  289.  
  290. void readtoks ( integer n, halfword r )
  291. { readtoks_regmem 
  292.   register halfword p;
  293.   integer s;
  294.   register smallnumber m;
  295.  
  296.   scannerstatus = defining ; 
  297.   warningindex = r ; 
  298.   defref = getavail () ; 
  299.   tokenrefcount ( defref ) = 0 ; 
  300.   p = defref ; 
  301.   storenewtoken ( endmatchtoken ) ; 
  302.   if ( n < 0 || n > 15 )
  303.     m = 16 ; 
  304.   else
  305.     m = n ; 
  306.   s = alignstate ; 
  307.   alignstate = 1000000L ; 
  308.  
  309.   do {
  310.     beginfilereading () ; 
  311.     curinput .namefield = m + 1 ; 
  312.     if ( readopen [ m ] == closed ) 
  313.       if ( interaction > nonstopmode ) 
  314.     if ( n < 0 ) 
  315.       terminput("");
  316.     else {
  317.       wakeupterminal () ; 
  318.       println () ; 
  319.       sprintcs ( r ) ; 
  320.       terminput("=");
  321.       n = -1 ; 
  322.     } 
  323.       else
  324.     fatalerror( STR_H_FE_CANNOTREAD );
  325.     else if ( readopen [ m ] == justopen ) 
  326.       if ( inputln ( readfile [ m ] , false ) ) 
  327.     readopen [ m ] = normal ; 
  328.       else {
  329.     aclose ( readfile [ m ] ) ; 
  330.     readopen [ m ] = closed ; 
  331.       }
  332.     else {
  333.       if ( ! inputln ( readfile [ m ] , true ) ) {
  334.     aclose ( readfile [ m ] ) ; 
  335.     readopen [ m ] = closed ; 
  336.     if ( alignstate != 1000000L ) {
  337.       runaway () ; 
  338.       print_err("File ended within ");
  339.       printesc( STR_READ );
  340.       zhelp1( STR_H_THISREADHASUNBALANCED );
  341.       alignstate = 1000000L ; 
  342.       error () ; 
  343.     }
  344.       }
  345.     }
  346.     curinput .limitfield = last ; 
  347.     if ( endlinecharinactive () ) 
  348.       decr ( curinput .limitfield ) ; 
  349.     else
  350.       buffer [ curinput .limitfield ] = endlinechar ; 
  351.     first = curinput .limitfield + 1 ; 
  352.     curinput .locfield = curinput .startfield ; 
  353.     curinput .statefield = 33 ; 
  354.     while ( true ) {
  355.       gettoken();
  356.       if ( curtok == 0 )
  357.     goto lab30;
  358.       /* TeX 3.141 change begin */
  359.       if ( alignstate < 1000000L ) {
  360.     do {
  361.       gettoken();
  362.     } while( curtok != 0 );
  363.     alignstate = 1000000L;
  364.     goto lab30;
  365.       }
  366.       /* TeX 3.141 change end */
  367.       storenewtoken( curtok );
  368.     }
  369. lab30:
  370.     endfilereading();
  371.   } while ( alignstate != 1000000L );
  372.  
  373.   curval = defref ; 
  374.   scannerstatus = normal ; 
  375.   alignstate = s;
  376. }
  377.  
  378.  
  379. void passtext ( void )
  380. { passtext_regmem
  381.   register integer l;
  382.   smallnumber savescannerstatus;
  383.  
  384.   savescannerstatus = scannerstatus ; 
  385.   scannerstatus = skipping ; 
  386.   l = 0 ; 
  387.   skipline = line ; 
  388.   while ( true ) {
  389.     register eightbits r_curcmd;
  390.  
  391.     r_curcmd = getnext () ; 
  392.     if ( r_curcmd == fiorelse ) {
  393.       if ( l == 0 )
  394.     goto lab30 ; 
  395.       if ( curchr == ficode ) 
  396.     decr ( l ) ; 
  397.     } else if ( r_curcmd == iftest )
  398.       incr ( l ) ; 
  399.   }
  400. lab30:
  401.   scannerstatus = savescannerstatus ; 
  402. }
  403.  
  404.  
  405. void changeiflimit ( smallnumber l, halfword p )
  406. { changeiflimit_regmem 
  407.   register halfword q;
  408.  
  409.   if ( p == condptr ) 
  410.     iflimit = l ; 
  411.   else {
  412.     q = condptr ; 
  413.     while ( true ) {
  414.       if ( q == 0 ) 
  415.      confusion("if");
  416.       if ( link ( q ) == p ) {
  417.     ztype ( q ) = l ; 
  418.     return ; 
  419.       } 
  420.       q = link ( q ) ; 
  421.     } 
  422.   }
  423. }
  424.  
  425.  
  426. void conditional ( void )
  427. { conditional_regmem 
  428.   boolean b;
  429.   register integer m, n;
  430.   register halfword p, q;
  431.   halfword savecondptr;
  432.   register smallnumber thisif;
  433.  
  434.   {
  435.     p = getnode ( ifnodesize ) ; 
  436.     link ( p ) = condptr ; 
  437.     ztype ( p ) = iflimit ; 
  438.     subtype ( p ) = curif ; 
  439.     iflinefield ( p ) = ifline ; 
  440.     condptr = p ; 
  441.     curif = curchr ; 
  442.     iflimit = ifcode ; 
  443.     ifline = line ; 
  444.   }
  445.   savecondptr = condptr ; 
  446.   thisif = curchr ; 
  447.  
  448.   switch ( thisif ) {
  449.   case ifcharcode : 
  450.   case ifcatcode : 
  451.     { register eightbits r_curcmd;
  452.  
  453.       getxtokenoractivechar;
  454.       if ( r_curcmd > 13 || curchr > 255 ) {
  455.     m = 0;
  456.     n = 256;
  457.       } else {      
  458.     m = r_curcmd;
  459.     n = curchr;
  460.       } 
  461.       getxtokenoractivechar;
  462.       if ( r_curcmd > 13 || curchr > 255 ) {
  463.     curcmd = r_curcmd = 0;
  464.     curchr = 256;
  465.       } 
  466. #ifdef ERW_TRACING
  467.     /*  zeige nachdem die beiden Tokens gelesen wurde, die entsprechenden
  468.      *  Werte im log-file
  469.      */
  470.       if ( tracingcommands > 2 ) {
  471.     begindiagnostic ();
  472.     printchar( 123 );
  473. #if 0
  474.     if( thisif == ifcharcode ) {
  475.       print(STR_IF);  printchar(' ');
  476.       printint(n);  c_print(" = ");  printint(curchr);
  477.     } else {
  478.       print(STR_IFCAT);  printchar(' ');
  479.       printcmdchr(m, n);  c_print(" = ");  printcmdchr(r_curcmd, curchr);
  480.     }
  481. #else
  482.     /* Format: {if<cat> <cmdchr1> (<num1>) = <cmdchr2> (<num2>)}
  483.      */
  484.     print( (thisif == ifcharcode) ? STR_IF : STR_IFCAT );  printchar(' ');
  485.     printcmdchr(m, n);  c_print(" (");
  486.     printint( (thisif == ifcharcode) ? n : m ); c_print(") = ");
  487.     printcmdchr(r_curcmd, curchr); c_print(" (");
  488.     printint( (thisif == ifcharcode) ? curchr : r_curcmd );
  489.     printchar(')');
  490. #endif
  491.     printchar( 125 );
  492.     enddiagnostic ( false );
  493.       }
  494. #endif
  495.       if ( thisif == ifcharcode )
  496.     b = ( n == curchr );
  497.       else
  498.     b = ( m == r_curcmd );
  499.     }
  500.     break;
  501.   case ifintcode:
  502.   case ifdimcode:
  503.     { schar r;
  504.  
  505.       if ( thisif == ifintcode )
  506.     n = scanint ();
  507.       else
  508.     n = scandimen ( false , false , false );
  509.       (void) getxnbtoken(0);
  510.  
  511.       if ( ( curtok >= othertoken + 60 ) && ( curtok <= othertoken + 62 ) ) 
  512.     r = curtok - othertoken - 60;
  513.       else {
  514.     print_err("Missing = inserted for ");
  515.     printcmdchr( iftest, thisif );
  516.     zhelp1( STR_H_IWASEXPECTING_DIDNT );
  517.     backerror();
  518.     r = 1 /* 61 */;
  519.       }
  520.  
  521.       if ( thisif == ifintcode ) 
  522.     m = scanint ();
  523.       else
  524.     m = scandimen ( false , false , false );
  525.  
  526.       switch ( r ) {
  527.       case 0 /* 60 */:
  528.     b = ( n < m );
  529.     break;
  530.       case 1 /* 61 */: 
  531.     b = ( n == m );
  532.     break;
  533.       case 2 /* 62 */: 
  534.     b = ( n > m );
  535.     break;
  536.       }
  537.     }
  538.     break ; 
  539.   case ifoddcode : 
  540.     b = odd( scanint() );
  541.     break ; 
  542.   case ifvmodecode : 
  543.     b = ( abs ( curlist .modefield ) == vmode );
  544.     break ; 
  545.   case ifhmodecode : 
  546.     b = ( abs ( curlist .modefield ) == hmode );
  547.     break ; 
  548.   case ifmmodecode : 
  549.     b = ( abs ( curlist .modefield ) == mmode );
  550.     break ; 
  551.   case ifinnercode : 
  552.     b = ( curlist .modefield < 0 );
  553.     break;
  554.   case ifvoidcode : 
  555.   case ifhboxcode : 
  556.   case ifvboxcode : 
  557.     {
  558.       p = box( scaneightbitint() );
  559.       if ( thisif == ifvoidcode )
  560.     b = ( p == 0 );
  561.       else if ( p == 0 )
  562.     b = false;
  563.       else if ( thisif == ifhboxcode )
  564.     b = ( ztype ( p ) == hlistnode );
  565.       else
  566.     b = ( ztype ( p ) == vlistnode );
  567.     }
  568.     break ; 
  569.   case ifxcode : 
  570.     { smallnumber savescannerstatus;
  571.  
  572.       savescannerstatus = scannerstatus;
  573.       scannerstatus = normal;
  574.       p = getnext();
  575.       n = curcs;
  576.       /* p = curcmd; */
  577.       q = curchr;
  578.       getnext();
  579. #ifdef ERW_TRACING
  580.     /*  zeige die beiden Tokens bzw. falls Commands gleich und Makros
  581.      * wird Teil der Definition im log-file gezeigt.
  582.      */
  583.     /* Format:
  584.      *   {ifx <type> <<macroname>:<definition>.>
  585.      *      = <type> <<macroname>:<definition>.>}
  586.      */
  587.       if ( tracingcommands > 2 ) {
  588.     begindiagnostic ();
  589.     printchar( 123 );
  590.     print(STR_IFX);  printchar(' ');
  591.     printcmdchr(p, q);
  592.     if( p >= call ) {
  593.       if ( n != 0 ) {
  594.         printchar(' ');
  595.         sprintcs( n );
  596.       }
  597.       if( q != 0 ) {
  598.         printchar(':');
  599.         showtokenlist( link(q), 0, 32 );  /* maxprintline/2 - 13 */
  600.         printchar('.');
  601.       }
  602.     }
  603.     println(); c_print("   = ");
  604.     printcmdchr(curcmd, curchr);
  605.     if( curcmd >= call ) {
  606.       if( curcs != 0 ) {
  607.         printchar(' ');
  608.         sprintcs( curcs );
  609.       }
  610.       if( curchr != 0 ) {
  611.         printchar(':');
  612.         showtokenlist( link(curchr), 0, 32 );
  613.         printchar('.');
  614.       }
  615.     }
  616.     printchar( 125 );
  617.     enddiagnostic ( false );
  618.       }
  619. #endif
  620.       if ( curcmd != p )
  621.     b = false;
  622.       else if ( p /*curcmd*/ < call )    /* es gilt: curcmd == p */
  623.     b = ( curchr == q );
  624.       else {                /* und jetzt: curcmd/p >= call */
  625.     p = link ( curchr );
  626.     q = link ( equiv(n) );
  627.     if ( p == q ) {
  628.       b = true;
  629.     } else {
  630. #if 0
  631.       while ( ( p != 0 ) && ( q != 0 ) ) {
  632.         if ( info ( p ) != info ( q ) )
  633.           p = 0;
  634.         else {
  635.           p = link ( p );
  636.           q = link ( q );
  637.         }
  638.       }
  639.       b = ( ( p == 0 ) && ( q == 0 ) );
  640. #else
  641.       b = false;
  642.       while( 1 ) {
  643.         if( (p == 0) || (q == 0) ) {
  644.           if( p == q )  /* <==> ( (p == 0) && (q == 0) ) */
  645.         b = true;
  646.           break;
  647.         }
  648.         if ( info(p) != info(q) ) {
  649.           break;
  650.         }
  651.         p = link(p); q = link(q);
  652.       }
  653. #endif
  654.     }
  655.       }
  656.       scannerstatus = savescannerstatus;
  657.     }
  658.     break;
  659.   case ifeofcode :
  660.     n = scanfourbitint ();
  661.     b = ( readopen [ /*curval*/ n ] == closed );
  662.     break;
  663.   case iftruecode : 
  664.     b = true ; 
  665.     break ; 
  666.   case iffalsecode : 
  667.     b = false ; 
  668.     break ; 
  669.   case ifcasecode : 
  670.     {
  671.       n = scanint ();
  672.       if ( tracingcommands > 1 ) {
  673.     begindiagnostic () ; 
  674.     c_print("{case ");
  675.     printint ( n ) ; 
  676.     printchar ( 125 ) ; 
  677.     enddiagnostic ( false ) ; 
  678.       } 
  679.       while ( n != 0 ) {
  680.     passtext();
  681.     if ( condptr == savecondptr )
  682.       if ( curchr == orcode )
  683.         decr ( n );
  684.       else
  685.         goto lab50;
  686.     else if ( curchr == ficode ) {
  687.       p = condptr;
  688.       ifline = iflinefield ( p );
  689.       curif = subtype ( p );
  690.       iflimit = ztype ( p );
  691.       condptr = link ( p );
  692.       freenode( p, ifnodesize );
  693.     }
  694.       }
  695.       changeiflimit( orcode, savecondptr );
  696.       return;
  697.     }
  698.     break;
  699.   }
  700.  
  701.   if ( tracingcommands > 1 ) {
  702.     begindiagnostic ();
  703.     c_print( b ? "{true}" : "{false}" );
  704.     enddiagnostic ( false );
  705.   }
  706.  
  707.   if ( b ) {
  708.     changeiflimit ( elsecode, savecondptr );
  709.     return;
  710.   }
  711.  
  712.   while ( true ) {
  713.     passtext();
  714.     if ( condptr == savecondptr ) {
  715.       if ( curchr != orcode ) 
  716.     goto lab50 ; 
  717.       print_err("Extra ");
  718.       printesc( STR_OR );
  719.       zhelp1( STR_H_IMIGNORING_IF );
  720.       error () ; 
  721.     } else if ( curchr == ficode ) {
  722.       p = condptr ; 
  723.       ifline = iflinefield ( p ) ; 
  724.       curif = subtype ( p ) ; 
  725.       iflimit = ztype ( p ) ; 
  726.       condptr = link ( p ) ; 
  727.       freenode ( p , ifnodesize ) ; 
  728.     }
  729.   }
  730. lab50:
  731.   if ( curchr == ficode ) {
  732.     p = condptr ; 
  733.     ifline = iflinefield ( p ) ; 
  734.     curif = subtype ( p ) ; 
  735.     iflimit = ztype ( p ) ; 
  736.     condptr = link ( p ) ; 
  737.     freenode ( p , ifnodesize ) ; 
  738.   } else
  739.     iflimit = ficode ; 
  740. }
  741.  
  742. #if 0        /* nach filename.c */
  743.  
  744. /* =========  Part 29: File Names =========== */
  745.  
  746. /* Diese Routinen sollte man so abaendern, dass sie vielleicht statt dem
  747.  * String Pool feste oder dynamische C-Arrays benutzen.  TeX hat jetzt die
  748.  * unangenehme Eigenschaft, fuer jeden(!) Filenamen, selbst wenn er schon
  749.  * vorhanden ist, einen neuen String yu verwenden.
  750.  */
  751.  
  752. /*
  753.  *  Die naechsten drei Routinen werden nur von scanfilename() und
  754.  *  promptfilename() aufgerufen.
  755.  */
  756.  
  757.   static
  758. void beginname ( void )
  759. { beginname_regmem 
  760.  
  761.   areadelimiter = 0;
  762.   extdelimiter = 0;
  763. } 
  764.  
  765.   static
  766. boolean morename ( ASCIIcode c )
  767. { morename_regmem
  768.  
  769.   if ( c == 32 )
  770.     return(false);
  771.  
  772.   strroom( 1 );
  773.   appendchar( c );
  774.   if ( c == 47 ) {        /* / */
  775.     areadelimiter = curlength;
  776.     extdelimiter = 0;
  777.   } else if ( c == 46 )        /* . */
  778.     extdelimiter = curlength;
  779.  
  780.   return(true);
  781. }
  782.  
  783.   static
  784. void endname ( void )
  785. { endname_regmem
  786.  
  787.   if ( strptr + 3 > maxstrings )
  788.     overflow(1, maxstrings - initstrptr);
  789.  
  790.   /* Falls kein Directory angegeben wurde, ist curarea = "",
  791.    * ansonsten wird curarea auf das Directory gesetzt.
  792.    */
  793.   if ( areadelimiter == 0 )
  794.     curarea = 335;
  795.   else {
  796.     curarea = strptr;
  797.     strstart [ strptr + 1 ] = strstart [ strptr ] + areadelimiter;
  798.     incr ( strptr );
  799.   }
  800.  
  801.   /* Falls keine Extension angegeben wurde, ist curext = "" und curname
  802.    * der aktuelle String.
  803.    * Ansonsten ist curname der String bis zu curext und curext der restliche
  804.    * aktuelle String.
  805.    */
  806.   if ( extdelimiter == 0 ) {
  807.     curext = 335;
  808.     curname = makestring();
  809.   } else {
  810.     curname = strptr;
  811.     strstart[strptr+1] = strstart[strptr] + extdelimiter - areadelimiter - 1;
  812.     incr ( strptr );
  813.     curext = makestring();
  814.   }
  815. }
  816.  
  817.  
  818.  
  819. void packfilename( strnumber n, strnumber a, strnumber e )
  820. { packfilename_regmem
  821.   register integer k;
  822.   register ASCIIcode c;
  823.   register poolpointer j;
  824.  
  825.   k = 0;
  826.   {register integer for_end; j = strstart [ a ] ; for_end = strstart [ a + 1 
  827.   ] - 1 ; if ( j <= for_end) do 
  828.     {
  829.       c = strpool [ j ] ; 
  830.       incr ( k ) ; 
  831.       if ( k <= FILENAMESIZE ) 
  832.       nameoffile [ k ] = xchr [ c ] ; 
  833.     } 
  834.   while ( j++ < for_end ) ; } 
  835.   {register integer for_end; j = strstart [ n ] ; for_end = strstart [ n + 1 
  836.   ] - 1 ; if ( j <= for_end) do 
  837.     {
  838.       c = strpool [ j ] ; 
  839.       incr ( k ) ; 
  840.       if ( k <= FILENAMESIZE ) 
  841.       nameoffile [ k ] = xchr [ c ] ; 
  842.     } 
  843.   while ( j++ < for_end ) ; } 
  844.   {register integer for_end; j = strstart [ e ] ; for_end = strstart [ e + 1 
  845.   ] - 1 ; if ( j <= for_end) do 
  846.     {
  847.       c = strpool [ j ] ; 
  848.       incr ( k ) ; 
  849.       if ( k <= FILENAMESIZE ) 
  850.       nameoffile [ k ] = xchr [ c ] ; 
  851.     } 
  852.   while ( j++ < for_end ) ; } 
  853.  
  854.   if ( k <= FILENAMESIZE ) 
  855.    namelength = k ; 
  856.   else
  857.     namelength = FILENAMESIZE ; 
  858.  
  859.   {register integer for_end; k = namelength + 1 ; for_end = FILENAMESIZE 
  860.   ; if ( k <= for_end) do 
  861.     nameoffile [ k ] = ' ' ; 
  862.   while ( k++ < for_end ) ; } 
  863. }
  864.  
  865.  
  866. void packbufferedname ( smallnumber n, integer a, integer b )
  867. { packbufferedname_regmem 
  868.   register integer k  ; 
  869.   register ASCIIcode c  ; 
  870.   register integer j  ; 
  871.  
  872.   if ( n + b - a + 5 > FILENAMESIZE ) 
  873.     b = a + FILENAMESIZE - n - 5 ; 
  874.   k = 0 ; 
  875.   {register integer for_end; j = 1 ; for_end = n ; if ( j <= for_end) do 
  876.     {
  877.       c = xord [ TEXformatdefault [ j ] ] ; 
  878.       incr ( k ) ; 
  879.       if ( k <= FILENAMESIZE ) 
  880.       nameoffile [ k ] = xchr [ c ] ; 
  881.     } 
  882.   while ( j++ < for_end ) ; } 
  883.   {register integer for_end; j = a ; for_end = b ; if ( j <= for_end) do 
  884.     {
  885.       c = buffer [ j ] ; 
  886.       incr ( k ) ; 
  887.       if ( k <= FILENAMESIZE ) 
  888.       nameoffile [ k ] = xchr [ c ] ; 
  889.     } 
  890.   while ( j++ < for_end ) ; } 
  891.   {register integer for_end; j = formatdefaultlength - 3 ; for_end = 
  892.   formatdefaultlength ; if ( j <= for_end) do 
  893.     {
  894.       c = xord [ TEXformatdefault [ j ] ] ; 
  895.       incr ( k ) ; 
  896.       if ( k <= FILENAMESIZE ) 
  897.       nameoffile [ k ] = xchr [ c ] ; 
  898.     } 
  899.   while ( j++ < for_end ) ; } 
  900.   if ( k <= FILENAMESIZE ) 
  901.   namelength = k ; 
  902.   else namelength = FILENAMESIZE ; 
  903.   {register integer for_end; k = namelength + 1 ; for_end = FILENAMESIZE 
  904.   ; if ( k <= for_end) do 
  905.     nameoffile [ k ] = ' ' ; 
  906.   while ( k++ < for_end ) ; } 
  907. }
  908.  
  909.  
  910. strnumber makenamestring ( void )
  911. { makenamestring_regmem 
  912.   register integer k  ; 
  913.  
  914.   if ( ( poolptr + namelength > poolsize ) || ( strptr == maxstrings )
  915.     || ( curlength > 0 ) )
  916.     return( (strnumber)63 );
  917.  
  918.   {register integer for_end; k = 1 ; for_end = namelength ; if ( k <= 
  919.   for_end) do 
  920.     appendchar ( xord [ nameoffile [ k ] ] ) ; 
  921.   while ( k++ < for_end ) ; } 
  922.  
  923.   return( makestring () );
  924. } 
  925.  
  926.  
  927. #if 0
  928. strnumber amakenamestring ( alphafile f )
  929. { amakenamestring_regmem
  930.  
  931.   return( makenamestring () );
  932. }
  933.  
  934.  
  935. strnumber bmakenamestring ( bytefile f )
  936. { bmakenamestring_regmem 
  937.  
  938.   return( makenamestring () );
  939. }
  940.  
  941.  
  942. strnumber wmakenamestring ( wordfile f )
  943. { wmakenamestring_regmem 
  944.  
  945.   return( makenamestring () );
  946. }
  947. #endif
  948.  
  949.  
  950. void scanfilename ( void )
  951. { scanfilename_regmem
  952.   register eightbits r_curcmd;
  953.  
  954.   nameinprogress = true;
  955.   beginname();
  956.   r_curcmd = getxnbtoken(0);
  957.  
  958.   while ( true ) {
  959.     if ( r_curcmd > 12 || (curchr > 255) ) {
  960.       backinput ();
  961.       goto lab30;
  962.     }
  963.     if ( ! morename( curchr ) )
  964.       goto lab30;
  965.     r_curcmd = getxtoken();
  966.   }
  967.  
  968. lab30:
  969.   endname();
  970.   nameinprogress = false;
  971. }
  972.  
  973.  
  974. void packjobname ( strnumber s )
  975. { packjobname_regmem
  976.  
  977.   curarea = 335 ;
  978.   curext = s ;
  979.   curname = jobname ;
  980.   packfilename ( curname , curarea , curext );
  981. }
  982.  
  983.  
  984. /* Da wir nach der Adresse des naechsten Strings abfragen (ist schneller
  985.  * als `strcmp()', wird er hier einmalig angelegt.
  986.  */
  987. static char input_file_name[] = "input file name";
  988.  
  989.  
  990. void promptfilename ( char *s, strnumber e )
  991. {/* 30 */ promptfilename_regmem 
  992.   register integer k  ; 
  993.  
  994.   if ( interaction == scrollmode ) 
  995.     wakeupterminal () ; 
  996.   if ( s == input_file_name ) {
  997.     print_err("I can't find file `");
  998.   } else {
  999.     print_err("I can't write on file `");
  1000.   } 
  1001.   printfilename ( curname , curarea , curext ) ; 
  1002.   c_print("'.");
  1003.   if ( e == STR_DOT_TEX )
  1004.     showcontext();
  1005.   c_printnl("Please type another ");
  1006.   c_print ( s );
  1007.   if ( interaction < scrollmode ) 
  1008.     fatalerror( STR_H_FE_JOBAB_FILE );
  1009.   clearterminal () ; 
  1010.   terminput(": ");
  1011.   {
  1012.     beginname () ; 
  1013.     k = first ; 
  1014.     while ( ( buffer [ k ] == 32 ) && ( k < last ) )
  1015.       incr ( k );
  1016.     while ( true ) {
  1017.       if ( k == last ) 
  1018.     goto lab30 ; 
  1019.       if ( ! morename ( buffer [ k ] ) ) 
  1020.     goto lab30 ; 
  1021.       incr ( k ) ; 
  1022.     }
  1023. lab30:
  1024.     endname () ; 
  1025.   } 
  1026.   if ( curext == 335 ) 
  1027.     curext = e;
  1028.   packfilename ( curname , curarea , curext ) ; 
  1029. }
  1030.  
  1031.  
  1032. void openlogfile ( void )
  1033. { openlogfile_regmem 
  1034.   integer oldsetting;
  1035.   register integer k;
  1036.   register integer l;
  1037.   ccharpointer months;
  1038.  
  1039.   oldsetting = selector;
  1040.  
  1041.   if ( jobname == 0 ) 
  1042.     jobname = STR_TEXPUT;
  1043.   packjobname( STR_DOT_LOG );  
  1044.   while ( ! aopenout ( logfile ) ) {
  1045.     selector = termonly ; 
  1046.     promptfilename("transcript file name", STR_DOT_LOG );
  1047.   }
  1048.   logname = amakenamestring ( logfile ) ; 
  1049.   selector = logonly ; 
  1050.   logopened = true ; 
  1051.   {
  1052. #if 0
  1053.     (void) Fputs( logfile ,  "This is TeX, C Version 3.1t2" ) ; 
  1054. #else
  1055.     (void) Fputs( logfile, banner );
  1056. #endif
  1057. #ifdef MLTEX
  1058.   /* if user has given ML-TeX switch in IniTeX, output a second line */
  1059.   if( is_ML_TeX )
  1060.     (void) Fputs(logfile, "\nThis is ML-TeX, C Version 3+");
  1061. #endif
  1062.     print ( formatident ) ; 
  1063.     c_print("  ");
  1064.     printint ( zday ) ; 
  1065.     printchar ( 32 ) ; 
  1066.     months = "JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC";
  1067.     {register integer for_end; k = 3 * zmonth - 3 ; for_end = 3 * zmonth - 1
  1068.     ; if ( k <= for_end) do 
  1069.       (void) putc( months [ k ] ,  logfile );
  1070.     while ( k++ < for_end ) ; } 
  1071.     printchar ( 32 ) ; 
  1072.     printint ( zyear ) ; 
  1073.     printchar ( 32 ) ; 
  1074.     printtwo ( ztime / 60 ) ; 
  1075.     printchar ( 58 ) ; 
  1076.     printtwo ( ztime % 60 ) ; 
  1077.   }
  1078. #ifdef INP_PTR
  1079.   /*  Da bei INP_PTR curinput auf oberstes Element von inputstack[] zeigt ..
  1080.    *  ist nichts zu tun.
  1081.    */
  1082. #else
  1083.   inputstack [ inputptr ] = curinput ; 
  1084. #endif
  1085.   c_printnl("**");
  1086.   l = inputstack [ 0 ] .limitfield ; 
  1087.   if ( buffer [ l ] == endlinechar ) 
  1088.     decr ( l );
  1089.   {register integer for_end; k = 1 ; for_end = l ; if ( k <= for_end) do 
  1090.     print ( buffer [ k ] ) ; 
  1091.   while ( k++ < for_end ) ; } 
  1092.   println () ; 
  1093.   selector = oldsetting + 2 ; 
  1094. }
  1095.  
  1096.  
  1097. void startinput ( void )
  1098. {/* 30 */ startinput_regmem 
  1099.  
  1100.   scanfilename ();
  1101.   if ( curext == 335 ) 
  1102.     packfilename ( curname , curarea , STR_DOT_TEX );
  1103.   else
  1104.     packfilename ( curname , curarea , curext );
  1105.  
  1106.   while ( true ) {
  1107.     beginfilereading () ; 
  1108.     if ( aopenin ( inputfile [ curinput .indexfield ] , TEXINPUTPATH ) ) 
  1109.       goto lab30 ; 
  1110.     if ( curext == 335 ) {
  1111.       packfilename ( curname , curarea , curext ) ; 
  1112.       if ( aopenin ( inputfile [ curinput .indexfield ] , TEXINPUTPATH ) ) 
  1113.       goto lab30 ; 
  1114.     } 
  1115.     endfilereading () ; 
  1116.     promptfilename( input_file_name, STR_DOT_TEX );
  1117.   }
  1118. lab30:
  1119.   curinput .namefield = amakenamestring ( inputfile[curinput.indexfield] );
  1120.   if ( jobname == 0 ) {
  1121.     jobname = curname;
  1122.     openlogfile();
  1123.   }
  1124.   if ( termoffset + length ( curinput .namefield ) > maxprintline - 3 )
  1125.     println();
  1126.   else if ( ( termoffset > 0 ) || ( fileoffset > 0 ) )
  1127.     printchar ( 32 );
  1128.   printchar ( 40 );
  1129.   incr ( openparens );
  1130.   print ( curinput .namefield );
  1131.   flush ( stdout );
  1132.   curinput .statefield = 33;
  1133.  
  1134.   line = 1;
  1135.   if ( inputln ( inputfile [ curinput .indexfield ] , false ) )
  1136.     ;
  1137.  
  1138.   curinput.limitfield = last;    /* (br) added */
  1139.   if ( pausing > 0 )        /* (br) added */
  1140.     firmuptheline () ;
  1141.  
  1142.   if ( endlinecharinactive () ) 
  1143.     decr ( curinput .limitfield ) ; 
  1144.   else
  1145.     buffer [ curinput .limitfield ] = endlinechar ; 
  1146.   first = curinput .limitfield + 1 ; 
  1147.   curinput .locfield = curinput .startfield ; 
  1148. }
  1149.  
  1150. #endif
  1151.  
  1152. /* -- end -- */
  1153.