home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 3 / Meeting_Pearls_III.iso / Pearls / texmf / source / TeX / tex / gettoken.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-08-18  |  14.0 KB  |  642 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4. #undef DOSTAT
  5.  
  6.  
  7. long_halfword gettoken ( )    /* eightbits */
  8. { gettoken_regmem
  9.   register long_halfword r_curcmd;
  10.  
  11.   nonewcontrolsequence = false ; 
  12.   r_curcmd = getnext ();
  13.   nonewcontrolsequence = true ; 
  14.  
  15.   if ( curcs == 0 ) {
  16. #if defined(AMIGA) && defined(BIG) && defined(LATTICE)
  17.     curtok = ( r_curcmd * 256 ) + curchr;
  18. #else
  19.  
  20. #ifdef BIG
  21.     register unsigned short *cp = (unsigned short *)&curtok;
  22.  
  23.     *cp++ = 0;            /* typeof(curtok) = halfword */
  24.  
  25.     { register unsigned char *ccp = (unsigned char *)cp;
  26.  
  27.       *ccp++ = r_curcmd;
  28.       *ccp   = curchr;
  29.     }
  30. #else
  31.     register unsigned char *cp = (unsigned char *)&curtok;
  32.  
  33.     *cp++ = r_curcmd;
  34.     *cp   = curchr;
  35. #endif
  36.  
  37. #endif
  38.   } else
  39.     curtok = (halfword)cstokenflag + curcs;
  40.  
  41.   return(r_curcmd);
  42. }
  43.  
  44.  
  45. long_halfword getxtoken ( )     /* eightbits */
  46. { getxtoken_regmem
  47.   register long_halfword r_curcmd;
  48.  
  49. lab20:
  50.   r_curcmd = getnext ();
  51.   if ( (eightbits)r_curcmd <= maxcommand )
  52.      goto lab30;
  53.   if ( (eightbits)r_curcmd >= call ) 
  54.      if ( (eightbits)r_curcmd < endtemplate ) 
  55.     macrocall ();
  56.      else {
  57.     curcs = frozenendv ; 
  58.     curcmd = r_curcmd = endv;
  59.     goto lab30 ; 
  60.      }
  61.   else
  62.      expand ();
  63.   goto lab20;
  64.  
  65. lab30:
  66.   if ( curcs == 0 ) {
  67. #if defined(AMIGA) && defined(BIG) && defined(LATTICE)
  68.     curtok = ( r_curcmd * 256 ) + curchr;
  69. #else
  70.  
  71. #ifdef BIG
  72.     register short *cp = (short *)&curtok;
  73.  
  74.     *cp++ = 0;            /* typeof(curtok) = halfword */
  75.     { register char *ccp = (char *)cp;
  76.       *ccp++ = r_curcmd;
  77.       *ccp   = curchr;
  78.     }
  79. #else
  80.     register char *cp = (char *)&curtok;
  81.     *cp++ = r_curcmd;
  82.     *cp   = curchr;
  83. #endif
  84.  
  85. #endif
  86.   } else
  87.     curtok = (halfword)cstokenflag + curcs ;
  88.  
  89.   return(r_curcmd);
  90. }
  91.  
  92.  
  93.     /* get next nonblank (nonrelax) token */
  94.     /* = 404./406. repeat getxtoken() until (curcmd != spacer...) */
  95. long_halfword getxnbtoken ( boolean nonrelax )     /* eightbits */
  96. { getxtoken_regmem
  97.   register long_halfword r_curcmd;
  98.  
  99. lab20:
  100.   r_curcmd = getnext ();
  101.   if ( (eightbits)r_curcmd <= maxcommand ) {
  102.      if( (eightbits)r_curcmd == spacer )
  103.     goto lab20;
  104.      if( nonrelax && (eightbits)r_curcmd == relax )
  105.     goto lab20;
  106.      goto lab30 ;
  107.   }
  108.   if ( (eightbits)r_curcmd >= call ) 
  109.      if ( (eightbits)r_curcmd < endtemplate ) 
  110.     macrocall ();
  111.      else {
  112.     curcs = frozenendv ; 
  113.     curcmd = r_curcmd = endv;
  114.     goto lab30;     /* curcmd ist: != spacer && != relax */
  115.      }
  116.   else
  117.      expand ();
  118.   goto lab20;
  119.  
  120. lab30:
  121.   if ( curcs == 0 ) {
  122. #if defined(AMIGA) && defined(BIG) && defined(LATTICE)
  123.     curtok = ( r_curcmd * 256 ) + curchr;
  124. #else
  125. #ifdef BIG
  126.     register short *cp = (short *)&curtok;
  127.     *cp++ = 0;            /* typeof(curtok) = halfword */
  128.     { register char *ccp = (char *)cp;
  129.       *ccp++ = r_curcmd; *ccp   = curchr;
  130.     }
  131. #else
  132.     register char *cp = (char *)&curtok;
  133.     *cp++ = r_curcmd; *cp   = curchr;
  134. #endif
  135. #endif
  136.   } else
  137.     curtok = (halfword)cstokenflag + curcs ;
  138.  
  139.   return(r_curcmd);
  140. }
  141.  
  142.  
  143. long_halfword xtoken ()
  144. { xtoken_regmem
  145.   register long_halfword r_curcmd = curcmd;
  146.  
  147.   while ( (eightbits)r_curcmd > maxcommand ) {
  148.     expand ();
  149.     r_curcmd = getnext () ;
  150.   }
  151.  
  152.   if ( curcs == 0 ) {
  153. #if 0
  154.     curtok = ( r_curcmd * 256 ) + curchr ; 
  155. #else
  156.  
  157. #ifdef BIG
  158.     register short *cp = (short *)&curtok;
  159.  
  160.     *cp++ = 0;            /* typeof(curtok) = halfword */
  161.     { register char *ccp = (char *)cp;
  162.       *ccp++ = r_curcmd;
  163.       *ccp   = curchr;
  164.     }
  165. #else
  166.     register char *cp = (char *)&curtok;
  167.     *cp++ = r_curcmd;
  168.     *cp   = curchr;
  169. #endif
  170.  
  171. #endif
  172.   } else
  173.     curtok = (halfword)cstokenflag + curcs ; 
  174.  
  175.   return(r_curcmd);
  176. }
  177.  
  178. #ifdef DOSTAT
  179. static int calls = 0;
  180. static int tokenlistno = 0;
  181. static int externalfile = 0;
  182. static int aligntest = 0;
  183. #endif
  184.  
  185.  
  186. long_halfword getnext ( )
  187. { getnext_regmem
  188.  
  189.   register instaterecord *curinpp;
  190.  
  191.   /* register integer k; */
  192.   /* register halfword t; */
  193.   /* register schar cat; */
  194.   register ASCIIcode c, cc;
  195.   register schar d  ;
  196.  
  197.   register long_halfword tmp_curchr;
  198.   register eightbits r_curcmd;
  199.  
  200. lab20:
  201. #ifdef INP_PTR
  202.   curinpp = curinput_ptr;
  203. # undef curinput
  204. # define curinput    (*curinpp)
  205. #else
  206.   curinpp = &curinput;
  207. # define curinput    (*curinpp)
  208. #endif
  209.  
  210. #ifdef DOSTAT
  211. calls++;
  212. #endif
  213.  
  214.   curcs = 0 ;
  215.   if ( curinput .statefield != tokenlist ) {
  216.     /* 343. Input from external file, ... */
  217. #ifdef DOSTAT
  218. externalfile++;
  219. #endif
  220. lab25:
  221.     if ( curinput.limitfield >= curinput.locfield ) {
  222.       tmp_curchr = buffer[curinput.locfield];
  223.       incr ( curinput .locfield ) ;
  224. lab21:
  225.       r_curcmd = catcode ( tmp_curchr ) ;
  226.       switch ( r_curcmd ) {
  227.       case 9 :        /* 345. Cases where characters are ignored. */
  228.     goto lab25 ;
  229.     break ;
  230.       case 0 :        /* escape */
  231.     { register schar cat;
  232.  
  233.       if ( curinput .locfield > curinput .limitfield )
  234.         curcs = nullcs ;
  235.       else {
  236.         register ASCIIcode *cp, *endp;
  237.         endp = &buffer[curinput.limitfield];
  238.  
  239. lab26:
  240.         cp = &buffer[curinput.locfield];
  241.         tmp_curchr = *cp++;
  242.  
  243.         cat = catcode ( tmp_curchr ) ;
  244.         if ( cat == 11 )
  245.           curinput .statefield = 17 ;
  246.         else if ( cat == 10 )
  247.           curinput .statefield = 17 ;
  248.         else curinput .statefield = 1 ;
  249.  
  250.         if ( cat == 11 && cp <= endp ) {
  251.           do {
  252.         tmp_curchr = *cp++;
  253.         cat = catcode ( tmp_curchr ) ;
  254.           } while ( ! ( cat != 11 || cp > endp ) ) ;
  255.  
  256.           if ( *cp == (halfword) tmp_curchr )
  257.         if ( cat == 7 )
  258.         if ( cp < endp ) {
  259.           c = *(cp + 1);
  260.           if ( c < 128 ) {
  261.             d = 2 ;
  262.             if ( ( c >= 48 && c <= 57 ) || ( c >= 97 && c <= 102 ) )
  263.               if ( cp + 2 <= endp ) {
  264.             cc = *(cp + 2 );
  265.             if ( ( cc >= 48 && cc <= 57 )
  266.                 || ( cc >= 97 && cc <= 102 ) )
  267.               incr ( d ) ;
  268.               }
  269.           { halfword tmp_curchr;
  270.  
  271.             if ( d > 2 ) {
  272.               tmp_curchr = c - ( (c <= 57) ? 48 : 87);
  273.               tmp_curchr = 16*tmp_curchr + cc - ((cc <= 57) ? 48 : 87);
  274.               *(cp - 1) = tmp_curchr;
  275.             } else 
  276.               *(cp - 1) = c + ( (c < 64) ? +64 : -64 );
  277.           }
  278.             curinput.limitfield -= d;  endp -= d;
  279.             first -= d;
  280.             while ( cp <= endp ) {
  281.               *cp = *(cp + d);
  282.               cp++;
  283.             }
  284.             goto lab26;
  285.           }
  286.         }
  287.  
  288.           if ( cat != 11 )
  289.         --cp;
  290.  
  291.           { integer k;
  292.         k = cp - buffer;
  293.  
  294.         if ( k > curinput .locfield + 1 ) {
  295.           curcs = idlookup(curinput.locfield, k-curinput.locfield);
  296.           curinput.locfield = k ;
  297.           goto lab40 ;
  298.         }
  299.           }
  300.  
  301.         } else {
  302.  
  303.           if ( *cp == (halfword) tmp_curchr )
  304.         if ( cat == 7 )
  305.         if ( cp < endp ) {
  306.           c = *(cp + 1);
  307.           if ( c < 128 ) {
  308.             d = 2 ;
  309.             if ( ( c >= 48 && c <= 57 ) || ( c >= 97 && c <= 102 ) )
  310.               if ( cp + 2 <= endp ) {
  311.             cc = *(cp + 2 );
  312.             if ( ( cc >= 48 && cc <= 57 )
  313.                 || ( cc >= 97 && cc <= 102 ) )
  314.               incr ( d ) ;
  315.               }
  316.           { halfword tmp_curchr;
  317.             if ( d > 2 ) {
  318.               tmp_curchr = c - ( (c <= 57) ? 48 : 87);
  319.               tmp_curchr = 16*tmp_curchr + cc - ((cc <= 57) ? 48 : 87);
  320.               *(cp - 1) = tmp_curchr;
  321.             } else 
  322.               *(cp - 1) = c + ( (c < 64) ? +64 : -64 );
  323.           }
  324.             curinput .limitfield -= d;  endp -= d;
  325.             first -= d;
  326.             while ( cp <= endp ) {
  327.               *cp = *(cp + d);
  328.               cp++;
  329.             }
  330.             goto lab26 ;
  331.         }
  332.           }
  333.         }
  334.  
  335.         curcs = singlebase + buffer [ curinput .locfield ];
  336.         incr ( curinput .locfield ) ;
  337.       }
  338.  
  339. lab40:      curcmd = r_curcmd = eqtype ( curcs );
  340.       curchr = equiv ( curcs );
  341.       if ( r_curcmd >= outercall ) {
  342.         checkoutervalidity () ;
  343.         r_curcmd = curcmd;
  344.       }
  345.     }
  346.     break ;
  347.       case 13 :        /* active_char */
  348.     {
  349.       curinput .statefield = 1 ;
  350.       curcs = tmp_curchr + activebase ;
  351.       curcmd = r_curcmd = eqtype ( curcs ) ;
  352.       curchr = equiv ( curcs ) ;
  353.       if ( r_curcmd >= outercall ) {
  354.         checkoutervalidity () ;
  355.         r_curcmd = curcmd;
  356.       }
  357.     }
  358.     break ;
  359.       case 7 :        /* sup_mark */
  360.     {
  361.       if( (halfword)tmp_curchr == buffer [ curinput .locfield ] ) {
  362.         if( curinput .locfield < curinput .limitfield ) {
  363.           c = buffer [ curinput .locfield + 1 ] ;
  364.           if ( c < 128 ) {
  365.         curinput .locfield = curinput .locfield + 2 ;
  366.         if ( (c >= 48 && c <= 57) || (c >= 97 && c <= 102) ) {
  367.           if ( curinput .locfield <= curinput .limitfield ) {
  368.             cc = buffer [ curinput .locfield ] ;
  369.             if ( (cc >= 48 && cc <= 57 ) || (cc >= 97 && cc <= 102) ) {
  370.               incr ( curinput .locfield ) ;
  371.               tmp_curchr = 16 * ( c - ( (c <= 57) ? 48 : 87 ) );
  372.               tmp_curchr = tmp_curchr + cc - ( (cc <= 57) ? 48 : 87 );
  373.               curchr = tmp_curchr;
  374.               goto lab21 ;
  375.             }
  376.           }
  377.         }
  378.         tmp_curchr = c + ( (c < 64) ? +64 : -64 );
  379.         curchr = tmp_curchr;
  380.         goto lab21 ;
  381.           }
  382.         }
  383.       }
  384.       curinput .statefield = 1 ;
  385.       curchr = tmp_curchr;
  386.       curcmd = r_curcmd;
  387.     }
  388.     break ;
  389.       case 15 :        /* invalid_char */
  390.     {
  391.       curcmd = r_curcmd;
  392.       curchr = tmp_curchr;
  393.  
  394.       print_err("Text line contains an invalid character");
  395.       zhelp1( STR_H_AFUNNY_SYMBOL );
  396.       deletionsallowed = false ;
  397.       error () ;
  398.       deletionsallowed = true ;
  399.       goto lab20 ;
  400.     }
  401.     break ;
  402.       case 10 :        /* spacer */
  403.     if( curinput.statefield == 1 ) {
  404.       curinput.statefield = 17;
  405.       curchr = 32;
  406.       curcmd = r_curcmd;
  407.       return r_curcmd;
  408.     }
  409.     goto lab25;
  410.     break;
  411.       case 5 :        /* carret + midline */
  412.     curinput .locfield = curinput .limitfield + 1 ;
  413.     if( curinput.statefield == 1 ) {
  414.       curcmd = 10 ;
  415.       curchr = 32 ;
  416.       return 10;
  417.     } else if( curinput.statefield == 17 ) {  /* carret + skipblanks */
  418.       goto getnewline; /* goto lab25; */
  419.     } else {        /* carret + newline */
  420.       curcs = parloc ;
  421.       curcmd = r_curcmd = eqtype ( curcs ) ;
  422.       curchr = equiv ( curcs ) ;
  423.       if ( r_curcmd >= outercall ) {
  424.         checkoutervalidity () ;
  425.         r_curcmd = curcmd;
  426.       }
  427.     }
  428.     break ;
  429.       case 14 :        /* comment */
  430.     curinput .locfield = curinput .limitfield + 1 ;
  431.     goto getnewline; /* goto lab25; */
  432.     break ;
  433.  
  434.       case 4 :        /* tabmark + (skipblanks,newline) */
  435.     curinput .statefield = 1 ;
  436.     curchr = tmp_curchr;
  437.     curcmd = r_curcmd;
  438.     if( alignstate != 0 ) {        /* siehe unten [342.] */
  439.       return r_curcmd;
  440.     }
  441.     break;
  442.  
  443.       case 1 :        /* leftbrace */
  444.     incr ( alignstate ) ;
  445.     curinput .statefield = 1 ;
  446.     curchr = tmp_curchr;
  447.     curcmd = r_curcmd;
  448.     return r_curcmd;
  449.     break ;
  450.  
  451.       case 2 :        /* rightbrace */
  452.     decr ( alignstate ) ;
  453.     /* Fall through */
  454.  
  455.       case 3 :
  456.       case 6 :
  457.       case 8 :
  458.       case 11 :
  459.       case 12 :
  460.     curinput .statefield = 1 ;
  461.     curchr = tmp_curchr;
  462.     curcmd = r_curcmd;
  463.     return r_curcmd;
  464.     break ;
  465.  
  466.       default:
  467.     curchr = tmp_curchr;
  468.     curcmd = r_curcmd;
  469.     break ;
  470.       }
  471.  
  472.     } else {
  473.  
  474. getnewline:
  475.  
  476. #ifdef DOSTAT
  477. printf("\n STAT(get_next): calls: %d  external: %d  token: %d  aligntest: %d\n",
  478. calls, externalfile, tokenlistno, aligntest);
  479. #endif
  480.  
  481.       curinput .statefield = 33 ;
  482.       if ( curinput .namefield > 17 ) {
  483.     incr ( line ) ;
  484.     first = curinput .startfield ;
  485.     if ( ! forceeof ) {
  486.       if ( inputln ( inputfile [ curinput .indexfield ] , true ) ) {
  487.         curinput.limitfield = last;    /* (br) added */
  488.         if ( pausing > 0 )        /* (br) added */
  489.           firmuptheline () ;
  490.       } else
  491.         forceeof = true ;
  492.     }
  493.     if ( forceeof ) {
  494.       printchar ( 41 ) ;
  495.       decr ( openparens ) ;
  496.       flush ( stdout ) ;
  497.       forceeof = false ;
  498.       endfilereading () ;
  499.       checkoutervalidity () ;
  500.       goto lab20 ;
  501.     }
  502.     if ( endlinecharinactive () )
  503.       decr ( curinput .limitfield ) ;
  504.     else
  505.       buffer [ curinput .limitfield ] = endlinechar ;
  506.     first = curinput .limitfield + 1 ;
  507.     curinput .locfield = curinput .startfield ;
  508.       } else {
  509.     if ( ! ( curinput .namefield == 0 ) ) {
  510.       curcmd = 0 ;
  511.       curchr = 0 ;
  512.       return 0;    /* curcmd */
  513.     }
  514.     if ( inputptr > 0 ) {
  515.       endfilereading () ;
  516.       goto lab20 ;
  517.     }
  518.     if ( selector < logonly )
  519.       openlogfile () ;
  520.     if ( interaction > nonstopmode ) {
  521.       if ( endlinecharinactive () )
  522.         incr ( curinput .limitfield ) ;
  523.       if ( curinput .limitfield == curinput .startfield )
  524.         c_printnl("(Please type a command or say `\\end')");
  525.       println () ;
  526.       first = curinput .startfield ;
  527.       terminput("*");
  528.       curinput .limitfield = last ;
  529.       if ( endlinecharinactive () )
  530.         decr ( curinput .limitfield ) ;
  531.       else
  532.         buffer [ curinput .limitfield ] = endlinechar ;
  533.       first = curinput .limitfield + 1 ;
  534.       curinput .locfield = curinput .startfield ;
  535.     } else
  536.       fatalerror( STR_H_FE_JOBAB_NO );
  537.       }
  538.       if ( interrupt != 0 )
  539.     pauseforinstructions () ;
  540.       goto lab25 ;
  541.     }
  542.  
  543.   } else if ( curinput .locfield == 0 ) {  /* 357. Input from token list */
  544.  
  545.     endtokenlist () ;
  546.     goto lab20 ;
  547.  
  548.   } else {
  549.  
  550. #ifndef REG_A5
  551.     register memoryword *mem = zmem;
  552. #endif
  553.     register halfword *t;
  554.  
  555. #ifdef DOSTAT
  556. tokenlistno++;
  557. #endif
  558.     t = &(info ( curinput.locfield )) ;
  559.     curinput.locfield = link ( curinput.locfield ) ;
  560.     if ( *t >= cstokenflag ) {
  561.       curcs = *t - cstokenflag ;
  562.       curcmd = r_curcmd = eqtype ( curcs ) ;
  563.       curchr = equiv ( curcs ) ;
  564.       if ( r_curcmd >= outercall )
  565.     if ( r_curcmd == dontexpand ) {
  566.       curcs = info ( curinput .locfield ) - cstokenflag ;
  567.       curinput .locfield = 0 ;
  568.       curcmd = r_curcmd = eqtype ( curcs ) ;
  569.       curchr = equiv ( curcs ) ;
  570.       if ( r_curcmd > maxcommand ) {
  571.         curcmd = r_curcmd = 0 ;
  572.         curchr = noexpandflag ;
  573.       }
  574.     } else {
  575.       checkoutervalidity () ;
  576.       r_curcmd = curcmd;
  577.     }
  578.     } else {
  579. #if 1
  580.       register unsigned char *cp = (unsigned char *)t + sizeof(halfword)-2;
  581.       curcmd = r_curcmd = *cp++;
  582.       curchr = *cp;
  583. #else
  584.       curcmd = r_curcmd = t / 256 ;
  585.       curchr = t % 256 ;
  586. #endif
  587.       switch ( r_curcmd ) {
  588.       case 0 :
  589.     return r_curcmd;
  590.       case 1 :
  591.     incr ( alignstate ) ;
  592.     return r_curcmd;
  593.       case 2 :
  594.     decr ( alignstate ) ;
  595.     return r_curcmd;
  596.       case 4 :
  597.     if ( alignstate != 0 )    /* siehe unten [342.] */
  598.       return r_curcmd;
  599.     break;
  600.       case 5 :
  601.     begintokenlist ( paramstack [paramstart + curchr - 1] , parameter ) ;
  602.     goto lab20 ;
  603.     break ;
  604.       default:
  605.     return r_curcmd;
  606.     break ;
  607.       }
  608.     }
  609.   }
  610.  
  611.  
  612. #ifdef DOSTAT
  613. aligntest++;
  614. #endif
  615.  
  616.   /* 342. If an alignment entry ... [curcmd == 4 || curcmd == 5] */
  617.  
  618.   if ( r_curcmd <= 5 )
  619.     if ( r_curcmd >= 4 )
  620.       if ( alignstate == 0 ) {
  621.  
  622. #ifndef REG_A5
  623.         register memoryword *mem = zmem;  
  624. #endif
  625.  
  626.     if ( scannerstatus == aligning )
  627.        fatalerror( STR_H_FE_INTERWOVEN );
  628.     curcmd = extrainfo ( curalign ) ;
  629.     extrainfo ( curalign ) = curchr ;
  630.     if ( curcmd == omit )
  631.        begintokenlist ( omittemplate , vtemplate ) ;
  632.     else
  633.        begintokenlist ( vpart ( curalign ) , vtemplate ) ;
  634.     alignstate = 1000000L ;
  635.     goto lab20 ;
  636.       }
  637.  
  638.   return r_curcmd;
  639. }
  640.  
  641. #undef curinput
  642.