![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lex.l CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 40BSD / cmd / efl|
Return to lex.l CVS log | Up to [CSRG BSD Unix] / 40BSD / cmd / efl |
1.1 root 1: %Start DOTSON
2: %{
3: #include <ctype.h>
4: #include "defs"
5: #include "tokdefs"
6:
7: typedef union { int ival; ptr pval; } YYSTYPE;
8: extern YYSTYPE yylval;
9: YYSTYPE prevl;
10: int prevv;
11: char *copys();
12: static ptr p;
13: static ptr q;
14: static FILE *fd;
15: static int quoted, k;
16: static int rket = 0;
17: FILE *opincl();
18: ptr mkdef(), mkcomm(), mkname(), mkimcon();
19:
20: #define RET(x) { RETI(x,x); }
21:
22: #define RETL(yv,yl) {yylval=prevl=yl;igeol=comneed=0;return(prevv=yv); }
23: #define RETP(yv,yl) {yylval.pval=prevl.pval=yl;igeol=comneed=0;return(prevv=yv); }
24: #define RETI(yv,yl) {yylval.ival=prevl.ival=yl;igeol=comneed=0;return(prevv=yv); }
25: #define REL(n) { RETI(RELOP, OPREL+n);}
26: #define AS(n) { RETI(ASGNOP, OPASGN+n); }
27: #define RETC(x) { RETP(CONST, mkconst(x,yytext) ); }
28: #define RETZ(x) { yytext[yyleng-1] = '\0'; RETP(CONST, mkimcon(x,yytext) ); }
29:
30: %}
31:
32: D [0-9]
33: d [dD][+-]?[0-9]+
34: e [eE][+-]?[0-9]+
35: i [iI]
36:
37: %%
38:
39: [a-zA-Z][a-zA-Z0-9_]* {
40: lower(yytext);
41: if(lettneed && yyleng==1)
42: { RETI(LETTER, yytext[0]); }
43: else if(defneed)
44: {
45: register char *q1, *q2;
46: for(q2=q1=yytext+yyleng+1 ; (*q1 = efgetc)!='\n' ; ++q1)
47: ;
48: *q1 = '\0';
49: p = mkdef(yytext, q2);
50: defneed = 0;
51: ++yylineno;
52: unput('\n');
53: }
54: else if(optneed)
55: { RETP(OPTNAME, copys(yytext)); }
56: else if(comneed && ( (q=name(yytext,1))==NULL || q->tag!=TDEFINE) )
57: { RETP(COMNAME, mkcomm(yytext) ); }
58: else if(q = name(yytext,1)) switch(q->tag)
59: {
60: case TDEFINE:
61: filelines[filedepth] = yylineno;
62: filemacs[filedepth] = efmacp;
63: pushchars[filedepth] = (yysptr>yysbuf?
64: *--yysptr : -1);
65: if(++filedepth >= MAXINCLUDEDEPTH)
66: fatal("macro or include too deep");
67: filelines[filedepth] = yylineno = 1;
68: efmacp = q->varp->valp;
69: filenames[filedepth] = NULL;
70: break; /*now process new input */
71:
72: case TSTRUCT:
73: RETP(STRUCTNAME, q);
74:
75: case TNAME:
76: RETP(NAME, q);
77:
78: case TKEYWORD:
79: if(q->subtype == END)
80: {
81: register int c;
82: eofneed = YES;
83: while((c=input())!=';'&&c!='\n'&&c!=EOF)
84: ;
85: NLSTATE;
86: }
87: RET(q->subtype);
88:
89: default:
90: fatal1("lex: impossible type code %d", q->tag);
91: }
92: else RETP(NAME, mkname(yytext) );
93: }
94:
95: "," RET(COMMA);
96: ";" RET(EOS);
97:
98: "(" RET(LPAR);
99: ")" RET(RPAR);
100:
101:
102: "[" |
103: "{" RET(LBRACK);
104:
105: "]" |
106: "}" { if(iobrlevel>0) RET(RBRACK); rket = 1; RET(EOS); }
107:
108: "," RET(COMMA);
109: ":" RET(COLON);
110:
111: "$" RET(REPOP);
112:
113: <DOTSON>"."[oO][rR]"." |
114: "|" RETI(OR,OPOR);
115: <DOTSON>"."[cC][oO][rR]"." |
116: "||" RETI(OR,OP2OR);
117: <DOTSON>"."[aA][nN][dD]"." |
118: "&" RETI(AND,OPAND);
119: <DOTSON>"."[cC][aA][nN][dD]"." |
120: "&&" RETI(AND,OP2AND);
121: <DOTSON>"."[nN][oO][tT]"." |
122: "~" RETI(NOT,OPNOT);
123: "!" RETI(NOT,OPNOT);
124:
125: <DOTSON>"."[lL][tT]"." |
126: "<" REL(OPLT);
127: <DOTSON>"."[lL][eE]"." |
128: "<=" REL(OPLE);
129: <DOTSON>"."[gG][tT]"." |
130: ">" REL(OPGT);
131: <DOTSON>"."[gG][eE]"." |
132: ">=" REL(OPGE);
133: <DOTSON>"."[eE][qQ]"." |
134: "==" REL(OPEQ);
135: <DOTSON>"."[nN][eE]"." |
136: "~=" |
137: "!=" REL(OPNE);
138:
139: "->" RET(ARROW);
140: "." RET(QUALOP);
141:
142: "+" RETI(ADDOP, OPPLUS);
143: "-" RETI(ADDOP, OPMINUS);
144: "*" RETI(MULTOP, OPSTAR);
145: "/" RETI(MULTOP, OPSLASH);
146:
147: "**" |
148: "^" RETI(POWER, OPPOWER);
149:
150: "++" RETI(DOUBLEADDOP, OPPLUS);
151: "--" RETI(DOUBLEADDOP, OPMINUS);
152:
153: "=" AS(OPASGN);
154: "+=" AS(OPPLUS);
155: "-=" AS(OPMINUS);
156: "*=" AS(OPSTAR);
157: "/=" AS(OPSLASH);
158: "**=" |
159: "^=" AS(OPPOWER);
160:
161: "&=" AS(OPAND);
162: "&&=" AS(OP2AND);
163: "|=" AS(OPOR);
164: "||=" AS(OP2OR);
165:
166: \'[^\n']*\' |
167: \"[^\n"]*\" { yytext[yyleng-1] = '\0'; p = mkconst(TYCHAR,yytext+1);
168: RETP(CONST,p); }
169:
170: {D}+[hH] { /* nh construct */
171: int i, n; char c;
172: yytext[yyleng-1] = '\0'; n = convci(yytext);
173: for(i = 0; i<n ; ++i)
174: if( (c=yytext[i]=input()) == '\n' || c=='\0') break;
175: yytext[i] = '\0';
176: p = mkconst(TYCHAR,yytext);
177: p->vtypep = mkint(i);
178: RETP(CONST, p);
179: }
180:
181: {D}+ RETC(TYINT);
182:
183: {D}+"."{D}* |
184: {D}*"."{D}+ RETC(TYREAL);
185:
186: {D}+"."?{D}*{e} |
187: {D}*"."{D}+{e} RETC(TYREAL);
188:
189: {D}+"."?{D}*{d} |
190: {D}*"."{D}+{d} RETC(TYLREAL);
191:
192: {D}+{i} { yytext[yyleng-1] = '.';
193: RETP(CONST,mkimcon(TYCOMPLEX,yytext)); }
194:
195: {D}+"."{D}*{i} |
196: {D}*"."{D}+{i} RETZ(TYCOMPLEX);
197:
198: {D}+"."?{D}*{e}{i} |
199: {D}*"."{D}+{e}{i} RETZ(TYCOMPLEX);
200:
201: {D}+"."?{D}*{d}{i} |
202: {D}*"."{D}+{d}{i} RETZ(TYLCOMPLEX);
203:
204: "#".* { if(! nocommentflag) goto litline; }
205:
206: ^"%".* { if(thisexec) thisexec->nftnst += 2;
207: if(inproc)
208: {
209: unput('\n');
210: RETP(ESCAPE, copys(yytext));
211: }
212:
213: litline: p = mkchain( copys(yytext), CHNULL);
214: if(inproc==0 && yytext[0]=='%')
215: prevcomments = hookup(prevcomments, p);
216: else
217: comments = hookup(comments,p);
218: }
219:
220: " " ;
221: \t ;
222: \f ;
223:
224: "_"[ \t]*\n ;
225:
226: \n { if(igeol) { igeol=0; prevv = NEWLINE; }
227: else if(prevv>=NAME || prevv==RPAR || prevv==RBRACK
228: || prevv== -1 || prevv==QUALOP)
229: RET(EOS); }
230:
231: . { char * linerr();
232: fprintf(diagfile, "Bad input character %c %s\n", yytext[0], linerr());
233: ++nerrs;
234: }
235:
236: ^[ \t]*[iI][nN][cC][lL][uU][dD][eE].*\n { /* Include statement */
237: char *q1;
238: register char *q2;
239: for(q1=yytext ; *q1==' ' || *q1=='\t' ; ++q1) ;
240: quoted = NO;
241: for(q1 += 7 ; *q1==' ' || *q1=='\t' ||
242: *q1=='\'' || *q1=='"' || *q1=='(' ; ++q1 )
243: if(*q1=='"' || *q1=='\'')
244: quoted = YES;
245: for(q2=q1 ; *q2!='\0' && *q2!=' ' && *q2!='\n' &&
246: *q2!='\'' && *q2!='"' && *q2!=')' ; ++q2 )
247: ;
248: *q2 = '\0';
249: if( ! quoted)
250: for(k=0; (q = name(q1,1)) && q->tag==TDEFINE ; ++k)
251: {
252: if(k > MAXINCLUDEDEPTH)
253: fatal1("Macros too deep for %s", yytext);
254: q1 = q->varp->valp;
255: }
256: if( (fd = opincl(&q1)) == NULL)
257: {
258: fprintf(diagfile, "Cannot open file %s. Stop.\n", q1);
259: exit(2);
260: }
261: filelines[filedepth] = yylineno;
262: pushchars[filedepth] = '\n';
263: if(++filedepth >= MAXINCLUDEDEPTH)
264: fatal("macro or include too deep");
265: fileptrs[filedepth] = yyin = fd;
266: filenames[filedepth] = copys(q1);
267: filelines[filedepth] = yylineno = 1;
268: filemacs[filedepth] = NULL;
269: }
270:
271: %%
272:
273: yywrap()
274: {
275: if(filedepth == 0)
276: {
277: ateof = 1;
278: return(1);
279: }
280:
281: if(efmacp == 0)
282: {
283: fclose(yyin);
284: cfree(filenames[filedepth]);
285: }
286:
287: --filedepth;
288: if( filemacs[filedepth] )
289: efmacp = filemacs[filedepth];
290: else {
291: yyin = fileptrs[filedepth];
292: efmacp = 0;
293: }
294: yylineno = filelines[filedepth];
295: if(pushchars[filedepth] != -1)
296: unput( pushchars[filedepth] );
297: return(0);
298: }
299:
300:
301:
302: lower(s) /* replace upper with lower case letters */
303: register char *s;
304: {
305: register char *t;
306: for(t=s ; *t ; ++t)
307: if( isupper(*t) )
308: *s++ = tolower(*t);
309: else if(*t != '_')
310: *s++ = *t;
311: }
312:
313:
314:
315:
316: setdot(k)
317: int k;
318: {
319: if(k)
320: BEGIN DOTSON;
321: else BEGIN 0;
322: }
323:
324:
325:
326:
327: FILE *opincl(namep)
328: char **namep;
329: {
330: #ifndef unix
331: return( fopen(*namep, "r") );
332: #else
333:
334: /* On Unix, follow the C include conventions */
335:
336: register char *s, *lastslash;
337: char *dir, *name, temp[100];
338: int i;
339: FILE *fp;
340:
341: name = *namep;
342: if(name[0] == '/')
343: return( fopen(name, "r") );
344:
345: dir = basefile;
346: for(i = filedepth ; i>=0 ; --i)
347: if( filemacs[i] == NULL)
348: {
349: dir = filenames[i];
350: break;
351: }
352:
353: lastslash = NULL;
354: for(s = dir ; *s ; ++s)
355: if(*s == '/')
356: lastslash = s;
357: if(lastslash)
358: {
359: *lastslash = '\0';
360: sprintf(temp, "%s/%s", dir, name);
361: *lastslash = '/';
362: if( fp = fopen(temp, "r") )
363: *namep = temp;
364: }
365: else
366: fp = fopen(name, "r");
367:
368: if(fp == NULL)
369: {
370: sprintf(temp, "/usr/include/%s", name);
371: fp = fopen(temp, "r");
372: *namep = temp;
373: }
374: return(fp);
375:
376: #endif
377: }
378:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.