DataMuseum.dk

Presents historical artifacts from the history of:

DKUUG/EUUG Conference tapes

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about DKUUG/EUUG Conference tapes

Excavated with: AutoArchaeologist - Free & Open Source Software.


top - metrics - download
Index: T l

⟦623903059⟧ TextFile

    Length: 20351 (0x4f7f)
    Types: TextFile
    Names: »lex.yy.c«

Derivation

└─⟦b20c6495f⟧ Bits:30007238 EUUGD18: Wien-båndet, efterår 1987
    └─⟦this⟧ »EUUGD18/General/Repunsel/lex.yy.c« 

TextFile

# include "stdio.h"
# define U(x) x
# define NLSTATE yyprevious=YYNEWLINE
# define BEGIN yybgin = yysvec + 1 +
# define INITIAL 0
# define YYLERR yysvec
# define YYSTATE (yyestate-yysvec-1)
# define YYOPTIM 1
# define YYLMAX 200
# define output(c) putc(c,yyout)
# define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getc(yyin))==10?(yylineno++,yytchar):yytchar)==EOF?0:yytchar)
# define unput(c) {yytchar= (c);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;}
# define yymore() (yymorfg=1)
# define ECHO fprintf(yyout, "%s",yytext)
# define REJECT { nstr = yyreject(); goto yyfussy;}
int yyleng; extern char yytext[];
int yymorfg;
extern char *yysptr, yysbuf[];
int yytchar;
FILE *yyin = {stdin}, *yyout = {stdout};
extern int yylineno;
struct yysvf { 
    struct yywork *yystoff;
    struct yysvf *yyother;
    int *yystops;};
struct yysvf *yyestate;
extern struct yysvf yysvec[], *yybgin;
     char buf[128];

# define YYNEWLINE 10
yylex(){
int nstr; extern int yyprevious;
while((nstr = yylook()) >= 0)
yyfussy: switch(nstr){
case 0:
if(yywrap()) return(0); break;
case 1:
           return("ANT");
break;
case 2:
             return("ANT");
break;
case 3:
      return("WOODEN");
break;
case 4:
           return("WOOD");
break;
case 5:
            return("ROOT");
break;
case 6:
           return("STUMP");
break;
case 7:
            return("TWIG");
break;
case 8:
            return("TWIG");
break;
case 9:
          return("BRANCH");
break;
case 10:
            return("BARK");
break;
case 11:
        return("LETTUCE");
break;
case 12:
           return("'EAR ");
break;
case 13:
            return(" 'EAR ");
break;
case 14:
           return("'EAR ");
break;
case 15:
            return(" 'EAR ");
break;
case 16:
             return("LOG");
break;
case 17:
            return("LOG");
break;
case 18:
           return("LEAF");
break;
case 19:
            return("LEAF");
break;
case 20:
            return("TREE");
break;
case 21:
             return("SAP");
break;
case 22:
            return("BUSH");
break;
case 23:
           return("HEDGE");
break;
case 24:
           return("FLOWER");
break;
case 25:
          return("FLOWER");
break;
case 26:
          return("POD'n");
break;
case 27:
         return("POD'ner");
break;
case 28:
             return("POD");
break;
case 29:
           return("SOIL ");
break;
case 30:
            return("SOIL");
break;
case 31:
            return("CARROT");
break;
case 32:
          return("CARROT");
break;
case 33:
             return("PUN");
break;
case 34:
           return("A FRAYED");
break;
case 35:
          return("FUNGI");
break;
case 36:
          return("FUNGI");
break;
case 37:
          return("FUNGI");
break;
case 38:
             return("WHEY");
break;
case 39:
            return("SPORE");
break;
case 40:
          return("LICHEN");
break;
case 41:
          return("NATURE");
break;
case 42:
            return("MOSS");
break;
case 43:
            return("MOLD");
break;
case 44:
             return("PUN");
break;
case 45:
            return("SLAW");
break;
case 46:
             return("KNOT");
break;
case 47:
           return("GRAIN");
break;
case 48:
              return("DEW");
break;
case 49:
                return("PINE");
break;
case 50:
       return("WALNUT");
break;
case 51:
             return("HAY");
break;
case 52:
        return("ORANGE");
break;
case 53:
           return("PEAS");
break;
case 54:
           return("PEAS");
break;
case 55:
          return("PEAS");
break;
case 56:
            return("BEAN");
break;
case 57:
           return("CLOVER");
break;
case 58:
            return("PEEL");
break;
case -1:
break;
default:
fprintf(yyout,"bad switch yylook %d",nstr);
} return(0); }
/* end of yylex */


int yyvstop[] = {
0,

1,
0,

48,
0,

2,
0,

44,
0,

51,
0,

16,
0,

46,
0,

28,
0,

33,
0,

21,
0,

29,
0,

38,
0,

44,
0,

49,
0,

10,
0,

56,
0,

22,
0,

31,
0,

19,
0,

17,
0,

43,
0,

42,
0,

58,
0,

39,
0,

5,
0,

45,
0,

30,
0,

20,
0,

7,
0,

8,
0,

24,
0,

47,
0,

23,
0,

18,
0,

53,
0,

54,
0,

6,
0,

4,
0,

13,
0,

15,
0,

57,
0,

34,
0,

52,
0,

9,
0,

32,
0,

25,
0,

12,
0,

14,
0,

11,
0,

40,
0,

41,
0,

26,
0,

55,
0,

37,
0,

36,
0,

27,
0,

50,
0,

35,
0,

3,
0,
0};
# define YYTYPE int
struct yywork { YYTYPE verify, advance; } yycrank[] = {
0,0,     0,0, 0,0, 0,0, 
0,0,     0,0, 0,0, 0,0, 
0,0,     0,0, 0,0, 0,0, 
0,0,     0,0, 0,0, 0,0, 
0,0,     0,0, 0,0, 0,0, 
0,0,     0,0, 0,0, 0,0, 
0,0,     0,0, 0,0, 0,0, 
0,0,     0,0, 0,0, 0,0, 
0,0,     1,3, 0,0, 0,0, 
0,0,     0,0, 0,0, 1,4, 
0,0,     0,0, 0,0, 0,0, 
0,0,     0,0, 0,0, 0,0, 
0,0,     0,0, 0,0, 0,0, 
0,0,     0,0, 0,0, 0,0, 
0,0,     0,0, 0,0, 0,0, 
0,0,     0,0, 0,0, 0,0, 
0,0,     0,0, 1,5, 1,6, 
1,7,     1,8, 0,0, 1,9, 
1,10,    1,11,     0,0, 0,0, 
0,0,     1,12,     1,13,     1,14,     
0,0,     1,15,     0,0, 1,16,     
1,17,    1,18,     0,0, 0,0, 
1,19,    0,0, 0,0, 0,0, 
0,0,     0,0, 0,0, 0,0, 
0,0,     0,0, 1,5, 1,6, 
1,7,     1,8, 6,30,     1,20,     
1,10,    1,21,     6,31,     3,25,     
7,34,    1,12,     1,13,     1,14,     
8,35,    1,22,     3,26,     1,23,     
1,17,    1,24,     5,27,     6,32,     
1,19,    10,38,    6,33,     9,36,     
11,39,   12,40,    5,28,     13,43,    
14,45,   12,41,    5,29,     16,53,    
9,37,    13,44,    17,54,    12,42,    
15,47,   20,63,    18,58,    21,64,    
15,48,   22,65,    14,46,    18,59,    
15,49,   17,55,    23,53,    15,50,    
17,56,   23,66,    15,51,    19,60,    
24,67,   17,57,    25,68,    26,69,    
15,52,   27,70,    19,61,    28,71,    
29,72,   30,73,    31,74,    32,75,    
33,76,   19,62,    34,77,    36,78,    
37,79,   38,80,    39,81,    40,85,    
41,87,   39,82,    42,88,    43,90,    
44,91,   45,92,    46,93,    47,94,    
48,95,   42,89,    49,96,    50,97,    
51,98,   52,100,   53,101,   39,83,    
54,102,  55,103,   40,86,    56,104,   
57,106,  58,107,   39,84,    51,99,    
59,109,  58,108,   60,110,   61,111,   
62,112,  63,113,   64,82,    65,96,    
66,108,  67,107,   69,117,   68,115,   
70,118,  72,119,   73,120,   74,121,   
65,114,  75,122,   76,123,   77,124,   
78,126,  79,128,   78,127,   80,129,   
81,130,  82,131,   83,132,   64,84,    
68,116,  85,133,   86,135,   87,136,   
77,125,  89,137,   90,138,   91,139,   
92,140,  94,141,   95,143,   96,145,   
97,146,  99,147,   101,148,  103,149,  
105,150, 85,134,   106,151,  95,144,   
107,152, 108,153,  109,154,  111,155,  
112,156, 94,142,   113,157,  115,158,  
116,159, 117,160,  118,161,  119,162,  
122,163, 125,164,  126,165,  127,166,  
128,167, 129,169,  130,170,  131,171,  
56,105,  132,172,  134,173,  135,174,  
136,175, 140,176,  141,177,  142,178,  
143,179, 145,180,  146,181,  151,182,  
155,183, 156,184,  157,185,  158,186,  
159,187, 160,188,  161,189,  162,190,  
163,191, 164,192,  166,193,  167,194,  
168,195, 170,196,  172,197,  174,198,  
128,168, 175,199,  176,200,  177,201,  
178,202, 181,203,  183,204,  184,205,  
185,206, 194,207,  195,208,  202,209,  
204,210, 205,211,  206,212,  211,213,  
0,0};
struct yysvf yysvec[] = {
0,  0,   0,
yycrank+1,    0,        0,   
yycrank+0,    yysvec+1, 0,   
yycrank+3,    0,        0,   
yycrank+0,    0,        yyvstop+1,
yycrank+16,   0,        0,   
yycrank+5,    0,        0,   
yycrank+11,   0,        0,   
yycrank+1,    0,        0,   
yycrank+15,   0,        0,   
yycrank+7,    0,        0,   
yycrank+23,   0,        0,   
yycrank+24,   0,        0,   
yycrank+16,   0,        0,   
yycrank+31,   0,        0,   
yycrank+39,   0,        0,   
yycrank+20,   0,        0,   
yycrank+37,   0,        0,   
yycrank+24,   0,        0,   
yycrank+54,   0,        0,   
yycrank+20,   yysvec+9, 0,   
yycrank+38,   0,        0,   
yycrank+36,   yysvec+15,     0,   
yycrank+35,   0,        0,   
yycrank+38,   yysvec+18,     0,   
yycrank+53,   0,        0,   
yycrank+37,   0,        0,   
yycrank+43,   0,        0,   
yycrank+59,   0,        0,   
yycrank+59,   0,        0,   
yycrank+47,   0,        0,   
yycrank+61,   0,        0,   
yycrank+66,   0,        0,   
yycrank+49,   0,        0,   
yycrank+52,   0,        0,   
yycrank+0,    0,        yyvstop+3,
yycrank+56,   0,        0,   
yycrank+58,   0,        0,   
yycrank+72,   0,        0,   
yycrank+73,   0,        0,   
yycrank+74,   0,        0,   
yycrank+65,   0,        0,   
yycrank+71,   0,        0,   
yycrank+67,   0,        0,   
yycrank+61,   0,        0,   
yycrank+61,   0,        0,   
yycrank+62,   0,        0,   
yycrank+65,   0,        0,   
yycrank+83,   0,        0,   
yycrank+81,   0,        0,   
yycrank+82,   0,        0,   
yycrank+84,   0,        0,   
yycrank+75,   0,        0,   
yycrank+75,   0,        0,   
yycrank+76,   0,        0,   
yycrank+78,   0,        0,   
yycrank+159,  0,        0,   
yycrank+75,   0,        0,   
yycrank+92,   0,        0,   
yycrank+91,   0,        0,   
yycrank+77,   0,        0,   
yycrank+78,   0,        0,   
yycrank+83,   0,        0,   
yycrank+91,   0,        0,   
yycrank+102,  0,        0,   
yycrank+102,  0,        0,   
yycrank+99,   0,        0,   
yycrank+104,  0,        0,   
yycrank+110,  0,        0,   
yycrank+105,  0,        0,   
yycrank+111,  0,        0,   
yycrank+0,    0,        yyvstop+5,
yycrank+99,   0,        0,   
yycrank+103,  0,        0,   
yycrank+101,  0,        0,   
yycrank+103,  0,        0,   
yycrank+110,  0,        0,   
yycrank+114,  0,        0,   
yycrank+99,   0,        0,   
yycrank+185,  0,        yyvstop+7,
yycrank+114,  0,        0,   
yycrank+106,  0,        0,   
yycrank+118,  0,        0,   
yycrank+121,  0,        0,   
yycrank+0,    0,        yyvstop+9,
yycrank+123,  0,        0,   
yycrank+194,  0,        0,   
yycrank+122,  0,        0,   
yycrank+0,    0,        yyvstop+11,
yycrank+126,  0,        0,   
yycrank+130,  0,        0,   
yycrank+115,  0,        0,   
yycrank+115,  0,        0,   
yycrank+0,    0,        yyvstop+13,
yycrank+133,  0,        0,   
yycrank+135,  0,        0,   
yycrank+136,  0,        0,   
yycrank+139,  0,        0,   
yycrank+0,    0,        yyvstop+15,
yycrank+123,  0,        0,   
yycrank+0,    0,        yyvstop+17,
yycrank+122,  0,        0,   
yycrank+0,    0,        yyvstop+19,
yycrank+120,  0,        0,   
yycrank+0,    0,        yyvstop+21,
yycrank+132,  0,        0,   
yycrank+133,  0,        0,   
yycrank+143,  0,        0,   
yycrank+142,  0,        0,   
yycrank+143,  0,        0,   
yycrank+0,    0,        yyvstop+23,
yycrank+215,  0,        0,   
yycrank+140,  0,        0,   
yycrank+218,  0,        yyvstop+25,
yycrank+0,    0,        yyvstop+27,
yycrank+137,  0,        0,   
yycrank+151,  0,        0,   
yycrank+139,  0,        0,   
yycrank+149,  0,        0,   
yycrank+216,  0,        0,   
yycrank+0,    0,        yyvstop+29,
yycrank+0,    0,        yyvstop+31,
yycrank+157,  0,        0,   
yycrank+0,    0,        yyvstop+33,
yycrank+0,    0,        yyvstop+35,
yycrank+146,  0,        0,   
yycrank+144,  0,        0,   
yycrank+158,  0,        0,   
yycrank+189,  0,        0,   
yycrank+151,  0,        0,   
yycrank+230,  0,        0,   
yycrank+162,  0,        0,   
yycrank+233,  0,        0,   
yycrank+0,    0,        yyvstop+37,
yycrank+165,  0,        0,   
yycrank+150,  0,        0,   
yycrank+158,  0,        0,   
yycrank+0,    0,        yyvstop+39,
yycrank+0,    0,        yyvstop+41,
yycrank+0,    0,        yyvstop+43,
yycrank+155,  0,        0,   
yycrank+159,  0,        0,   
yycrank+161,  0,        0,   
yycrank+171,  0,        0,   
yycrank+0,    0,        yyvstop+45,
yycrank+172,  0,        0,   
yycrank+159,  0,        0,   
yycrank+0,    0,        yyvstop+47,
yycrank+0,    0,        yyvstop+49,
yycrank+0,    0,        yyvstop+51,
yycrank+0,    0,        yyvstop+53,
yycrank+163,  0,        0,   
yycrank+0,    0,        yyvstop+55,
yycrank+0,    0,        yyvstop+57,
yycrank+0,    0,        yyvstop+59,
yycrank+166,  0,        0,   
yycrank+177,  0,        0,   
yycrank+175,  0,        0,   
yycrank+247,  0,        0,   
yycrank+248,  0,        0,   
yycrank+249,  0,        0,   
yycrank+182,  0,        0,   
yycrank+167,  0,        0,   
yycrank+180,  0,        0,   
yycrank+169,  0,        0,   
yycrank+0,    0,        yyvstop+61,
yycrank+172,  0,        0,   
yycrank+170,  0,        0,   
yycrank+171,  0,        0,   
yycrank+0,    0,        yyvstop+63,
yycrank+257,  0,        0,   
yycrank+0,    0,        yyvstop+65,
yycrank+258,  0,        0,   
yycrank+0,    0,        yyvstop+67,
yycrank+176,  0,        0,   
yycrank+190,  0,        0,   
yycrank+193,  0,        0,   
yycrank+185,  0,        0,   
yycrank+195,  0,        0,   
yycrank+0,    0,        yyvstop+69,
yycrank+0,    0,        yyvstop+71,
yycrank+196,  0,        0,   
yycrank+0,    0,        yyvstop+73,
yycrank+187,  0,        0,   
yycrank+189,  0,        yyvstop+75,
yycrank+183,  0,        0,   
yycrank+0,    0,        yyvstop+77,
yycrank+0,    0,        yyvstop+79,
yycrank+0,    0,        yyvstop+81,
yycrank+0,    0,        yyvstop+83,
yycrank+0,    0,        yyvstop+85,
yycrank+0,    0,        yyvstop+87,
yycrank+0,    0,        yyvstop+89,
yycrank+0,    0,        yyvstop+91,
yycrank+180,  0,        0,   
yycrank+181,  0,        0,   
yycrank+0,    0,        yyvstop+93,
yycrank+0,    0,        yyvstop+95,
yycrank+0,    0,        yyvstop+97,
yycrank+0,    0,        yyvstop+99,
yycrank+0,    0,        yyvstop+101,
yycrank+0,    0,        yyvstop+103,
yycrank+189,  0,        0,   
yycrank+0,    0,        yyvstop+105,
yycrank+188,  0,        0,   
yycrank+266,  0,        0,   
yycrank+185,  0,        0,   
yycrank+0,    0,        yyvstop+107,
yycrank+0,    0,        yyvstop+109,
yycrank+0,    0,        yyvstop+111,
yycrank+0,    0,        yyvstop+113,
yycrank+191,  0,        0,   
yycrank+0,    0,        yyvstop+115,
yycrank+0,    0,        yyvstop+117,
0,  0,   0};
struct yywork *yytop = yycrank+307;
struct yysvf *yybgin = yysvec+1;
char yymatch[] = {
00  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
01  ,'A' ,'B' ,'C' ,'D' ,01  ,'F' ,'G' ,
'H' ,01  ,01  ,01  ,'L' ,'M' ,'N' ,01  ,
'P' ,01  ,'R' ,'S' ,'T' ,01  ,01  ,'W' ,
01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
01  ,'A' ,'B' ,'C' ,'D' ,01  ,'F' ,'G' ,
'H' ,01  ,01  ,01  ,'L' ,'M' ,'N' ,01  ,
'P' ,01  ,'r' ,'S' ,'t' ,01  ,01  ,'W' ,
01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
0};
char yyextra[] = {
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0};
#ident   "@(#)libl:lib/ncform     1.3"
int yylineno =1;
# define YYU(x) x
# define NLSTATE yyprevious=YYNEWLINE
char yytext[YYLMAX];
struct yysvf *yylstate [YYLMAX], **yylsp, **yyolsp;
char yysbuf[YYLMAX];
char *yysptr = yysbuf;
int *yyfnd;
extern struct yysvf *yyestate;
int yyprevious = YYNEWLINE;
yylook(){
    register struct yysvf *yystate, **lsp;
    register struct yywork *yyt;
    struct yysvf *yyz;
    int yych, yyfirst;
    struct yywork *yyr;
# ifdef LEXDEBUG
    int debug;
# endif
    char *yylastch;
    /* start off machines */
# ifdef LEXDEBUG
    debug = 0;
# endif
    yyfirst=1;
    if (!yymorfg)
         yylastch = yytext;
    else {
         yymorfg=0;
         yylastch = yytext+yyleng;
         }
    for(;;){
         lsp = yylstate;
         yyestate = yystate = yybgin;
         if (yyprevious==YYNEWLINE) yystate++;
         for (;;){
# ifdef LEXDEBUG
              if(debug)fprintf(yyout,"state %d\n",yystate-yysvec-1);
# endif
              yyt = yystate->yystoff;
              if(yyt == yycrank && !yyfirst){  /* may not be any transitions */
                   yyz = yystate->yyother;
                   if(yyz == 0)break;
                   if(yyz->yystoff == yycrank)break;
                   }
              *yylastch++ = yych = input();
              yyfirst=0;
         tryagain:
# ifdef LEXDEBUG
              if(debug){
                   fprintf(yyout,"char ");
                   allprint(yych);
                   putchar('\n');
                   }
# endif
              yyr = yyt;
              if ( (int)yyt > (int)yycrank){
                   yyt = yyr + yych;
                   if (yyt <= yytop && yyt->verify+yysvec == yystate){
                        if(yyt->advance+yysvec == YYLERR)  /* error transitions */
                             {unput(*--yylastch);break;}
                        *lsp++ = yystate = yyt->advance+yysvec;
                        goto contin;
                        }
                   }
# ifdef YYOPTIM
              else if((int)yyt < (int)yycrank) {      /* r < yycrank */
                   yyt = yyr = yycrank+(yycrank-yyt);
# ifdef LEXDEBUG
                   if(debug)fprintf(yyout,"compressed state\n");
# endif
                   yyt = yyt + yych;
                   if(yyt <= yytop && yyt->verify+yysvec == yystate){
                        if(yyt->advance+yysvec == YYLERR)  /* error transitions */
                             {unput(*--yylastch);break;}
                        *lsp++ = yystate = yyt->advance+yysvec;
                        goto contin;
                        }
                   yyt = yyr + YYU(yymatch[yych]);
# ifdef LEXDEBUG
                   if(debug){
                        fprintf(yyout,"try fall back character ");
                        allprint(YYU(yymatch[yych]));
                        putchar('\n');
                        }
# endif
                   if(yyt <= yytop && yyt->verify+yysvec == yystate){
                        if(yyt->advance+yysvec == YYLERR)  /* error transition */
                             {unput(*--yylastch);break;}
                        *lsp++ = yystate = yyt->advance+yysvec;
                        goto contin;
                        }
                   }
              if ((yystate = yystate->yyother) && (yyt= yystate->yystoff) != yycrank){
# ifdef LEXDEBUG
                   if(debug)fprintf(yyout,"fall back to state %d\n",yystate-yysvec-1);
# endif
                   goto tryagain;
                   }
# endif
              else
                   {unput(*--yylastch);break;}
         contin:
# ifdef LEXDEBUG
              if(debug){
                   fprintf(yyout,"state %d char ",yystate-yysvec-1);
                   allprint(yych);
                   putchar('\n');
                   }
# endif
              ;
              }
# ifdef LEXDEBUG
         if(debug){
              fprintf(yyout,"stopped at %d with ",*(lsp-1)-yysvec-1);
              allprint(yych);
              putchar('\n');
              }
# endif
         while (lsp-- > yylstate){
              *yylastch-- = 0;
              if (*lsp != 0 && (yyfnd= (*lsp)->yystops) && *yyfnd > 0){
                   yyolsp = lsp;
                   if(yyextra[*yyfnd]){          /* must backup */
                        while(yyback((*lsp)->yystops,-*yyfnd) != 1 && lsp > yylstate){
                             lsp--;
                             unput(*yylastch--);
                             }
                        }
                   yyprevious = YYU(*yylastch);
                   yylsp = lsp;
                   yyleng = yylastch-yytext+1;
                   yytext[yyleng] = 0;
# ifdef LEXDEBUG
                   if(debug){
                        fprintf(yyout,"\nmatch ");
                        sprint(yytext);
                        fprintf(yyout," action %d\n",*yyfnd);
                        }
# endif
                   return(*yyfnd++);
                   }
              unput(*yylastch);
              }
         if (yytext[0] == 0  /* && feof(yyin) */)
              {
              yysptr=yysbuf;
              return(0);
              }
         yyprevious = yytext[0] = input();
         if (yyprevious>0)
              output(yyprevious);
         yylastch=yytext;
# ifdef LEXDEBUG
         if(debug)putchar('\n');
# endif
         }
    }
yyback(p, m)
    int *p;
{
if (p==0) return(0);
while (*p)
    {
    if (*p++ == m)
         return(1);
    }
return(0);
}
    /* the following are only used in the lex library */
yyinput(){
    return(input());
    }
yyoutput(c)
  int c; {
    output(c);
    }
yyunput(c)
   int c; {
    unput(c);
    }