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