IFENT * ifent; // Current ifent
static IFENT ifent0; // Root ifent
-static IFENT * f_ifent; // Freelist of ifents
-static int disabled; // Assembly conditionally disabled
+IFENT * f_ifent; // Freelist of ifents
+int disabled; // Assembly conditionally disabled
int just_bss; // 1, ds.b in microprocessor mode
-VALUE pcloc; // Value of "PC" at beginning of line
+uint32_t pcloc; // Value of "PC" at beginning of line
SYM * lab_sym; // Label on line (or NULL)
const char extra_stuff[] = "extra (unexpected) text found after addressing mode";
0L, // 0115
0L, // 0116
0L, // 0117
- M_CREG, // 0120 (caches - TODO: is this correct or does it need its own bitfield?)
+ M_CACHE40, // 0120
M_CREG, // 0121
M_FREG, // 0122
M_FPSCR // 0123
char * equate; // Symbol (or NULL)
int labtyp = 0; // Label type (':', DCOLON)
int equtyp = 0; // Equ type ('=', DEQUALS)
- VALUE eval; // Expression value
+ uint64_t eval; // Expression value
WORD eattr; // Expression attributes
SYM * esym; // External symbol involved in expr.
WORD siz = 0; // Size suffix to mnem/diretve/macro
label = NULL; // No label
lab_sym = NULL; // No (exported) label
equate = NULL; // No equate
- tk = tok; // Save first token in line
- pcloc = (VALUE)sloc; // Set beginning-of-line PC
+ tk = tok.u32; // Save first token in line
+ pcloc = (uint32_t)sloc; // Set beginning-of-line PC
loop1: // Internal line processing loop
- if (*tok == EOL) // Restart loop if end-of-line
+ if (*tok.u32 == EOL) // Restart loop if end-of-line
goto loop;
// First token MUST be a symbol (Shamus: not sure why :-/)
- if (*tok != SYMBOL)
+ if (*tok.u32 != SYMBOL)
{
- if ((*tok >= KW_D0) && (*tok <= KW_R31))
+ if ((*tok.u32 >= KW_D0) && (*tok.u32 <= KW_R31))
error("cannot use reserved keyword as label name or .equ");
else
error("syntax error; expected symbol");
goto loop;
}
- j = (int)tok[2]; // Skip equates (normal statements)
+ j = (int)tok.u32[2]; // Skip equates (normal statements)
if (j == '=' || j == DEQUALS || j == SET || j == REG || j == EQUREG || j == CCDEF)
{
- equate = string[tok[1]];
+ equate = string[tok.u32[1]];
equtyp = j;
- tok += 3;
+ tok.u32 += 3;
goto normal;
}
if (j == ':' || j == DCOLON)
{
as68label:
- label = string[tok[1]]; // Get label name
- labtyp = tok[2]; // Get label type
- tok += 3; // Go to next line token
+ label = string[tok.u32[1]]; // Get label name
+ labtyp = tok.u32[2]; // Get label type
+ tok.u32 += 3; // Go to next line token
// AS68 MODE:
// Looks like another label follows the previous one, so handle
// the previous one until there aren't any more
- if (as68_flag && (*tok == SYMBOL && tok[2] == ':'))
+ if (as68_flag && (*tok.u32 == SYMBOL && tok.u32[2] == ':'))
{
if (HandleLabel(label, labtyp) != 0)
goto loop;
}
// EOL is legal here...
- if (*tok == EOL)
+ if (*tok.u32 == EOL)
goto normal;
- // Next token MUST be a symbol
- if (*tok++ != SYMBOL)
+ // First token MUST be a symbol (if we get here, tok didn't advance)
+ if (*tok.u32++ != SYMBOL)
{
error("syntax error; expected symbol");
goto loop;
}
- opname = p = string[*tok++];
+ opname = p = string[*tok.u32++];
// Check to see if the SYMBOL is a keyword (a mnemonic or directive).
// On output, `state' will have one of the values:
// Check for ".b" ".w" ".l" after directive, macro or mnemonic.
siz = SIZN;
- if (*tok == DOTW)
- siz = SIZW, tok++;
- else if (*tok == DOTL)
- siz = SIZL, tok++;
- else if (*tok == DOTB)
- siz = SIZB, tok++;
- else if(*tok == DOTD)
- siz = SIZD, tok++;
- else if(*tok == DOTP)
- siz = SIZP, tok++;
- else if(*tok == DOTQ)
- siz = SIZQ, tok++;
- else if(*tok == DOTS)
- siz = SIZS, tok++;
- else if(*tok == DOTX)
- siz = SIZX, tok++;
-
+ switch (*tok.u32)
+ {
+ case DOTW: siz = SIZW, tok.u32++; break;
+ case DOTL: siz = SIZL, tok.u32++; break;
+ case DOTB: siz = SIZB, tok.u32++; break;
+ case DOTD: siz = SIZD, tok.u32++; break;
+ case DOTP: siz = SIZP, tok.u32++; break;
+ case DOTQ: siz = SIZQ, tok.u32++; break;
+ case DOTS: siz = SIZS, tok.u32++; break;
+ case DOTX: siz = SIZX, tok.u32++; break;
+ }
// Do special directives (500..999) (These must be handled in "real time")
if (state >= 500 && state < 1000)
{
case MN_IF:
d_if();
- goto loop;
+ goto loop;
+
case MN_ELSE:
d_else();
goto loop;
+
case MN_ENDIF:
d_endif();
goto loop;
+
case MN_IIF: // .iif --- immediate if
if (disabled || expr(exprbuf, &eval, &eattr, &esym) != OK)
goto loop;
goto loop;
}
- if (*tok++ != ',')
+ if (*tok.u32++ != ',')
{
error(comma_error);
goto loop;
goto loop;
goto loop1;
+
case MN_MACRO: // .macro --- macro definition
if (!disabled)
{
}
goto loop;
+
case MN_EXITM: // .exitm --- exit macro
case MN_ENDM: // .endm --- same as .exitm
if (!disabled)
}
goto loop;
+
case MN_REPT:
if (!disabled)
{
goto loop;
}
- DefineRept();
+ HandleRept();
}
goto loop;
+
case MN_ENDR:
if (!disabled)
error("mis-nested .endr");
}
// Check for register to equate to
- if ((*tok >= KW_R0) && (*tok <= KW_R31))
+ if ((*tok.u32 >= KW_R0) && (*tok.u32 <= KW_R31))
{
// sy->sattre = EQUATEDREG | RISCSYM; // Mark as equated register
sy->sattre = EQUATEDREG; // Mark as equated register
- riscreg = (*tok - KW_R0);
+ riscreg = (*tok.u32 - KW_R0);
//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
#endif
// Check for ",<bank #>" override notation
- if ((tok[1] == ',') && (tok[2] == CONST))
+ if ((tok.u32[1] == ',') && (tok.u32[2] == CONST))
{
// Advance token pointer to the constant
- tok += 3;
+ tok.u32 += 3;
// Anything other than a 0 or a 1 will result in "No Bank"
- if (*tok == 0)
+ if (*(uint64_t *)tok.u32 == 0)
registerbank = BANK_0;
- else if (*tok == 1)
+ else if (*(uint64_t *)tok.u32 == 1)
registerbank = BANK_1;
}
// & what does this $80000080 constant mean???
// eval = 0x80000080 + (riscreg) + (registerbank << 8);
eval = riscreg;
- tok++;
+ tok.u32++;
}
// Checking for a register symbol
- else if (tok[0] == SYMBOL)
+ else if (tok.u32[0] == SYMBOL)
{
- sy2 = lookup(string[tok[1]], LABEL, j);
+ sy2 = lookup(string[tok.u32[1]], LABEL, j);
// Make sure symbol is a valid equreg
if (!sy2 || !(sy2->sattre & EQUATEDREG))
eattr = ABS | DEFINED | GLOBAL; // Copy symbols attributes
sy->sattre = sy2->sattre;
eval = (sy2->svalue & 0xFFFFF0FF);
- tok += 2;
+ tok.u32 += 2;
}
}
else
if (reglist(&rmask) < 0)
goto loop;
- eval = (VALUE)rmask;
+ eval = (uint32_t)rmask;
eattr = ABS | DEFINED;
}
else if (equtyp == CCDEF)
sy->sattre |= EQUATEDCC;
eattr = ABS | DEFINED | GLOBAL;
- if (tok[0] == SYMBOL)
+ if (tok.u32[0] == SYMBOL)
{
- sy2 = lookup(string[tok[1]], LABEL, j);
+ sy2 = lookup(string[tok.u32[1]], LABEL, j);
if (!sy2 || !(sy2->sattre & EQUATEDCC))
{
eattr = ABS | DEFINED | GLOBAL;
sy->sattre = sy2->sattre;
eval = sy2->svalue;
- tok += 2;
+ tok.u32 += 2;
}
}
else if (expr(exprbuf, &eval, &eattr, &esym) != OK)
goto loop;
}
//equ a equr
- else if (*tok == SYMBOL)
+ else if (*tok.u32 == SYMBOL)
{
- sy2 = lookup(string[tok[1]], LABEL, j);
+ sy2 = lookup(string[tok.u32[1]], LABEL, j);
if (sy2 && (sy2->sattre & EQUATEDREG))
{
}
sy->sattr |= eattr | EQUATED; // Symbol inherits value and attributes
- sy->svalue = eval;
+ sy->svalue = (uint32_t)eval;
if (list_flag) // Put value in listing
- listvalue(eval);
+ listvalue((uint32_t)eval);
at_eol(); // Must be at EOL now
goto loop;
if (amode(1) < 0) // Parse 0, 1 or 2 addr modes
goto loop;
- if (*tok != EOL)
+ if (*tok.u32 != EOL)
error(extra_stuff);
amsk0 = amsktab[am0];
lab_sym = symbol;
+ // Yes, our CS professors told us to write checks for equality this way,
+ // but damn, it hurts my brain every time I look at it. :-/
if (0 == environment)
curenv++;
return 0;
}
-
-//
-// .if, Start conditional assembly
-//
-int d_if(void)
-{
- IFENT * rif;
- WORD eattr;
- VALUE eval;
- SYM * esym;
-
- // Alloc an IFENTRY
- if ((rif = f_ifent) == NULL)
- rif = (IFENT *)malloc(sizeof(IFENT));
- else
- f_ifent = rif->if_prev;
-
- rif->if_prev = ifent;
- ifent = rif;
-
- if (!disabled)
- {
- if (expr(exprbuf, &eval, &eattr, &esym) != OK)
- return 0;
-
- if ((eattr & DEFINED) == 0)
- return error(undef_error);
-
- disabled = !eval;
- }
-
- rif->if_state = (WORD)disabled;
- return 0;
-}
-
-
-//
-// .else, Do alternate case for .if
-//
-int d_else(void)
-{
- IFENT * rif = ifent;
-
- if (rif->if_prev == NULL)
- return error("mismatched .else");
-
- if (disabled)
- disabled = rif->if_prev->if_state;
- else
- disabled = 1;
-
- rif->if_state = (WORD)disabled;
- return 0;
-}
-
-
-//
-// .endif, End of conditional assembly block
-// This is also called by fpop() to pop levels of IFENTs in case a macro or
-// include file exits early with `exitm' or `end'.
-//
-int d_endif (void)
-{
- IFENT * rif = ifent;
-
- if (rif->if_prev == NULL)
- return error("mismatched .endif");
-
- ifent = rif->if_prev;
- disabled = rif->if_prev->if_state;
- rif->if_prev = f_ifent;
- f_ifent = rif;
- return 0;
-}
-