.equr overhaul part 4: handle equrundef (and the other permutations of the directive)

[rmac] / token.c

diff --git a/token.c b/token.c
index 811ae854c401882da80adf742d988b41ee28b70b..2d3742fedc6d2643ef3d50f6ecfe118120777aed 100644 (file)
--- a/token.c
+++ b/token.c
@@ -974,6 +974,8 @@ int TokenizeLine(void)
        int stuffnull;                          // 1:terminate SYMBOL '\0' at *nullspot
        uint8_t c1;
        int stringNum = 0;                      // Pointer to string locations in tokenized line
+       SYM* sy;                                        // For looking up symbols (.equr)
+       int equrundef = 0;                      // Flag for equrundef scanning
 
 retry:
 
@@ -1199,10 +1201,54 @@ DEBUG { printf("TokenizeLine: Calling fpop() from SRC_IFILE...\n"); }
                        case 121:   // date
                                j = -1;
                        }
+                       
+                       // If we detected equrundef/regundef set relevant flag
+                       if (j == KW_EQURUNDEF)
+                       {
+                               equrundef = 1;
+                               j = -1;
+                               //printf("line %d, equrundef found\n", curlineno);
+                       }
 
                        // If not tokenized keyword OR token was not found
                        if ((j < 0) || (state < 0))
                        {
+                               // Only proceed if no equrundef has been detected. In that case we need to store the symbol
+                               // because the directive handler (d_equrundef) will run outside this loop, further into procln.c
+                               if (!equrundef)
+                               {
+                                       // Last attempt: let's see if this is an equated register
+                                       char temp = *ln;
+                                       *ln = 0;
+                                       sy = lookup(nullspot, LABEL, 0);
+                                       *ln = temp;
+                                       if (sy)
+                                       {
+                                               if (sy->sattre & EQUATEDREG)
+                                               {
+                                                       uint32_t register_token = sy->svalue;
+                                                       if (rgpu || rdsp)
+                                                       {
+                                                               // If we are in GPU or DSP mode then mark the register bank.
+                                                               // We will use it during EvaluateRegisterFromTokenStream()
+                                                               // when we check if we can use the equated register with the currently
+                                                               // selected bank.
+                                                               // Note (ggn): I find all this superfluous. Do we really want to be so
+                                                               //             protective? Plus, the current implementation happily skips
+                                                               //                         these checks on .equr that are set during fixups - oops!
+                                                               register_token |= 0x80000000;           // Mark that this is an .equr
+                                                               if (sy->sattre & BANK_1)
+                                                               {
+                                                                       register_token |= 0x40000000;   // Mark bank 1
+                                                               }
+                                                       }
+                                                       *tk.u32++ = register_token;
+                                                       stuffnull = 0;
+                                                       continue;
+                                               }
+                                       }
+                               }
+                               // Ok, that failed, let's store the symbol instead
                                *tk.u32++ = SYMBOL;
                                string[stringNum] = nullspot;
                                *tk.u32++ = stringNum;