Return to grapl.l CVS log

Up to [Research Unix] / researchv9 / cmd / grap

Annotation of researchv9/cmd/grap/grapl.l, revision 1.1

1.1     ! root        1: %Start A str def thru sh
        !             2: 
        !             3: %{
        !             4: #undef input
        !             5: #undef unput
        !             6: #include <stdio.h>
        !             7: #include <ctype.h>
        !             8: #include "grap.h"
        !             9: #include "y.tab.h"
        !            10: 
        !            11: extern struct  symtab  symtab[];
        !            12: 
        !            13: #define        CADD    cbuf[clen++]=yytext[0]; if(clen>=CBUFLEN-1) {yyerror("string too long", cbuf); BEGIN A;}
        !            14: #define        CBUFLEN 1500
        !            15: char   cbuf[CBUFLEN];
        !            16: int    clen, cflag;
        !            17: int    c, delim, shcnt;
        !            18: %}
        !            19: 
        !            20: A      [a-zA-Z_]
        !            21: B      [a-zA-Z0-9_]
        !            22: D      [0-9]
        !            23: WS     [ \t]
        !            24: 
        !            25: %%
        !            26:        if (yybgin-yysvec-1 == 0) {     /* witchcraft */
        !            27:                BEGIN A;
        !            28:        }
        !            29: 
        !            30: <A>{WS}                ;
        !            31: <A>"\\"\n      ;
        !            32: <A>\n          return(ST);
        !            33: <A>";"         return(ST);
        !            34: 
        !            35: <A>line                return(yylval.i = LINE);
        !            36: <A>arrow       { yylval.i = ARROW; return(LINE); }
        !            37: <A>circle      return(yylval.i = CIRCLE);
        !            38: <A>frame       return(FRAME);
        !            39: <A>tick(s)?    return(TICKS);
        !            40: <A>grid(line)?(s)?     return(GRID);
        !            41: <A>coord(s)?   return(COORD);
        !            42: <A>log         return(LOG);
        !            43: <A>exp         return(EXP);
        !            44: <A>sin         return(SIN);
        !            45: <A>cos         return(COS);
        !            46: <A>atan2       return(ATAN2);
        !            47: <A>sqrt                return(SQRT);
        !            48: <A>rand                return(RAND);
        !            49: <A>max         return(MAX);
        !            50: <A>min         return(MIN);
        !            51: <A>int         return(INT);
        !            52: <A>print       return(PRINT);
        !            53: <A>sprintf     return(SPRINTF);
        !            54: <A>pic{WS}.*   { yylval.p = tostring(yytext+3); return(PIC); }
        !            55: <A>graph{WS}.* { yylval.p = tostring(yytext+5); return(GRAPH); }
        !            56: 
        !            57: <A>for         return(FOR);
        !            58: <A>^Endfor\n   { endfor(); }
        !            59: <A>do          { yylval.p = delimstr("loop body"); BEGIN A; return(DOSTR); }
        !            60: 
        !            61: <A>copy|include        { return(COPY); }
        !            62: <A>thru|through        { BEGIN thru; return(THRU); }
        !            63: <thru>{WS}+    ;
        !            64: <thru>{A}{B}*|.        { yylval.op = copythru(yytext); BEGIN A; return(DEFNAME); }
        !            65: <A>until       return(UNTIL);
        !            66: 
        !            67: <A>if          return(IF);
        !            68: <A>then                { yylval.p = delimstr("then part"); BEGIN A; return(THEN); }
        !            69: <A>else                { yylval.p = delimstr("else part"); BEGIN A; return(ELSE); }
        !            70: 
        !            71: <A>next                return(NEXT);
        !            72: <A>draw                return(yylval.i = DRAW);
        !            73: <A>new         return(yylval.i = NEW);
        !            74: <A>plot                return(yylval.i = PLOT);
        !            75: <A>label(s)?   return(LABEL);
        !            76: <A>x           return(X);
        !            77: <A>y           return(Y);
        !            78: 
        !            79: <A>top         { yylval.i = TOP; return SIDE; }
        !            80: <A>bot(tom)?   { yylval.i = BOT; return SIDE; }
        !            81: <A>left                { yylval.i = LEFT; return SIDE; }
        !            82: <A>right       { yylval.i = RIGHT; return SIDE; }
        !            83: <A>up          return(yylval.i = UP);
        !            84: <A>down                return(yylval.i = DOWN);
        !            85: <A>across      return(yylval.i = ACROSS);
        !            86: <A>height|ht   return(yylval.i = HEIGHT);
        !            87: <A>wid(th)?    return(yylval.i = WIDTH);
        !            88: <A>rad(ius)?   return(yylval.i = RADIUS);
        !            89: <A>invis       return(yylval.i = INVIS);
        !            90: <A>dot(ted)    return(yylval.i = DOT);
        !            91: <A>dash(ed)    return(yylval.i = DASH);
        !            92: <A>solid       return(yylval.i = SOLID);
        !            93: 
        !            94: <A>ljust       { yylval.i = LJUST; return JUST; }
        !            95: <A>rjust       { yylval.i = RJUST; return JUST; }
        !            96: <A>above       { yylval.i = ABOVE; return JUST; }
        !            97: <A>below       { yylval.i = BELOW; return JUST; }
        !            98: <A>size                return(yylval.i = SIZE);
        !            99: 
        !           100: <A>from                return(yylval.i = FROM);
        !           101: <A>to          return(yylval.i = TO);
        !           102: <A>by|step     return(yylval.i = BY);
        !           103: <A>at          return(yylval.i = AT);
        !           104: <A>with                return(yylval.i = WITH);
        !           105: <A>in          return(yylval.i = IN);
        !           106: <A>out         return(yylval.i = OUT);
        !           107: <A>off         return(yylval.i = OFF);
        !           108: 
        !           109: <A>sh{WS}+ {   BEGIN sh;
        !           110:                if ((delim = input()) == '{') {
        !           111:                        shcnt = 1;
        !           112:                        delim = '}';
        !           113:                }
        !           114:                shell_init();
        !           115:        }
        !           116: <sh>{A}{B}* {
        !           117:                int c;
        !           118:                Obj *p;
        !           119:                if (yytext[0] == delim) {
        !           120:                        shell_exec();
        !           121:                        BEGIN A;
        !           122:                } else {
        !           123:                        p = lookup(yytext, 0);
        !           124:                        if (p != NULL && p->type == DEFNAME) {
        !           125:                                c = input();
        !           126:                                unput(c);
        !           127:                                if (c == '(')
        !           128:                                        dodef(p);
        !           129:                                else
        !           130:                                        pbstr(p->val);
        !           131:                        } else
        !           132:                                shell_text(yytext);
        !           133:                }
        !           134:        }
        !           135: <sh>"{"                { shcnt++; shell_text(yytext); }
        !           136: <sh>"}"                { if (delim != '}' || --shcnt > 0)
        !           137:                        shell_text(yytext);
        !           138:                  else {
        !           139:                        shell_exec();
        !           140:                        BEGIN A;
        !           141:                  }
        !           142:                }
        !           143: <sh>.|\n       { if (yytext[0] == delim) {
        !           144:                        shell_exec();
        !           145:                        BEGIN A;
        !           146:                  } else
        !           147:                        shell_text(yytext);
        !           148:                }
        !           149: 
        !           150: <A>define{WS}+ { BEGIN def; }
        !           151: <def>{A}{B}*   { definition(yytext); BEGIN A; }
        !           152: 
        !           153: <A>({D}+("."?){D}*|"."{D}+)((e|E)("+"|-)?{D}+)?i? {
        !           154:                  yylval.f = atof(yytext); return(NUMBER); }
        !           155: 
        !           156: <A>^"."[^0-9].*        { if (yytext[1] == 'G' && yytext[2] == '2') {
        !           157:                        yylval.i = yytext[2];
        !           158:                        return(EOF);
        !           159:                  } else {
        !           160:                        yylval.p = tostring(yytext);
        !           161:                        return(PIC);
        !           162:                  }
        !           163:                }
        !           164: 
        !           165: <A>{A}{B}* {
        !           166:                int c;
        !           167:                Obj *p;
        !           168:                p = lookup(yytext, 1);
        !           169:                if (p->type == DEFNAME) {
        !           170:                        c = input();
        !           171:                        unput(c);
        !           172:                        if (c == '(')   /* it's name(...) */
        !           173:                                dodef(p);
        !           174:                        else    /* no argument list */
        !           175:                                pbstr(p->val);
        !           176:                } else {
        !           177:                        yylval.op = p;
        !           178:                        return p->type; /* NAME or VARNAME */
        !           179:                }
        !           180:        }
        !           181: 
        !           182: <A>"=="                return(EQ);
        !           183: <A>">="                return(GE);
        !           184: <A>"<="                return(LE);
        !           185: <A>"!="                return(NE);
        !           186: <A>">"         return(GT);
        !           187: <A>"<"         return(LT);
        !           188: <A>"&&"                return(AND);
        !           189: <A>"||"                return(OR);
        !           190: <A>"!"         return(NOT);    
        !           191: 
        !           192: <A>\"          { BEGIN str; clen = 0; }
        !           193: 
        !           194: <A>#.*         ;
        !           195: 
        !           196: <A>.           { yylval.i = yytext[0]; return(yytext[0]); }
        !           197: 
        !           198: <str>\"                { BEGIN A; cbuf[clen] = 0;
        !           199:                  yylval.p = tostring(cbuf); return(STRING); }
        !           200: <str>\n                { yyerror("newline in string"); BEGIN A; return(ST); }
        !           201: <str>"\\\""    { cbuf[clen++] = '\\'; cbuf[clen++] = '"'; }
        !           202: <str>"\\\\"    { cbuf[clen++] = '\\'; cbuf[clen++] = '\\'; }
        !           203: <str>.         { CADD; }
        !           204: 
        !           205: %%

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