//
// RMAC - Reboot's Macro Assembler for all Atari computers
// TOKEN.C - Token Handling
-// Copyright (C) 199x Landon Dyer, 2011-2017 Reboot and Friends
+// Copyright (C) 199x Landon Dyer, 2011-2019 Reboot and Friends
// RMAC derived from MADMAC v1.07 Written by Landon Dyer, 1986
// Source utilised with the kind permission of Landon Dyer
//
#include "token.h"
+
+#include <errno.h>
#include "direct.h"
#include "error.h"
#include "macro.h"
TOKEN * tok; // Ptr to current token
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
+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
dotxtab['W'] = DOTW;
dotxtab['l'] = DOTL; // .l .L
dotxtab['L'] = DOTL;
- dotxtab['i'] = DOTI; // .i .I (???)
+ dotxtab['i'] = DOTI; // .i .I (WTF is this???)
dotxtab['I'] = DOTI;
- dotxtab['D'] = DOTD; // .d .D (quad word)
+ dotxtab['D'] = DOTD; // .d .D (double)
dotxtab['d'] = DOTD;
dotxtab['S'] = DOTS; // .s .S
dotxtab['s'] = DOTS;
- dotxtab['Q'] = DOTQ; // .q .Q
+ dotxtab['Q'] = DOTQ; // .q .Q (quad word)
dotxtab['q'] = DOTQ;
dotxtab['X'] = DOTX; // .x .x
dotxtab['x'] = DOTX;
*dst++ = *s++;
continue;
case '?': // \? <macro> set `questmark' flag
- ++s;
+ s++;
questmark = 1;
break;
case '#': // \#, number of arguments
switch ((int)*tk++)
{
case SYMBOL:
-#if 0
-// d = (char *)*tk++;
- d = string[*tk++];
-#else
- // This fix should be done for strings too
d = symbolString[*tk++];
DEBUG { printf("ExM: SYMBOL=\"%s\"", d); }
-#endif
break;
case STRING:
-#if 0
-// d = (char *)*tk++;
- d = string[*tk++];
-#else
d = symbolString[*tk++];
-#endif
+
if (dst >= edst)
goto overflow;
// to choke on legitimate code... Need to investigate this further
// before changing anything else here!
case CONST:
- sprintf(numbuf, "$%lx", (uint64_t)*tk++);
+// sprintf(numbuf, "$%lx", (uint64_t)*tk++);
+ sprintf(numbuf, "$%" PRIX64, (uint64_t)*tk++);
tk++;
d = numbuf;
break;
// strp = irept->ir_nextln;
}
+ // Mark the current macro line in the irept object
+ // This is probably overkill - a global variable
+ // would suffice here (it only gets used during
+ // error reporting anyway)
+ irept->lineno = irept->ir_nextln->lineno;
// strcpy(irbuf, (char *)(irept->ir_nextln + 1));
strcpy(irbuf, irept->ir_nextln->line);
{
uint8_t * ln = NULL; // Ptr to current position in line
uint8_t * p; // Random character ptr
- TOKEN * tk; // Token-deposit ptr
+ PTR tk; // Token-deposit ptr
int state = 0; // State for keyword detector
int j = 0; // Var for keyword detector
uint8_t c; // Random char
int stuffnull; // 1:terminate SYMBOL '\0' at *nullspot
uint8_t c1;
int stringNum = 0; // Pointer to string locations in tokenized line
- uint64_t * tk64;
retry:
- if (cur_inobj == NULL) // Return EOF if input stack is empty
+ if (cur_inobj == NULL) // Return EOF if input stack is empty
return TKEOF;
// Get another line of input from the current input source: a file, a
if ((ln = GetNextLine()) == NULL)
{
DEBUG { printf("TokenizeLine: Calling fpop() from SRC_IFILE...\n"); }
- if (fpop() == 0) // Pop input level
- goto retry; // Try for more lines
+ if (fpop() == 0) // Pop input level
+ goto retry; // Try for more lines
else
{
ifent->if_prev = (IFENT *)-1; //Signal Assemble() that we have reached EOF with unbalanced if/endifs
}
}
- curlineno++; // Bump line number
+ curlineno++; // Bump line number
lntag = SPACE;
if (as68_flag)
// General housekeeping
tok = tokeol; // Set "tok" to EOL in case of error
- tk = etok; // Reset token ptr
+ tk.u32 = etok; // Reset token ptr
stuffnull = 0; // Don't stuff nulls
totlines++; // Bump total #lines assembled
// token stream:
ln++;
stuffnull = 0;
- *tk++ = (TOKEN)dotxtab[*ln++];
+ *tk.u32++ = (TOKEN)dotxtab[*ln++];
continue;
}
}
*ln++ = EOS; // Terminate symbol
stuffnull = 0; // And never try it again
- // Character following the `.' must have a DOT attribute, and
+ // Character following the '.' must have a DOT attribute, and
// the chararacter after THAT one must not have a start-symbol
// attribute (to prevent symbols that look like, for example,
// "zingo.barf", which might be a good idea anyway....)
}
// Make j = -1 if user tries to use a RISC register while in 68K mode
- if (!(rgpu || rdsp) && ((TOKEN)j >= KW_R0 && (TOKEN)j <= KW_R31))
+ if (!(rgpu || rdsp || dsp56001) && ((TOKEN)j >= KW_R0 && (TOKEN)j <= KW_R31))
{
j = -1;
}
// If not tokenized keyword OR token was not found
if ((j < 0) || (state < 0))
{
- *tk++ = SYMBOL;
-//#warning
-//problem here: nullspot is a char * but TOKEN is a uint32_t. On a 64-bit
-//system, this will cause all kinds of mischief.
-#if 0
- *tk++ = (TOKEN)nullspot;
-#else
+ *tk.u32++ = SYMBOL;
string[stringNum] = nullspot;
- *tk++ = stringNum;
+ *tk.u32++ = stringNum;
stringNum++;
-#endif
}
else
{
- *tk++ = (TOKEN)j;
+ *tk.u32++ = (TOKEN)j;
stuffnull = 0;
}
- if (v) // Record attribute token (if any)
- *tk++ = (TOKEN)v;
+ if (v) // Record attribute token (if any)
+ *tk.u32++ = (TOKEN)v;
- if (stuffnull) // Arrange for string termination on next pass
+ if (stuffnull) // Arrange for string termination on next pass
nullspot = ln;
continue;
// Handle identity tokens
if (c & SELF)
{
- *tk++ = *ln++;
+ *tk.u32++ = *ln++;
continue;
}
case '!': // ! or !=
if (*ln == '=')
{
- *tk++ = NE;
- ++ln;
+ *tk.u32++ = NE;
+ ln++;
}
else
- *tk++ = '!';
+ *tk.u32++ = '!';
continue;
case '\'': // 'string'
if (m6502)
{
// Hardcoded for now, maybe this will change in the future
- *tk++ = STRINGA8;
+ *tk.u32++ = STRINGA8;
goto dostring;
}
// Fall through
case '\"': // "string"
- *tk++ = STRING;
+ *tk.u32++ = STRING;
dostring:
c1 = ln[-1];
string[stringNum] = ln;
- *tk++ = stringNum;
+ *tk.u32++ = stringNum;
stringNum++;
for(p=ln; *ln!=EOS && *ln!=c1;)
case '$': // $, hex constant
if (chrtab[*ln] & HDIGIT)
{
- if (cursize == 'q' || cursize == 'Q')
- {
- // Parse 64-bit integer
- uint64_t v64 = 0;
-
- while (hextab[*ln] >= 0)
- v64 = (v64 << 4) + (int)hextab[*ln++];
-
- *(uint64_t *)tk = v64;
- tk = tk + 2;
-
- continue;
- }
v = 0;
// Parse the hex value
while (hextab[*ln] >= 0)
v = (v << 4) + (int)hextab[*ln++];
+ *tk.u32++ = CONST;
+ *tk.u64++ = v;
+
if (*ln == '.')
{
- if (obj_format == BSD)
+ if ((*(ln + 1) == 'w') || (*(ln + 1) == 'W'))
{
- if ((*(ln + 1) & 0xDF) == 'B')
- {
- v &= 0x000000FF;
- ln += 2;
- }
- else if ((*(ln + 1) & 0xDF) == 'W')
- {
- v &= 0x0000FFFF;
- ln += 2;
- }
- else if ((*(ln + 1) & 0xDF) == 'L')
- {
- v &= 0xFFFFFFFF;
- ln += 2;
- }
+ *tk.u32++ = DOTW;
+ ln += 2;
}
- }
-
- *tk++ = CONST;
- tk64 = (uint64_t *)tk;
- *tk64++ = v;
- tk = (TOKEN *)tk64;
-
- if (obj_format == ALCYON)
- {
- if (*ln == '.')
+ else if ((*(ln + 1) == 'l') || (*(ln + 1) == 'L'))
{
- if ((*(ln + 1) == 'w') || (*(ln + 1) == 'W'))
- {
- *tk++ = DOTW;
- ln += 2;
- }
- else if ((*(ln + 1) == 'l') || (*(ln + 1) == 'L'))
- {
- *tk++ = DOTL;
- ln += 2;
- }
+ *tk.u32++ = DOTL;
+ ln += 2;
}
}
}
else
- *tk++ = '$';
+ *tk.u32++ = '$';
continue;
case '<': // < or << or <> or <=
switch (*ln)
{
case '<':
- *tk++ = SHL;
- ++ln;
+ *tk.u32++ = SHL;
+ ln++;
continue;
case '>':
- *tk++ = NE;
- ++ln;
+ *tk.u32++ = NE;
+ ln++;
continue;
case '=':
- *tk++ = LE;
- ++ln;
+ *tk.u32++ = LE;
+ ln++;
continue;
default:
- *tk++ = '<';
+ *tk.u32++ = '<';
continue;
}
case ':': // : or ::
if (*ln == ':')
{
- *tk++ = DCOLON;
- ++ln;
+ *tk.u32++ = DCOLON;
+ ln++;
}
else
- *tk++ = ':';
+ *tk.u32++ = ':';
continue;
case '=': // = or ==
if (*ln == '=')
{
- *tk++ = DEQUALS;
- ++ln;
+ *tk.u32++ = DEQUALS;
+ ln++;
}
else
- *tk++ = '=';
+ *tk.u32++ = '=';
continue;
case '>': // > or >> or >=
switch (*ln)
{
case '>':
- *tk++ = SHR;
+ *tk.u32++ = SHR;
ln++;
continue;
case '=':
- *tk++ = GE;
+ *tk.u32++ = GE;
ln++;
continue;
default:
- *tk++ = '>';
+ *tk.u32++ = '>';
continue;
}
case '%': // % or binary constant
if (*ln < '0' || *ln > '1')
{
- *tk++ = '%';
+ *tk.u32++ = '%';
continue;
}
}
}
- *tk++ = CONST;
- tk64 = (uint64_t *)tk;
- *tk64++ = v;
- tk = (TOKEN *)tk64;
+ *tk.u32++ = CONST;
+ *tk.u64++ = v;
continue;
case '@': // @ or octal constant
if (*ln < '0' || *ln > '7')
{
- *tk++ = '@';
+ *tk.u32++ = '@';
continue;
}
if (*ln == '.')
{
- if ((*(ln+1) == 'b') || (*(ln+1) == 'B'))
+ if ((*(ln + 1) == 'b') || (*(ln + 1) == 'B'))
{
v &= 0x000000FF;
ln += 2;
}
- if ((*(ln+1) == 'w') || (*(ln+1) == 'W'))
+ if ((*(ln + 1) == 'w') || (*(ln + 1) == 'W'))
{
v &= 0x0000FFFF;
ln += 2;
}
- if ((*(ln+1) == 'l') || (*(ln+1) == 'L'))
+ if ((*(ln + 1) == 'l') || (*(ln + 1) == 'L'))
{
v &= 0xFFFFFFFF;
ln += 2;
}
}
- *tk++ = CONST;
- tk64 = (uint64_t *)tk;
- *tk64++ = v;
- tk = (TOKEN *)tk64;
+ *tk.u32++ = CONST;
+ *tk.u64++ = v;
continue;
case '^': // ^ or ^^ <operator-name>
if (*ln != '^')
{
- *tk++ = '^';
+ *tk.u32++ = '^';
continue;
}
continue;
}
- *tk++ = (TOKEN)j;
+ *tk.u32++ = (TOKEN)j;
continue;
default:
interror(2); // Bad MULTX entry in chrtab
// Handle decimal constant
if (c & DIGIT)
{
+ uint8_t * numStart = ln;
v = 0;
while ((int)chrtab[*ln] & DIGIT)
{
v &= 0x000000FF;
ln += 2;
- *tk++ = CONST;
- tk64 = (uint64_t *)tk;
- *tk64++ = v;
- tk = (uint32_t *)tk64;
- *tk++ = DOTB;
+ *tk.u32++ = CONST;
+ *tk.u64++ = v;
+ *tk.u32++ = DOTB;
}
else if ((*(ln + 1) == 'w') || (*(ln + 1) == 'W'))
{
v &= 0x0000FFFF;
ln += 2;
- *tk++ = CONST;
- tk64 = (uint64_t *)tk;
- *tk64++ = v;
- tk = (uint32_t *)tk64;
-
- *tk++ = DOTW;
+ *tk.u32++ = CONST;
+ *tk.u64++ = v;
+ *tk.u32++ = DOTW;
}
else if ((*(ln + 1) == 'l') || (*(ln + 1) == 'L'))
{
v &= 0xFFFFFFFF;
ln += 2;
- *tk++ = CONST;
- tk64 = (uint64_t *)tk;
- *tk64++ = v;
- tk = (uint32_t *)tk64;
-
- *tk++ = DOTL;
+ *tk.u32++ = CONST;
+ *tk.u64++ = v;
+ *tk.u32++ = DOTL;
}
else if ((int)chrtab[*(ln + 1)] & DIGIT)
{
- // Hey, more digits after the dot, so assume it's a
- // fractional number
- double fract = 10;
- ln++;
- f = (double)v;
-
- while ((int)chrtab[*ln] & DIGIT)
- {
- f = f + (double)(*ln++ - '0') / fract;
- fract *= 10;
- }
-
- *tk++ = FCONST;
- *((double *)tk) = f;
- tk += 2;
+ // Hey, more digits after the dot, so we assume it's a
+ // floating point number of some kind... numEnd will point
+ // to the first non-float character after it's done
+ char * numEnd;
+ errno = 0;
+ double f = strtod(numStart, &numEnd);
+ ln = (uint8_t *)numEnd;
+
+ if (errno != 0)
+ return error("floating point parse error");
+
+ // N.B.: We use the C compiler's internal double
+ // representation for all internal float calcs and
+ // are reasonably sure that the size of said double
+ // is 8 bytes long (which we check for in fltpoint.c)
+ *tk.u32++ = FCONST;
+ *tk.dp = f;
+ tk.u64++;
continue;
}
}
else
{
- *tk++ = CONST;
- tk64 = (uint64_t *)tk;
- *tk64++ = v;
- tk = (TOKEN *)tk64;
+ *tk.u32++ = CONST;
+ *tk.u64++ = v;
}
//printf("CONST: %i\n", v);
// Terminate line of tokens and return "success."
goteol:
- tok = etok; // Set tok to beginning of line
+ tok = etok; // Set tok to beginning of line
- if (stuffnull) // Terminate last SYMBOL
+ if (stuffnull) // Terminate last SYMBOL
*nullspot = EOS;
- *tk++ = EOL;
+ *tk.u32++ = EOL;
return OK;
}
}
+void DumpToken(TOKEN t)
+{
+ if (t == COLON)
+ printf("[COLON]");
+ else if (t == CONST)
+ printf("[CONST]");
+ else if (t == FCONST)
+ printf("[FCONST]");
+ else if (t == ACONST)
+ printf("[ACONST]");
+ else if (t == STRING)
+ printf("[STRING]");
+ else if (t == SYMBOL)
+ printf("[SYMBOL]");
+ else if (t == EOS)
+ printf("[EOS]");
+ else if (t == TKEOF)
+ printf("[TKEOF]");
+ else if (t == DEQUALS)
+ printf("[DEQUALS]");
+ else if (t == SET)
+ printf("[SET]");
+ else if (t == REG)
+ printf("[REG]");
+ else if (t == DCOLON)
+ printf("[DCOLON]");
+ else if (t == GE)
+ printf("[GE]");
+ else if (t == LE)
+ printf("[LE]");
+ else if (t == NE)
+ printf("[NE]");
+ else if (t == SHR)
+ printf("[SHR]");
+ else if (t == SHL)
+ printf("[SHL]");
+ else if (t == UNMINUS)
+ printf("[UNMINUS]");
+ else if (t == DOTB)
+ printf("[DOTB]");
+ else if (t == DOTW)
+ printf("[DOTW]");
+ else if (t == DOTL)
+ printf("[DOTL]");
+ else if (t == DOTQ)
+ printf("[DOTQ]");
+ else if (t == DOTS)
+ printf("[DOTS]");
+ else if (t == DOTD)
+ printf("[DOTD]");
+ else if (t == DOTI)
+ printf("[DOTI]");
+ else if (t == ENDEXPR)
+ printf("[ENDEXPR]");
+ else if (t == CR_ABSCOUNT)
+ printf("[CR_ABSCOUNT]");
+ else if (t == CR_DEFINED)
+ printf("[CR_DEFINED]");
+ else if (t == CR_REFERENCED)
+ printf("[CR_REFERENCED]");
+ else if (t == CR_STREQ)
+ printf("[CR_STREQ]");
+ else if (t == CR_MACDEF)
+ printf("[CR_MACDEF]");
+ else if (t == CR_TIME)
+ printf("[CR_TIME]");
+ else if (t == CR_DATE)
+ printf("[CR_DATE]");
+ else if (t >= 0x20 && t <= 0x2F)
+ printf("[%c]", (char)t);
+ else if (t >= 0x3A && t <= 0x3F)
+ printf("[%c]", (char)t);
+ else if (t >= 0x80 && t <= 0x87)
+ printf("[D%u]", ((uint32_t)t) - 0x80);
+ else if (t >= 0x88 && t <= 0x8F)
+ printf("[A%u]", ((uint32_t)t) - 0x88);
+ else
+ printf("[%X:%c]", (uint32_t)t, (char)t);
+}
+
+
void DumpTokenBuffer(void)
{
printf("Tokens [%X]: ", sloc);
printf("[COLON]");
else if (*t == CONST)
{
- printf("[CONST: $%lX]", ((uint64_t)t[1] << 32) | (uint64_t)t[2]);
+ PTR tp;
+ tp.u32 = t + 1;
+ printf("[CONST: $%lX]", *tp.u64);
+ t += 2;
+ }
+ else if (*t == FCONST)
+ {
+ PTR tp;
+ tp.u32 = t + 1;
+ printf("[FCONST: $%lX]", *tp.u64);
t += 2;
}
else if (*t == ACONST)
printf("[DOTW]");
else if (*t == DOTL)
printf("[DOTL]");
+ else if (*t == DOTQ)
+ printf("[DOTQ]");
+ else if (*t == DOTS)
+ printf("[DOTS]");
+ else if (*t == DOTD)
+ printf("[DOTD]");
else if (*t == DOTI)
printf("[DOTI]");
else if (*t == ENDEXPR)