![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to misc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 3BSD / cmd / make|
Return to misc.c CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd / make |
1.1 root 1: #include "defs"
2:
3: FSTATIC struct nameblock *hashtab[HASHSIZE];
4: FSTATIC int nhashed = 0;
5:
6:
7: /* simple linear hash. hash function is sum of
8: characters mod hash table size.
9: */
10: hashloc(s)
11: char *s;
12: {
13: register int i;
14: register int hashval;
15: register char *t;
16:
17: hashval = 0;
18:
19: for(t=s; *t!='\0' ; ++t)
20: hashval += *t;
21:
22: hashval %= HASHSIZE;
23:
24: for(i=hashval;
25: hashtab[i]!=0 && unequal(s,hashtab[i]->namep);
26: i = (i+1)%HASHSIZE ) ;
27:
28: return(i);
29: }
30:
31:
32: struct nameblock *srchname(s)
33: char *s;
34: {
35: return( hashtab[hashloc(s)] );
36: }
37:
38:
39:
40: struct nameblock *makename(s)
41: char *s;
42: {
43: /* make a fresh copy of the string s */
44:
45: char *copys();
46: register struct nameblock *p;
47:
48: if(nhashed++ > HASHSIZE-3)
49: fatal("Hash table overflow");
50:
51: p = ALLOC(nameblock);
52: p->nxtnameblock = firstname;
53: p->namep = copys(s);
54: p->linep = 0;
55: p->done = 0;
56: p->septype = 0;
57: p->modtime = 0;
58:
59: firstname = p;
60: if(mainname == NULL)
61: if(s[0]!='.' || hasslash(s) )
62: mainname = p;
63:
64: hashtab[hashloc(s)] = p;
65:
66: return(p);
67: }
68:
69:
70:
71: hasslash(s)
72: char *s;
73: {
74: for( ; *s ; ++s)
75: if(*s == '/')
76: return(YES);
77: return(NO);
78: }
79:
80:
81:
82: char *copys(s)
83: register char *s;
84: {
85: char *calloc();
86: register char *t, *t0;
87:
88: t = t0 = calloc( strlen(s)+1 , sizeof(char) );
89: while(*t++ = *s++)
90: ;
91: return(t0);
92: }
93:
94:
95:
96: char *concat(a,b,c) /* c = concatenation of a and b */
97: register char *a,*b;
98: char *c;
99: {
100: register char *t;
101: t = c;
102:
103: while(*t = *a++) t++;
104: while(*t++ = *b++);
105: return(c);
106: }
107:
108:
109:
110: suffix(a,b,p) /* is b the suffix of a? if so, set p = prefix */
111: register char *a,*b,*p;
112: {
113: char *a0,*b0;
114: a0 = a;
115: b0 = b;
116:
117: while(*a++);
118: while(*b++);
119:
120: if( (a-a0) < (b-b0) ) return(0);
121:
122: while(b>b0)
123: if(*--a != *--b) return(0);
124:
125: while(a0<a) *p++ = *a0++;
126: *p = '\0';
127:
128: return(1);
129: }
130:
131:
132:
133:
134:
135:
136: int *ckalloc(n)
137: register int n;
138: {
139: register int *p;
140:
141: if( p = (int *) calloc(1,n) )
142: return(p);
143:
144: fatal("out of memory");
145: /* NOTREACHED */
146: }
147:
148: /* copy string a into b, substituting for arguments */
149: char *subst(a,b)
150: register char *a,*b;
151: {
152: static depth = 0;
153: register char *s;
154: char vname[100];
155: struct varblock *varptr(), *vbp;
156: char closer;
157:
158: if(++depth > 100)
159: fatal("infinitely recursive macro?");
160: if(a!=0) while(*a)
161: {
162: if(*a != '$') *b++ = *a++;
163: else if(*++a=='\0' || *a=='$')
164: *b++ = *a++;
165: else {
166: s = vname;
167: if( *a=='(' || *a=='{' )
168: {
169: closer = ( *a=='(' ? ')' : '}');
170: ++a;
171: while(*a == ' ') ++a;
172: while(*a!=' ' && *a!=closer && *a!='\0') *s++ = *a++;
173: while(*a!=closer && *a!='\0') ++a;
174: if(*a == closer) ++a;
175: }
176: else *s++ = *a++;
177:
178: *s = '\0';
179: if( (vbp = varptr(vname)) ->varval != 0)
180: {
181: b = subst(vbp->varval, b);
182: vbp->used = YES;
183: }
184: }
185: }
186:
187: *b = '\0';
188: --depth;
189: return(b);
190: }
191:
192:
193: setvar(v,s)
194: char *v, *s;
195: {
196: struct varblock *varptr(), *p;
197:
198: p = varptr(v);
199: if(p->noreset == 0)
200: {
201: p->varval = s;
202: p->noreset = inarglist;
203: if(p->used && unequal(v,"@") && unequal(v,"*")
204: && unequal(v,"<") && unequal(v,"?") )
205: fprintf(stderr, "Warning: %s changed after being used\n",v);
206: }
207: }
208:
209:
210: eqsign(a) /*look for arguments with equal signs but not colons */
211: char *a;
212: {
213: register char *s, *t;
214:
215: while(*a == ' ') ++a;
216: for(s=a ; *s!='\0' && *s!=':' ; ++s)
217: if(*s == '=')
218: {
219: for(t = a ; *t!='=' && *t!=' ' && *t!='\t' ; ++t );
220: *t = '\0';
221:
222: for(++s; *s==' ' || *s=='\t' ; ++s);
223: setvar(a, copys(s));
224: return(YES);
225: }
226:
227: return(NO);
228: }
229:
230:
231: struct varblock *varptr(v)
232: char *v;
233: {
234: register struct varblock *vp;
235:
236: for(vp = firstvar; vp ; vp = vp->nxtvarblock)
237: if(! unequal(v , vp->varname))
238: return(vp);
239:
240: vp = ALLOC(varblock);
241: vp->nxtvarblock = firstvar;
242: firstvar = vp;
243: vp->varname = copys(v);
244: vp->varval = 0;
245: return(vp);
246: }
247:
248:
249: fatal1(s, t)
250: char *s, *t;
251: {
252: char buf[100];
253: fatal( sprintf(buf, s, t) );
254: }
255:
256:
257:
258: fatal(s)
259: char *s;
260: {
261: if(s) fprintf(stderr, "Make: %s. Stop.\n", s);
262: else fprintf(stderr, "\nStop.\n");
263: #ifdef unix
264: fflush(stdout);
265: _exit(1);
266: #endif
267: #ifdef gcos
268: exit(0);
269: #endif
270: }
271:
272:
273:
274: yyerror(s)
275: char *s;
276: {
277: char buf[50];
278: extern int yylineno;
279:
280: fatal( sprintf(buf, "line %d: %s", yylineno, s) );
281: }
282:
283:
284:
285: struct chain *appendq(head, tail)
286: struct chain *head;
287: char *tail;
288: {
289: register struct chain *p, *q;
290:
291: p = ALLOC(chain);
292: p->datap = tail;
293:
294: if(head)
295: {
296: for(q = head ; q->nextp ; q = q->nextp)
297: ;
298: q->nextp = p;
299: return(head);
300: }
301: else
302: return(p);
303: }
304:
305:
306:
307:
308:
309: char *mkqlist(p)
310: struct chain *p;
311: {
312: register char *qbufp, *s;
313: static char qbuf[QBUFMAX];
314:
315: if(p == NULL)
316: {
317: qbuf[0] = '\0';
318: return;
319: }
320:
321: qbufp = qbuf;
322:
323: for( ; p ; p = p->nextp)
324: {
325: s = p->datap;
326: if(qbufp+strlen(s) > &qbuf[QBUFMAX-3])
327: {
328: fprintf(stderr, "$? list too long\n");
329: break;
330: }
331: while (*s)
332: *qbufp++ = *s++;
333: *qbufp++ = ' ';
334: }
335: *--qbufp = '\0';
336: return(qbuf);
337: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.