42 |
|
|
43 |
|
long eclock = -1; /* value storage timer */ |
44 |
|
|
45 |
< |
static char context[MAXWORD]; /* current context path */ |
45 |
> |
static char context[MAXWORD+1]; /* current context path */ |
46 |
|
|
47 |
|
static VARDEF *hashtbl[NHASH]; /* definition list */ |
48 |
|
static int htndx; /* index for */ |
195 |
|
if (*ctx != CNTXMARK) |
196 |
|
*cpp++ = CNTXMARK; /* make sure there's a mark */ |
197 |
|
do { |
198 |
< |
if (cpp >= context+MAXWORD-1) { |
199 |
< |
*cpp = '\0'; |
200 |
< |
wputs(context); |
201 |
< |
wputs(": context path too long\n"); |
202 |
< |
return(NULL); |
203 |
< |
} |
198 |
> |
if (cpp >= context+MAXWORD) |
199 |
> |
break; /* just copy what we can */ |
200 |
|
if (isid(*ctx)) |
201 |
|
*cpp++ = *ctx++; |
202 |
|
else { |
213 |
|
register char *nam; |
214 |
|
int lvl; |
215 |
|
{ |
216 |
< |
static char nambuf[MAXWORD]; |
217 |
< |
register char *cp = nambuf, *cpp = context; |
218 |
< |
/* check for explicit global */ |
216 |
> |
static char nambuf[MAXWORD+1]; |
217 |
> |
register char *cp = nambuf, *cpp; |
218 |
> |
/* check for explicit local */ |
219 |
|
if (*nam == CNTXMARK) |
220 |
< |
return(lvl > 0 ? NULL : nam+1); |
221 |
< |
/* check for repeat call */ |
222 |
< |
if (nam == nambuf) |
223 |
< |
return(lvl > 0 ? NULL : nambuf); |
220 |
> |
if (lvl > 0) /* only action is to refuse search */ |
221 |
> |
return(NULL); |
222 |
> |
else |
223 |
> |
nam++; |
224 |
> |
else if (nam == nambuf) /* check for repeat call */ |
225 |
> |
return(lvl > 0 ? NULL : nam); |
226 |
|
/* copy name to static buffer */ |
227 |
|
while (*nam) { |
228 |
< |
if (cp >= nambuf+MAXWORD-1) |
228 |
> |
if (cp >= nambuf+MAXWORD) |
229 |
|
goto toolong; |
230 |
< |
if ((*cp++ = *nam++) == CNTXMARK) |
233 |
< |
cpp = NULL; /* flag a qualified name */ |
230 |
> |
*cp++ = *nam++; |
231 |
|
} |
232 |
< |
if (cpp == NULL) { |
232 |
> |
/* check for explicit global */ |
233 |
> |
if (cp > nambuf && cp[-1] == CNTXMARK) { |
234 |
|
if (lvl > 0) |
235 |
< |
return(NULL); /* no higher level */ |
236 |
< |
if (cp[-1] == CNTXMARK) { |
237 |
< |
cp--; cpp = context; /* current context explicitly */ |
238 |
< |
} else |
239 |
< |
cpp = ""; /* else fully qualified */ |
240 |
< |
} else /* else skip the requested levels */ |
241 |
< |
while (lvl-- > 0) { |
242 |
< |
if (!*cpp) |
243 |
< |
return(NULL); /* return NULL if past global level */ |
244 |
< |
while (*++cpp && *cpp != CNTXMARK) |
245 |
< |
; |
248 |
< |
} |
235 |
> |
return(NULL); |
236 |
> |
*--cp = '\0'; |
237 |
> |
return(nambuf); /* already qualified */ |
238 |
> |
} |
239 |
> |
cpp = context; /* else skip the requested levels */ |
240 |
> |
while (lvl-- > 0) { |
241 |
> |
if (!*cpp) |
242 |
> |
return(NULL); /* return NULL if past global level */ |
243 |
> |
while (*++cpp && *cpp != CNTXMARK) |
244 |
> |
; |
245 |
> |
} |
246 |
|
while (*cpp) { /* copy context to static buffer */ |
247 |
< |
if (cp >= nambuf+MAXWORD-1) |
247 |
> |
if (cp >= nambuf+MAXWORD) |
248 |
|
goto toolong; |
249 |
|
*cp++ = *cpp++; |
250 |
|
} |
254 |
– |
*cp = '\0'; |
255 |
– |
return(nambuf); /* return qualified name */ |
251 |
|
toolong: |
252 |
|
*cp = '\0'; |
253 |
< |
eputs(nambuf); |
259 |
< |
eputs(": name too long\n"); |
260 |
< |
quit(1); |
253 |
> |
return(nambuf); /* return qualified name */ |
254 |
|
} |
255 |
|
|
256 |
|
|
333 |
|
char *name; |
334 |
|
{ |
335 |
|
register VARDEF *vp; |
336 |
+ |
LIBR *libp; |
337 |
|
int hv; |
338 |
|
|
339 |
|
if ((vp = varlookup(name)) != NULL) { |
340 |
|
vp->nlinks++; |
341 |
|
return(vp); |
342 |
|
} |
343 |
< |
name = qualname(name, 0); /* use fully qualified name */ |
343 |
> |
#ifdef FUNCTION |
344 |
> |
libp = liblookup(name); |
345 |
> |
#else |
346 |
> |
libp = NULL; |
347 |
> |
#endif |
348 |
> |
if (libp == NULL) /* if name not in library */ |
349 |
> |
name = qualname(name, 0); /* use fully qualified version */ |
350 |
|
hv = hash(name); |
351 |
|
vp = (VARDEF *)emalloc(sizeof(VARDEF)); |
352 |
|
vp->name = savestr(name); |
353 |
|
vp->nlinks = 1; |
354 |
|
vp->def = NULL; |
355 |
< |
vp->lib = NULL; |
355 |
> |
vp->lib = libp; |
356 |
|
vp->next = hashtbl[hv]; |
357 |
|
hashtbl[hv] = vp; |
358 |
|
return(vp); |
482 |
|
{ |
483 |
|
register EPNODE *ep; |
484 |
|
char *qname; |
485 |
< |
EPNODE *lastdef; |
485 |
> |
register VARDEF *vdef; |
486 |
|
|
487 |
|
if (nextc == ';') { /* empty statement */ |
488 |
|
scan(); |
498 |
|
ep = getdefn(); |
499 |
|
qname = qualname(dname(ep), 0); |
500 |
|
#ifdef REDEFW |
501 |
< |
if ((lastdef = dlookup(qname)) != NULL) { |
502 |
< |
wputs(qname); |
503 |
< |
if (lastdef->type == ':') |
504 |
< |
wputs(": redefined constant expression\n"); |
505 |
< |
else |
506 |
< |
wputs(": redefined\n"); |
507 |
< |
} |
501 |
> |
if ((vdef = varlookup(qname)) != NULL) |
502 |
> |
if (vdef->def != NULL) { |
503 |
> |
wputs(qname); |
504 |
> |
if (vdef->def->type == ':') |
505 |
> |
wputs(": redefined constant expression\n"); |
506 |
> |
else |
507 |
> |
wputs(": redefined\n"); |
508 |
> |
} |
509 |
|
#ifdef FUNCTION |
510 |
< |
else if (ep->v.kid->type == FUNC && liblookup(qname) != NULL) { |
511 |
< |
wputs(qname); |
512 |
< |
wputs(": definition hides library function\n"); |
513 |
< |
} |
510 |
> |
else if (ep->v.kid->type == FUNC && vdef->lib != NULL) { |
511 |
> |
wputs(qname); |
512 |
> |
wputs(": definition hides library function\n"); |
513 |
> |
} |
514 |
|
#endif |
515 |
|
#endif |
516 |
|
if (ep->type == ':') |
535 |
|
{ |
536 |
|
register EPNODE *ep1, *ep2; |
537 |
|
|
538 |
< |
if (!isalpha(nextc)) |
538 |
> |
if (!isalpha(nextc) && nextc != CNTXMARK) |
539 |
|
syntax("illegal variable name"); |
540 |
|
|
541 |
|
ep1 = newnode(); |