| 218 |
|
int lvl; |
| 219 |
|
{ |
| 220 |
|
static char nambuf[MAXWORD]; |
| 221 |
< |
register char *cp = nambuf, *cpp = context; |
| 222 |
< |
/* check for repeat call */ |
| 223 |
< |
if (nam == nambuf) |
| 224 |
< |
return(lvl > 0 ? NULL : nambuf); |
| 221 |
> |
register char *cp = nambuf, *cpp; |
| 222 |
> |
/* check for explicit local */ |
| 223 |
> |
if (*nam == CNTXMARK) |
| 224 |
> |
if (lvl > 0) /* only action is to refuse search */ |
| 225 |
> |
return(NULL); |
| 226 |
> |
else |
| 227 |
> |
nam++; |
| 228 |
> |
else if (nam == nambuf) /* check for repeat call */ |
| 229 |
> |
return(lvl > 0 ? NULL : nam); |
| 230 |
|
/* copy name to static buffer */ |
| 231 |
|
while (*nam) { |
| 232 |
|
if (cp >= nambuf+MAXWORD-1) |
| 233 |
|
goto toolong; |
| 234 |
< |
if ((*cp++ = *nam++) == CNTXMARK) |
| 230 |
< |
cpp = NULL; /* flag a qualified name */ |
| 234 |
> |
*cp++ = *nam++; |
| 235 |
|
} |
| 236 |
< |
if (cpp == NULL) { |
| 236 |
> |
/* check for explicit global */ |
| 237 |
> |
if (cp > nambuf && cp[-1] == CNTXMARK) { |
| 238 |
|
if (lvl > 0) |
| 239 |
< |
return(NULL); /* no higher level */ |
| 240 |
< |
if (cp[-1] == CNTXMARK) { |
| 241 |
< |
cp--; cpp = context; /* current context explicitly */ |
| 242 |
< |
} else |
| 243 |
< |
cpp = ""; /* else fully qualified */ |
| 244 |
< |
} else /* else skip the requested levels */ |
| 245 |
< |
while (lvl-- > 0) { |
| 246 |
< |
if (!*cpp) |
| 247 |
< |
return(NULL); /* return NULL if past global level */ |
| 248 |
< |
while (*++cpp && *cpp != CNTXMARK) |
| 249 |
< |
; |
| 245 |
< |
} |
| 239 |
> |
return(NULL); |
| 240 |
> |
*--cp = '\0'; |
| 241 |
> |
return(nambuf); /* already qualified */ |
| 242 |
> |
} |
| 243 |
> |
cpp = context; /* else skip the requested levels */ |
| 244 |
> |
while (lvl-- > 0) { |
| 245 |
> |
if (!*cpp) |
| 246 |
> |
return(NULL); /* return NULL if past global level */ |
| 247 |
> |
while (*++cpp && *cpp != CNTXMARK) |
| 248 |
> |
; |
| 249 |
> |
} |
| 250 |
|
while (*cpp) { /* copy context to static buffer */ |
| 251 |
|
if (cp >= nambuf+MAXWORD-1) |
| 252 |
|
goto toolong; |
| 256 |
|
return(nambuf); /* return qualified name */ |
| 257 |
|
toolong: |
| 258 |
|
*cp = '\0'; |
| 259 |
< |
wputs(nambuf); |
| 260 |
< |
wputs(": name too long\n"); |
| 261 |
< |
return(NULL); |
| 259 |
> |
eputs(nambuf); |
| 260 |
> |
eputs(": name too long\n"); |
| 261 |
> |
quit(1); |
| 262 |
|
} |
| 263 |
|
|
| 264 |
|
|
| 265 |
+ |
incontext(qn) /* is qualified name in current context? */ |
| 266 |
+ |
register char *qn; |
| 267 |
+ |
{ |
| 268 |
+ |
while (*qn && *qn != CNTXMARK) /* find context mark */ |
| 269 |
+ |
; |
| 270 |
+ |
return(!strcmp(qn, context)); |
| 271 |
+ |
} |
| 272 |
+ |
|
| 273 |
+ |
|
| 274 |
|
#ifdef OUTCHAN |
| 275 |
|
chanout(cs) /* set output channels */ |
| 276 |
|
int (*cs)(); |
| 290 |
|
register int i; |
| 291 |
|
register VARDEF *vp; |
| 292 |
|
register EPNODE *ep; |
| 293 |
< |
|
| 293 |
> |
/* if context is global, clear all */ |
| 294 |
|
for (i = 0; i < NHASH; i++) |
| 295 |
|
for (vp = hashtbl[i]; vp != NULL; vp = vp->next) |
| 296 |
< |
if (lvl >= 2) |
| 297 |
< |
dremove(vp->name); |
| 298 |
< |
else |
| 299 |
< |
dclear(vp->name); |
| 296 |
> |
if (!context[0] || incontext(vp->name)) |
| 297 |
> |
if (lvl >= 2) |
| 298 |
> |
dremove(vp->name); |
| 299 |
> |
else |
| 300 |
> |
dclear(vp->name); |
| 301 |
|
#ifdef OUTCHAN |
| 302 |
|
if (lvl >= 1) { |
| 303 |
|
for (ep = outchan; ep != NULL; ep = ep->sibling) |
| 341 |
|
char *name; |
| 342 |
|
{ |
| 343 |
|
register VARDEF *vp; |
| 344 |
+ |
LIBR *libp; |
| 345 |
|
int hv; |
| 346 |
|
|
| 347 |
|
if ((vp = varlookup(name)) != NULL) { |
| 348 |
|
vp->nlinks++; |
| 349 |
|
return(vp); |
| 350 |
|
} |
| 351 |
< |
name = qualname(name, 0); /* use fully qualified name */ |
| 351 |
> |
#ifdef FUNCTION |
| 352 |
> |
libp = liblookup(name); |
| 353 |
> |
#else |
| 354 |
> |
libp = NULL; |
| 355 |
> |
#endif |
| 356 |
> |
if (libp == NULL) /* if name not in library */ |
| 357 |
> |
name = qualname(name, 0); /* use fully qualified version */ |
| 358 |
|
hv = hash(name); |
| 359 |
|
vp = (VARDEF *)emalloc(sizeof(VARDEF)); |
| 360 |
|
vp->name = savestr(name); |
| 361 |
|
vp->nlinks = 1; |
| 362 |
|
vp->def = NULL; |
| 363 |
< |
vp->lib = NULL; |
| 363 |
> |
vp->lib = libp; |
| 364 |
|
vp->next = hashtbl[hv]; |
| 365 |
|
hashtbl[hv] = vp; |
| 366 |
|
return(vp); |
| 490 |
|
{ |
| 491 |
|
register EPNODE *ep; |
| 492 |
|
char *qname; |
| 493 |
< |
EPNODE *lastdef; |
| 493 |
> |
register VARDEF *vdef; |
| 494 |
|
|
| 495 |
|
if (nextc == ';') { /* empty statement */ |
| 496 |
|
scan(); |
| 506 |
|
ep = getdefn(); |
| 507 |
|
qname = qualname(dname(ep), 0); |
| 508 |
|
#ifdef REDEFW |
| 509 |
< |
if ((lastdef = dlookup(qname)) != NULL) { |
| 510 |
< |
wputs(qname); |
| 511 |
< |
if (lastdef->type == ':') |
| 512 |
< |
wputs(": redefined constant expression\n"); |
| 513 |
< |
else |
| 514 |
< |
wputs(": redefined\n"); |
| 515 |
< |
} |
| 509 |
> |
if ((vdef = varlookup(qname)) != NULL) |
| 510 |
> |
if (vdef->def != NULL) { |
| 511 |
> |
wputs(qname); |
| 512 |
> |
if (vdef->def->type == ':') |
| 513 |
> |
wputs(": redefined constant expression\n"); |
| 514 |
> |
else |
| 515 |
> |
wputs(": redefined\n"); |
| 516 |
> |
} |
| 517 |
|
#ifdef FUNCTION |
| 518 |
< |
else if (ep->v.kid->type == FUNC && liblookup(qname) != NULL) { |
| 519 |
< |
wputs(qname); |
| 520 |
< |
wputs(": definition hides library function\n"); |
| 521 |
< |
} |
| 518 |
> |
else if (ep->v.kid->type == FUNC && vdef->lib != NULL) { |
| 519 |
> |
wputs(qname); |
| 520 |
> |
wputs(": definition hides library function\n"); |
| 521 |
> |
} |
| 522 |
|
#endif |
| 523 |
|
#endif |
| 524 |
|
if (ep->type == ':') |
