![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gram.y CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / bin / make|
Return to gram.y CVS log | Up to [CSRG BSD Unix] / 42BSD / bin / make |
1.1 root 1: %{#include "defs"
2: static char *sccsid = "@(#)gram.y 4.1 (Berkeley) 81/02/28";
3: %}
4:
5: %term NAME SHELLINE START MACRODEF COLON DOUBLECOLON GREATER
6: %union
7: {
8: struct shblock *yshblock;
9: struct depblock *ydepblock;
10: struct nameblock *ynameblock;
11: }
12:
13: %type <yshblock> SHELLINE, shlist, shellist
14: %type <ynameblock> NAME, namelist
15: %type <ydepblock> deplist, dlist
16:
17:
18: %%
19:
20: %{
21: struct depblock *pp;
22: FSTATIC struct shblock *prevshp;
23:
24: FSTATIC struct nameblock *lefts[NLEFTS];
25: struct nameblock *leftp;
26: FSTATIC int nlefts;
27:
28: struct lineblock *lp, *lpp;
29: FSTATIC struct depblock *prevdep;
30: FSTATIC int sepc;
31: %}
32:
33:
34: file:
35: | file comline
36: ;
37:
38: comline: START
39: | MACRODEF
40: | START namelist deplist shellist = {
41: while( --nlefts >= 0)
42: {
43: leftp = lefts[nlefts];
44: if(leftp->septype == 0)
45: leftp->septype = sepc;
46: else if(leftp->septype != sepc)
47: fprintf(stderr, "Inconsistent rules lines for `%s'\n",
48: leftp->namep);
49: else if(sepc==ALLDEPS && *(leftp->namep)!='.' && $4!=0)
50: {
51: for(lp=leftp->linep; lp->nxtlineblock!=0; lp=lp->nxtlineblock)
52: if(lp->shp)
53: fprintf(stderr, "Multiple rules lines for `%s'\n",
54: leftp->namep);
55: }
56:
57: lp = ALLOC(lineblock);
58: lp->nxtlineblock = NULL;
59: lp->depp = $3;
60: lp->shp = $4;
61:
62: if(! unequal(leftp->namep, ".SUFFIXES") && $3==0)
63: leftp->linep = 0;
64: else if(leftp->linep == 0)
65: leftp->linep = lp;
66: else {
67: for(lpp = leftp->linep; lpp->nxtlineblock;
68: lpp = lpp->nxtlineblock) ;
69: if(sepc==ALLDEPS && leftp->namep[0]=='.')
70: lpp->shp = 0;
71: lpp->nxtlineblock = lp;
72: }
73: }
74: }
75: | error
76: ;
77:
78: namelist: NAME = { lefts[0] = $1; nlefts = 1; }
79: | namelist NAME = { lefts[nlefts++] = $2;
80: if(nlefts>=NLEFTS) fatal("Too many lefts"); }
81: ;
82:
83: deplist:
84: {
85: char junk[10];
86: sprintf(junk, "%d", yylineno);
87: fatal1("Must be a separator on rules line %s", junk);
88: }
89: | dlist
90: ;
91:
92: dlist: sepchar = { prevdep = 0; $$ = 0; }
93: | dlist NAME = {
94: pp = ALLOC(depblock);
95: pp->nxtdepblock = NULL;
96: pp->depname = $2;
97: if(prevdep == 0) $$ = pp;
98: else prevdep->nxtdepblock = pp;
99: prevdep = pp;
100: }
101: ;
102:
103: sepchar: COLON = { sepc = ALLDEPS; }
104: | DOUBLECOLON = { sepc = SOMEDEPS; }
105: ;
106:
107: shellist: = {$$ = 0; }
108: | shlist = { $$ = $1; }
109: ;
110:
111: shlist: SHELLINE = { $$ = $1; prevshp = $1; }
112: | shlist SHELLINE = { $$ = $1;
113: prevshp->nxtshblock = $2;
114: prevshp = $2;
115: }
116: ;
117:
118: %%
119:
120: char *zznextc; /* zero if need another line; otherwise points to next char */
121: int yylineno;
122: extern FILE * fin;
123:
124: yylex()
125: {
126: register char *p;
127: register char *q;
128: char word[INMAX];
129:
130: if(zznextc == 0)
131: return( nextlin() );
132:
133: while( isspace(*zznextc) )
134: ++zznextc;
135:
136: if(*zznextc == '\0')
137: return( nextlin() );
138:
139: if(*zznextc == ':')
140: {
141: if(*++zznextc == ':')
142: {
143: ++zznextc;
144: return(DOUBLECOLON);
145: }
146: else return(COLON);
147: }
148:
149: if(*zznextc == '>')
150: {
151: ++zznextc;
152: return(GREATER);
153: }
154:
155: if(*zznextc == ';')
156: return( retsh(zznextc) );
157:
158: p = zznextc;
159: q = word;
160:
161: while( ! ( funny[*p] & TERMINAL) )
162: *q++ = *p++;
163:
164: if(p != zznextc)
165: {
166: *q = '\0';
167: if((yylval.ynameblock=srchname(word))==0)
168: yylval.ynameblock = makename(word);
169: zznextc = p;
170: return(NAME);
171: }
172:
173: else {
174: fprintf(stderr,"Bad character %c (octal %o), line %d",
175: *zznextc,*zznextc,yylineno);
176: fatal( (char *) NULL );
177: }
178: return(0); /* never executed */
179: }
180:
181:
182:
183:
184:
185: retsh(q)
186: char *q;
187: {
188: register char *p;
189: struct shblock *sp;
190: char *copys();
191:
192: for(p=q+1 ; *p==' '||*p=='\t' ; ++p) ;
193:
194: sp = ALLOC(shblock);
195: sp->nxtshblock = NULL;
196: sp->shbp = (fin == NULL ? p : copys(p) );
197: yylval.yshblock = sp;
198: zznextc = 0;
199: return(SHELLINE);
200: }
201:
202: nextlin()
203: {
204: static char yytext[INMAX];
205: static char *yytextl = yytext+INMAX;
206: char *text, templin[INMAX];
207: register char c;
208: register char *p, *t;
209: char lastch, *lastchp;
210: extern char **linesptr;
211: int incom;
212: int kc;
213:
214: again:
215:
216: incom = NO;
217: zznextc = 0;
218:
219: if(fin == NULL)
220: {
221: if( (text = *linesptr++) == 0)
222: return(0);
223: ++yylineno;
224: }
225:
226: else {
227: for(p = text = yytext ; p<yytextl ; *p++ = kc)
228: switch(kc = getc(fin))
229: {
230: case '\t':
231: if(p != yytext)
232: break;
233: case ';':
234: incom = YES;
235: break;
236:
237: case '#':
238: if(! incom)
239: kc = '\0';
240: break;
241:
242: case '\n':
243: ++yylineno;
244: if(p==yytext || p[-1]!='\\')
245: {
246: *p = '\0';
247: goto endloop;
248: }
249: p[-1] = ' ';
250: while( (kc=getc(fin))=='\t' || kc==' ' || kc=='\n')
251: if(kc == '\n')
252: ++yylineno;
253:
254: if(kc != EOF)
255: break;
256: case EOF:
257: *p = '\0';
258: return(0);
259: }
260:
261: fatal("line too long");
262: }
263:
264: endloop:
265:
266: if((c = text[0]) == '\t')
267: return( retsh(text) );
268:
269: if(isalpha(c) || isdigit(c) || c==' ' || c=='.')
270: for(p=text+1; *p!='\0'; )
271: if(*p == ':')
272: break;
273: else if(*p++ == '=')
274: {
275: eqsign(text);
276: return(MACRODEF);
277: }
278:
279: /* substitute for macros on dependency line up to the semicolon if any */
280:
281: for(t = yytext ; *t!='\0' && *t!=';' ; ++t)
282: ;
283:
284: lastchp = t;
285: lastch = *t;
286: *t = '\0';
287:
288: subst(yytext, templin); /* Substitute for macros on dependency lines */
289:
290: if(lastch)
291: {
292: for(t = templin ; *t ; ++t)
293: ;
294: *t = lastch;
295: while( *++t = *++lastchp ) ;
296: }
297:
298: p = templin;
299: t = yytext;
300: while( *t++ = *p++ )
301: ;
302:
303: for(p = zznextc = text ; *p ; ++p )
304: if(*p!=' ' && *p!='\t')
305: return(START);
306: goto again;
307: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.