//
-// RMAC - Reboot's Macro Assembler for the Atari Jaguar Console System
+// RMAC - Reboot's Macro Assembler for all Atari computers
// TOKEN.C - Token Handling
// Copyright (C) 199x Landon Dyer, 2011-2017 Reboot and Friends
// RMAC derived from MADMAC v1.07 Written by Landon Dyer, 1986
int lnsave; // 1; strcpy() text of current line
-int curlineno; // Current line number
+uint16_t curlineno; // Current line number (64K max currently)
int totlines; // Total # of lines
int mjump_align = 0; // mjump alignment flag
char lntag; // Line tag
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)
-char chrtab[] = {
+uint8_t chrtab[0x100] = {
ILLEG, ILLEG, ILLEG, ILLEG, // NUL SOH STX ETX
ILLEG, ILLEG, ILLEG, ILLEG, // EOT ENQ ACK BEL
ILLEG, WHITE, ILLEG, ILLEG, // BS HT LF VT
MULTX, MULTX, // : ;
MULTX, MULTX, MULTX, STSYM+CTSYM, // < = > ?
- MULTX, STSYM+CTSYM+HDIGIT, // @ A
- (char)((BYTE)DOT)+STSYM+CTSYM+HDIGIT, STSYM+CTSYM+HDIGIT, // B C
- STSYM+CTSYM+HDIGIT, STSYM+CTSYM+HDIGIT, // D E
- STSYM+CTSYM+HDIGIT, STSYM+CTSYM, // F G
- STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM, // H I J K
- (char)((BYTE)DOT)+STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM, // L M N O
-
- STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM, (char)((BYTE)DOT)+STSYM+CTSYM, // P Q R S
- STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM, (char)((BYTE)DOT)+STSYM+CTSYM, // T U V W
- STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM, SELF, // X Y Z [
- SELF, SELF, MULTX, STSYM+CTSYM, // \ ] ^ _
-
- ILLEG, STSYM+CTSYM+HDIGIT, // ` a
- (char)((BYTE)DOT)+STSYM+CTSYM+HDIGIT, STSYM+CTSYM+HDIGIT, // b c
- STSYM+CTSYM+HDIGIT, STSYM+CTSYM+HDIGIT, // d e
- STSYM+CTSYM+HDIGIT, STSYM+CTSYM, // f g
- STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM, // h i j k
- (char)((BYTE)DOT)+STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM, // l m n o
-
- STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM, (char)((BYTE)DOT)+STSYM+CTSYM, // p q r s
- STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM, (char)((BYTE)DOT)+STSYM+CTSYM, // t u v w
- STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM, SELF, // x y z {
- SELF, SELF, SELF, ILLEG // | } ~ DEL
+ MULTX, STSYM+CTSYM+HDIGIT, // @ A
+ DOT+STSYM+CTSYM+HDIGIT, STSYM+CTSYM+HDIGIT, // B C
+ DOT+STSYM+CTSYM+HDIGIT, STSYM+CTSYM+HDIGIT, // D E
+ STSYM+CTSYM+HDIGIT, STSYM+CTSYM, // F G
+ STSYM+CTSYM, DOT+STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM, // H I J K
+ DOT+STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM, // L M N O
+
+ DOT+STSYM+CTSYM, DOT+STSYM+CTSYM, STSYM+CTSYM, DOT+STSYM+CTSYM, // P Q R S
+ STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM, DOT+STSYM+CTSYM, // T U V W
+ STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM, SELF,// X Y Z [
+ SELF, SELF, MULTX, STSYM+CTSYM, // \ ] ^ _
+
+ ILLEG, STSYM+CTSYM+HDIGIT, // ` a
+ DOT+STSYM+CTSYM+HDIGIT, STSYM+CTSYM+HDIGIT, // b c
+ DOT+STSYM+CTSYM+HDIGIT, STSYM+CTSYM+HDIGIT, // d e
+ STSYM+CTSYM+HDIGIT, STSYM+CTSYM, // f g
+ STSYM+CTSYM, DOT+STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM, // h i j k
+ DOT+STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM, // l m n o
+
+ DOT+STSYM+CTSYM, DOT+STSYM+CTSYM, STSYM+CTSYM, DOT+STSYM+CTSYM, // p q r s
+ STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM, DOT+STSYM+CTSYM, // t u v w
+ DOT+STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM, SELF, // x y z {
+ SELF, SELF, SELF, ILLEG, // | } ~ DEL
+
+ // Anything above $7F is illegal (and yes, we need to check for this,
+ // otherwise you get strange and spurious errors that will lead you astray)
+ ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG,
+ ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG,
+ ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG,
+ ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG,
+ ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG,
+ ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG,
+ ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG,
+ ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG,
+ ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG,
+ ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG,
+ ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG,
+ ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG,
+ ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG,
+ ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG,
+ ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG,
+ ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG, ILLEG
};
// Names of registers
static char * regname[] = {
- "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
- "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
- "pc", "ssp", "usp", "sr", "ccr"
+ "d0","d1","d2","d3","d4","d5","d6","d7", // 128,135
+ "a0","a1","a2","a3","a4","a5","a6","sp", // 136,143
+ "ssp","pc","sr","ccr","regequ","set","reg","r0", // 144,151
+ "r1","r2","r3","r4","r5","r6","r7","r8", // 152,159
+ "r9","r10","r11","r12","r13","r14","r15","r16", // 160,167
+ "r17","r18","r19","r20","r21","r22","r23","r24", // 168,175
+ "r25","r26","r27","r28","r29","r30","r31","ccdef", // 176,183
+ "usp","ic40","dc40","bc40","sfc","dfc","","vbr", // 184,191
+ "cacr","caar","msp","isp","tc","itt0","itt1","dtt0", // 192,199
+ "dtt1","mmusr","urp","srp","iacr0","iacr1","dacr0","dacr1", // 200,207
+ "tt0","tt1","crp","","","","","", // 208,215
+ "","","","","fpiar","fpsr","fpcr","", // 216,223
+ "fp0","fp1","fp2","fp3","fp4","fp5","fp6","fp7", // 224,231
+ "","","","","","","","", // 232,239
+ "","","","","","","","", // 240,247
+ "","","","","","","","", // 248,255
+ "","","","","x0","x1","y0","y1", // 256,263
+ "","b0","","b2","","b1","a","b", // 264,271
+ "mr","omr","la","lc","ssh","ssl","ss","", // 272,279
+ "n0","n1","n2","n3","n4","n5","n6","n7", // 280,287
+ "m0","m1","m2","m3","m4","m5","m6","m7", // 288,295
+ "","","","","","","l","p", // 296,303
+ "mr","omr","la","lc","ssh","ssl","ss","", // 304,311
+ "a10","b10","x","y","","","ab","ba" // 312,319
};
static char * riscregname[] = {
// These characters are legal immediately after a period
dotxtab['b'] = DOTB; // .b .B .s .S
dotxtab['B'] = DOTB;
- dotxtab['s'] = DOTB;
- dotxtab['S'] = DOTB;
+ //dotxtab['s'] = DOTB;
+ //dotxtab['S'] = DOTB;
dotxtab['w'] = DOTW; // .w .W
dotxtab['W'] = DOTW;
dotxtab['l'] = DOTL; // .l .L
dotxtab['L'] = DOTL;
dotxtab['i'] = DOTI; // .i .I (???)
dotxtab['I'] = DOTI;
+ dotxtab['D'] = DOTD; // .d .D (quad word)
+ dotxtab['d'] = DOTD;
+ dotxtab['S'] = DOTS; // .s .S
+ dotxtab['s'] = DOTS;
+ dotxtab['Q'] = DOTQ; // .q .Q
+ dotxtab['q'] = DOTQ;
+ dotxtab['X'] = DOTX; // .x .x
+ dotxtab['x'] = DOTX;
+ dotxtab['P'] = DOTP; // .p .P
+ dotxtab['p'] = DOTP;
}
inobj->inobj.ifile = ifile;
break;
+
case SRC_IMACRO: // Alloc and init an IMACRO
if (f_imacro == NULL)
imacro = malloc(sizeof(IMACRO));
inobj->inobj.imacro = imacro;
break;
+
case SRC_IREPT: // Alloc and init an IREPT
inobj->inobj.irept = malloc(sizeof(IREPT));
- DEBUG printf("alloc IREPT\n");
+ DEBUG { printf("alloc IREPT\n"); }
break;
}
*d++ = *s++;
if (*s != '}')
- return error("missing '}'");
+ return error("missing closing brace ('}')");
else
s++;
}
// Lookup the argument and copy its (string) value into the
// destination string
- DEBUG printf("argument='%s'\n", mname);
+ DEBUG { printf("argument='%s'\n", mname); }
if ((arg = lookup(mname, MACARG, macnum)) == NULL)
- return errors("undefined argument: '%s'", mname);
+ return error("undefined argument: '%s'", mname);
else
{
// Convert a string of tokens (terminated with EOL) back into
// macro invocation) then it is ignored.
i = (int)arg->svalue;
arg_num:
- DEBUG printf("~argnumber=%d (argBase=%u)\n", i, imacro->argBase);
+ DEBUG { printf("~argnumber=%d\n", i); }
tk = NULL;
if (i < imacro->im_nargs)
{
-#if 0
-// tk = argp[i];
-// tk = argPtrs[i];
- tk = argPtrs[imacro->argBase + i];
-#else
tk = imacro->argument[i].token;
symbolString = imacro->argument[i].string;
//DEBUG
//{
// printf("ExM: Preparing to parse argument #%u...\n", i);
-// dumptok(tk);
+// DumpTokens(tk);
//}
-#endif
}
// \?arg yields:
#else
// This fix should be done for strings too
d = symbolString[*tk++];
-DEBUG printf("ExM: SYMBOL=\"%s\"", d);
+DEBUG { printf("ExM: SYMBOL=\"%s\"", d); }
#endif
break;
case STRING:
*dst++ = '"';
continue;
break;
-// Shamus: Changing the format specifier from %lx to %ux caused
-// the assembler to choke on legitimate code... Need to investigate
-// this further before changing anything else here!
+// Shamus: Changing the format specifier from %lx to %ux caused the assembler
+// to choke on legitimate code... Need to investigate this further
+// before changing anything else here!
case CONST:
- sprintf(numbuf, "$%lx", (LONG)*tk++);
+ sprintf(numbuf, "$%lx", (uint64_t)*tk++);
+ tk++;
d = numbuf;
break;
case DEQUALS:
overflow:
*dst = EOS;
- DEBUG printf("*** OVERFLOW LINE ***\n%s\n", dest);
+ DEBUG { printf("*** OVERFLOW LINE ***\n%s\n", dest); }
return fatal("line too long as a result of macro expansion");
}
{
IMACRO * imacro = cur_inobj->inobj.imacro;
// LONG * strp = imacro->im_nextln;
- struct LineList * strp = imacro->im_nextln;
+ LLIST * strp = imacro->im_nextln;
if (strp == NULL) // End-of-macro
return NULL;
//
char * GetNextRepeatLine(void)
{
-
IREPT * irept = cur_inobj->inobj.irept;
- LONG * strp = irept->ir_nextln; // initial null
+// LONG * strp = irept->ir_nextln; // initial null
// Do repeat at end of .rept block's string list
- if (strp == NULL)
+// if (strp == NULL)
+ if (irept->ir_nextln == NULL)
{
- DEBUG printf("back-to-top-of-repeat-block count=%d\n", (int)irept->ir_count);
+ DEBUG { printf("back-to-top-of-repeat-block count=%d\n", (int)irept->ir_count); }
irept->ir_nextln = irept->ir_firstln; // copy first line
if (irept->ir_count-- == 0)
{
- DEBUG printf("end-repeat-block\n");
+ DEBUG { printf("end-repeat-block\n"); }
return NULL;
}
- strp = irept->ir_nextln;
+// strp = irept->ir_nextln;
}
- strcpy(irbuf, (char *)(irept->ir_nextln + 1));
- DEBUG printf("repeat line='%s'\n", irbuf);
- irept->ir_nextln = (LONG *)*strp;
+// strcpy(irbuf, (char *)(irept->ir_nextln + 1));
+ strcpy(irbuf, irept->ir_nextln->line);
+ DEBUG { printf("repeat line='%s'\n", irbuf); }
+// irept->ir_nextln = (LONG *)*strp;
+ irept->ir_nextln = irept->ir_nextln->next;
return irbuf;
}
int include(int handle, char * fname)
{
// Debug mode
- if (debug)
- printf("[include: %s, cfileno=%u]\n", fname, cfileno);
+ DEBUG { printf("[include: %s, cfileno=%u]\n", fname, cfileno); }
// Alloc and initialize include-descriptors
INOBJ * inobj = a_inobj(SRC_IFILE);
IFILE * ifile = inobj->inobj.ifile;
- ifile->ifhandle = handle; // Setup file handle
- ifile->ifind = ifile->ifcnt = 0; // Setup buffer indices
- ifile->ifoldlineno = curlineno; // Save old line number
- ifile->ifoldfname = curfname; // Save old filename
- ifile->ifno = cfileno; // Save old file number
+ ifile->ifhandle = handle; // Setup file handle
+ ifile->ifind = ifile->ifcnt = 0; // Setup buffer indices
+ ifile->ifoldlineno = curlineno; // Save old line number
+ ifile->ifoldfname = curfname; // Save old filename
+ ifile->ifno = cfileno; // Save old file number
// NB: This *must* be preincrement, we're adding one to the filecount here!
- cfileno = ++filecount; // Compute NEW file number
- curfname = strdup(fname); // Set current filename (alloc storage)
- curlineno = 0; // Start on line zero
+ cfileno = ++filecount; // Compute NEW file number
+ curfname = strdup(fname); // Set current filename (alloc storage)
+ curlineno = 0; // Start on line zero
// Add another file to the file-record
FILEREC * fr = (FILEREC *)malloc(sizeof(FILEREC));
fr->frec_name = curfname;
if (last_fr == NULL)
- filerec = fr; // Add first filerec
+ filerec = fr; // Add first filerec
else
- last_fr->frec_next = fr; // Append to list of filerecs
+ last_fr->frec_next = fr; // Append to list of filerecs
last_fr = fr;
- DEBUG printf("[include: curfname: %s, cfileno=%u]\n", curfname, cfileno);
+ DEBUG { printf("[include: curfname: %s, cfileno=%u]\n", curfname, cfileno); }
return OK;
}
//
int fpop(void)
{
- IFILE * ifile;
- IMACRO * imacro;
- LONG * p, * p1;
INOBJ * inobj = cur_inobj;
- if (inobj != NULL)
+ if (inobj == NULL)
+ return 0;
+
+ // Pop IFENT levels until we reach the conditional assembly context we
+ // were at when the input object was entered.
+ int numUnmatched = 0;
+
+ while (ifent != inobj->in_ifent)
{
- // Pop IFENT levels until we reach the conditional assembly context we
- // were at when the input object was entered.
- int numUnmatched = 0;
+ if (d_endif() != 0) // Something bad happened during endif parsing?
+ return -1; // If yes, bail instead of getting stuck in a loop
- while (ifent != inobj->in_ifent)
- {
- if (d_endif() != 0) // Something bad happened during endif parsing?
- return -1; // If yes, bail instead of getting stuck in a loop
+ numUnmatched++;
+ }
- numUnmatched++;
- }
+ // Give a warning to the user that we had to wipe their bum for them
+ if (numUnmatched > 0)
+ warn("missing %d .endif(s)", numUnmatched);
- // Give a warning to the user that we had to wipe their bum for them
- if (numUnmatched > 0)
- warni("missing %d .endif(s)", numUnmatched);
+ tok = inobj->in_otok; // Restore tok and otok
+ etok = inobj->in_etok;
- tok = inobj->in_otok; // Restore tok and otok
- etok = inobj->in_etok;
+ switch (inobj->in_type)
+ {
+ case SRC_IFILE: // Pop and release an IFILE
+ {
+ DEBUG { printf("[Leaving: %s]\n", curfname); }
+
+ IFILE * ifile = inobj->inobj.ifile;
+ ifile->if_link = f_ifile;
+ f_ifile = ifile;
+ close(ifile->ifhandle); // Close source file
+DEBUG { printf("[fpop (pre): curfname=%s]\n", curfname); }
+ curfname = ifile->ifoldfname; // Set current filename
+DEBUG { printf("[fpop (post): curfname=%s]\n", curfname); }
+DEBUG { printf("[fpop: (pre) cfileno=%d ifile->ifno=%d]\n", (int)cfileno, (int)ifile->ifno); }
+ curlineno = ifile->ifoldlineno; // Set current line#
+ DEBUG { printf("cfileno=%d ifile->ifno=%d\n", (int)cfileno, (int)ifile->ifno); }
+ cfileno = ifile->ifno; // Restore current file number
+DEBUG { printf("[fpop: (post) cfileno=%d ifile->ifno=%d]\n", (int)cfileno, (int)ifile->ifno); }
+ break;
+ }
- switch (inobj->in_type)
- {
- case SRC_IFILE: // Pop and release an IFILE
- if (debug)
- printf("[Leaving: %s]\n", curfname);
-
- ifile = inobj->inobj.ifile;
- ifile->if_link = f_ifile;
- f_ifile = ifile;
- close(ifile->ifhandle); // Close source file
-if (debug) printf("[fpop (pre): curfname=%s]\n", curfname);
- curfname = ifile->ifoldfname; // Set current filename
-if (debug) printf("[fpop (post): curfname=%s]\n", curfname);
-if (debug) printf("[fpop: (pre) cfileno=%d ifile->ifno=%d]\n", (int)cfileno, (int)ifile->ifno);
- curlineno = ifile->ifoldlineno; // Set current line#
- DEBUG printf("cfileno=%d ifile->ifno=%d\n", (int)cfileno, (int)ifile->ifno);
- cfileno = ifile->ifno; // Restore current file number
-if (debug) printf("[fpop: (post) cfileno=%d ifile->ifno=%d]\n", (int)cfileno, (int)ifile->ifno);
- break;
- case SRC_IMACRO: // Pop and release an IMACRO
- imacro = inobj->inobj.imacro;
- imacro->im_link = f_imacro;
- f_imacro = imacro;
- break;
- case SRC_IREPT: // Pop and release an IREPT
- DEBUG printf("dealloc IREPT\n");
- p = inobj->inobj.irept->ir_firstln;
+ case SRC_IMACRO: // Pop and release an IMACRO
+ {
+ IMACRO * imacro = inobj->inobj.imacro;
+ imacro->im_link = f_imacro;
+ f_imacro = imacro;
+ break;
+ }
- while (p != NULL)
- {
- p1 = (LONG *)*p;
- p = p1;
- }
+ case SRC_IREPT: // Pop and release an IREPT
+ {
+ DEBUG { printf("dealloc IREPT\n"); }
+ LLIST * p = inobj->inobj.irept->ir_firstln;
- break;
+ // Deallocate repeat lines
+ while (p != NULL)
+ {
+ free(p->line);
+ p = p->next;
}
- cur_inobj = inobj->in_link;
- inobj->in_link = f_inobj;
- f_inobj = inobj;
+ break;
+ }
}
+ cur_inobj = inobj->in_link;
+ inobj->in_link = f_inobj;
+ f_inobj = inobj;
+
return 0;
}
//
int TokenizeLine(void)
{
- char * ln = NULL; // Ptr to current position in line
- char * p; // Random character ptr
+ uint8_t * ln = NULL; // Ptr to current position in line
+ uint8_t * p; // Random character ptr
TOKEN * tk; // Token-deposit ptr
int state = 0; // State for keyword detector
int j = 0; // Var for keyword detector
- char c; // Random char
- VALUE v; // Random value
- char * nullspot = NULL; // Spot to clobber for SYMBOL termination
+ uint8_t c; // Random char
+ uint64_t v; // Random value
+ uint32_t cursize = 0; // Current line's size (.b, .w, .l, .s, .q, .d)
+ double f; // Random float
+ uint8_t * nullspot = NULL; // Spot to clobber for SYMBOL termination
int stuffnull; // 1:terminate SYMBOL '\0' at *nullspot
- char c1;
+ uint8_t c1;
int stringNum = 0; // Pointer to string locations in tokenized line
+ uint64_t * tk64;
retry:
case SRC_IFILE:
if ((ln = GetNextLine()) == NULL)
{
-if (debug) printf("TokenizeLine: Calling fpop() from SRC_IFILE...\n");
+DEBUG { printf("TokenizeLine: Calling fpop() from SRC_IFILE...\n"); }
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
+ ifent->if_prev = (IFENT *)-1; //Signal Assemble() that we have reached EOF with unbalanced if/endifs
return TKEOF;
}
}
}
break;
+
// Macro-block:
// o Handle end-of-macro;
// o tag the listing-line with an at (@) sign.
case SRC_IMACRO:
if ((ln = GetNextMacroLine()) == NULL)
{
- if (ExitMacro() == 0) // Exit macro (pop args, do fpop(), etc)
- goto retry; // Try for more lines...
+ if (ExitMacro() == 0) // Exit macro (pop args, do fpop(), etc)
+ goto retry; // Try for more lines...
else
- return TKEOF; // Oops, we got a non zero return code, signal EOF
+ return TKEOF; // Oops, we got a non zero return code, signal EOF
}
lntag = '@';
break;
+
// Repeat-block:
// o Handle end-of-repeat-block;
// o tag the listing-line with a pound (#) sign.
case SRC_IREPT:
if ((ln = GetNextRepeatLine()) == NULL)
{
-if (debug) printf("TokenizeLine: Calling fpop() from SRC_IREPT...\n");
+ DEBUG { printf("TokenizeLine: Calling fpop() from SRC_IREPT...\n"); }
fpop();
goto retry;
}
break;
}
- // Save text of the line. We only do this during listings and within
+ // Save text of the line. We only do this during listings and within
// macro-type blocks, since it is expensive to unconditionally copy every
// line.
if (lnsave)
strcpy(lnbuf, ln);
- // General house-keeping
+ // General housekeeping
tok = tokeol; // Set "tok" to EOL in case of error
tk = etok; // Reset token ptr
stuffnull = 0; // Don't stuff nulls
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;
- // o handle symbols;
- // o handle single-character tokens (operators, etc.);
- // o handle multiple-character tokens (constants, strings, etc.).
+ // o skip whitespace;
+ // o handle end-of-line;
+ // o handle symbols;
+ // o handle single-character tokens (operators, etc.);
+ // o handle multiple-character tokens (constants, strings, etc.).
for(; *ln!=EOS;)
{
// Skip whitespace, handle EOL
- while ((int)chrtab[*ln] & WHITE)
+ while (chrtab[*ln] & WHITE)
ln++;
// Handle EOL, comment with ';'
if (((chrtab[*ln] & DOT) == 0) || (dotxtab[*ln] == 0))
return error("[bwsl] must follow '.' in symbol");
- v = (VALUE)dotxtab[*ln++];
+ v = (uint32_t)dotxtab[*ln++];
+ cursize = (uint32_t)v;
if (chrtab[*ln] & CTSYM)
- return error("misuse of '.', not allowed in symbols");
+ return error("misuse of '.'; not allowed in symbols");
}
// If the symbol is small, check to see if it's really the name of
// Handle multiple-character tokens
if (c & MULTX)
{
-
switch (*ln++)
{
case '!': // ! or !=
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--;
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++];
- // ggn: Okay, some comments here are in order I think....
- // The original madmac sources didn't parse the size at
- // this point (i.e. .b/.w/.l). It was probably done at
- // another point, although it's unclear to me exactly
- // where. So why change this? My understanding (at least
- // from what SCPCD said on IRC) is that .w addressing
- // formats produce wrong code on jaguar (or doesn't execute
- // properly? something like that). So the code was changed
- // to mask off the upper bits depending on length (note: I
- // don't think .b is valid at all! I only know of .w/.l, so
- // this should probably be wiped). Then the code that
- // parses the constant and checks to see if it's between
- // $ffff0000 and $8000 never got triggered, so yay job
- // done! ...now say we want to assemble a st .prg. One of
- // the most widely spread optimisations is move.X expr.w,Y
- // (or vice versa, or both, anyway...) to access hardware
- // registers (which are mapped to $fxxxxx). This botchy
- // thing would create "hilarious" code while trying to
- // access hardware registers. So I made a condition to see
- // if st mode or jaguar is active and apply the both or
- // not. One last note: this is hardcoded to get optimised
- // for now on ST mode, i.e. it can't generate code like
- // move.w $00001234,d0 - it'll always get optimised to
- // move.w $1234.w,d0. It's probably ok, but maybe a warning
- // should be emitted? Or maybe finding a way to make it not
- // auto-optimise? I think it's ok for now...
if (*ln == '.')
{
if (obj_format == BSD)
}
else if ((*(ln + 1) & 0xDF) == 'L')
{
+ v &= 0xFFFFFFFF;
ln += 2;
}
}
}
*tk++ = CONST;
- *tk++ = v;
+ tk64 = (uint64_t *)tk;
+ *tk64++ = v;
+ tk = (TOKEN *)tk64;
if (obj_format == ALCYON)
{
- if ((*(ln + 1) == 'w') || (*(ln + 1) == 'W'))
+ if (*ln == '.')
{
- *tk++ = DOTW;
- ln += 2;
- }
- else if ((*(ln + 1) == 'l') || (*(ln + 1) == 'L'))
- {
- *tk++ = DOTL;
- ln += 2;
+ if ((*(ln + 1) == 'w') || (*(ln + 1) == 'W'))
+ {
+ *tk++ = DOTW;
+ ln += 2;
+ }
+ else if ((*(ln + 1) == 'l') || (*(ln + 1) == 'L'))
+ {
+ *tk++ = DOTL;
+ ln += 2;
+ }
}
}
}
if ((*(ln + 1) == 'l') || (*(ln + 1) == 'L'))
{
+ v &= 0xFFFFFFFF;
ln += 2;
}
}
*tk++ = CONST;
- *tk++ = v;
+ tk64 = (uint64_t *)tk;
+ *tk64++ = v;
+ tk = (TOKEN *)tk64;
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;
+ tk64 = (uint64_t *)tk;
+ *tk64++ = v;
+ tk = (TOKEN *)tk64;
continue;
case '^': // ^ or ^^ <operator-name>
if (*ln != '^')
{
v &= 0x000000FF;
ln += 2;
+ *tk++ = CONST;
+ tk64 = (uint64_t *)tk;
+ *tk64++ = v;
+ tk = (uint32_t *)tk64;
+ *tk++ = 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;
}
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;
+ }
+ 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;
+ continue;
}
}
+ else
+ {
+ *tk++ = CONST;
+ tk64 = (uint64_t *)tk;
+ *tk64++ = v;
+ tk = (TOKEN *)tk64;
+ }
- *tk++ = CONST;
- *tk++ = v;
//printf("CONST: %i\n", v);
continue;
}
// Handle illegal character
- return error("illegal character");
+ return error("illegal character $%02X found", *ln);
}
// Terminate line of tokens and return "success."
// expansion, and is NOT subject to macro expansion. The whitespace may also
// be EOL.
//
-//int d_goto(WORD siz) {
-//int d_goto(void)
int d_goto(WORD unused)
{
- char * s1, * s2;
-
// Setup for the search
if (*tok != SYMBOL)
return error("missing label");
-// sym = (char *)tok[1];
char * sym = string[tok[1]];
tok += 2;
return error("goto not in macro");
IMACRO * imacro = cur_inobj->inobj.imacro;
-// defln = (LONG *)imacro->im_macro->svalue;
- struct LineList * defln = imacro->im_macro->lineList;
+ LLIST * defln = imacro->im_macro->lineList;
- // Find the label, starting with the first line.
+ // Attempt to find the label, starting with the first line.
for(; defln!=NULL; defln=defln->next)
{
-// if (*(char *)(defln + 1) == ':')
+ // Must start with a colon
if (defln->line[0] == ':')
{
// Compare names (sleazo string compare)
- // This string compare is not right. Doesn't check for lengths.
- // (actually it does, but in a crappy, unclear way.)
-WARNING(!!!! Bad string comparison !!!)
- s1 = sym;
-// s2 = (char *)(defln + 1) + 1;
- s2 = defln->line;
-
- while (*s1 == *s2)
+ char * s1 = sym;
+ char * s2 = defln->line;
+
+ // Either we will match the strings to EOS on both, or we will
+ // match EOS on string 1 to whitespace on string 2. Otherwise, we
+ // have no match.
+ while ((*s1 == *s2) || ((*s1 == EOS) && (chrtab[*s2] & WHITE)))
{
+ // If we reached the end of string 1 (sym), we're done.
+ // Note that we're also checking for the end of string 2 as
+ // well, since we've established they're equal above.
if (*s1 == EOS)
- break;
- else
{
- s1++;
- s2++;
+ // Found the label, set new macro next-line and return.
+ imacro->im_nextln = defln;
+ return 0;
}
- }
- // Found the label, set new macro next-line and return.
- if ((*s2 == EOS) || ((int)chrtab[*s2] & WHITE))
- {
- imacro->im_nextln = defln;
- return 0;
+ s1++;
+ s2++;
}
}
}
void DumpTokenBuffer(void)
{
- TOKEN * t;
printf("Tokens [%X]: ", sloc);
- for(t=tokbuf; *t!=EOL; t++)
+ for(TOKEN * t=tokbuf; *t!=EOL; t++)
{
if (*t == COLON)
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)
- printf("[ACONST]");
+ {
+ printf("[ACONST: $%X, $%X]", (uint32_t)t[1], (uint32_t)t[2]);
+ t += 2;
+ }
else if (*t == STRING)
{
t++;
projects / rmac / blobdiff