Remember where each symbol was defined and where it was referenced. Write this

[cc65] / src / ca65 / symtab.h

diff --git a/src/ca65/symtab.h b/src/ca65/symtab.h
index 20aa2a354f2b4ccf22f18901829f05bd1721d5ce..ea7e66515c7bed5e036b9b522ee3b74c3671d77d 100644 (file)
--- a/src/ca65/symtab.h
+++ b/src/ca65/symtab.h
@@ -6,10 +6,10 @@
 /*                                                                           */
 /*                                                                           */
 /*                                                                           */
-/* (C) 1998-2003 Ullrich von Bassewitz                                       */
-/*               Römerstraße 52                                              */
-/*               D-70794 Filderstadt                                         */
-/* EMail:        uz@cc65.org                                                 */
+/* (C) 1998-2011, Ullrich von Bassewitz                                      */
+/*                Roemerstrasse 52                                           */
+/*                D-70794 Filderstadt                                        */
+/* EMail:         uz@cc65.org                                                */
 /*                                                                           */
 /*                                                                           */
 /* This software is provided 'as-is', without any expressed or implied       */
@@ -59,34 +59,30 @@
 #define ST_NONE         0x00            /* No flags */
 #define ST_DEFINED      0x01            /* Scope has been defined */
 
-/* Symbol table types */
-#define ST_GLOBAL       0x00            /* Root level */
-#define ST_PROC         0x01            /* .PROC */
-#define ST_SCOPE        0x02            /* .SCOPE */
-#define ST_STRUCT       0x03            /* .STRUCT/.UNION */
-#define ST_ENUM         0x04            /* .ENUM */
-#define ST_UNDEF        0xFF
-
 /* A symbol table */
 typedef struct SymTable SymTable;
 struct SymTable {
+    SymTable*           Next;           /* Pointer to next table in list */
     SymTable*           Left;           /* Pointer to smaller entry */
     SymTable*           Right;          /* Pointer to greater entry */
     SymTable*                  Parent;         /* Link to enclosing scope if any */
     SymTable*           Childs;         /* Pointer to child scopes */
+    SymEntry*           Label;          /* Scope label */
+    Collection          Spans;          /* Spans for this scope */
+    unsigned            Id;             /* Scope id */
     unsigned short      Flags;          /* Symbol table flags */
-    unsigned char      AddrSize;       /* Address size */
+    unsigned char      AddrSize;       /* Address size */
     unsigned char       Type;           /* Type of the scope */
     unsigned            Level;          /* Lexical level */
     unsigned                   TableSlots;     /* Number of hash table slots */
-    unsigned                   TableEntries;   /* Number of entries in the table */
+    unsigned                   TableEntries;   /* Number of entries in the table */
     unsigned            Name;           /* Name of the scope */
     SymEntry*                  Table[1];       /* Dynamic allocation */
 };
 
 /* Symbol tables */
-SymTable*              CurrentScope;   /* Pointer to current symbol table */
-SymTable*      RootScope;      /* Root symbol table */
+extern SymTable*        CurrentScope;   /* Pointer to current symbol table */
+extern SymTable*       RootScope;      /* Root symbol table */
 
 
 
@@ -96,29 +92,39 @@ SymTable*   RootScope;      /* Root symbol table */
 
 
 
-void SymEnterLevel (const char* ScopeName, unsigned char Type, unsigned char AddrSize);
+void SymEnterLevel (const StrBuf* ScopeName, unsigned char Type,
+                    unsigned char AddrSize, SymEntry* OwnerSym);
 /* Enter a new lexical level */
 
 void SymLeaveLevel (void);
 /* Leave the current lexical level */
 
-SymTable* SymFindScope (SymTable* Parent, const char* Name, int AllocNew);
+SymTable* SymFindScope (SymTable* Parent, const StrBuf* Name, int AllocNew);
 /* Find a scope in the given enclosing scope */
 
-SymTable* SymFindAnyScope (SymTable* Parent, const char* Name);
+SymTable* SymFindAnyScope (SymTable* Parent, const StrBuf* Name);
 /* Find a scope in the given or any of its parent scopes. The function will
  * never create a new symbol, since this can only be done in one specific
  * scope.
  */
 
-SymEntry* SymFind (SymTable* Scope, const char* Name, int AllocNew);
+SymEntry* SymFindLocal (SymEntry* Parent, const StrBuf* StrBuf, int AllocNew);
+/* Find a cheap local symbol. If AllocNew is given and the entry is not
+ * found, create a new one. Return the entry found, or the new entry created,
+ * or - in case AllocNew is zero - return 0.
+ */
+
+SymEntry* SymFind (SymTable* Scope, const StrBuf* Name, int AllocNew);
 /* Find a new symbol table entry in the given table. If AllocNew is given and
  * the entry is not found, create a new one. Return the entry found, or the
  * new entry created, or - in case AllocNew is zero - return 0.
  */
 
-int SymIsZP (SymEntry* Sym);
-/* Return true if the symbol is explicitly marked as zeropage symbol */
+SymEntry* SymFindAny (SymTable* Scope, const StrBuf* Name);
+/* Find a symbol in the given or any of its parent scopes. The function will
+ * never create a new symbol, since this can only be done in one specific
+ * scope.
+ */
 
 #if defined(HAVE_INLINE)
 INLINE unsigned char GetSymTabType (const SymTable* S)
@@ -130,9 +136,6 @@ INLINE unsigned char GetSymTabType (const SymTable* S)
 #  define GetSymTabType(S)      ((S)->Type)
 #endif
 
-unsigned char GetCurrentSymTabType ();
-/* Return the type of the current symbol table */
-
 void SymCheck (void);
 /* Run through all symbols and check for anomalies and errors */
 
@@ -148,6 +151,9 @@ void WriteExports (void);
 void WriteDbgSyms (void);
 /* Write a list of all symbols to the object file */
 
+void WriteScopes (void);
+/* Write the scope table to the object file */
+
 
 
 /* End of symtab.h */
@@ -156,4 +162,3 @@ void WriteDbgSyms (void);
 
 
 
-