/*****************************************************************************/
/* */
-/* toklist.c */
+/* toklist.c */
/* */
-/* Token list for the ca65 macroassembler */
+/* Token list for the ca65 macroassembler */
/* */
/* */
/* */
-/* (C) 1998-2008, Ullrich von Bassewitz */
+/* (C) 1998-2012, Ullrich von Bassewitz */
/* Roemerstrasse 52 */
/* D-70794 Filderstadt */
/* EMail: uz@cc65.org */
/* ca65 */
#include "error.h"
#include "istack.h"
+#include "lineinfo.h"
#include "nexttok.h"
#include "scanner.h"
#include "toklist.h"
/*****************************************************************************/
-/* Code */
+/* Data */
+/*****************************************************************************/
+
+
+
+/* Number of currently pushed token lists */
+static unsigned PushCounter = 0;
+
+
+
+/*****************************************************************************/
+/* Code */
/*****************************************************************************/
TokNode* NewTokNode (void)
/* Create and return a token node with the current token value */
{
- TokNode* T;
/* Allocate memory */
- T = xmalloc (sizeof (TokNode));
+ TokNode* N = xmalloc (sizeof (TokNode));
/* Initialize the token contents */
- T->Next = 0;
- T->Tok = Tok;
- T->WS = WS;
- T->IVal = IVal;
- SB_Init (&T->SVal);
- SB_Copy (&T->SVal, &SVal);
+ N->Next = 0;
+ SB_Init (&N->T.SVal);
+ CopyToken (&N->T, &CurTok);
/* Return the node */
- return T;
+ return N;
}
-void FreeTokNode (TokNode* T)
+void FreeTokNode (TokNode* N)
/* Free the given token node */
{
- SB_Done (&T->SVal);
- xfree (T);
+ SB_Done (&N->T.SVal);
+ xfree (N);
}
-void TokSet (TokNode* T)
-/* Set the scanner token from the given token node */
+void TokSet (TokNode* N)
+/* Set the scanner token from the given token node. */
{
/* Set the values */
- Tok = T->Tok;
- WS = T->WS;
- IVal = T->IVal;
- SB_Copy (&SVal, &T->SVal);
+ CopyToken (&CurTok, &N->T);
+ SB_Terminate (&CurTok.SVal);
}
-enum TC TokCmp (const TokNode* T)
+enum TC TokCmp (const TokNode* N)
/* Compare the token given as parameter against the current token */
{
- if (T->Tok != Tok) {
- /* Different token */
- return tcDifferent;
+ if (N->T.Tok != CurTok.Tok) {
+ /* Different token */
+ return tcDifferent;
}
/* If the token has string attribute, check it */
- if (TokHasSVal (T->Tok)) {
- if (SB_Compare (&SVal, &T->SVal) != 0) {
- return tcSameToken;
- }
- } else if (TokHasIVal (T->Tok)) {
- if (T->IVal != IVal) {
- return tcSameToken;
- }
+ if (TokHasSVal (N->T.Tok)) {
+ if (SB_Compare (&CurTok.SVal, &N->T.SVal) != 0) {
+ return tcSameToken;
+ }
+ } else if (TokHasIVal (N->T.Tok)) {
+ if (N->T.IVal != CurTok.IVal) {
+ return tcSameToken;
+ }
}
/* Tokens are identical */
-void InitTokList (TokList* T)
-/* Initialize a token list structure for later use */
-{
- /* Initialize the fields */
- T->Next = 0;
- T->Root = 0;
- T->Last = 0;
- T->RepCount = 0;
- T->RepMax = 1;
- T->Count = 0;
- T->Check = 0;
- T->Data = 0;
-}
-
-
-
TokList* NewTokList (void)
/* Create a new, empty token list */
{
TokList* T = xmalloc (sizeof (TokList));
/* Initialize the fields */
- InitTokList (T);
+ T->Next = 0;
+ T->Root = 0;
+ T->Last = 0;
+ T->RepCount = 0;
+ T->RepMax = 1;
+ T->Count = 0;
+ T->Check = 0;
+ T->Data = 0;
+ T->LI = 0;
/* Return the new list */
return T;
/* Free the token list */
TokNode* T = List->Root;
while (T) {
- TokNode* Tmp = T;
- T = T->Next;
- FreeTokNode (Tmp);
+ TokNode* Tmp = T;
+ T = T->Next;
+ FreeTokNode (Tmp);
+ }
+
+ /* Free associated line info */
+ if (List->LI) {
+ EndLine (List->LI);
}
/* If we have associated data, free it */
if (List->Data) {
- xfree (List->Data);
+ xfree (List->Data);
}
/* Free the list structure itself */
-enum Token GetTokListTerm (enum Token Term)
+enum token_t GetTokListTerm (enum token_t Term)
/* Determine if the following token list is enclosed in curly braces. This is
* the case if the next token is the opening brace. If so, skip it and return
* a closing brace, otherwise return Term.
*/
{
- if (Tok == TOK_LCURLY) {
+ if (CurTok.Tok == TOK_LCURLY) {
NextTok ();
return TOK_RCURLY;
} else {
/* Insert the node into the list */
if (List->Root == 0) {
- List->Root = T;
+ List->Root = T;
} else {
- List->Last->Next = T;
+ List->Last->Next = T;
}
List->Last = T;
/* Cast the generic pointer to an actual list */
TokList* L = List;
- /* Last may never be a NULL pointer, otherwise there's a bug in the code */
- CHECK (L->Last != 0);
+ /* If there are no more tokens, decrement the repeat counter. If it goes
+ * zero, delete the list and remove the function from the stack.
+ */
+ if (L->Last == 0) {
+ if (++L->RepCount >= L->RepMax) {
+ /* Done with this list */
+ FreeTokList (L);
+ --PushCounter;
+ PopInput ();
+ return 0;
+ } else {
+ /* Replay one more time */
+ L->Last = L->Root;
+ }
+ }
/* Set the next token from the list */
TokSet (L->Last);
+ /* Set the line info for the new token */
+ if (L->LI) {
+ EndLine (L->LI);
+ }
+ L->LI = StartLine (&CurTok.Pos, LI_TYPE_ASM, PushCounter);
+
/* If a check function is defined, call it, so it may look at the token
* just set and changed it as apropriate.
*/
if (L->Check) {
- L->Check (L);
+ L->Check (L);
}
/* Set the pointer to the next token */
L->Last = L->Last->Next;
- /* If this was the last token, decrement the repeat counter. If it goes
- * zero, delete the list and remove the function from the stack.
- */
- if (L->Last == 0) {
- if (++L->RepCount >= L->RepMax) {
- /* Done with this list */
- FreeTokList (L);
- PopInput ();
- } else {
- /* Replay one more time */
- L->Last = L->Root;
- }
- }
-
/* We have a token */
return 1;
}
{
/* If the list is empty, just delete it and bail out */
if (List->Count == 0) {
- FreeTokList (List);
- return;
+ FreeTokList (List);
+ return;
}
/* Reset the last pointer to the first element */
List->Last = List->Root;
/* Insert the list specifying our input function */
+ ++PushCounter;
PushInput (ReplayTokList, List, Desc);
}
-
-
-
projects / cc65 / blobdiff