6502/cc65
1
0
Fork 0
mirror of https://github.com/cc65/cc65.git synced 2025-01-03 16:33:19 +00:00
Code Issues Projects Releases Wiki Activity

Write scopes in id order, so we don't need to write out the id itself. Add the

Browse Source 
size of the scope to the output file and a flag bit that tells us if the scope
has a size.


git-svn-id: svn://svn.cc65.org/cc65/trunk@5097 b7a2c559-68d2-44c3-8de9-860c34a00d81
This commit is contained in:
uz 2011-07-31 15:37:51 +00:00
parent 8ec6f66bf0
commit 72a13e1a21
7 changed files with 82 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/ca65/enum.c
View File

@ -67,7 +67,7 @@ void DoEnum (void)
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 ();
}

9
src/ca65/main.c
View File

@ -869,7 +869,7 @@ int main (int argc, char* argv [])
/* 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.
@ -1018,12 +1018,17 @@ int main (int argc, char* argv [])
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 ();
}

10
src/ca65/pseudo.c
View File

@ -817,7 +817,7 @@ static void DoEnd (void)
static void DoEndProc (void)
/* Leave a lexical level */
{
if (GetCurrentSymTabType () != SCOPETYPE_PROC) {
if (GetCurrentSymTabType () != SCOPE_PROC) {
/* No local scope */
ErrorSkip ("No open .PROC");
} else {
@ -830,7 +830,7 @@ static void DoEndProc (void)
static void DoEndScope (void)
/* Leave a lexical level */
{
if ( GetCurrentSymTabType () != SCOPETYPE_SCOPE) {
if ( GetCurrentSymTabType () != SCOPE_SCOPE) {
/* No local scope */
ErrorSkip ("No open .SCOPE");
} else {
@ -1539,7 +1539,7 @@ static void DoProc (void)
}
/* Enter a new scope */
SymEnterLevel (&Name, SCOPETYPE_PROC, AddrSize, Sym);
SymEnterLevel (&Name, SCOPE_PROC, AddrSize, Sym);
/* Free memory for Name */
SB_Done (&Name);
@ -1666,7 +1666,7 @@ static void DoScope (void)
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);
@ -1760,7 +1760,7 @@ static void DoTag (void)
ErrorSkip ("Unknown struct");
return;
}
if (GetSymTabType (Struct) != SCOPETYPE_STRUCT) {
if (GetSymTabType (Struct) != SCOPE_STRUCT) {
ErrorSkip ("Not a struct");
return;
}

4
src/ca65/struct.c
View File

@ -108,7 +108,7 @@ static long DoStructInternal (long Offs, unsigned Type)
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;
@ -195,7 +195,7 @@ static long DoStructInternal (long Offs, unsigned Type)
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);

43
src/ca65/symtab.c
View File

@ -111,14 +111,16 @@ static SymTable* NewSymTable (SymTable* Parent, const StrBuf* Name)
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;
@ -128,18 +130,13 @@ static SymTable* NewSymTable (SymTable* Parent, const StrBuf* Name)
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) {
@ -224,7 +221,7 @@ void SymEnterLevel (const StrBuf* ScopeName, unsigned char Type,
* 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);
}
}
@ -905,7 +902,7 @@ void WriteScopes (void)
if (DbgSyms) {
/* Get head of list */
const SymTable* S = LastScope;
SymTable* S = RootScope;
/* Write the scope count to the file */
ObjWriteVar (ScopeCount);
@ -913,11 +910,20 @@ void WriteScopes (void)
/* 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;
/* Id of scope */
ObjWriteVar (S->Id);
/* 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;
}
/* Scope must be defined */
CHECK (S->Type != SCOPE_UNDEF);
/* Id of parent scope */
if (S->Parent) {
@ -929,8 +935,8 @@ void WriteScopes (void)
/* Lexical level */
ObjWriteVar (S->Level);
/* Scope flags (currently always zero) */
ObjWriteVar (0);
/* Scope flags */
ObjWriteVar (Flags);
/* Type of scope */
ObjWriteVar (S->Type);
@ -938,6 +944,11 @@ void WriteScopes (void)
/* 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);

24
src/common/scopedefs.h
View File

@ -44,16 +44,24 @@
/* 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
};

37
src/od65/dump.c
View File

@ -238,13 +238,13 @@ static const char* GetScopeType (unsigned Type)
/* 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";
}
}
@ -709,7 +709,7 @@ void DumpObjDbgSyms (FILE* F, unsigned long Offset)
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);
}
}
@ -821,21 +821,32 @@ void DumpObjScopes (FILE* F, unsigned long Offset)
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");