TOKEN * etok; // Ptr past last token in tokbuf[]
TOKEN tokeol[1] = {EOL}; // Bailout end-of-line token
char * string[TOKBUFSIZE*2]; // Token buffer string pointer storage
+int optimizeOff; // Optimization override flag
// File record, used to maintain a list of every include file ever visited
#define FILEREC struct _filerec
FILEREC * filerec;
FILEREC * last_fr;
-INOBJ * cur_inobj; // Ptr current input obj (IFILE/IMACRO)
-static INOBJ * f_inobj; // Ptr list of free INOBJs
-static IFILE * f_ifile; // Ptr list of free IFILEs
-static IMACRO * f_imacro; // Ptr list of free IMACROs
+INOBJ * cur_inobj; // Ptr current input obj (IFILE/IMACRO)
+static INOBJ * f_inobj; // Ptr list of free INOBJs
+static IFILE * f_ifile; // Ptr list of free IFILEs
+static IMACRO * f_imacro; // Ptr list of free IMACROs
-static TOKEN tokbuf[TOKBUFSIZE]; // Token buffer (stack-like, all files)
+static TOKEN tokbuf[TOKBUFSIZE]; // Token buffer (stack-like, all files)
uint8_t chrtab[0x100] = {
ILLEG, ILLEG, ILLEG, ILLEG, // NUL SOH STX ETX
// to choke on legitimate code... Need to investigate this further
// before changing anything else here!
case CONST:
- sprintf(numbuf, "$%lx", (long unsigned int)*tk++);
+ tk++; // Skip the hi LONG...
+ sprintf(numbuf, "$%lx", (uint64_t)*tk++);
d = numbuf;
break;
case DEQUALS:
case SRC_IREPT: // Pop and release an IREPT
{
DEBUG { printf("dealloc IREPT\n"); }
-// LONG * p = inobj->inobj.irept->ir_firstln;
LLIST * p = inobj->inobj.irept->ir_firstln;
// Deallocate repeat lines
while (p != NULL)
{
-// Shamus: ggn confirmed that this will cause a segfault on 64-bit versions of
-// RMAC. This is just stupid and wrong anyway, so we need to fix crapola
-// like this...
-// LONG * p1 = (LONG *)*p;
-// p = p1;
free(p->line);
p = p->next;
}
int state = 0; // State for keyword detector
int j = 0; // Var for keyword detector
uint8_t c; // Random char
- VALUE v; // Random value
+ uint64_t v; // Random value
uint8_t * nullspot = NULL; // Spot to clobber for SYMBOL termination
int stuffnull; // 1:terminate SYMBOL '\0' at *nullspot
uint8_t c1;
case SRC_IREPT:
if ((ln = GetNextRepeatLine()) == NULL)
{
-DEBUG { printf("TokenizeLine: Calling fpop() from SRC_IREPT...\n"); }
+ DEBUG { printf("TokenizeLine: Calling fpop() from SRC_IREPT...\n"); }
fpop();
goto retry;
}
if (*ln == '*' || *ln == ';' || ((*ln == '/') && (*(ln + 1) == '/')))
goto goteol;
+ // And here we have a very ugly hack for signalling a single line 'turn off
+ // optimization'. There's really no nice way to do this, so hack it is!
+ optimizeOff = 0; // Default is to take optimizations as they come
+
+ if (*ln == '!')
+ {
+ optimizeOff = 1; // Signal that we don't want to optimize this line
+ ln++; // & skip over the darned thing
+ }
+
// Main tokenization loop;
// o skip whitespace;
// o handle end-of-line;
if (((chrtab[*ln] & DOT) == 0) || (dotxtab[*ln] == 0))
return error("[bwsl] must follow '.' in symbol");
- v = (VALUE)dotxtab[*ln++];
+ v = (uint32_t)dotxtab[*ln++];
if (chrtab[*ln] & CTSYM)
return error("misuse of '.'; not allowed in symbols");
case '\\':
c = '\\';
break;
+ case '!':
+ // If we're evaluating a macro
+ // this is valid and expands to
+ // "dot-size"
+ break;
default:
warn("bad backslash code in string");
ln--;
}
else if ((*(ln + 1) & 0xDF) == 'L')
{
+ v &= 0xFFFFFFFF;
ln += 2;
}
}
}
*tk++ = CONST;
- *tk++ = v;
+ *tk++ = v >> 32; // High LONG of 64-bit value
+ *tk++ = v & 0xFFFFFFFF; // Low LONG of 64-bit value
if (obj_format == ALCYON)
{
if ((*(ln + 1) == 'l') || (*(ln + 1) == 'L'))
{
+ v &= 0xFFFFFFFF;
ln += 2;
}
}
*tk++ = CONST;
- *tk++ = v;
+ *tk++ = v >> 32; // High LONG of 64-bit value
+ *tk++ = v & 0xFFFFFFFF; // Low LONG of 64-bit value
continue;
case '@': // @ or octal constant
if (*ln < '0' || *ln > '7')
if ((*(ln+1) == 'l') || (*(ln+1) == 'L'))
{
+ v &= 0xFFFFFFFF;
ln += 2;
}
}
*tk++ = CONST;
- *tk++ = v;
+ *tk++ = v >> 32; // High LONG of 64-bit value
+ *tk++ = v & 0xFFFFFFFF; // Low LONG of 64-bit value
continue;
case '^': // ^ or ^^ <operator-name>
if (*ln != '^')
{
v &= 0x000000FF;
ln += 2;
+ *tk++ = CONST;
+ *tk++ = 0; // Hi LONG of 64-bits
+ *tk++ = v;
+ *tk++ = DOTB;
}
else if ((*(ln + 1) == 'w') || (*(ln + 1) == 'W'))
{
v &= 0x0000FFFF;
ln += 2;
+ *tk++ = CONST;
+ *tk++ = 0; // Hi LONG of 64-bits
+ *tk++ = v;
+ *tk++ = DOTW;
}
else if ((*(ln + 1) == 'l') || (*(ln + 1) == 'L'))
{
+ v &= 0xFFFFFFFF;
ln += 2;
+ *tk++ = CONST;
+ *tk++ = 0; // Hi LONG of 64-bits
+ *tk++ = v;
+ *tk++ = DOTL;
}
}
+ else
+ {
+ *tk++ = CONST;
+ *tk++ = v >> 32; // High LONG of 64-bit value
+ *tk++ = v & 0xFFFFFFFF; // Low LONG of 64-bit value
+ }
- *tk++ = CONST;
- *tk++ = v;
//printf("CONST: %i\n", v);
continue;
}
printf("[COLON]");
else if (*t == CONST)
{
- t++;
- printf("[CONST: $%X]", (uint32_t)*t);
+ printf("[CONST: $%lX]", ((uint64_t)t[1] << 32) | (uint64_t)t[2]);
+ t += 2;
}
else if (*t == ACONST)
{
projects / rmac / blobdiff