![[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] / 40BSD / cmd / make|
Return to misc.c CVS log | Up to [CSRG BSD Unix] / 40BSD / 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: if( (t = t0 = calloc( strlen(s)+1 , sizeof(char)) ) == NULL)
89: fatal("out of memory");
90: while(*t++ = *s++)
91: ;
92: return(t0);
93: }
94:
95:
96:
97: char *concat(a,b,c) /* c = concatenation of a and b */
98: register char *a,*b;
99: char *c;
100: {
101: register char *t;
102: t = c;
103:
104: while(*t = *a++) t++;
105: while(*t++ = *b++);
106: return(c);
107: }
108:
109:
110:
111: suffix(a,b,p) /* is b the suffix of a? if so, set p = prefix */
112: register char *a,*b,*p;
113: {
114: char *a0,*b0;
115: a0 = a;
116: b0 = b;
117:
118: while(*a++);
119: while(*b++);
120:
121: if( (a-a0) < (b-b0) ) return(0);
122:
123: while(b>b0)
124: if(*--a != *--b) return(0);
125:
126: while(a0<a) *p++ = *a0++;
127: *p = '\0';
128:
129: return(1);
130: }
131:
132:
133:
134:
135:
136:
137: int *ckalloc(n)
138: register int n;
139: {
140: register int *p;
141:
142: if( p = (int *) calloc(1,n) )
143: return(p);
144:
145: fatal("out of memory");
146: /* NOTREACHED */
147: }
148:
149: /* copy string a into b, substituting for arguments */
150: char *subst(a,b)
151: register char *a,*b;
152: {
153: static depth = 0;
154: register char *s;
155: char vname[100];
156: struct varblock *varptr(), *vbp;
157: char closer;
158:
159: if(++depth > 100)
160: fatal("infinitely recursive macro?");
161: if(a!=0) while(*a)
162: {
163: if(*a != '$') *b++ = *a++;
164: else if(*++a=='\0' || *a=='$')
165: *b++ = *a++;
166: else {
167: s = vname;
168: if( *a=='(' || *a=='{' )
169: {
170: closer = ( *a=='(' ? ')' : '}');
171: ++a;
172: while(*a == ' ') ++a;
173: while(*a!=' ' && *a!=closer && *a!='\0') *s++ = *a++;
174: while(*a!=closer && *a!='\0') ++a;
175: if(*a == closer) ++a;
176: }
177: else *s++ = *a++;
178:
179: *s = '\0';
180: if( (vbp = varptr(vname)) ->varval != 0)
181: {
182: b = subst(vbp->varval, b);
183: vbp->used = YES;
184: }
185: }
186: }
187:
188: *b = '\0';
189: --depth;
190: return(b);
191: }
192:
193:
194: setvar(v,s)
195: char *v, *s;
196: {
197: struct varblock *varptr(), *p;
198:
199: p = varptr(v);
200: if(p->noreset == 0)
201: {
202: p->varval = s;
203: p->noreset = inarglist;
204: if(p->used && unequal(v,"@") && unequal(v,"*")
205: && unequal(v,"<") && unequal(v,"?") )
206: fprintf(stderr, "Warning: %s changed after being used\n",v);
207: }
208: }
209:
210:
211: eqsign(a) /*look for arguments with equal signs but not colons */
212: char *a;
213: {
214: register char *s, *t;
215:
216: while(*a == ' ') ++a;
217: for(s=a ; *s!='\0' && *s!=':' ; ++s)
218: if(*s == '=')
219: {
220: for(t = a ; *t!='=' && *t!=' ' && *t!='\t' ; ++t );
221: *t = '\0';
222:
223: for(++s; *s==' ' || *s=='\t' ; ++s);
224: setvar(a, copys(s));
225: return(YES);
226: }
227:
228: return(NO);
229: }
230:
231:
232: struct varblock *varptr(v)
233: char *v;
234: {
235: register struct varblock *vp;
236:
237: for(vp = firstvar; vp ; vp = vp->nxtvarblock)
238: if(! unequal(v , vp->varname))
239: return(vp);
240:
241: vp = ALLOC(varblock);
242: vp->nxtvarblock = firstvar;
243: firstvar = vp;
244: vp->varname = copys(v);
245: vp->varval = 0;
246: return(vp);
247: }
248:
249:
250: fatal1(s, t)
251: char *s, *t;
252: {
253: char buf[100];
254: sprintf(buf, s, t);
255: fatal(buf);
256: }
257:
258:
259:
260: fatal(s)
261: char *s;
262: {
263: if(s) fprintf(stderr, "Make: %s. Stop.\n", s);
264: else fprintf(stderr, "\nStop.\n");
265: #ifdef unix
266: exit(1);
267: #endif
268: #ifdef gcos
269: exit(0);
270: #endif
271: }
272:
273:
274:
275: yyerror(s)
276: char *s;
277: {
278: char buf[50];
279: extern int yylineno;
280:
281: sprintf(buf, "line %d: %s", yylineno, s);
282: fatal(buf);
283: }
284:
285:
286:
287: struct chain *appendq(head, tail)
288: struct chain *head;
289: char *tail;
290: {
291: register struct chain *p, *q;
292:
293: p = ALLOC(chain);
294: p->datap = tail;
295:
296: if(head)
297: {
298: for(q = head ; q->nextp ; q = q->nextp)
299: ;
300: q->nextp = p;
301: return(head);
302: }
303: else
304: return(p);
305: }
306:
307:
308:
309:
310:
311: char *mkqlist(p)
312: struct chain *p;
313: {
314: register char *qbufp, *s;
315: static char qbuf[QBUFMAX];
316:
317: if(p == NULL)
318: {
319: qbuf[0] = '\0';
320: return;
321: }
322:
323: qbufp = qbuf;
324:
325: for( ; p ; p = p->nextp)
326: {
327: s = p->datap;
328: if(qbufp+strlen(s) > &qbuf[QBUFMAX-3])
329: {
330: fprintf(stderr, "$? list too long\n");
331: break;
332: }
333: while (*s)
334: *qbufp++ = *s++;
335: *qbufp++ = ' ';
336: }
337: *--qbufp = '\0';
338: return(qbuf);
339: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.