Return to awk.lx.l CVS log

Up to [CSRG BSD Unix] / 41BSD / cmd / awk

Annotation of 41BSD/cmd/awk/awk.lx.l, revision 1.1

1.1     ! root        1: %Start A str chc sc reg comment
        !             2: 
        !             3: %{
        !             4: #include       "awk.h"
        !             5: #include       "awk.def"
        !             6: #undef input   /* defeat lex */
        !             7: extern int     yylval;
        !             8: extern int     mustfld;
        !             9: 
        !            10: int    lineno  = 1;
        !            11: #ifdef DEBUG
        !            12: #      define  RETURN(x)       {if (dbg) ptoken(x); return(x); }
        !            13: #else
        !            14: #      define  RETURN(x)       return(x)
        !            15: #endif
        !            16: #define        CADD    cbuf[clen++]=yytext[0]; if(clen>=CBUFLEN-1) {yyerror("string too long", cbuf); BEGIN A;}
        !            17: #define        CBUFLEN 150
        !            18: char   cbuf[CBUFLEN];
        !            19: int    clen, cflag;
        !            20: %}
        !            21: 
        !            22: A      [a-zA-Z_]
        !            23: B      [a-zA-Z0-9_]
        !            24: D      [0-9]
        !            25: WS     [ \t]
        !            26: 
        !            27: %%
        !            28:        switch (yybgin-yysvec-1) {      /* witchcraft */
        !            29:        case 0:
        !            30:                BEGIN A;
        !            31:                break;
        !            32:        case sc:
        !            33:                BEGIN A;
        !            34:                RETURN('}');
        !            35:        }
        !            36: 
        !            37: <A>^\n         lineno++;
        !            38: <A>^{WS}*#.*\n lineno++;       /* strip comment lines */
        !            39: <A>{WS}                ;
        !            40: <A,reg>"\\"\n  lineno++;
        !            41: <A>"||"                RETURN(BOR);
        !            42: <A>BEGIN       RETURN(XBEGIN);
        !            43: <A>END         RETURN(XEND);
        !            44: <A>PROGEND     RETURN(EOF);
        !            45: <A>"&&"                RETURN(AND);
        !            46: <A>"!"         RETURN(NOT);
        !            47: <A>"!="                { yylval = NE; RETURN(RELOP); }
        !            48: <A>"~"         { yylval = MATCH; RETURN(MATCHOP); }
        !            49: <A>"!~"                { yylval = NOTMATCH; RETURN(MATCHOP); }
        !            50: <A>"<"         { yylval = LT; RETURN(RELOP); }
        !            51: <A>"<="                { yylval = LE; RETURN(RELOP); }
        !            52: <A>"=="                { yylval = EQ; RETURN(RELOP); }
        !            53: <A>">="                { yylval = GE; RETURN(RELOP); }
        !            54: <A>">"         { yylval = GT; RETURN(RELOP); }
        !            55: <A>">>"                { yylval = APPEND; RETURN(RELOP); }
        !            56: <A>"++"                { yylval = INCR; RETURN(INCR); }
        !            57: <A>"--"                { yylval = DECR; RETURN(DECR); }
        !            58: <A>"+="                { yylval = ADDEQ; RETURN(ASGNOP); }
        !            59: <A>"-="                { yylval = SUBEQ; RETURN(ASGNOP); }
        !            60: <A>"*="                { yylval = MULTEQ; RETURN(ASGNOP); }
        !            61: <A>"/="                { yylval = DIVEQ; RETURN(ASGNOP); }
        !            62: <A>"%="                { yylval = MODEQ; RETURN(ASGNOP); }
        !            63: <A>"="         { yylval = ASSIGN; RETURN(ASGNOP); }
        !            64: 
        !            65: <A>"$"{D}+     {       if (atoi(yytext+1)==0) {
        !            66:                                yylval = (hack)lookup("$record", symtab, 0);
        !            67:                                RETURN(STRING);
        !            68:                        } else {
        !            69:                                yylval = fieldadr(atoi(yytext+1));
        !            70:                                RETURN(FIELD);
        !            71:                        }
        !            72:                }
        !            73: <A>"$"{WS}*    { RETURN(INDIRECT); }
        !            74: <A>NF          { mustfld=1; yylval = (hack)setsymtab(yytext, NULL, 0.0, NUM, symtab); RETURN(VAR); }
        !            75: <A>({D}+("."?){D}*|"."{D}+)((e|E)("+"|-)?{D}+)?        {
        !            76:                yylval = (hack)setsymtab(yytext, NULL, atof(yytext), CON|NUM, symtab); RETURN(NUMBER); }
        !            77: <A>"}"{WS}*\n  { BEGIN sc; lineno++; RETURN(';'); }
        !            78: <A>"}"         { BEGIN sc; RETURN(';'); }
        !            79: <A>;\n         { lineno++; RETURN(';'); }
        !            80: <A>\n          { lineno++; RETURN(NL); }
        !            81: <A>while       RETURN(WHILE);
        !            82: <A>for         RETURN(FOR);
        !            83: <A>if          RETURN(IF);
        !            84: <A>else                RETURN(ELSE);
        !            85: <A>next                RETURN(NEXT);
        !            86: <A>exit                RETURN(EXIT);
        !            87: <A>break       RETURN(BREAK);
        !            88: <A>continue    RETURN(CONTINUE);
        !            89: <A>print       { yylval = PRINT; RETURN(PRINT); }
        !            90: <A>printf      { yylval = PRINTF; RETURN(PRINTF); }
        !            91: <A>sprintf     { yylval = SPRINTF; RETURN(SPRINTF); }
        !            92: <A>split       { yylval = SPLIT; RETURN(SPLIT); }
        !            93: <A>substr      RETURN(SUBSTR);
        !            94: <A>index       RETURN(INDEX);
        !            95: <A>in          RETURN(IN);
        !            96: <A>getline     RETURN(GETLINE);
        !            97: <A>length      { yylval = FLENGTH; RETURN(FNCN); }
        !            98: <A>log         { yylval = FLOG; RETURN(FNCN); }
        !            99: <A>int         { yylval = FINT; RETURN(FNCN); }
        !           100: <A>exp         { yylval = FEXP; RETURN(FNCN); }
        !           101: <A>sqrt                { yylval = FSQRT; RETURN(FNCN); }
        !           102: <A>{A}{B}*     { yylval = (hack)setsymtab(yytext, tostring(""), 0.0, STR|NUM, symtab); RETURN(VAR); }
        !           103: <A>\"          { BEGIN str; clen=0; }
        !           104: 
        !           105: <A>#           { BEGIN comment; }
        !           106: <comment>\n    { BEGIN A; lineno++; RETURN(NL); }
        !           107: <comment>.     ;
        !           108: 
        !           109: <A>.           { yylval = yytext[0]; RETURN(yytext[0]); }
        !           110: 
        !           111: <reg>"["       { BEGIN chc; clen=0; cflag=0; }
        !           112: <reg>"[^"      { BEGIN chc; clen=0; cflag=1; }
        !           113: 
        !           114: <reg>"?"       RETURN(QUEST);
        !           115: <reg>"+"       RETURN(PLUS);
        !           116: <reg>"*"       RETURN(STAR);
        !           117: <reg>"|"       RETURN(OR);
        !           118: <reg>"."       RETURN(DOT);
        !           119: <reg>"("       RETURN('(');
        !           120: <reg>")"       RETURN(')');
        !           121: <reg>"^"       RETURN('^');
        !           122: <reg>"$"       RETURN('$');
        !           123: <reg>\\{D}{D}{D}       { sscanf(yytext+1, "%o", &yylval); RETURN(CHAR); }
        !           124: <reg>\\.       {       if (yytext[1]=='n') yylval = '\n';
        !           125:                        else if (yytext[1] == 't') yylval = '\t';
        !           126:                        else yylval = yytext[1];
        !           127:                        RETURN(CHAR);
        !           128:                }
        !           129: <reg>"/"       { BEGIN A; unput('/'); }
        !           130: <reg>\n                { yyerror("newline in regular expression"); lineno++; BEGIN A; }
        !           131: <reg>.         { yylval = yytext[0]; RETURN(CHAR); }
        !           132: 
        !           133: <str>\"                { char *s; BEGIN A; cbuf[clen]=0; s = tostring(cbuf);
        !           134:                cbuf[clen] = ' '; cbuf[++clen] = 0;
        !           135:                yylval = (hack)setsymtab(cbuf, s, 0.0, CON|STR, symtab); RETURN(STRING); }
        !           136: <str>\n                { yyerror("newline in string"); lineno++; BEGIN A; }
        !           137: <str>"\\\""    { cbuf[clen++]='"'; }
        !           138: <str,chc>"\\"n { cbuf[clen++]='\n'; }
        !           139: <str,chc>"\\"t { cbuf[clen++]='\t'; }
        !           140: <str,chc>"\\\\"        { cbuf[clen++]='\\'; }
        !           141: <str>.         { CADD; }
        !           142: 
        !           143: <chc>"\\""]"   { cbuf[clen++]=']'; }
        !           144: <chc>"]"       { BEGIN reg; cbuf[clen]=0; yylval = (hack)tostring(cbuf);
        !           145:                if (cflag==0) { RETURN(CCL); }
        !           146:                else { RETURN(NCCL); } }
        !           147: <chc>\n                { yyerror("newline in character class"); lineno++; BEGIN A; }
        !           148: <chc>.         { CADD; }
        !           149: 
        !           150: %%
        !           151: 
        !           152: input()
        !           153: {
        !           154:        register c;
        !           155:        extern char *lexprog;
        !           156: 
        !           157:        if (yysptr > yysbuf)
        !           158:                c = U(*--yysptr);
        !           159:        else if (yyin == NULL)
        !           160:                c = *lexprog++;
        !           161:        else
        !           162:                c = getc(yyin);
        !           163:        if (c == '\n')
        !           164:                yylineno++;
        !           165:        else if (c == EOF)
        !           166:                c = 0;
        !           167:        return(c);
        !           168: }
        !           169: 
        !           170: startreg()
        !           171: {
        !           172:        BEGIN reg;
        !           173: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.