1 /*****************************************************************************/
5 /* Macros for the ca65 macroassembler */
9 /* (C) 1998-2011, Ullrich von Bassewitz */
10 /* Roemerstrasse 52 */
11 /* D-70794 Filderstadt */
12 /* EMail: uz@cc65.org */
15 /* This software is provided 'as-is', without any expressed or implied */
16 /* warranty. In no event will the authors be held liable for any damages */
17 /* arising from the use of this software. */
19 /* Permission is granted to anyone to use this software for any purpose, */
20 /* including commercial applications, and to alter it and redistribute it */
21 /* freely, subject to the following restrictions: */
23 /* 1. The origin of this software must not be misrepresented; you must not */
24 /* claim that you wrote the original software. If you use this software */
25 /* in a product, an acknowledgment in the product documentation would be */
26 /* appreciated but is not required. */
27 /* 2. Altered source versions must be plainly marked as such, and must not */
28 /* be misrepresented as being the original software. */
29 /* 3. This notice may not be removed or altered from any source */
32 /*****************************************************************************/
59 /*****************************************************************************/
61 /*****************************************************************************/
65 static unsigned HT_GenHash (const void* Key);
66 /* Generate the hash over a key. */
68 static const void* HT_GetKey (void* Entry);
69 /* Given a pointer to the user entry data, return a pointer to the key */
71 static HashNode* HT_GetHashNode (void* Entry);
72 /* Given a pointer to the user entry data, return a pointer to the hash node */
74 static int HT_Compare (const void* Key1, const void* Key2);
75 /* Compare two keys. The function must return a value less than zero if
76 * Key1 is smaller than Key2, zero if both are equal, and a value greater
77 * than zero if Key1 is greater then Key2.
82 /*****************************************************************************/
84 /*****************************************************************************/
88 /* Struct that describes an identifer (macro param, local list) */
89 typedef struct IdDesc IdDesc;
91 IdDesc* Next; /* Linked list */
92 StrBuf Id; /* Identifier, dynamically allocated */
97 /* Struct that describes a macro definition */
98 typedef struct Macro Macro;
100 HashNode Node; /* Hash list node */
101 Macro* List; /* List of all macros */
102 unsigned LocalCount; /* Count of local symbols */
103 IdDesc* Locals; /* List of local symbols */
104 unsigned ParamCount; /* Parameter count of macro */
105 IdDesc* Params; /* Identifiers of macro parameters */
106 unsigned TokCount; /* Number of tokens for this macro */
107 TokNode* TokRoot; /* Root of token list */
108 TokNode* TokLast; /* Pointer to last token in list */
109 StrBuf Name; /* Macro name, dynamically allocated */
110 unsigned Expansions; /* Number of active macro expansions */
111 unsigned char Style; /* Macro style */
112 unsigned char Incomplete; /* Macro is currently built */
115 /* Hash table functions */
116 static const HashFunctions HashFunc = {
123 /* Macro hash table */
124 static HashTable MacroTab = STATIC_HASHTABLE_INITIALIZER (117, &HashFunc);
126 /* Structs that holds data for a macro expansion */
127 typedef struct MacExp MacExp;
129 MacExp* Next; /* Pointer to next expansion */
130 Macro* M; /* Which macro do we expand? */
131 unsigned IfSP; /* .IF stack pointer at start of expansion */
132 TokNode* Exp; /* Pointer to current token */
133 TokNode* Final; /* Pointer to final token */
134 unsigned LocalStart; /* Start of counter for local symbol names */
135 unsigned ParamCount; /* Number of actual parameters */
136 TokNode** Params; /* List of actual parameters */
137 TokNode* ParamExp; /* Node for expanding parameters */
138 unsigned LISlot; /* Slot for additional line infos */
141 /* Maximum number of nested macro expansions */
142 #define MAX_MACEXPANSIONS 256U
144 /* Number of active macro expansions */
145 static unsigned MacExpansions = 0;
147 /* Flag if a macro expansion should get aborted */
148 static int DoMacAbort = 0;
150 /* Counter to create local names for symbols */
151 static unsigned LocalName = 0;
153 /* Define style macros disabled if != 0 */
154 static unsigned DisableDefines = 0;
158 /*****************************************************************************/
159 /* Hash table functions */
160 /*****************************************************************************/
164 static unsigned HT_GenHash (const void* Key)
165 /* Generate the hash over a key. */
167 return HashBuf (Key);
172 static const void* HT_GetKey (void* Entry)
173 /* Given a pointer to the user entry data, return a pointer to the index */
175 return &((Macro*) Entry)->Name;
180 static HashNode* HT_GetHashNode (void* Entry)
181 /* Given a pointer to the user entry data, return a pointer to the hash node */
183 return &((Macro*) Entry)->Node;
188 static int HT_Compare (const void* Key1, const void* Key2)
189 /* Compare two keys. The function must return a value less than zero if
190 * Key1 is smaller than Key2, zero if both are equal, and a value greater
191 * than zero if Key1 is greater then Key2.
194 return SB_Compare (Key1, Key2);
199 /*****************************************************************************/
201 /*****************************************************************************/
205 static IdDesc* NewIdDesc (const StrBuf* Id)
206 /* Create a new IdDesc, initialize and return it */
208 /* Allocate memory */
209 IdDesc* I = xmalloc (sizeof (IdDesc));
211 /* Initialize the struct */
214 SB_Copy (&I->Id, Id);
216 /* Return the new struct */
222 static Macro* NewMacro (const StrBuf* Name, unsigned char Style)
223 /* Generate a new macro entry, initialize and return it */
225 /* Allocate memory */
226 Macro* M = xmalloc (sizeof (Macro));
228 /* Initialize the macro struct */
229 InitHashNode (&M->Node, M);
238 SB_Copy (&M->Name, Name);
243 /* Insert the macro into the hash table */
244 HT_Insert (&MacroTab, &M->Node);
246 /* Return the new macro struct */
252 static MacExp* NewMacExp (Macro* M)
253 /* Create a new expansion structure for the given macro */
257 /* Allocate memory */
258 MacExp* E = xmalloc (sizeof (MacExp));
260 /* Initialize the data */
262 E->IfSP = GetIfStack ();
265 E->LocalStart = LocalName;
266 LocalName += M->LocalCount;
268 E->Params = xmalloc (M->ParamCount * sizeof (TokNode*));
269 for (I = 0; I < M->ParamCount; ++I) {
273 E->LISlot = AllocLineInfoSlot (LI_TYPE_MACRO, MacExpansions);
275 /* Mark the macro as expanding */
278 /* One macro expansion more */
281 /* Return the new macro expansion */
287 static void FreeMacExp (MacExp* E)
288 /* Remove and free the current macro expansion */
292 /* One macro expansion less */
295 /* No longer expanding this macro */
298 /* Free the parameter lists */
299 for (I = 0; I < E->ParamCount; ++I) {
300 /* Free one parameter list */
301 TokNode* N = E->Params[I];
303 TokNode* P = N->Next;
310 /* Free the additional line info slot */
311 FreeLineInfoSlot (E->LISlot);
313 /* Free the final token if we have one */
315 FreeTokNode (E->Final);
318 /* Free the structure itself */
324 static void MacSkipDef (unsigned Style)
325 /* Skip a macro definition */
327 if (Style == MAC_STYLE_CLASSIC) {
328 /* Skip tokens until we reach the final .endmacro */
329 while (CurTok.Tok != TOK_ENDMACRO && CurTok.Tok != TOK_EOF) {
332 if (CurTok.Tok != TOK_EOF) {
335 Error ("`.ENDMACRO' expected");
338 /* Skip until end of line */
345 void MacDef (unsigned Style)
346 /* Parse a macro definition */
352 /* We expect a macro name here */
353 if (CurTok.Tok != TOK_IDENT) {
354 Error ("Identifier expected");
357 } else if (!UbiquitousIdents && FindInstruction (&CurTok.SVal) >= 0) {
358 /* The identifier is a name of a 6502 instruction, which is not
359 * allowed if not explicitly enabled.
361 Error ("Cannot use an instruction as macro name");
366 /* Did we already define that macro? */
367 if (HT_Find (&MacroTab, &CurTok.SVal) != 0) {
368 /* Macro is already defined */
369 Error ("A macro named `%m%p' is already defined", &CurTok.SVal);
370 /* Skip tokens until we reach the final .endmacro */
375 /* Define the macro */
376 M = NewMacro (&CurTok.SVal, Style);
378 /* Switch to raw token mode and skip the macro name */
379 EnterRawTokenMode ();
382 /* If we have a DEFINE style macro, we may have parameters in braces,
383 * otherwise we may have parameters without braces.
385 if (Style == MAC_STYLE_CLASSIC) {
388 if (CurTok.Tok == TOK_LPAREN) {
396 /* Parse the parameter list */
399 while (CurTok.Tok == TOK_IDENT) {
401 /* Create a struct holding the identifier */
402 IdDesc* I = NewIdDesc (&CurTok.SVal);
404 /* Insert the struct into the list, checking for duplicate idents */
405 if (M->ParamCount == 0) {
408 IdDesc* List = M->Params;
410 if (SB_Compare (&List->Id, &CurTok.SVal) == 0) {
411 Error ("Duplicate symbol `%m%p'", &CurTok.SVal);
413 if (List->Next == 0) {
426 /* Maybe there are more params... */
427 if (CurTok.Tok == TOK_COMMA) {
435 /* For class macros, we expect a separator token, for define style macros,
436 * we expect the closing paren.
438 if (Style == MAC_STYLE_CLASSIC) {
440 } else if (HaveParams) {
444 /* Preparse the macro body. We will read the tokens until we reach end of
445 * file, or a .endmacro (or end of line for DEFINE style macros) and store
446 * them into an token list internal to the macro. For classic macros, there
447 * the .LOCAL command is detected and removed at this time.
451 /* Check for end of macro */
452 if (Style == MAC_STYLE_CLASSIC) {
453 /* In classic macros, only .endmacro is allowed */
454 if (CurTok.Tok == TOK_ENDMACRO) {
458 /* May not have end of file in a macro definition */
459 if (CurTok.Tok == TOK_EOF) {
460 Error ("`.ENDMACRO' expected");
464 /* Accept a newline or end of file for new style macros */
465 if (TokIsSep (CurTok.Tok)) {
470 /* Check for a .LOCAL declaration */
471 if (CurTok.Tok == TOK_LOCAL && Style == MAC_STYLE_CLASSIC) {
477 /* Skip .local or comma */
480 /* Need an identifer */
481 if (CurTok.Tok != TOK_IDENT && CurTok.Tok != TOK_LOCAL_IDENT) {
482 Error ("Identifier expected");
487 /* Put the identifier into the locals list and skip it */
488 I = NewIdDesc (&CurTok.SVal);
494 /* Check for end of list */
495 if (CurTok.Tok != TOK_COMMA) {
501 /* We need end of line after the locals */
506 /* Create a token node for the current token */
509 /* If the token is an ident, check if it is a local parameter */
510 if (CurTok.Tok == TOK_IDENT) {
512 IdDesc* I = M->Params;
514 if (SB_Compare (&I->Id, &CurTok.SVal) == 0) {
515 /* Local param name, replace it */
516 N->T.Tok = TOK_MACPARAM;
525 /* Insert the new token in the list */
526 if (M->TokCount == 0) {
528 M->TokRoot = M->TokLast = N;
530 /* We have already tokens */
531 M->TokLast->Next = N;
536 /* Read the next token */
540 /* Skip the .endmacro for a classic macro */
541 if (Style == MAC_STYLE_CLASSIC) {
545 /* Reset the Incomplete flag now that parsing is done */
549 /* Switch out of raw token mode */
550 LeaveRawTokenMode ();
555 void MacUndef (const StrBuf* Name)
556 /* Undefine the macro with the given name. */
558 /* Search for the macro */
559 Macro* M = HT_FindEntry (&MacroTab, Name);
561 /* Don't let the user kid with us */
563 Error ("No such macro: %m%p", Name);
566 if (M->Expansions > 0) {
567 Error ("Cannot delete a macro that is currently expanded");
571 /* Remove the macro from the macro table */
572 HT_RemoveEntry (&MacroTab, M);
577 static int MacExpand (void* Data)
578 /* If we're currently expanding a macro, set the the scanner token and
579 * attribute to the next value and return true. If we are not expanding
580 * a macro, return false.
583 /* Cast the Data pointer to the actual data structure */
584 MacExp* Mac = (MacExp*) Data;
586 /* Check if we should abort this macro */
592 /* Abort any open .IF statements in this macro expansion */
593 CleanupIfStack (Mac->IfSP);
595 /* Terminate macro expansion */
599 /* We're expanding a macro. Check if we are expanding one of the
604 /* Ok, use token from parameter list */
605 TokSet (Mac->ParamExp, Mac->LISlot);
607 /* Set pointer to next token */
608 Mac->ParamExp = Mac->ParamExp->Next;
615 /* We're not expanding macro parameters. Check if we have tokens left from
620 /* Use next macro token */
621 TokSet (Mac->Exp, Mac->LISlot);
623 /* Set pointer to next token */
624 Mac->Exp = Mac->Exp->Next;
626 /* Is it a request for actual parameter count? */
627 if (CurTok.Tok == TOK_PARAMCOUNT) {
628 CurTok.Tok = TOK_INTCON;
629 CurTok.IVal = Mac->ParamCount;
633 /* Is it the name of a macro parameter? */
634 if (CurTok.Tok == TOK_MACPARAM) {
636 /* Start to expand the parameter token list */
637 Mac->ParamExp = Mac->Params [CurTok.IVal];
639 /* Recursive call to expand the parameter */
640 return MacExpand (Mac);
643 /* If it's an identifier, it may in fact be a local symbol */
644 if ((CurTok.Tok == TOK_IDENT || CurTok.Tok == TOK_LOCAL_IDENT) &&
645 Mac->M->LocalCount) {
646 /* Search for the local symbol in the list */
648 IdDesc* I = Mac->M->Locals;
650 if (SB_Compare (&CurTok.SVal, &I->Id) == 0) {
651 /* This is in fact a local symbol, change the name. Be sure
652 * to generate a local label name if the original name was
653 * a local label, and also generate a name that cannot be
654 * generated by a user.
656 if (SB_At (&I->Id, 0) == LocalStart) {
657 /* Must generate a local symbol */
658 SB_Printf (&CurTok.SVal, "%cLOCAL-MACRO_SYMBOL-%04X",
659 LocalStart, Mac->LocalStart + Index);
662 SB_Printf (&CurTok.SVal, "LOCAL-MACRO_SYMBOL-%04X",
663 Mac->LocalStart + Index);
676 /* The token was successfully set */
681 /* No more macro tokens. Do we have a final token? */
684 /* Set the final token and remove it */
685 TokSet (Mac->Final, Mac->LISlot);
686 FreeTokNode (Mac->Final);
689 /* The token was successfully set */
695 /* End of macro expansion */
698 /* Pop the input function */
701 /* No token available */
707 static void StartExpClassic (MacExp* E)
708 /* Start expanding a classic macro */
712 /* Skip the macro name */
715 /* Read the actual parameters */
716 while (!TokIsSep (CurTok.Tok)) {
720 /* Check for maximum parameter count */
721 if (E->ParamCount >= E->M->ParamCount) {
722 ErrorSkip ("Too many macro parameters");
726 /* The macro may optionally be enclosed in curly braces */
727 Term = GetTokListTerm (TOK_COMMA);
729 /* Read tokens for one parameter, accept empty params */
731 while (CurTok.Tok != Term && CurTok.Tok != TOK_SEP) {
735 /* Check for end of file */
736 if (CurTok.Tok == TOK_EOF) {
737 Error ("Unexpected end of file");
742 /* Get the next token in a node */
745 /* Insert it into the list */
747 E->Params [E->ParamCount] = T;
757 /* One parameter more */
760 /* If the macro argument was enclosed in curly braces, end-of-line
761 * is an error. Skip the closing curly brace.
763 if (Term == TOK_RCURLY) {
764 if (CurTok.Tok == TOK_SEP) {
765 Error ("End of line encountered within macro argument");
771 /* Check for a comma */
772 if (CurTok.Tok == TOK_COMMA) {
779 /* We must be at end of line now, otherwise something is wrong */
782 /* Insert a new token input function */
783 PushInput (MacExpand, E, ".MACRO");
788 static void StartExpDefine (MacExp* E)
789 /* Start expanding a DEFINE style macro */
791 /* A define style macro must be called with as many actual parameters
792 * as there are formal ones. Get the parameter count.
794 unsigned Count = E->M->ParamCount;
796 /* Skip the current token */
799 /* Read the actual parameters */
804 /* The macro may optionally be enclosed in curly braces */
805 token_t Term = GetTokListTerm (TOK_COMMA);
807 /* Check if there is really a parameter */
808 if (TokIsSep (CurTok.Tok) || CurTok.Tok == Term) {
809 ErrorSkip ("Macro parameter #%u is empty", E->ParamCount+1);
814 /* Read tokens for one parameter */
820 /* Get the next token in a node */
823 /* Insert it into the list */
825 E->Params [E->ParamCount] = T;
834 } while (CurTok.Tok != Term && !TokIsSep (CurTok.Tok));
836 /* One parameter more */
839 /* If the macro argument was enclosed in curly braces, end-of-line
840 * is an error. Skip the closing curly brace.
842 if (Term == TOK_RCURLY) {
843 if (TokIsSep (CurTok.Tok)) {
844 Error ("End of line encountered within macro argument");
850 /* Check for a comma */
852 if (CurTok.Tok == TOK_COMMA) {
855 Error ("`,' expected");
860 /* Macro expansion will overwrite the current token. This is a problem
861 * for define style macros since these are called from the scanner level.
862 * To avoid it, remember the current token and re-insert it, once macro
865 E->Final = NewTokNode ();
867 /* Insert a new token input function */
868 PushInput (MacExpand, E, ".DEFINE");
873 void MacExpandStart (void)
874 /* Start expanding the macro in SVal */
878 /* Search for the macro */
879 Macro* M = HT_FindEntry (&MacroTab, &CurTok.SVal);
880 CHECK (M != 0 && (M->Style != MAC_STYLE_DEFINE || DisableDefines == 0));
882 /* We cannot expand an incomplete macro */
884 Error ("Cannot expand an incomplete macro");
888 /* Don't allow too many nested macro expansions - otherwise it is possible
889 * to force an endless loop and assembler crash.
891 if (MacExpansions >= MAX_MACEXPANSIONS) {
892 Error ("Too many nested macro expansions");
896 /* Create a structure holding expansion data */
899 /* Call the apropriate subroutine */
901 case MAC_STYLE_CLASSIC: StartExpClassic (E); break;
902 case MAC_STYLE_DEFINE: StartExpDefine (E); break;
903 default: Internal ("Invalid macro style: %d", M->Style);
910 /* Abort the current macro expansion */
912 /* Must have an expansion */
913 CHECK (MacExpansions > 0);
915 /* Set a flag so macro expansion will terminate on the next call */
921 int IsMacro (const StrBuf* Name)
922 /* Return true if the given name is the name of a macro */
924 return (HT_Find (&MacroTab, Name) != 0);
929 int IsDefine (const StrBuf* Name)
930 /* Return true if the given name is the name of a define style macro */
934 /* Never if disabled */
935 if (DisableDefines) {
939 /* Check if we have such a macro */
940 M = HT_FindEntry (&MacroTab, Name);
941 return (M != 0 && M->Style == MAC_STYLE_DEFINE);
946 int InMacExpansion (void)
947 /* Return true if we're currently expanding a macro */
949 return (MacExpansions > 0);
954 void DisableDefineStyleMacros (void)
955 /* Disable define style macros until EnableDefineStyleMacros is called */
962 void EnableDefineStyleMacros (void)
963 /* Re-enable define style macros previously disabled with
964 * DisableDefineStyleMacros.
967 PRECONDITION (DisableDefines > 0);