-SymTable* ParseScopedIdent (char* Name, StrBuf* FullName)
+SymTable* ParseScopedIdent (char* Name, StrBuf* ScopeName)
/* Parse a (possibly scoped) identifer. Name must point to a buffer big enough
* to hold such an identifier. The scope of the name must exist and is returned
* as function result, while the last part (the identifier) which may be either
- * a symbol or a scope depending on the context is returned in Name. FullName
- * is a string buffer that is used to store the full name of the identifier
- * including the scope. It is used internally and may be used by the caller
- * for error messages or similar.
+ * a symbol or a scope depending on the context is returned in Name. ScopeName
+ * is a string buffer that is used to store the name of the scope, the
+ * identifier lives in. It does contain anything but the identifier itself, so
+ * if ScopeName is empty on return, no explicit scope was specified. The full
+ * name of the identifier (including the scope) is ScopeName+Name.
*/
{
/* Get the starting table */
} else if (Tok == TOK_IDENT) {
/* Remember the name and skip it */
- SB_AppendStr (FullName, strcpy (Name, SVal));
+ strcpy (Name, SVal);
NextTok ();
/* If no namespace symbol follows, we're already done */
if (Tok != TOK_NAMESPACE) {
- SB_Terminate (FullName);
+ SB_Terminate (ScopeName);
return CurrentScope;
}
+ /* Pass the scope back to the caller */
+ SB_AppendStr (ScopeName, Name);
+
/* The scope must exist, so search for it starting with the current
* scope.
*/
Scope = SymFindAnyScope (CurrentScope, Name);
if (Scope == 0) {
/* Scope not found */
- SB_Terminate (FullName);
- Error ("No such scope: `%s'", SB_GetConstBuf (FullName));
+ SB_Terminate (ScopeName);
+ Error ("No such scope: `%s'", SB_GetConstBuf (ScopeName));
return 0;
}
/* Invalid token */
Error ("Identifier expected");
- SB_Terminate (FullName);
+ SB_Terminate (ScopeName);
Name[0] = '\0';
return 0;
}
/* Skip the namespace token that follows */
- SB_AppendStr (FullName, "::");
+ SB_AppendStr (ScopeName, "::");
NextTok ();
/* Resolve scopes. */
/* Next token must be an identifier. */
if (Tok != TOK_IDENT) {
Error ("Identifier expected");
- SB_Terminate (FullName);
+ SB_Terminate (ScopeName);
Name[0] = '\0';
return 0;
}
/* Remember and skip the identifier */
- SB_AppendStr (FullName, strcpy (Name, SVal));
+ strcpy (Name, SVal);
NextTok ();
/* If a namespace token follows, we search for another scope, otherwise
*/
if (Tok != TOK_NAMESPACE) {
/* Symbol */
- SB_Terminate (FullName);
+ SB_Terminate (ScopeName);
return Scope;
}
+ /* Pass the scope back to the caller */
+ SB_AppendStr (ScopeName, Name);
+
/* Search for the child scope */
Scope = SymFindScope (Scope, Name, SYM_FIND_EXISTING);
if (Scope == 0) {
/* Scope not found */
- SB_Terminate (FullName);
- Error ("No such scope: `%s'", SB_GetConstBuf (FullName));
+ SB_Terminate (ScopeName);
+ Error ("No such scope: `%s'", SB_GetConstBuf (ScopeName));
return 0;
}
/* Skip the namespace token that follows */
- SB_AppendStr (FullName, "::");
+ SB_AppendStr (ScopeName, "::");
NextTok ();
}
}
-
+
SymEntry* ParseScopedSymName (int AllocNew)
* and return the symbol table entry.
*/
{
- StrBuf FullName = AUTO_STRBUF_INITIALIZER;
+ StrBuf ScopeName = AUTO_STRBUF_INITIALIZER;
char Ident[sizeof (SVal)];
+ int NoScope;
+ SymEntry* Sym;
/* Parse the scoped symbol name */
- SymTable* Scope = ParseScopedIdent (Ident, &FullName);
+ SymTable* Scope = ParseScopedIdent (Ident, &ScopeName);
- /* We don't need FullName any longer */
- DoneStrBuf (&FullName);
+ /* If ScopeName is empty, no scope was specified */
+ NoScope = SB_IsEmpty (&ScopeName);
+
+ /* We don't need ScopeName any longer */
+ DoneStrBuf (&ScopeName);
/* Check if the scope is valid. Errors have already been diagnosed by
* the routine, so just exit.
*/
if (Scope) {
- /* Search for the symbol and return it */
- return SymFind (Scope, Ident, AllocNew);
+ /* Search for the symbol and return it. If no scope was specified,
+ * search also in the upper levels.
+ */
+ if (NoScope && !AllocNew) {
+ Sym = SymFindAny (Scope, Ident);
+ } else {
+ Sym = SymFind (Scope, Ident, AllocNew);
+ }
} else {
/* No scope ==> no symbol. To avoid errors in the calling routine that
* may not expect NULL to be returned if AllocNew is true, create a new
* symbol.
*/
if (AllocNew) {
- return NewSymEntry (Ident, SF_NONE);
+ Sym = NewSymEntry (Ident, SF_NONE);
} else {
- return 0;
+ Sym = 0;
}
}
+
+ /* Return the symbol found */
+ return Sym;
}
* symbol space and return the symbol table struct.
*/
{
- StrBuf FullName = AUTO_STRBUF_INITIALIZER;
- char Ident[sizeof (SVal)];
+ StrBuf ScopeName = AUTO_STRBUF_INITIALIZER;
+ char Name[sizeof (SVal)];
+ int NoScope;
+
/* Parse the scoped symbol name */
- SymTable* Scope = ParseScopedIdent (Ident, &FullName);
+ SymTable* Scope = ParseScopedIdent (Name, &ScopeName);
+
+ /* If ScopeName is empty, no scope was specified */
+ NoScope = SB_IsEmpty (&ScopeName);
/* We don't need FullName any longer */
- DoneStrBuf (&FullName);
+ DoneStrBuf (&ScopeName);
- /* Check if the scope is valid. Errors have already been diagnosed by
- * the routine, so just exit.
+ /* If we got no error, search for the child scope withint the enclosing one.
+ * Beware: If no explicit parent scope was specified, search in all upper
+ * levels.
*/
if (Scope) {
/* Search for the last scope */
- Scope = SymFindScope (Scope, Ident, SYM_FIND_EXISTING);
+ if (NoScope) {
+ Scope = SymFindAnyScope (Scope, Name);
+ } else {
+ Scope = SymFindScope (Scope, Name, SYM_FIND_EXISTING);
+ }
}
return Scope;
}
projects / cc65 / blobdiff