#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
#define DECL_MR
#include "risckw.h"
+
IFENT * ifent; // Current ifent
static IFENT ifent0; // Root ifent
static IFENT * f_ifent; // Freelist of ifents
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] = {
}; // 0112 length
+// Function prototypes
+int HandleLabel(char *, int);
+
+
//
// Initialize Line Processor
//
-void init_procln(void)
+void InitLineProcessor(void)
{
disabled = 0;
ifent = &ifent0;
//
// Line Processor
//
-void assemble(void)
+void Assemble(void)
{
int state; // Keyword machine state (output)
int j; // Random int, must be fast
SYM * sy, * sy2; // Symbol (temp usage)
char * opname = NULL; // Name of dirctve/mnemonic/macro
int listflag; // 0: Don't call listeol()
- int as68mode = 0; // 1: Handle multiple labels
+// int as68mode = 0; // 1: Handle multiple labels
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();
// First token MUST be a symbol
if (*tok != SYMBOL)
{
- error(syntax_error);
+// error(syntax_error);
+ error("syntax error; expected symbol");
goto 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;
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
// and come back at `as68label' above.
if (as68_flag)
{
- as68mode = 0;
+// as68mode = 0;
+ // Looks like another label follows the previous one, so handle
+ // the previous one
if (*tok == SYMBOL && tok[2] == ':')
{
- as68mode = 1;
- goto do_label;
+// as68mode = 1;
+// goto do_label;
+ if (HandleLabel(label, labtyp) != 0)
+ goto loop;
+
+ goto as68label;
}
}
}
- if (*tok == EOL) // EOL is legal here...
+ // EOL is legal here...
+ if (*tok == EOL)
goto normal;
// Next token MUST be a symbol
if (*tok++ != SYMBOL)
{
- error(syntax_error);
+// error(syntax_error);
+ error("syntax error; expected symbol");
goto loop;
}
// 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:
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)
if (label != NULL)
warn(lab_ignored);
- defmac();
+ DefineMacro();
}
goto loop;
case MN_ENDM: // .endm --- same as .exitm
if (!disabled)
{
+ // Label on a macro definition is bad mojo... Warn the user
if (label != NULL)
warn(lab_ignored);
- exitmac();
+ ExitMacro();
}
goto loop;
case MN_REPT:
if (!disabled)
{
+#if 0
if (label != NULL)
warn(lab_ignored);
+#else
+ // Handle labels on REPT directive lines...
+ if (label)
+ {
+ if (HandleLabel(label, labtyp) != 0)
+ goto loop;
+ }
+#endif
defrept();
}
// 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)
{
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
// 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)
{
{
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))
if (tok[0] == SYMBOL)
{
- sy2 = lookup((char *)tok[1], LABEL, j);
+ sy2 = lookup(string[tok[1]], LABEL, j);
if (!sy2 || !(sy2->sattre & EQUATEDCC))
{
//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)
if (label != NULL)
{
do_label:
- j = 0;
-
- if (*label == '.')
- j = curenv;
-
+#if 0
+ // 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;
}
lab_sym = sy;
if (!j)
- ++curenv;
+ curenv++;
// Make label global
if (labtyp == DCOLON)
sy->sattr |= GLOBAL;
}
-
+#else
+ // Non-zero == error occurred
+ if (HandleLabel(label, labtyp) != 0)
+ goto loop;
+#endif
// If we're in as68 mode, and there's another label, go back and handle it
- if (as68_flag && as68mode)
- goto as68label;
+// if (as68_flag && as68mode)
+// goto as68label;
}
// Punt on EOL
// Call RISC code generator if we found a mnemonic
if (state >= 3000)
{
- risccg(state);
+ GenerateRISCCode(state);
goto loop;
}
}
if (state < 0)
{
if ((sy = lookup(opname, MACRO, 0)) != NULL)
- invokemac(sy, siz);
+ InvokeMacro(sy, siz);
else
errors("unknown op '%s'", opname);
}
+//
+// Handle the creation of labels
+//
+int HandleLabel(char * label, int labelType)
+{
+ // Check for dot in front of label; means this is a local label if present
+ int j = (*label == '.' ? curenv : 0);
+ SYM * sy = lookup(label, LABEL, j);
+
+ if (sy == NULL)
+ {
+ sy = NewSymbol(label, LABEL, j);
+ sy->sattr = 0;
+ sy->sattre = RISCSYM;
+ }
+ else if (sy->sattr & DEFINED)
+ return errors("multiply-defined label '%s'", label);
+
+ // Put symbol in "order of definition" list
+ if (!(sy->sattr & SDECLLIST))
+ sym_decl(sy);
+
+ if (orgactive)
+ {
+ sy->svalue = orgaddr;
+ sy->sattr |= ABS | DEFINED | EQUATED;
+ }
+ else
+ {
+ sy->svalue = sloc;
+ sy->sattr |= DEFINED | cursect;
+ }
+
+ lab_sym = sy;
+
+ if (!j)
+ curenv++;
+
+ // Make label global if it has a double colon
+ if (labelType == DCOLON)
+ {
+ if (j)
+ return error(locgl_error);
+
+ sy->sattr |= GLOBAL;
+ }
+
+ return 0;
+}
+
+
//
// .if, Start Conditional Assembly
//
// 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;
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);
projects / rmac / blobdiff