int Anon = (CurTok.Tok != TOK_IDENT);
if (!Anon) {
/* Enter a new scope, then skip the name */
- SymEnterLevel (&CurTok.SVal, SCOPETYPE_ENUM, ADDR_SIZE_ABS, 0);
+ SymEnterLevel (&CurTok.SVal, SCOPE_ENUM, ADDR_SIZE_ABS, 0);
NextTok ();
}
/* Enter the base lexical level. We must do that here, since we may
* define symbols using -D.
*/
- SymEnterLevel (&GlobalNameSpace, SCOPETYPE_FILE, ADDR_SIZE_DEFAULT, 0);
+ SymEnterLevel (&GlobalNameSpace, SCOPE_FILE, ADDR_SIZE_DEFAULT, 0);
/* Initialize the line infos. Must be done here, since we need line infos
* for symbol definitions.
SymCheck ();
}
+ /* If we didn't have any errors, close the file scope lexical level */
+ if (ErrorCount == 0) {
+ SymLeaveLevel ();
+ }
+
/* If we didn't have any errors, check and resolve the segment data */
if (ErrorCount == 0) {
SegCheck ();
}
- /* If we didn't have any errors, check the assertions */
+ /* If we didn't have any errors, check the assertions */
if (ErrorCount == 0) {
CheckAssertions ();
}
static void DoEndProc (void)
/* Leave a lexical level */
{
- if (GetCurrentSymTabType () != SCOPETYPE_PROC) {
+ if (GetCurrentSymTabType () != SCOPE_PROC) {
/* No local scope */
ErrorSkip ("No open .PROC");
} else {
static void DoEndScope (void)
/* Leave a lexical level */
{
- if ( GetCurrentSymTabType () != SCOPETYPE_SCOPE) {
+ if ( GetCurrentSymTabType () != SCOPE_SCOPE) {
/* No local scope */
ErrorSkip ("No open .SCOPE");
} else {
}
/* Enter a new scope */
- SymEnterLevel (&Name, SCOPETYPE_PROC, AddrSize, Sym);
+ SymEnterLevel (&Name, SCOPE_PROC, AddrSize, Sym);
/* Free memory for Name */
SB_Done (&Name);
AddrSize = OptionalAddrSize ();
/* Enter the new scope */
- SymEnterLevel (&Name, SCOPETYPE_SCOPE, AddrSize, 0);
+ SymEnterLevel (&Name, SCOPE_SCOPE, AddrSize, 0);
/* Free memory for Name */
SB_Done (&Name);
ErrorSkip ("Unknown struct");
return;
}
- if (GetSymTabType (Struct) != SCOPETYPE_STRUCT) {
+ if (GetSymTabType (Struct) != SCOPE_STRUCT) {
ErrorSkip ("Not a struct");
return;
}
int Anon = (CurTok.Tok != TOK_IDENT);
if (!Anon) {
/* Enter a new scope, then skip the name */
- SymEnterLevel (&CurTok.SVal, SCOPETYPE_STRUCT, ADDR_SIZE_ABS, 0);
+ SymEnterLevel (&CurTok.SVal, SCOPE_STRUCT, ADDR_SIZE_ABS, 0);
NextTok ();
/* Start at zero offset in the new scope */
Offs = 0;
Struct = ParseScopedSymTable ();
if (Struct == 0) {
ErrorSkip ("Unknown struct/union");
- } else if (GetSymTabType (Struct) != SCOPETYPE_STRUCT) {
+ } else if (GetSymTabType (Struct) != SCOPE_STRUCT) {
ErrorSkip ("Not a struct/union");
} else {
SymEntry* SizeSym = GetSizeOfScope (Struct);
SymTable* S = xmalloc (sizeof (SymTable) + (Slots-1) * sizeof (SymEntry*));
/* Set variables and clear hash table entries */
+ S->Next = 0;
S->Left = 0;
S->Right = 0;
S->Childs = 0;
S->OwnerSym = 0;
S->SegRanges = AUTO_COLLECTION_INITIALIZER;
+ S->Id = ScopeCount++;
S->Flags = ST_NONE;
S->AddrSize = ADDR_SIZE_DEFAULT;
- S->Type = SCOPETYPE_UNDEF;
+ S->Type = SCOPE_UNDEF;
S->Level = Level;
S->TableSlots = Slots;
S->TableEntries = 0;
S->Table[Slots] = 0;
}
- /* Insert the symbol table into the list of all symbol tables and maintain
- * a unqiue id for each scope. Count the number of scopes.
- */
- S->Next = LastScope;
+ /* Insert the symbol table into the list of all symbol tables */
if (RootScope == 0) {
- S->Id = 0;
RootScope = S;
} else {
- S->Id = LastScope->Id + 1;
+ LastScope->Next = S;
}
LastScope = S;
- ++ScopeCount;
/* Insert the symbol table into the child tree of the parent */
if (Parent) {
* does not allocate memory for useless data (unhandled types here don't
* occupy space in any segment).
*/
- if (CurrentScope->Type <= SCOPETYPE_HAS_DATA) {
+ if (CurrentScope->Type <= SCOPE_HAS_DATA) {
AddSegRanges (&CurrentScope->SegRanges);
}
}
if (DbgSyms) {
/* Get head of list */
- const SymTable* S = LastScope;
+ SymTable* S = RootScope;
/* Write the scope count to the file */
ObjWriteVar (ScopeCount);
/* Walk through all scopes and write them to the file */
while (S) {
- /* Type must be defined */
- CHECK (S->Type != SCOPETYPE_UNDEF);
+ /* Flags for this scope */
+ unsigned Flags = 0;
+
+ /* Check if this scope has a size. If so, remember it in the
+ * flags.
+ */
+ long Size;
+ SymEntry* SizeSym = FindSizeOfScope (S);
+ if (SizeSym != 0 && SymIsConst (SizeSym, &Size)) {
+ Flags |= SCOPE_SIZE;
+ }
- /* Id of scope */
- ObjWriteVar (S->Id);
+ /* Scope must be defined */
+ CHECK (S->Type != SCOPE_UNDEF);
/* Id of parent scope */
if (S->Parent) {
/* Lexical level */
ObjWriteVar (S->Level);
- /* Scope flags (currently always zero) */
- ObjWriteVar (0);
+ /* Scope flags */
+ ObjWriteVar (Flags);
/* Type of scope */
ObjWriteVar (S->Type);
/* Name of the scope */
ObjWriteVar (S->Name);
+ /* If the scope has a size, write it to the file */
+ if (SCOPE_HAS_SIZE (Flags)) {
+ ObjWriteVar (Size);
+ }
+
/* Segment ranges for this scope */
WriteSegRanges (&S->SegRanges);
+/* Size of scope available? */
+#define SCOPE_SIZELESS 0x00U /* No scope size available */
+#define SCOPE_SIZE 0x01U /* Scope has a size */
+#define SCOPE_MASK_SIZE 0x01U /* Size mask */
+
+#define SCOPE_HAS_SIZE(x) (((x) & SCOPE_MASK_SIZE) == SCOPE_SIZE)
+
+
/* Scope types */
enum {
- SCOPETYPE_GLOBAL, /* Global level */
- SCOPETYPE_FILE, /* File level */
- SCOPETYPE_PROC, /* .PROC */
- SCOPETYPE_SCOPE, /* .SCOPE */
- SCOPETYPE_HAS_DATA = SCOPETYPE_SCOPE, /* Last scope that contains data */
- SCOPETYPE_STRUCT, /* .STRUCT/.UNION */
- SCOPETYPE_ENUM, /* .ENUM */
- SCOPETYPE_UNDEF = 0xFF
+ SCOPE_GLOBAL, /* Global level */
+ SCOPE_FILE, /* File level */
+ SCOPE_PROC, /* .PROC */
+ SCOPE_SCOPE, /* .SCOPE */
+ SCOPE_HAS_DATA = SCOPE_SCOPE, /* Last scope that contains data */
+ SCOPE_STRUCT, /* .STRUCT/.UNION */
+ SCOPE_ENUM, /* .ENUM */
+ SCOPE_UNDEF = 0xFF
};
/* Return the name of a scope type */
{
switch (Type) {
- case SCOPETYPE_GLOBAL: return "Global scope";
- case SCOPETYPE_FILE: return "File scope";
- case SCOPETYPE_PROC: return ".PROC";
- case SCOPETYPE_SCOPE: return ".SCOPE";
- case SCOPETYPE_STRUCT: return ".STRUCT";
- case SCOPETYPE_ENUM: return ".ENUM";
- case SCOPETYPE_UNDEF: return "Undefined";
+ case SCOPE_GLOBAL: return "Global scope";
+ case SCOPE_FILE: return "File scope";
+ case SCOPE_PROC: return ".PROC";
+ case SCOPE_SCOPE: return ".SCOPE";
+ case SCOPE_STRUCT: return ".STRUCT";
+ case SCOPE_ENUM: return ".ENUM";
+ case SCOPE_UNDEF: return "Undefined";
default: return "Unknown scope type";
}
}
printf (" Value:%15s0x%08lX (%lu)\n", "", Value, Value);
}
if (SYM_HAS_SIZE (Type)) {
- printf (" Size:%16s0x%04lX (%lu)\n", "", Size, Size);
+ printf (" Size:%20s0x%04lX (%lu)\n", "", Size, Size);
}
}
unsigned SegCount;
unsigned J;
+ /* Read the data */
+ unsigned ParentId = ReadVar (F);
+ unsigned LexicalLevel = ReadVar (F);
+ unsigned Flags = ReadVar (F);
+ const char* ScopeType = GetScopeType (ReadVar (F));
+
/* Print the header */
printf (" Index:%27u\n", I);
/* Print the data */
- printf (" Id:%28lu\n", ReadVar (F));
- printf (" Parent id:%21lu\n", ReadVar (F));
- printf (" Lexical level:%17lu\n", ReadVar (F));
- printf (" Flags:%25lu\n", ReadVar (F));
- printf (" Type:%26s\n", GetScopeType (ReadVar (F)));
+ printf (" Parent id:%21u\n", ParentId);
+ printf (" Lexical level:%17u\n", LexicalLevel);
+ printf (" Flags:%21s0x%02X\n", "", Flags);
+ printf (" Type:%26s\n", ScopeType);
/* Resolve and print the name */
Name = GetString (&StrPool, ReadVar (F));
Len = strlen (Name);
printf (" Name:%*s\"%s\"\n", (int)(24-Len), "", Name);
+ /* Size */
+ if (SCOPE_HAS_SIZE (Flags)) {
+ unsigned long Size = ReadVar (F);
+ printf (" Size:%20s0x%04lX (%lu)\n", "", Size, Size);
+ }
+
/* Segment ranges */
SegCount = ReadVar (F);
printf (" Segment ranges:\n");
projects / cc65 / commitdiff