![[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] / 41BSD / cmd / awk|
Return to awk.lx.l CVS log | Up to [CSRG BSD Unix] / 41BSD / 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]; 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.