![[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] / 43BSDReno / usr.bin / awk|
Return to awk.lx.l CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / awk |
1.1 root 1: /* awk.lx.l 4.4 90/06/25 */
2:
3: %X str chc reg comment
4:
5: %{
6: #include <string.h>
7: #include "awk.h"
8: #include "awk.def"
9: extern int yylval;
10: extern int mustfld;
11: extern int ldbg;
12: extern char *lexprog;
13:
14: #undef YY_INPUT
15: #define YY_INPUT(buf,result,max_size) \
16: { \
17: if ( lexprog ) \
18: { \
19: result = strlen( lexprog ); \
20: if ( result > max_size ) \
21: { \
22: result = max_size; \
23: strncpy( buf, lexprog, result ); \
24: } \
25: else \
26: strcpy( buf, lexprog ); \
27: lexprog += result; \
28: } \
29: else \
30: result = read( fileno(yyin), buf, max_size ); \
31: }
32:
33: int lineno = 1;
34: #define RETURN(x) {if (ldbg) ptoken(x); return(x); }
35: #define CADD cbuf[clen++]=yytext[0]; if(clen>=CBUFLEN-1) {yyerror("string too long", cbuf); BEGIN INITIAL;}
36: #define CBUFLEN 150
37: char cbuf[CBUFLEN];
38: int clen, cflag;
39: %}
40:
41: A [a-zA-Z_]
42: B [a-zA-Z0-9_]
43: D [0-9]
44: WS [ \t]
45:
46: %%
47: static int sc_flag = 0;
48:
49: if ( sc_flag ) {
50: BEGIN INITIAL;
51: sc_flag = 0;
52: RETURN('}');
53: }
54:
55: ^\n lineno++;
56: ^{WS}*#.*\n lineno++; /* strip comment lines */
57: {WS} ;
58: <INITIAL,reg>"\\"\n lineno++;
59: "||" RETURN(BOR);
60: BEGIN RETURN(XBEGIN);
61: END RETURN(XEND);
62: PROGEND RETURN(EOF);
63: "&&" RETURN(AND);
64: "!" RETURN(NOT);
65: "!=" { yylval = NE; RETURN(RELOP); }
66: "~" { yylval = MATCH; RETURN(MATCHOP); }
67: "!~" { yylval = NOTMATCH; RETURN(MATCHOP); }
68: "<" { yylval = LT; RETURN(RELOP); }
69: "<=" { yylval = LE; RETURN(RELOP); }
70: "==" { yylval = EQ; RETURN(RELOP); }
71: ">=" { yylval = GE; RETURN(RELOP); }
72: ">" { yylval = GT; RETURN(RELOP); }
73: ">>" { yylval = APPEND; RETURN(RELOP); }
74: "++" { yylval = INCR; RETURN(INCR); }
75: "--" { yylval = DECR; RETURN(DECR); }
76: "+=" { yylval = ADDEQ; RETURN(ASGNOP); }
77: "-=" { yylval = SUBEQ; RETURN(ASGNOP); }
78: "*=" { yylval = MULTEQ; RETURN(ASGNOP); }
79: "/=" { yylval = DIVEQ; RETURN(ASGNOP); }
80: "%=" { yylval = MODEQ; RETURN(ASGNOP); }
81: "=" { yylval = ASSIGN; RETURN(ASGNOP); }
82:
83: "$"{D}+ { if (atoi(yytext+1)==0) {
84: yylval = (hack)lookup("$record", symtab, 0);
85: RETURN(STRING);
86: } else {
87: yylval = fieldadr(atoi(yytext+1));
88: RETURN(FIELD);
89: }
90: }
91: "$"{WS}* { RETURN(INDIRECT); }
92: NF { mustfld=1; yylval = (hack)setsymtab(yytext, EMPTY, 0.0, NUM, symtab); RETURN(VAR); }
93: ({D}+("."?){D}*|"."{D}+)((e|E)("+"|-)?{D}+)? {
94: yylval = (hack)setsymtab(yytext, EMPTY, atof(yytext), CON|NUM, symtab); RETURN(NUMBER); }
95: "}"{WS}*\n { sc_flag = 1; lineno++; RETURN(';'); }
96: "}" { sc_flag = 1; RETURN(';'); }
97: ;\n { lineno++; RETURN(';'); }
98: \n { lineno++; RETURN(NL); }
99: while RETURN(WHILE);
100: for RETURN(FOR);
101: if RETURN(IF);
102: else RETURN(ELSE);
103: next RETURN(NEXT);
104: exit RETURN(EXIT);
105: break RETURN(BREAK);
106: continue RETURN(CONTINUE);
107: print { yylval = PRINT; RETURN(PRINT); }
108: printf { yylval = PRINTF; RETURN(PRINTF); }
109: sprintf { yylval = SPRINTF; RETURN(SPRINTF); }
110: split { yylval = SPLIT; RETURN(SPLIT); }
111: substr RETURN(SUBSTR);
112: index RETURN(INDEX);
113: in RETURN(IN);
114: getline RETURN(GETLINE);
115: length { yylval = FLENGTH; RETURN(FNCN); }
116: log { yylval = FLOG; RETURN(FNCN); }
117: int { yylval = FINT; RETURN(FNCN); }
118: exp { yylval = FEXP; RETURN(FNCN); }
119: sqrt { yylval = FSQRT; RETURN(FNCN); }
120: {A}{B}* { yylval = (hack)setsymtab(yytext, tostring(""), 0.0, STR|NUM, symtab); RETURN(VAR); }
121: \" { BEGIN str; clen=0; }
122:
123: # { BEGIN comment; }
124: <comment>\n { BEGIN INITIAL; lineno++; RETURN(NL); }
125: <comment>. ;
126:
127: . { yylval = yytext[0]; RETURN(yytext[0]); }
128:
129: <reg>"[" { BEGIN chc; clen=0; cflag=0; }
130: <reg>"[^" { BEGIN chc; clen=0; cflag=1; }
131:
132: <reg>"?" RETURN(QUEST);
133: <reg>"+" RETURN(PLUS);
134: <reg>"*" RETURN(STAR);
135: <reg>"|" RETURN(OR);
136: <reg>"." RETURN(DOT);
137: <reg>"(" RETURN('(');
138: <reg>")" RETURN(')');
139: <reg>"^" RETURN('^');
140: <reg>"$" RETURN('$');
141: <reg>\\{D}{D}{D} { sscanf(yytext+1, "%o", &yylval); RETURN(CHAR); }
142: <reg>\\. { if (yytext[1]=='n') yylval = '\n';
143: else if (yytext[1] == 't') yylval = '\t';
144: else yylval = yytext[1];
145: RETURN(CHAR);
146: }
147: <reg>"/" { BEGIN INITIAL; unput('/'); }
148: <reg>\n { yyerror("newline in regular expression"); lineno++; BEGIN INITIAL; }
149: <reg>. { yylval = yytext[0]; RETURN(CHAR); }
150:
151: <str>\" { char *s; BEGIN INITIAL; cbuf[clen]=0; s = tostring(cbuf);
152: cbuf[clen] = ' '; cbuf[++clen] = 0;
153: yylval = (hack)setsymtab(cbuf, s, 0.0, CON|STR, symtab); RETURN(STRING); }
154: <str>\n { yyerror("newline in string"); lineno++; BEGIN INITIAL; }
155: <str>"\\\"" { cbuf[clen++]='"'; }
156: <str,chc>"\\"n { cbuf[clen++]='\n'; }
157: <str,chc>"\\"t { cbuf[clen++]='\t'; }
158: <str,chc>"\\\\" { cbuf[clen++]='\\'; }
159: <str>. { CADD; }
160:
161: <chc>"\\""]" { cbuf[clen++]=']'; }
162: <chc>"]" { BEGIN reg; cbuf[clen]=0; yylval = (hack)tostring(cbuf);
163: if (cflag==0) { RETURN(CCL); }
164: else { RETURN(NCCL); } }
165: <chc>\n { yyerror("newline in character class"); lineno++; BEGIN INITIAL; }
166: <chc>. { CADD; }
167:
168: %%
169:
170: startreg()
171: {
172: BEGIN reg;
173: }
174:
175: ptoken(n)
176: {
177: extern struct tok {
178: char *tnm;
179: int yval;
180: } tok[];
181: extern int yylval;
182:
183: printf("lex:");
184: if (n < 128) {
185: printf(" %c\n",n);
186: return;
187: }
188: if (n <= 256 || n >= LASTTOKEN) {
189: printf("? %o\n",n);
190: return;
191: }
192: printf(" %s",tok[n-257].tnm);
193: switch (n) {
194:
195: case RELOP:
196: case MATCHOP:
197: case ASGNOP:
198: case STRING:
199: case FIELD:
200: case VAR:
201: case NUMBER:
202: case FNCN:
203: printf(" (%s)", yytext);
204: break;
205:
206: case CHAR:
207: printf(" (%o)", yylval);
208: break;
209: }
210: putchar('\n');
211: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.