![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to awk.lx.l CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / prefer / prefawk|
Return to awk.lx.l CVS log | Up to [Research Unix] / researchv10no / cmd / prefer / prefawk |
1.1 ! root 1: %Start A str sc reg comment ! 2: ! 3: %{ ! 4: #include "awk.h" ! 5: #include "y.tab.h" ! 6: ! 7: #undef input /* defeat lex */ ! 8: #undef unput ! 9: ! 10: extern YYSTYPE yylval; ! 11: extern int infunc; ! 12: ! 13: int lineno = 1; ! 14: int bracecnt = 0; ! 15: int brackcnt = 0; ! 16: int parencnt = 0; ! 17: #define DEBUG ! 18: #ifdef DEBUG ! 19: # define RET(x) {if(dbg)printf("lex %s [%s]\n", tokname(x), yytext); return(x); } ! 20: #else ! 21: # define RET(x) return(x) ! 22: #endif ! 23: ! 24: #define CADD cbuf[clen++] = yytext[0]; \ ! 25: if (clen >= CBUFLEN-1) { \ ! 26: yyerror("string/reg expr %.10s... too long", cbuf); \ ! 27: BEGIN A; \ ! 28: } ! 29: ! 30: uchar cbuf[CBUFLEN]; ! 31: uchar *s; ! 32: int clen, cflag; ! 33: %} ! 34: ! 35: A [a-zA-Z_] ! 36: B [a-zA-Z0-9_] ! 37: D [0-9] ! 38: WS [ \t] ! 39: ! 40: %% ! 41: switch (yybgin-yysvec-1) { /* witchcraft */ ! 42: case 0: ! 43: BEGIN A; ! 44: break; ! 45: case sc: ! 46: BEGIN A; ! 47: RET('}'); ! 48: } ! 49: ! 50: <A>\n { lineno++; RET(NL); } ! 51: <A>#.* { lineno++; RET(NL); } /* strip comment lines */ ! 52: <A>{WS}+ { ; } ! 53: <A>; { RET(';'); } ! 54: ! 55: <A>"\\"\n { lineno++; } ! 56: <A>BEGIN { RET(XBEGIN); } ! 57: <A>END { RET(XEND); } ! 58: <A>func(tion)? { if (infunc) yyerror("illegal nested function"); RET(FUNC); } ! 59: <A>return { if (!infunc) yyerror("return not in function"); RET(RETURN); } ! 60: <A>"&&" { RET(AND); } ! 61: <A>"||" { RET(BOR); } ! 62: <A>"!" { RET(NOT); } ! 63: <A>"!=" { yylval.i = NE; RET(NE); } ! 64: <A>"~" { yylval.i = MATCH; RET(MATCHOP); } ! 65: <A>"!~" { yylval.i = NOTMATCH; RET(MATCHOP); } ! 66: <A>"<" { yylval.i = LT; RET(LT); } ! 67: <A>"<=" { yylval.i = LE; RET(LE); } ! 68: <A>"==" { yylval.i = EQ; RET(EQ); } ! 69: <A>">=" { yylval.i = GE; RET(GE); } ! 70: <A>">" { yylval.i = GT; RET(GT); } ! 71: <A>">>" { yylval.i = APPEND; RET(APPEND); } ! 72: <A>"++" { yylval.i = INCR; RET(INCR); } ! 73: <A>"--" { yylval.i = DECR; RET(DECR); } ! 74: <A>"+=" { yylval.i = ADDEQ; RET(ASGNOP); } ! 75: <A>"-=" { yylval.i = SUBEQ; RET(ASGNOP); } ! 76: <A>"*=" { yylval.i = MULTEQ; RET(ASGNOP); } ! 77: <A>"/=" { yylval.i = DIVEQ; RET(ASGNOP); } ! 78: <A>"%=" { yylval.i = MODEQ; RET(ASGNOP); } ! 79: <A>"^=" { yylval.i = POWEQ; RET(ASGNOP); } ! 80: <A>"**=" { yylval.i = POWEQ; RET(ASGNOP); } ! 81: <A>"=" { yylval.i = ASSIGN; RET(ASGNOP); } ! 82: <A>"**" { RET(POWER); } ! 83: <A>"^" { RET(POWER); } ! 84: ! 85: <A>"$"{D}+ { yylval.cp = fieldadr(atoi(yytext+1)); RET(FIELD); } ! 86: <A>"$NF" { unputstr("(NF)"); return(INDIRECT); } ! 87: <A>"$"{A}{B}* { int c, n; ! 88: c = input(); unput(c); ! 89: if (c == '(' || c == '[' || infunc && (n=isarg(yytext+1)) >= 0) { ! 90: unputstr(yytext+1); ! 91: return(INDIRECT); ! 92: } else { ! 93: yylval.cp = setsymtab(yytext+1,"",0.0,STR|NUM,symtab); ! 94: RET(IVAR); ! 95: } ! 96: } ! 97: <A>"$" { RET(INDIRECT); } ! 98: <A>NF { yylval.cp = setsymtab(yytext, "", 0.0, NUM, symtab); RET(VARNF); } ! 99: ! 100: <A>({D}+("."?){D}*|"."{D}+)((e|E)("+"|-)?{D}+)? { ! 101: yylval.cp = setsymtab(yytext, tostring(yytext), atof(yytext), CON|NUM, symtab); ! 102: RET(NUMBER); } ! 103: ! 104: <A>while { RET(WHILE); } ! 105: <A>for { RET(FOR); } ! 106: <A>do { RET(DO); } ! 107: <A>if { RET(IF); } ! 108: <A>else { RET(ELSE); } ! 109: <A>next { RET(NEXT); } ! 110: <A>exit { RET(EXIT); } ! 111: <A>break { RET(BREAK); } ! 112: <A>continue { RET(CONTINUE); } ! 113: <A>print { yylval.i = PRINT; RET(PRINT); } ! 114: <A>printf { yylval.i = PRINTF; RET(PRINTF); } ! 115: <A>sprintf { yylval.i = SPRINTF; RET(SPRINTF); } ! 116: <A>split { yylval.i = SPLIT; RET(SPLIT); } ! 117: <A>substr { RET(SUBSTR); } ! 118: <A>sub { yylval.i = SUB; RET(SUB); } ! 119: <A>gsub { yylval.i = GSUB; RET(GSUB); } ! 120: <A>index { RET(INDEX); } ! 121: <A>match { RET(MATCHFCN); } ! 122: <A>in { RET(IN); } ! 123: <A>getline { RET(GETLINE); } ! 124: <A>close { RET(CLOSE); } ! 125: <A>delete { RET(DELETE); } ! 126: <A>length { yylval.i = FLENGTH; RET(BLTIN); } ! 127: <A>log { yylval.i = FLOG; RET(BLTIN); } ! 128: <A>int { yylval.i = FINT; RET(BLTIN); } ! 129: <A>exp { yylval.i = FEXP; RET(BLTIN); } ! 130: <A>sqrt { yylval.i = FSQRT; RET(BLTIN); } ! 131: <A>sin { yylval.i = FSIN; RET(BLTIN); } ! 132: <A>cos { yylval.i = FCOS; RET(BLTIN); } ! 133: <A>atan2 { yylval.i = FATAN; RET(BLTIN); } ! 134: <A>system { yylval.i = FSYSTEM; RET(BLTIN); } ! 135: <A>rand { yylval.i = FRAND; RET(BLTIN); } ! 136: <A>srand { yylval.i = FSRAND; RET(BLTIN); } ! 137: ! 138: <A>{A}{B}* { int n, c; ! 139: c = input(); unput(c); /* look for '(' */ ! 140: if (c != '(' && infunc && (n=isarg(yytext)) >= 0) { ! 141: yylval.i = n; ! 142: RET(ARG); ! 143: } else { ! 144: yylval.cp = setsymtab(yytext,"",0.0,STR|NUM,symtab); ! 145: if (c == '(') { ! 146: RET(CALL); ! 147: } else { ! 148: RET(VAR); ! 149: } ! 150: } ! 151: } ! 152: <A>\" { BEGIN str; clen = 0; } ! 153: ! 154: <A>"}" { if (--bracecnt < 0) yyerror("extra }"); BEGIN sc; RET(';'); } ! 155: <A>"]" { if (--brackcnt < 0) yyerror("extra ]"); RET(']'); } ! 156: <A>")" { if (--parencnt < 0) yyerror("extra )"); RET(')'); } ! 157: ! 158: <A>. { if (yytext[0] == '{') bracecnt++; ! 159: else if (yytext[0] == '[') brackcnt++; ! 160: else if (yytext[0] == '(') parencnt++; ! 161: RET(yylval.i = yytext[0]); /* everything else */ } ! 162: ! 163: <reg>\\. { cbuf[clen++] = '\\'; cbuf[clen++] = yytext[1]; } ! 164: <reg>\n { yyerror("newline in regular expression %.10s...", cbuf); lineno++; BEGIN A; } ! 165: <reg>"/" { BEGIN A; ! 166: cbuf[clen] = 0; ! 167: yylval.s = tostring(cbuf); ! 168: unput('/'); ! 169: RET(REGEXPR); } ! 170: <reg>. { CADD; } ! 171: ! 172: <str>\" { BEGIN A; ! 173: cbuf[clen] = 0; s = tostring(cbuf); ! 174: cbuf[clen] = ' '; cbuf[++clen] = 0; ! 175: yylval.cp = setsymtab(cbuf, s, 0.0, CON|STR, symtab); ! 176: RET(STRING); } ! 177: <str>\n { yyerror("newline in string %.10s...", cbuf); lineno++; BEGIN A; } ! 178: <str>"\\\"" { cbuf[clen++] = '"'; } ! 179: <str>"\\"n { cbuf[clen++] = '\n'; } ! 180: <str>"\\"t { cbuf[clen++] = '\t'; } ! 181: <str>"\\"f { cbuf[clen++] = '\f'; } ! 182: <str>"\\"r { cbuf[clen++] = '\r'; } ! 183: <str>"\\"b { cbuf[clen++] = '\b'; } ! 184: <str>"\\\\" { cbuf[clen++] = '\\'; } ! 185: <str>"\\"({D}{D}{D}|{D}{D}|{D}) { int n; ! 186: sscanf(yytext+1, "%o", &n); cbuf[clen++] = n; } ! 187: <str>"\\". { cbuf[clen++] = yytext[1]; } ! 188: <str>. { CADD; } ! 189: ! 190: %% ! 191: ! 192: startreg() ! 193: { ! 194: BEGIN reg; ! 195: clen = 0; ! 196: } ! 197: ! 198: /* input() and unput() are transcriptions of the standard lex ! 199: macros for input and output with additions for error message ! 200: printing. God help us all if someone changes how lex works. ! 201: */ ! 202: ! 203: uchar ebuf[300]; ! 204: uchar *ep = ebuf; ! 205: ! 206: input() ! 207: { ! 208: register c; ! 209: extern uchar *lexprog; ! 210: ! 211: if (yysptr > yysbuf) ! 212: c = U(*--yysptr); ! 213: else if (yyin == NULL) ! 214: c = *lexprog++; ! 215: else ! 216: c = getc(yyin); ! 217: if (c == '\n') ! 218: yylineno++; ! 219: else if (c == EOF) ! 220: c = 0; ! 221: if (ep >= ebuf + sizeof ebuf) ! 222: ep = ebuf; ! 223: return *ep++ = c; ! 224: } ! 225: ! 226: unput(c) ! 227: { ! 228: yytchar = c; ! 229: if (yytchar == '\n') ! 230: yylineno--; ! 231: *yysptr++ = yytchar; ! 232: if (--ep < ebuf) ! 233: ep = ebuf + sizeof(ebuf) - 1; ! 234: } ! 235: ! 236: ! 237: unputstr(s) ! 238: char *s; ! 239: { ! 240: int i; ! 241: ! 242: for (i = strlen(s)-1; i >= 0; i--) ! 243: unput(s[i]); ! 244: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.