Fixed assembler not complaining when using RISC regs in 68K mode.
[rmac] / procln.c
index edd21730331b07981cbda13a7270e204a049c8c1..9987aad70ef4c836d81a1fb08ea4fc8f95aae579 100644 (file)
--- a/procln.c
+++ b/procln.c
@@ -16,7 +16,7 @@
 #include "direct.h"
 #include "macro.h"
 #include "symbol.h"
-#include "risca.h"
+#include "riscasm.h"
 
 #define DEF_KW                                 // Declare keyword values 
 #include "kwtab.h"                             // Incl generated keyword tables & defs
@@ -29,6 +29,7 @@
 #define DECL_MR
 #include "risckw.h"
 
+
 IFENT * ifent;                                 // Current ifent
 static IFENT ifent0;                   // Root ifent
 static IFENT * f_ifent;                        // Freelist of ifents
@@ -38,11 +39,11 @@ VALUE pcloc;                                        // Value of "PC" at beginning of line
 IFENT * ifent;                                 // Current ifent
 SYM * lab_sym;                                 // Label on line (or NULL)
 
-char extra_stuff[] = "extra (unexpected) text found after addressing mode";
-char * comma_error = "missing comma";
-char * syntax_error = "syntax error";
-char * locgl_error = "cannot GLOBL local symbol";
-char * lab_ignored = "label ignored";
+const char extra_stuff[] = "extra (unexpected) text found after addressing mode";
+const char comma_error[] = "missing comma";
+const char syntax_error[] = "syntax error";
+const char locgl_error[] = "cannot GLOBL local symbol";
+const char lab_ignored[] = "label ignored";
 
 // Table to convert an addressing-mode number to a bitmask.
 LONG amsktab[0112] = {
@@ -91,7 +92,7 @@ LONG amsktab[0112] = {
 //
 // Initialize Line Processor
 //
-void init_procln(void)
+void InitLineProcessor(void)
 {
        disabled = 0;
        ifent = &ifent0;
@@ -103,7 +104,7 @@ void init_procln(void)
 //
 // Line Processor
 //
-void assemble(void)
+void Assemble(void)
 {
        int state;                                      // Keyword machine state (output)
        int j;                                          // Random int, must be fast
@@ -126,14 +127,14 @@ void assemble(void)
        WORD rmask;                                     // Register list, for REG
        int registerbank;                       // RISC register bank
        int riscreg;                            // RISC register
-
        listflag = 0;                           // Initialise listing flag
 
 loop:                                                  // Line processing loop label
 
        // Get another line of tokens
-       if (tokln() == TKEOF)
+       if (TokenizeLine() == TKEOF)
        {
+if (verb_flag) printf("Assemble: Found TKEOF flag...\n");
                if (list_flag && listflag)                      // Flush last line of source
                        listeol();
 
@@ -178,7 +179,7 @@ loop1:                                                                              // Internal line processing loop
 
        if (j == '=' || j == DEQUALS || j == SET || j == REG || j == EQUREG || j == CCDEF)
        {
-               equate = (char *)tok[1];
+               equate = string[tok[1]];
                equtyp = j;
                tok += 3;
                goto normal;
@@ -188,7 +189,8 @@ loop1:                                                                              // Internal line processing loop
        if (j == ':' || j == DCOLON)
        {
 as68label:
-               label = (char *)tok[1];                         // Get label name
+//             label = (char *)tok[1];                         // Get label name
+               label = string[tok[1]];                         // Get label name
                labtyp = tok[2];                                        // Get label type
                tok += 3;                                                       // Go to next line token
 
@@ -206,7 +208,8 @@ as68label:
                }
        }
 
-       if (*tok == EOL)                                                // EOL is legal here...
+       // EOL is legal here...
+       if (*tok == EOL)
                goto normal;
 
        // Next token MUST be a symbol
@@ -218,8 +221,12 @@ as68label:
 
 // This is the problem here: On 64-bit platforms, this cuts the native pointer
 // in half. We need to figure out how to fix this.
-#warning "!!! Bad pointer !!!"
+//#warning "!!! Bad pointer !!!"
+#if 0
        opname = p = (char *)*tok++;                    // Store opcode name here
+#else
+       opname = p = string[*tok++];
+#endif
 
        // Check to see if the SYMBOL is a keyword (a mnemonic or directive).
        // On output, `state' will have one of the values:
@@ -253,11 +260,11 @@ as68label:
        siz = SIZN;
 
        if (*tok == DOTW) 
-               siz = SIZW, ++tok;
+               siz = SIZW, tok++;
        else if (*tok == DOTL)
-               siz = SIZL, ++tok;
+               siz = SIZL, tok++;
        else if (*tok == DOTB)
-               siz = SIZB, ++tok;
+               siz = SIZB, tok++;
 
        // Do special directives (500..999) (These must be handled in "real time")
        if (state >= 500 && state < 1000)
@@ -299,7 +306,7 @@ as68label:
                                if (label != NULL)
                                        warn(lab_ignored);
 
-                               defmac();
+                               DefineMacro();
                        }
 
                        goto loop;
@@ -310,7 +317,7 @@ as68label:
                                if (label != NULL)
                                        warn(lab_ignored);
 
-                               exitmac();
+                               ExitMacro();
                        }
 
                        goto loop;
@@ -339,16 +346,20 @@ normal:
        // Do equates
        if (equate != NULL)
        {
-               j = 0;                                                          // Pick global or local sym enviroment
+               // Pick global or local symbol enviroment
+#if 0
+               j = 0;
 
                if (*equate == '.')
                        j = curenv;
-
+#else
+               j = (*equate == '.' ? curenv : 0);
+#endif
                sy = lookup(equate, LABEL, j);
 
                if (sy == NULL)
                {
-                       sy = newsym(equate, LABEL, j);
+                       sy = NewSymbol(equate, LABEL, j);
                        sy->sattr = 0;
 
                        if (equtyp == DEQUALS)
@@ -367,12 +378,14 @@ normal:
                {
                        if ((equtyp == EQUREG) && (sy->sattre & UNDEF_EQUR))
                        {
-                               sy->sattre |= ~UNDEF_EQUR; 
+//REALLY?                              sy->sattre |= ~UNDEF_EQUR; 
+                               sy->sattre &= ~UNDEF_EQUR; 
                                sy->svalue  = 0;
                        }
                        else if ((equtyp == CCDEF) && (sy->sattre & UNDEF_CC))
                        {
-                               sy->sattre |= ~UNDEF_CC;
+//REALLY?                              sy->sattre |= ~UNDEF_CC;
+                               sy->sattre &= ~UNDEF_CC;
                                sy->svalue = 0;
                        }
                        else
@@ -392,6 +405,14 @@ normal:
                // o  everything else
                if (equtyp == EQUREG)
                {
+//Linko's request to issue a warning on labels that equated to the same register
+//would go here. Not sure how to implement it though. :-/
+/*
+Maybe like this way:
+have an array of bools with 64 entries. Whenever a register is equated, set the
+corresponding register bool to true. Whenever it's undef'ed, set it to false. When
+checking to see if it's already been equated, issue a warning.
+*/
                        // Check that we are in a RISC section
                        if (!rgpu && !rdsp)
                        {
@@ -404,33 +425,55 @@ normal:
                        {
                                sy->sattre  = EQUATEDREG | RISCSYM;     // Mark as equated register
                                riscreg = (*tok - KW_R0);
-                               sy->sattre |= (riscreg << 8);           // Store register number
-
+//is there any reason to do this, since we're putting this in svalue?
+//i'm thinking, no. Let's test that out! :-D
+//                             sy->sattre |= (riscreg << 8);           // Store register number
+//everything seems to build fine without it... We'll leave it here Just In Case(tm)
+
+#define DEBODGE_REGBANK
+#ifdef DEBODGE_REGBANK
+                               // Default is current state of "regbank"
+                               registerbank = regbank;
+#else
+                               // Default is no register bank specified
+                               registerbank = BANK_N;
+#endif
+
+                               // Check for ",<bank #>" override notation
                                if ((tok[1] == ',') && (tok[2] == CONST))
                                {
+                                       // Advance token pointer to the constant
                                        tok += 3;
 
+                                       // Anything other than a 0 or a 1 will result in "No Bank"
                                        if (*tok == 0)
                                                registerbank = BANK_0;
                                        else if (*tok == 1)
                                                registerbank = BANK_1;
-                                       else
-                                               registerbank = BANK_N;
-                               }
-                               else
-                               {
-                                       registerbank = BANK_N;
                                }
 
+#ifdef DEBODGE_REGBANK
+                               sy->sattre |= registerbank;     // Store register bank
+#else
+// What needs to happen here is to prime registerbank with regbank, then use
+// registerbank down below for the bank marking.
+#warning "!!! regbank <-> registerbank confusion here !!!"
+// The question here is why, if we're allowed to override the ".regbankN" rules above,
+// then why is it using the one set by the directive in the extended attributes and
+// not in what ends up in symbol->svalue?
+// ".regbankN" is not an original Madmac directive, so it's suspect
                                sy->sattre |= regbank;          // Store register bank
+#endif
                                eattr = ABS | DEFINED | GLOBAL;
-                               eval = 0x80000080 + (riscreg) + (registerbank << 8);
+// & what does this $80000080 constant mean???
+//                             eval = 0x80000080 + (riscreg) + (registerbank << 8);
+                               eval = riscreg;
                                tok++;
                        }
                        // Checking for a register symbol
                        else if (tok[0] == SYMBOL)
                        {
-                               sy2 = lookup((char *)tok[1], LABEL, j);
+                               sy2 = lookup(string[tok[1]], LABEL, j);
 
                                // Make sure symbol is a valid equreg
                                if (!sy2 || !(sy2->sattre & EQUATEDREG))
@@ -467,7 +510,7 @@ normal:
 
                        if (tok[0] == SYMBOL)
                        {
-                               sy2 = lookup((char *)tok[1], LABEL, j);
+                               sy2 = lookup(string[tok[1]], LABEL, j);
 
                                if (!sy2 || !(sy2->sattre & EQUATEDCC))
                                {
@@ -488,14 +531,15 @@ normal:
                //equ a equr
                else if (*tok == SYMBOL)
                {
-                       sy2 = lookup((char *)tok[1], LABEL, j);
+                       sy2 = lookup(string[tok[1]], LABEL, j);
 
                        if (sy2 && (sy2->sattre & EQUATEDREG))
                        {
                                sy->stype = sy2->stype;
                                sy->sattr = sy2->sattr;
                                sy->sattre = sy2->sattre;
-                               sy->svalue = (sy2->svalue & 0xFFFFF0FF);
+//ICK                          sy->svalue = (sy2->svalue & 0xFFFFF0FF);
+                               sy->svalue = sy2->svalue;
                                goto loop;
                        }
                        else if (expr(exprbuf, &eval, &eattr, &esym) != OK)
@@ -524,16 +568,13 @@ normal:
        if (label != NULL)
        {
 do_label:
-               j = 0;
-
-               if (*label == '.')
-                       j = curenv;
-
+               // Check for dot in front of label; means this is a local label if present
+               j = (*label == '.' ? curenv : 0);
                sy = lookup(label, LABEL, j);
 
                if (sy == NULL)
                {
-                       sy = newsym(label, LABEL, j);
+                       sy = NewSymbol(label, LABEL, j);
                        sy->sattr = 0;
                        sy->sattre = RISCSYM;
                }
@@ -561,7 +602,7 @@ do_label:
                lab_sym = sy;
 
                if (!j)
-                       ++curenv;
+                       curenv++;
 
                // Make label global
                if (labtyp == DCOLON)
@@ -612,7 +653,7 @@ do_label:
                // Call RISC code generator if we found a mnemonic
                if (state >= 3000)
                {
-                       risccg(state);
+                       GenerateRISCCode(state);
                        goto loop;
                }
        }
@@ -621,7 +662,7 @@ do_label:
        if (state < 0)
        {
                if ((sy = lookup(opname, MACRO, 0)) != NULL) 
-                       invokemac(sy, siz);
+                       InvokeMacro(sy, siz);
                else
                        errors("unknown op '%s'", opname);
 
@@ -703,7 +744,6 @@ int d_if(void)
 
        // Alloc an IFENTRY
        if ((rif = f_ifent) == NULL)
-//             rif = (IFENT *)amem((LONG)sizeof(IFENT));
                rif = (IFENT *)malloc(sizeof(IFENT));
        else
                f_ifent = rif->if_prev;
@@ -713,7 +753,8 @@ int d_if(void)
 
        if (!disabled)
        {
-               if (expr(exprbuf, &eval, &eattr, &esym) != OK) return 0;
+               if (expr(exprbuf, &eval, &eattr, &esym) != OK)
+                       return 0;
 
                if ((eattr & DEFINED) == 0)
                        return error(undef_error);