First implementation of .UNDEF for deleting a macro.

git-svn-id: svn://svn.cc65.org/cc65/trunk@5049 b7a2c559-68d2-44c3-8de9-860c34a00d81

src/ca65/macro.c

@@ -106,9 +106,10 @@ struct Macro {
     unsigned 	    TokCount;	/* Number of tokens for this macro */
     TokNode* 	    TokRoot;	/* Root of token list */
     TokNode* 	    TokLast;	/* Pointer to last token in list */
+    StrBuf          Name;	/* Macro name, dynamically allocated */
+    unsigned        Expansions; /* Number of active macro expansions */
     unsigned char   Style;	/* Macro style */
     unsigned char   Incomplete; /* Macro is currently built */
-    StrBuf          Name;	/* Macro name, dynamically allocated */
 };
 
 /* Hash table functions */
@@ -122,9 +123,6 @@ static const HashFunctions HashFunc = {
 /* Macro hash table */
 static HashTable MacroTab = STATIC_HASHTABLE_INITIALIZER (117, &HashFunc);
 
-/* Global macro data */
-static Macro*  	MacroRoot = 0;	/* List of all macros */
-
 /* Structs that holds data for a macro expansion */
 typedef struct MacExp MacExp;
 struct MacExp {
@@ -152,6 +150,9 @@ static int DoMacAbort = 0;
 /* Counter to create local names for symbols */
 static unsigned LocalName = 0;
 
+/* Define style macros disabled if != 0 */
+static unsigned DisableDefines = 0;
+
 
 
 /*****************************************************************************/
@@ -233,14 +234,11 @@ static Macro* NewMacro (const StrBuf* Name, unsigned char Style)
     M->TokCount	  = 0;
     M->TokRoot    = 0;
     M->TokLast    = 0;
-    M->Style	  = Style;
-    M->Incomplete = 1;
     SB_Init (&M->Name);
     SB_Copy (&M->Name, Name);
-
+    M->Expansions = 0;
-    /* Insert the macro into the global macro list */
+    M->Style	  = Style;
-    M->List = MacroRoot;
+    M->Incomplete = 1;
-    MacroRoot = M;
 
     /* Insert the macro into the hash table */
     HT_Insert (&MacroTab, &M->Node);
@@ -268,12 +266,15 @@ static MacExp* NewMacExp (Macro* M)
     LocalName    += M->LocalCount;
     E->ParamCount = 0;
     E->Params     = xmalloc (M->ParamCount * sizeof (TokNode*));
-    E->ParamExp	  = 0;
     for (I = 0; I < M->ParamCount; ++I) {
 	E->Params[I] = 0;
     }
+    E->ParamExp	  = 0;
     E->LISlot     = AllocLineInfoSlot (LI_TYPE_MACRO, MacExpansions);
 
+    /* Mark the macro as expanding */
+    ++M->Expansions;
+
     /* One macro expansion more */
     ++MacExpansions;
 
@@ -291,6 +292,9 @@ static void FreeMacExp (MacExp* E)
     /* One macro expansion less */
     --MacExpansions;
 
+    /* No longer expanding this macro */
+    --E->M->Expansions;
+
     /* Free the parameter lists */
     for (I = 0; I < E->ParamCount; ++I) {
         /* Free one parameter list */
@@ -548,6 +552,28 @@ Done:
 
 
 
+void MacUndef (const StrBuf* Name)
+/* Undefine the macro with the given name. */
+{
+    /* Search for the macro */
+    Macro* M = HT_FindEntry (&MacroTab, Name);
+
+    /* Don't let the user kid with us */
+    if (M == 0) {
+        Error ("No such macro: %m%p", Name);
+        return;
+    }
+    if (M->Expansions > 0) {
+        Error ("Cannot delete a macro that is currently expanded");
+        return;
+    }
+
+    /* Remove the macro from the macro table */
+    HT_RemoveEntry (&MacroTab, M);
+}
+
+
+
 static int MacExpand (void* Data)
 /* If we're currently expanding a macro, set the the scanner token and
  * attribute to the next value and return true. If we are not expanding
@@ -678,19 +704,11 @@ MacEnd:
 
 
 
-static void StartExpClassic (Macro* M)
+static void StartExpClassic (MacExp* E)
-/* Start expanding the classic macro M */
+/* Start expanding a classic macro */
 {
-    MacExp*     E;
     token_t     Term;
 
-
-    /* Create a structure holding expansion data. This must be done before
-     * skipping the macro name, because the call to NextTok may cause a new
-     * expansion if the next token is actually a .define style macro.
-     */
-    E = NewMacExp (M);
-
     /* Skip the macro name */
     NextTok ();
 
@@ -700,7 +718,7 @@ static void StartExpClassic (Macro* M)
 	TokNode* Last;
 
        	/* Check for maximum parameter count */
-	if (E->ParamCount >= M->ParamCount) {
+	if (E->ParamCount >= E->M->ParamCount) {
        	    ErrorSkip ("Too many macro parameters");
 	    break;
     	}
@@ -767,16 +785,13 @@ static void StartExpClassic (Macro* M)
 
 
 
-static void StartExpDefine (Macro* M)
+static void StartExpDefine (MacExp* E)
 /* Start expanding a DEFINE style macro */
 {
-    /* Create a structure holding expansion data */
-    MacExp* E = NewMacExp (M);
-
     /* A define style macro must be called with as many actual parameters
      * as there are formal ones. Get the parameter count.
      */
-    unsigned Count = M->ParamCount;
+    unsigned Count = E->M->ParamCount;
 
     /* Skip the current token */
     NextTok ();
@@ -858,9 +873,11 @@ static void StartExpDefine (Macro* M)
 void MacExpandStart (void)
 /* Start expanding the macro in SVal */
 {
+    MacExp* E;
+
     /* Search for the macro */
     Macro* M = HT_FindEntry (&MacroTab, &CurTok.SVal);
-    CHECK (M != 0);
+    CHECK (M != 0 && (M->Style != MAC_STYLE_DEFINE || DisableDefines == 0));
 
     /* We cannot expand an incomplete macro */
     if (M->Incomplete) {
@@ -876,10 +893,13 @@ void MacExpandStart (void)
         return;
     }
 
+    /* Create a structure holding expansion data */
+    E = NewMacExp (M);
+
     /* Call the apropriate subroutine */
     switch (M->Style) {
-    	case MAC_STYLE_CLASSIC:	StartExpClassic (M);	break;
+    	case MAC_STYLE_CLASSIC:	StartExpClassic (E);	break;
-	case MAC_STYLE_DEFINE:	StartExpDefine (M);	break;
+    	case MAC_STYLE_DEFINE:	StartExpDefine (E);	break;
     	default:       	      	Internal ("Invalid macro style: %d", M->Style);
     }
 }
@@ -909,7 +929,15 @@ int IsMacro (const StrBuf* Name)
 int IsDefine (const StrBuf* Name)
 /* Return true if the given name is the name of a define style macro */
 {   
-    Macro* M = HT_FindEntry (&MacroTab, Name);
+    Macro* M;
+
+    /* Never if disabled */
+    if (DisableDefines) {             
+        return 0;
+    }
+
+    /* Check if we have such a macro */
+    M = HT_FindEntry (&MacroTab, Name);
     return (M != 0 && M->Style == MAC_STYLE_DEFINE);
 }
 
@@ -923,4 +951,22 @@ int InMacExpansion (void)
 
 
 
+void DisableDefineStyleMacros (void)
+/* Disable define style macros until EnableDefineStyleMacros is called */
+{
+    ++DisableDefines;
+}
+
+
+
+void EnableDefineStyleMacros (void)
+/* Re-enable define style macros previously disabled with
+ * DisableDefineStyleMacros.
+ */
+{
+    PRECONDITION (DisableDefines > 0);
+    --DisableDefines;
+}
+
+
 

src/ca65/macro.h

@@ -6,7 +6,7 @@
 /*                                                                           */
 /*                                                                           */
 /*                                                                           */
-/* (C) 1998-2008 Ullrich von Bassewitz                                       */
+/* (C) 1998-2011, Ullrich von Bassewitz                                      */
 /*                Roemerstrasse 52                                           */
 /*                D-70794 Filderstadt                                        */
 /* EMail:         uz@cc65.org                                                */
@@ -38,6 +38,16 @@
 
 
 
+/*****************************************************************************/
+/*                                 Forwards                                  */
+/*****************************************************************************/
+
+
+
+struct StrBuf;
+
+
+
 /*****************************************************************************/
 /*			    	     Data				     */
 /*****************************************************************************/
@@ -59,6 +69,9 @@
 void MacDef (unsigned Style);
 /* Parse a macro definition */
 
+void MacUndef (const struct StrBuf* Name);
+/* Undefine the macro with the given name. */
+
 void MacExpandStart (void);
 /* Start expanding the macro in SVal */
 
@@ -74,6 +87,14 @@ int IsDefine (const StrBuf* Name);
 int InMacExpansion (void);
 /* Return true if we're currently expanding a macro */
 
+void DisableDefineStyleMacros (void);
+/* Disable define style macros until EnableDefineStyleMacros is called */
+
+void EnableDefineStyleMacros (void);
+/* Re-enable define style macros previously disabled with
+ * DisableDefineStyleMacros.
+ */
+
 
 
 /* End of macro.h */

src/ca65/pseudo.c

@@ -1778,6 +1778,29 @@ static void DoTag (void)
 
 
 
+static void DoUnDef (void)
+/* Undefine a macro */
+{                              
+    /* The function is called with the .UNDEF token in place, because we need
+     * to disable .define macro expansions before reading the next token. 
+     * Otherwise the name of the macro would be expanded, so we would never 
+     * see it.
+     */
+    DisableDefineStyleMacros ();
+    NextTok ();
+    EnableDefineStyleMacros ();
+
+    /* We expect an identifier */
+    if (CurTok.Tok != TOK_IDENT) {
+	ErrorSkip ("Identifier expected");
+    } else {
+        MacUndef (&CurTok.SVal);
+        NextTok ();
+    }
+}
+
+
+
 static void DoUnexpected (void)
 /* Got an unexpected keyword */
 {
@@ -1970,6 +1993,7 @@ static CtrlDesc CtrlCmdTab [] = {
     { ccNone,           DoTag           },
     { ccNone,		DoUnexpected	},   	/* .TCOUNT */
     { ccNone,  	       	DoUnexpected	},   	/* .TIME */
+    { ccKeepToken,      DoUnDef         },
     { ccNone,           DoUnion         },
     { ccNone,           DoUnexpected    },      /* .VERSION */
     { ccNone,		DoWarning	},

src/ca65/scanner.c

@@ -278,6 +278,8 @@ struct DotKeyword {
     { ".TAG",           TOK_TAG         },
     { ".TCOUNT",	TOK_TCOUNT	},
     { ".TIME",         	TOK_TIME	},
+    { ".UNDEF",         TOK_UNDEF       },
+    { ".UNDEFINE",      TOK_UNDEF       },
     { ".UNION",         TOK_UNION       },
     { ".VERSION",       TOK_VERSION     },
     { ".WARNING",	TOK_WARNING	},

src/ca65/token.h

@@ -247,6 +247,7 @@ typedef enum token_t {
     TOK_TAG,
     TOK_TCOUNT,
     TOK_TIME,
+    TOK_UNDEF,
     TOK_UNION,
     TOK_VERSION,
     TOK_WARNING,