the10thwiz/cc65
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

More work on .sizeof

Browse Source 
git-svn-id: svn://svn.cc65.org/cc65/trunk@2702 b7a2c559-68d2-44c3-8de9-860c34a00d81
This commit is contained in:
cuz
2003-12-02 22:09:45 +00:00
parent 3a7c054f6b
commit 1a9a5f2687
8 changed files with 261 additions and 113 deletions
Download Patch File Download Diff File Expand all files Collapse all files

225
src/ca65/symbol.c
View File

@@ -35,6 +35,9 @@
#include <string.h>
/* common */
#include "strbuf.h"
/* ca65 */
#include "error.h"
#include "nexttok.h"
@@ -45,14 +48,103 @@
/*****************************************************************************/
/* Data */
/* Code */
/*****************************************************************************/
/*****************************************************************************/
/* Code */
/*****************************************************************************/
SymTable* ParseScopedIdent (char* Name, StrBuf* FullName)
/* 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.
*/
{
/* Get the starting table */
SymTable* Scope;
if (Tok == TOK_NAMESPACE) {
/* Start from the root scope */
Scope = RootScope;
} else if (Tok == TOK_IDENT) {
/* Remember the name and skip it */
SB_AppendStr (FullName, strcpy (Name, SVal));
NextTok ();
/* If no namespace symbol follows, we're already done */
if (Tok != TOK_NAMESPACE) {
SB_Terminate (FullName);
return CurrentScope;
}
/* 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));
return 0;
}
} else {
/* Invalid token */
Error ("Identifier expected");
SB_Terminate (FullName);
Name[0] = '\0';
return 0;
}
/* Skip the namespace token that follows */
SB_AppendStr (FullName, "::");
NextTok ();
/* Resolve scopes. */
while (1) {
/* Next token must be an identifier. */
if (Tok != TOK_IDENT) {
Error ("Identifier expected");
SB_Terminate (FullName);
Name[0] = '\0';
return 0;
}
/* Remember and skip the identifier */
SB_AppendStr (FullName, strcpy (Name, SVal));
NextTok ();
/* If a namespace token follows, we search for another scope, otherwise
* the name is a symbol and we're done.
*/
if (Tok != TOK_NAMESPACE) {
/* Symbol */
SB_Terminate (FullName);
return Scope;
}
/* 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));
return 0;
}
/* Skip the namespace token that follows */
SB_AppendStr (FullName, "::");
NextTok ();
}
}
@@ -61,110 +153,57 @@ SymEntry* ParseScopedSymName (int AllocNew)
* and return the symbol table entry.
*/
{
/* Get the starting table */
SymTable* Scope;
if (Tok == TOK_NAMESPACE) {
Scope = RootScope;
NextTok ();
StrBuf FullName = AUTO_STRBUF_INITIALIZER;
char Ident[sizeof (SVal)];
/* Parse the scoped symbol name */
SymTable* Scope = ParseScopedIdent (Ident, &FullName);
/* We don't need FullName any longer */
DoneStrBuf (&FullName);
/* 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);
} else {
Scope = CurrentScope;
/* ### Need to walk up the tree */
}
/* Resolve scopes */
while (1) {
/* An identifier must follow. Remember and skip it. */
char Name[sizeof (SVal)];
if (Tok != TOK_IDENT) {
Error ("Identifier expected");
return 0;
}
strcpy (Name, SVal);
NextTok ();
/* If the next token is a namespace token, handle the name as the
* name of a scope, otherwise it's the name of a symbol in that
* scope.
/* 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 (Tok == TOK_NAMESPACE) {
/* Search for the child scope */
Scope = SymFindScope (Scope, Name, AllocNew);
/* Skip the namespace token */
NextTok ();
/* If we didn't find the scope, bail out */
if (Scope == 0) {
return 0;
}
if (AllocNew) {
return NewSymEntry (Ident);
} else {
/* Search for the symbol and return it */
return SymFind (Scope, Name, AllocNew);
return 0;
}
}
}
SymTable* ParseScopedSymTable (int AllocNew)
SymTable* ParseScopedSymTable (void)
/* Parse a (possibly scoped) symbol table (scope) name, search for it in the
* symbol space and return the symbol table struct.
*/
{
/* Get the starting table */
SymTable* Scope;
if (Tok == TOK_NAMESPACE) {
Scope = RootScope;
NextTok ();
} else {
Scope = CurrentScope;
if (Tok != TOK_IDENT) {
Error ("Identifier expected");
return Scope;
}
StrBuf FullName = AUTO_STRBUF_INITIALIZER;
char Ident[sizeof (SVal)];
/* If no new scope should be allocated, the scope may specify any
* scope in any of the parent scopes, so search for it.
*/
if (!AllocNew) {
Scope = SymFindAnyScope (Scope, SVal);
NextTok ();
if (Tok != TOK_NAMESPACE) {
return Scope;
}
NextTok ();
}
/* Parse the scoped symbol name */
SymTable* Scope = ParseScopedIdent (Ident, &FullName);
/* We don't need FullName any longer */
DoneStrBuf (&FullName);
/* Check if the scope is valid. Errors have already been diagnosed by
* the routine, so just exit.
*/
if (Scope) {
/* Search for the last scope */
Scope = SymFindScope (Scope, Ident, SYM_FIND_EXISTING);
}
/* Resolve scopes. */
while (Tok == TOK_IDENT) {
/* Search for the child scope if we have a valid parent */
if (Scope) {
Scope = SymFindScope (Scope, SVal, AllocNew);
}
/* Skip the name token */
NextTok ();
/* If a namespace token follows, read on, otherwise bail out */
if (Tok == TOK_NAMESPACE) {
NextTok ();
if (Tok != TOK_IDENT) {
Error ("Identifier expected");
}
} else {
break;
}
}
/* Return the scope we found or created */
return Scope;
}