(c) message in header files and doc mini adjustments.
[rmac] / token.c
1 //
2 // RMAC - Reboot's Macro Assembler for all Atari computers
3 // TOKEN.C - Token Handling
4 // Copyright (C) 199x Landon Dyer, 2011-2017 Reboot and Friends
5 // RMAC derived from MADMAC v1.07 Written by Landon Dyer, 1986
6 // Source utilised with the kind permission of Landon Dyer
7 //
8
9 #include "token.h"
10 #include "direct.h"
11 #include "error.h"
12 #include "macro.h"
13 #include "procln.h"
14 #include "sect.h"
15 #include "symbol.h"
16
17 #define DECL_KW                         // Declare keyword arrays
18 #define DEF_KW                          // Declare keyword values
19 #include "kwtab.h"                      // Incl generated keyword tables & defs
20
21
22 int lnsave;                                     // 1; strcpy() text of current line
23 uint16_t curlineno;                     // Current line number (64K max currently)
24 int totlines;                           // Total # of lines
25 int mjump_align = 0;            // mjump alignment flag
26 char lntag;                                     // Line tag
27 char * curfname;                        // Current filename
28 char tolowertab[128];           // Uppercase ==> lowercase
29 int8_t hextab[128];                     // Table of hex values
30 char dotxtab[128];                      // Table for ".b", ".s", etc.
31 char irbuf[LNSIZ];                      // Text for .rept block line
32 char lnbuf[LNSIZ];                      // Text of current line
33 WORD filecount;                         // Unique file number counter
34 WORD cfileno;                           // Current file number
35 TOKEN * tok;                            // Ptr to current token
36 TOKEN * etok;                           // Ptr past last token in tokbuf[]
37 TOKEN tokeol[1] = {EOL};        // Bailout end-of-line token
38 char * string[TOKBUFSIZE*2];    // Token buffer string pointer storage
39
40 // File record, used to maintain a list of every include file ever visited
41 #define FILEREC struct _filerec
42 FILEREC
43 {
44    FILEREC * frec_next;
45    char * frec_name;
46 };
47
48 FILEREC * filerec;
49 FILEREC * last_fr;
50
51 INOBJ * cur_inobj;                                              // Ptr current input obj (IFILE/IMACRO)
52 static INOBJ * f_inobj;                                 // Ptr list of free INOBJs
53 static IFILE * f_ifile;                                 // Ptr list of free IFILEs
54 static IMACRO * f_imacro;                               // Ptr list of free IMACROs
55
56 static TOKEN tokbuf[TOKBUFSIZE];                // Token buffer (stack-like, all files)
57
58 char chrtab[] = {
59         ILLEG, ILLEG, ILLEG, ILLEG,                     // NUL SOH STX ETX
60         ILLEG, ILLEG, ILLEG, ILLEG,                     // EOT ENQ ACK BEL
61         ILLEG, WHITE, ILLEG, ILLEG,                     // BS HT LF VT
62         WHITE, ILLEG, ILLEG, ILLEG,                     // FF CR SO SI
63
64         ILLEG, ILLEG, ILLEG, ILLEG,                     // DLE DC1 DC2 DC3
65         ILLEG, ILLEG, ILLEG, ILLEG,                     // DC4 NAK SYN ETB
66         ILLEG, ILLEG, ILLEG, ILLEG,                     // CAN EM SUB ESC
67         ILLEG, ILLEG, ILLEG, ILLEG,                     // FS GS RS US
68
69         WHITE, MULTX, MULTX, SELF,                      // SP ! " #
70         MULTX+CTSYM, MULTX, SELF, MULTX,        // $ % & '
71         SELF, SELF, SELF, SELF,                         // ( ) * +
72         SELF, SELF, STSYM, SELF,                        // , - . /
73
74         DIGIT+HDIGIT+CTSYM, DIGIT+HDIGIT+CTSYM,         // 0 1
75         DIGIT+HDIGIT+CTSYM, DIGIT+HDIGIT+CTSYM,         // 2 3
76         DIGIT+HDIGIT+CTSYM, DIGIT+HDIGIT+CTSYM,         // 4 5
77         DIGIT+HDIGIT+CTSYM, DIGIT+HDIGIT+CTSYM,         // 6 7
78         DIGIT+HDIGIT+CTSYM, DIGIT+HDIGIT+CTSYM,         // 8 9
79         MULTX, MULTX,                                                           // : ;
80         MULTX, MULTX, MULTX, STSYM+CTSYM,                       // < = > ?
81
82         MULTX, STSYM+CTSYM+HDIGIT,                                                                      // @ A
83         (char)((BYTE)DOT)+STSYM+CTSYM+HDIGIT, STSYM+CTSYM+HDIGIT,       // B C
84         (char)((BYTE)DOT)+STSYM+CTSYM+HDIGIT, STSYM+CTSYM+HDIGIT,                                               // D E
85         STSYM+CTSYM+HDIGIT, STSYM+CTSYM,                                                        // F G
86         STSYM+CTSYM, (char)((BYTE)DOT)+STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM,                   // H I J K
87         (char)((BYTE)DOT)+STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM,   // L M N O
88
89         (char)((BYTE)DOT)+STSYM+CTSYM, (char)((BYTE)DOT)+STSYM+CTSYM, STSYM+CTSYM, (char)((BYTE)DOT)+STSYM+CTSYM,       // P Q R S
90         STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM, (char)((BYTE)DOT)+STSYM+CTSYM,   // T U V W
91         STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM, SELF,                            // X Y Z [
92         SELF, SELF, MULTX, STSYM+CTSYM,                                                         // \ ] ^ _
93
94         ILLEG, STSYM+CTSYM+HDIGIT,                                                                      // ` a
95         (char)((BYTE)DOT)+STSYM+CTSYM+HDIGIT, STSYM+CTSYM+HDIGIT,       // b c
96         (char)((BYTE)DOT)+STSYM+CTSYM+HDIGIT, STSYM+CTSYM+HDIGIT,                                               // d e
97         STSYM+CTSYM+HDIGIT, STSYM+CTSYM,                                                        // f g
98         STSYM+CTSYM, (char)((BYTE)DOT)+STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM,                   // h i j k
99         (char)((BYTE)DOT)+STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM,   // l m n o
100
101         (char)((BYTE)DOT)+STSYM+CTSYM, (char)((BYTE)DOT)+STSYM+CTSYM, STSYM+CTSYM, (char)((BYTE)DOT)+STSYM+CTSYM,       // p q r s
102         STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM, (char)((BYTE)DOT)+STSYM+CTSYM,   // t u v w
103         (char)((BYTE)DOT)+STSYM+CTSYM, STSYM+CTSYM, STSYM+CTSYM, SELF,                          // x y z {
104         SELF, SELF, SELF, ILLEG                                                                         // | } ~ DEL
105 };
106
107 // Names of registers
108 static char * regname[] = {
109         "d0","d1","d2","d3","d4","d5","d6","d7", // 128,135
110         "a0","a1","a2","a3","a4","a5","a6","sp", // 136,143
111         "ssp","pc","sr","ccr","regequ","set","reg","r0", // 144,151
112         "r1","r2","r3","r4","r5","r6","r7","r8", // 152,159
113         "r9","r10","r11","r12","r13","r14","r15","r16", // 160,167
114         "r17","r18","r19","r20","r21","r22","r23","r24", // 168,175
115         "r25","r26","r27","r28","r29","r30","r31","ccdef", // 176,183
116         "usp","ic40","dc40","bc40","sfc","dfc","","vbr", // 184,191
117         "cacr","caar","msp","isp","tc","itt0","itt1","dtt0", // 192,199
118         "dtt1","mmusr","urp","srp","iacr0","iacr1","dacr0","dacr1", // 200,207
119         "tt0","tt1","crp","","","","","", // 208,215
120         "","","","","fpiar","fpsr","fpcr","", // 216,223
121         "fp0","fp1","fp2","fp3","fp4","fp5","fp6","fp7", // 224,231
122         "","","","","","","","", // 232,239
123         "","","","","","","","", // 240,247
124         "","","","","","","","", // 248,255
125         "","","","","x0","x1","y0","y1", // 256,263
126         "","b0","","b2","","b1","a","b", // 264,271
127         "mr","omr","la","lc","ssh","ssl","ss","", // 272,279
128         "n0","n1","n2","n3","n4","n5","n6","n7", // 280,287
129         "m0","m1","m2","m3","m4","m5","m6","m7", // 288,295
130         "","","","","","","l","p", // 296,303
131         "mr","omr","la","lc","ssh","ssl","ss","", // 304,311
132         "a10","b10","x","y","","","ab","ba"  // 312,319
133 };
134
135 static char * riscregname[] = {
136          "r0",  "r1",  "r2",  "r3",  "r4", "r5",   "r6",  "r7",
137          "r8",  "r9", "r10", "r11", "r12", "r13", "r14", "r15",
138         "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
139         "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
140 };
141
142
143 //
144 // Initialize tokenizer
145 //
146 void InitTokenizer(void)
147 {
148         int i;                                                                  // Iterator
149         char * htab = "0123456789abcdefABCDEF"; // Hex character table
150
151         lnsave = 0;                                                             // Don't save lines
152         curfname = "";                                                  // No file, empty filename
153         filecount = (WORD)-1;
154         cfileno = (WORD)-1;                                             // cfileno gets bumped to 0
155         curlineno = 0;
156         totlines = 0;
157         etok = tokbuf;
158         f_inobj = NULL;
159         f_ifile = NULL;
160         f_imacro = NULL;
161         cur_inobj = NULL;
162         filerec = NULL;
163         last_fr = NULL;
164         lntag = SPACE;
165
166         // Initialize hex, "dot" and tolower tables
167         for(i=0; i<128; i++)
168         {
169                 hextab[i] = -1;
170                 dotxtab[i] = 0;
171                 tolowertab[i] = (char)i;
172         }
173
174         for(i=0; htab[i]!=EOS; i++)
175                 hextab[htab[i]] = (char)((i < 16) ? i : i - 6);
176
177         for(i='A'; i<='Z'; i++)
178                 tolowertab[i] |= 0x20;
179
180         // These characters are legal immediately after a period
181         dotxtab['b'] = DOTB;                                    // .b .B .s .S
182         dotxtab['B'] = DOTB;
183         //dotxtab['s'] = DOTB;
184         //dotxtab['S'] = DOTB;
185         dotxtab['w'] = DOTW;                                    // .w .W
186         dotxtab['W'] = DOTW;
187         dotxtab['l'] = DOTL;                                    // .l .L
188         dotxtab['L'] = DOTL;
189         dotxtab['i'] = DOTI;                                    // .i .I (???)
190         dotxtab['I'] = DOTI;
191         dotxtab['D'] = DOTD;                                    // .d .D (quad word)
192         dotxtab['d'] = DOTD;
193         dotxtab['S'] = DOTS;                                    // .s .S
194         dotxtab['s'] = DOTS;
195         dotxtab['Q'] = DOTQ;                                    // .q .Q
196         dotxtab['q'] = DOTQ;
197         dotxtab['X'] = DOTX;                                    // .x .x
198         dotxtab['x'] = DOTX;
199         dotxtab['P'] = DOTP;                                    // .p .P
200         dotxtab['p'] = DOTP;
201 }
202
203
204 void SetFilenameForErrorReporting(void)
205 {
206         WORD fnum = cfileno;
207
208         // Check for absolute top filename (this should never happen)
209         if (fnum == -1)
210         {
211                 curfname = "(*top*)";
212                 return;
213         }
214
215         FILEREC * fr = filerec;
216
217         // Advance to the correct record...
218         while (fr != NULL && fnum != 0)
219         {
220                 fr = fr->frec_next;
221                 fnum--;
222         }
223
224         // Check for file # record not found (this should never happen either)
225         if (fr == NULL)
226         {
227                 curfname = "(*NOT FOUND*)";
228                 return;
229         }
230
231         curfname = fr->frec_name;
232 }
233
234
235 //
236 // Allocate an IFILE or IMACRO
237 //
238 INOBJ * a_inobj(int typ)
239 {
240         INOBJ * inobj;
241         IFILE * ifile;
242         IMACRO * imacro;
243
244         // Allocate and initialize INOBJ first
245         if (f_inobj == NULL)
246                 inobj = malloc(sizeof(INOBJ));
247         else
248         {
249                 inobj = f_inobj;
250                 f_inobj = f_inobj->in_link;
251         }
252
253         switch (typ)
254         {
255         case SRC_IFILE:                                                 // Alloc and init an IFILE
256                 if (f_ifile == NULL)
257                         ifile = malloc(sizeof(IFILE));
258                 else
259                 {
260                         ifile = f_ifile;
261                         f_ifile = f_ifile->if_link;
262                 }
263
264                 inobj->inobj.ifile = ifile;
265                 break;
266         case SRC_IMACRO:                                                // Alloc and init an IMACRO
267                 if (f_imacro == NULL)
268                         imacro = malloc(sizeof(IMACRO));
269                 else
270                 {
271                         imacro = f_imacro;
272                         f_imacro = f_imacro->im_link;
273                 }
274
275                 inobj->inobj.imacro = imacro;
276                 break;
277         case SRC_IREPT:                                                 // Alloc and init an IREPT
278                 inobj->inobj.irept = malloc(sizeof(IREPT));
279                 DEBUG printf("alloc IREPT\n");
280                 break;
281         }
282
283         // Install INOBJ on top of input stack
284         inobj->in_ifent = ifent;                                // Record .if context on entry
285         inobj->in_type = (WORD)typ;
286         inobj->in_otok = tok;
287         inobj->in_etok = etok;
288         inobj->in_link = cur_inobj;
289         cur_inobj = inobj;
290
291         return inobj;
292 }
293
294
295 //
296 // Perform macro substitution from 'orig' to 'dest'. Return OK or some error.
297 // A macro reference is in one of two forms:
298 // \name <non-name-character>
299 // \{name}
300 // A doubled backslash (\\) is compressed to a single backslash (\).
301 // Argument definitions have been pre-tokenized, so we have to turn them back
302 // into text. This means that numbers, in particular, become hex, regardless of
303 // their representation when the macro was invoked. This is a hack.
304 // A label may appear at the beginning of the line:
305 // :<name><whitespace>
306 // (the colon must be in the first column). These labels are stripped before
307 // macro expansion takes place.
308 //
309 int ExpandMacro(char * src, char * dest, int destsiz)
310 {
311         int i;
312         int questmark;                  // \? for testing argument existence
313         char mname[128];                // Assume max size of a formal arg name
314         char numbuf[20];                // Buffer for text of CONSTs
315         TOKEN * tk;
316         SYM * arg;
317         char ** symbolString;
318
319         DEBUG { printf("ExM: src=\"%s\"\n", src); }
320
321         IMACRO * imacro = cur_inobj->inobj.imacro;
322         int macnum = (int)(imacro->im_macro->sattr);
323
324         char * dst = dest;                                              // Next dest slot
325         char * edst = dest + destsiz - 1;               // End + 1(?) of dest buffer
326
327         // Check for (and skip over) any "label" on the line
328         char * s = src;
329         char * d = NULL;
330
331         if (*s == ':')
332         {
333                 while (*s != EOS && !(chrtab[*s] & WHITE))
334                         s++;
335
336                 if (*s != EOS)
337                         s++;                                                    // Skip first whitespace
338         }
339
340         // Expand the rest of the line
341         while (*s != EOS)
342         {
343                 // Copy single character
344                 if (*s != '\\')
345                 {
346                         if (dst >= edst)
347                                 goto overflow;
348
349                         // Skip comments in case a loose @ or \ is in there
350                         // In that case the tokeniser was trying to expand it.
351                         if ((*s == ';') || ((*s == '/') && (*(s + 1) == '/')))
352                                 goto skipcomments;
353
354                         *dst++ = *s++;
355                 }
356                 // Do macro expansion
357                 else
358                 {
359                         questmark = 0;
360
361                         // Do special cases
362                         switch (*++s)
363                         {
364                         case '\\':                                              // \\, \ (collapse to single backslash)
365                                 if (dst >= edst)
366                                         goto overflow;
367
368                                 *dst++ = *s++;
369                                 continue;
370                         case '?':                                               // \? <macro>  set `questmark' flag
371                                 ++s;
372                                 questmark = 1;
373                                 break;
374                         case '#':                                               // \#, number of arguments
375                                 sprintf(numbuf, "%d", (int)imacro->im_nargs);
376                                 goto copystr;
377                         case '!':                                               // \! size suffix supplied on invocation
378                                 switch ((int)imacro->im_siz)
379                                 {
380                                 case SIZN: d = "";   break;
381                                 case SIZB: d = ".b"; break;
382                                 case SIZW: d = ".w"; break;
383                                 case SIZL: d = ".l"; break;
384                                 }
385
386                                 goto copy_d;
387                         case '~':                                               // ==> unique label string Mnnnn...
388                                 sprintf(numbuf, "M%u", curuniq);
389 copystr:
390                                 d = numbuf;
391 copy_d:
392                                 s++;
393
394                                 while (*d != EOS)
395                                 {
396                                         if (dst >= edst)
397                                                 goto overflow;
398                                         else
399                                                 *dst++ = *d++;
400                                 }
401
402                                 continue;
403                         case EOS:
404                                 return error("missing argument name");
405                         }
406
407                         // \n ==> argument number 'n', 0..9
408                         if (chrtab[*s] & DIGIT)
409                         {
410                                 i = *s++ - '1';
411
412                                 if (i < 0)
413                                         i = 9;
414
415                                 goto arg_num;
416                         }
417
418                         // Get argument name: \name, \{name}
419                         d = mname;
420
421                         // \label
422                         if (*s != '{')
423                         {
424                                 do
425                                 {
426                                         *d++ = *s++;
427                                 }
428                                 while (chrtab[*s] & CTSYM);
429                         }
430                         // \\{label}
431                         else
432                         {
433                                 for(++s; *s != EOS && *s != '}';)
434                                         *d++ = *s++;
435
436                                 if (*s != '}')
437                                         return error("missing '}'");
438                                 else
439                                         s++;
440                         }
441
442                         *d = EOS;
443
444                         // Lookup the argument and copy its (string) value into the
445                         // destination string
446                         DEBUG printf("argument='%s'\n", mname);
447
448                         if ((arg = lookup(mname, MACARG, macnum)) == NULL)
449                                 return errors("undefined argument: '%s'", mname);
450                         else
451                         {
452                                 // Convert a string of tokens (terminated with EOL) back into
453                                 // text. If an argument is out of range (not specified in the
454                                 // macro invocation) then it is ignored.
455                                 i = (int)arg->svalue;
456 arg_num:
457                                 DEBUG printf("~argnumber=%d (argBase=%u)\n", i, imacro->argBase);
458                                 tk = NULL;
459
460                                 if (i < imacro->im_nargs)
461                                 {
462 #if 0
463 //                                      tk = argp[i];
464 //                                      tk = argPtrs[i];
465                                         tk = argPtrs[imacro->argBase + i];
466 #else
467                                         tk = imacro->argument[i].token;
468                                         symbolString = imacro->argument[i].string;
469 //DEBUG
470 //{
471 //      printf("ExM: Preparing to parse argument #%u...\n", i);
472 //      dumptok(tk);
473 //}
474 #endif
475                                 }
476
477                                 // \?arg yields:
478                                 //    0  if the argument is empty or non-existant,
479                                 //    1  if the argument is not empty
480                                 if (questmark)
481                                 {
482                                         if (tk == NULL || *tk == EOL)
483                                                 questmark = 0;
484
485                                         if (dst >= edst)
486                                                 goto overflow;
487
488                                         *dst++ = (char)(questmark + '0');
489                                         continue;
490                                 }
491
492                                 // Argument # is in range, so expand it
493                                 if (tk != NULL)
494                                 {
495                                         while (*tk != EOL)
496                                         {
497                                                 // Reverse-translation from a token number to a string.
498                                                 // This is a hack. It might be better table-driven.
499                                                 d = NULL;
500
501                                                 if ((*tk >= KW_D0) && !rdsp && !rgpu)
502                                                 {
503                                                         d = regname[(int)*tk++ - KW_D0];
504                                                         goto strcopy;
505                                                 }
506                                                 else if ((*tk >= KW_R0) && (*tk <= KW_R31))
507                                                 {
508                                                         d = riscregname[(int)*tk++ - KW_R0];
509                                                         goto strcopy;
510                                                 }
511                                                 else
512                                                 {
513                                                         switch ((int)*tk++)
514                                                         {
515                                                         case SYMBOL:
516 #if 0
517 //                                                              d = (char *)*tk++;
518                                                                 d = string[*tk++];
519 #else
520                                                                 // This fix should be done for strings too
521                                                                 d = symbolString[*tk++];
522 DEBUG printf("ExM: SYMBOL=\"%s\"", d);
523 #endif
524                                                                 break;
525                                                         case STRING:
526 #if 0
527 //                                                              d = (char *)*tk++;
528                                                                 d = string[*tk++];
529 #else
530                                                                 d = symbolString[*tk++];
531 #endif
532                                                                 if (dst >= edst)
533                                                                         goto overflow;
534
535                                                                 *dst++ = '"';
536
537                                                                 while (*d != EOS)
538                                                                 {
539                                                                         if (dst >= edst)
540                                                                                 goto overflow;
541                                                                         else
542                                                                                 *dst++ = *d++;
543                                                                 }
544
545                                                                 if (dst >= edst)
546                                                                         goto overflow;
547
548                                                                 *dst++ = '"';
549                                                                 continue;
550                                                                 break;
551 // Shamus: Changing the format specifier from %lx to %ux caused the assembler
552 //         to choke on legitimate code... Need to investigate this further
553 //         before changing anything else here!
554                                                         case CONST:
555                                                                 sprintf(numbuf, "$%lx", (long unsigned int)*tk++);
556                                                                 d = numbuf;
557                                                                 break;
558                                                         case DEQUALS:
559                                                                 d = "==";
560                                                                 break;
561                                                         case SET:
562                                                                 d = "set";
563                                                                 break;
564                                                         case COLON:
565                                                                 d = ":";
566                                                                 break;
567                                                         case DCOLON:
568                                                                 d = "::";
569                                                                 break;
570                                                         case GE:
571                                                                 d = ">=";
572                                                                 break;
573                                                         case LE:
574                                                                 d = "<=";
575                                                                 break;
576                                                         case NE:
577                                                                 d = "<>";
578                                                                 break;
579                                                         case SHR:
580                                                                 d = ">>";
581                                                                 break;
582                                                         case SHL:
583                                                                 d = "<<";
584                                                                 break;
585                                                         case DOTB:
586                                                                 d = ".b";
587                                                                 break;
588                                                         case DOTW:
589                                                                 d = ".w";
590                                                                 break;
591                                                         case DOTL:
592                                                                 d = ".l";
593                                                                 break;
594                                                         case CR_ABSCOUNT:
595                                                                 d = "^^abscount";
596                                                                 break;
597                                                         case CR_DATE:
598                                                                 d = "^^date";
599                                                                 break;
600                                                         case CR_TIME:
601                                                                 d = "^^time";
602                                                                 break;
603                                                         case CR_DEFINED:
604                                                                 d = "^^defined ";
605                                                                 break;
606                                                         case CR_REFERENCED:
607                                                                 d = "^^referenced ";
608                                                                 break;
609                                                         case CR_STREQ:
610                                                                 d = "^^streq ";
611                                                                 break;
612                                                         case CR_MACDEF:
613                                                                 d = "^^macdef ";
614                                                                 break;
615                                                         default:
616                                                                 if (dst >= edst)
617                                                                         goto overflow;
618
619                                                                 *dst++ = (char)*(tk - 1);
620                                                                 break;
621                                                         }
622                                                 }
623
624                                                 // If 'd' != NULL, copy string to destination
625                                                 if (d != NULL)
626                                                 {
627 strcopy:
628                                                         DEBUG printf("d='%s'\n", d);
629
630                                                         while (*d != EOS)
631                                                         {
632                                                                 if (dst >= edst)
633                                                                         goto overflow;
634                                                                 else
635                                                                         *dst++ = *d++;
636                                                         }
637                                                 }
638                                         }
639                                 }
640                         }
641                 }
642         }
643
644 skipcomments:
645
646         *dst = EOS;
647         DEBUG { printf("ExM: dst=\"%s\"\n", dest); }
648         return OK;
649
650 overflow:
651         *dst = EOS;
652         DEBUG printf("*** OVERFLOW LINE ***\n%s\n", dest);
653         return fatal("line too long as a result of macro expansion");
654 }
655
656
657 //
658 // Get next line of text from a macro
659 //
660 char * GetNextMacroLine(void)
661 {
662         IMACRO * imacro = cur_inobj->inobj.imacro;
663 //      LONG * strp = imacro->im_nextln;
664         struct LineList * strp = imacro->im_nextln;
665
666         if (strp == NULL)                                               // End-of-macro
667                 return NULL;
668
669         imacro->im_nextln = strp->next;
670 //      ExpandMacro((char *)(strp + 1), imacro->im_lnbuf, LNSIZ);
671         ExpandMacro(strp->line, imacro->im_lnbuf, LNSIZ);
672
673         return imacro->im_lnbuf;
674 }
675
676
677 //
678 // Get next line of text from a repeat block
679 //
680 char * GetNextRepeatLine(void)
681 {
682         IREPT * irept = cur_inobj->inobj.irept;
683         LONG * strp = irept->ir_nextln;                 // initial null
684
685         // Do repeat at end of .rept block's string list
686         if (strp == NULL)
687         {
688                 DEBUG printf("back-to-top-of-repeat-block count=%d\n", (int)irept->ir_count);
689                 irept->ir_nextln = irept->ir_firstln;   // copy first line
690
691                 if (irept->ir_count-- == 0)
692                 {
693                         DEBUG printf("end-repeat-block\n");
694                         return NULL;
695                 }
696
697                 strp = irept->ir_nextln;
698         }
699
700         strcpy(irbuf, (char *)(irept->ir_nextln + 1));
701         DEBUG printf("repeat line='%s'\n", irbuf);
702         irept->ir_nextln = (LONG *)*strp;
703
704         return irbuf;
705 }
706
707
708 //
709 // Include a source file used at the root, and for ".include" files
710 //
711 int include(int handle, char * fname)
712 {
713         // Debug mode
714         if (debug)
715                 printf("[include: %s, cfileno=%u]\n", fname, cfileno);
716
717         // Alloc and initialize include-descriptors
718         INOBJ * inobj = a_inobj(SRC_IFILE);
719         IFILE * ifile = inobj->inobj.ifile;
720
721         ifile->ifhandle = handle;                               // Setup file handle
722         ifile->ifind = ifile->ifcnt = 0;                // Setup buffer indices
723         ifile->ifoldlineno = curlineno;                 // Save old line number
724         ifile->ifoldfname = curfname;                   // Save old filename
725         ifile->ifno = cfileno;                                  // Save old file number
726
727         // NB: This *must* be preincrement, we're adding one to the filecount here!
728         cfileno = ++filecount;                                  // Compute NEW file number
729         curfname = strdup(fname);                               // Set current filename (alloc storage)
730         curlineno = 0;                                                  // Start on line zero
731
732         // Add another file to the file-record
733         FILEREC * fr = (FILEREC *)malloc(sizeof(FILEREC));
734         fr->frec_next = NULL;
735         fr->frec_name = curfname;
736
737         if (last_fr == NULL)
738                 filerec = fr;                                           // Add first filerec
739         else
740                 last_fr->frec_next = fr;                        // Append to list of filerecs
741
742         last_fr = fr;
743         DEBUG printf("[include: curfname: %s, cfileno=%u]\n", curfname, cfileno);
744
745         return OK;
746 }
747
748
749 //
750 // Pop the current input level
751 //
752 int fpop(void)
753 {
754         IFILE * ifile;
755         IMACRO * imacro;
756         LONG * p, * p1;
757         INOBJ * inobj = cur_inobj;
758
759         if (inobj != NULL)
760         {
761                 // Pop IFENT levels until we reach the conditional assembly context we
762                 // were at when the input object was entered.
763                 int numUnmatched = 0;
764
765                 while (ifent != inobj->in_ifent)
766                 {
767                         if (d_endif() != 0)             // Something bad happened during endif parsing?
768                                 return -1;                      // If yes, bail instead of getting stuck in a loop
769
770                         numUnmatched++;
771                 }
772
773                 // Give a warning to the user that we had to wipe their bum for them
774                 if (numUnmatched > 0)
775                         warni("missing %d .endif(s)", numUnmatched);
776
777                 tok = inobj->in_otok;           // Restore tok and otok
778                 etok = inobj->in_etok;
779
780                 switch (inobj->in_type)
781                 {
782                 case SRC_IFILE:                         // Pop and release an IFILE
783                         if (debug)
784                                 printf("[Leaving: %s]\n", curfname);
785
786                         ifile = inobj->inobj.ifile;
787                         ifile->if_link = f_ifile;
788                         f_ifile = ifile;
789                         close(ifile->ifhandle);                 // Close source file
790 if (debug)      printf("[fpop (pre):  curfname=%s]\n", curfname);
791                         curfname = ifile->ifoldfname;   // Set current filename
792 if (debug)      printf("[fpop (post): curfname=%s]\n", curfname);
793 if (debug)      printf("[fpop: (pre)  cfileno=%d ifile->ifno=%d]\n", (int)cfileno, (int)ifile->ifno);
794                         curlineno = ifile->ifoldlineno; // Set current line#
795                         DEBUG printf("cfileno=%d ifile->ifno=%d\n", (int)cfileno, (int)ifile->ifno);
796                         cfileno = ifile->ifno;                  // Restore current file number
797 if (debug)      printf("[fpop: (post) cfileno=%d ifile->ifno=%d]\n", (int)cfileno, (int)ifile->ifno);
798                         break;
799                 case SRC_IMACRO:                                        // Pop and release an IMACRO
800                         imacro = inobj->inobj.imacro;
801                         imacro->im_link = f_imacro;
802                         f_imacro = imacro;
803                         break;
804                 case SRC_IREPT:                                         // Pop and release an IREPT
805                         DEBUG printf("dealloc IREPT\n");
806                         p = inobj->inobj.irept->ir_firstln;
807
808                         while (p != NULL)
809                         {
810                                 p1 = (LONG *)*p;
811                                 p = p1;
812                         }
813
814                         break;
815                 }
816
817                 cur_inobj = inobj->in_link;
818                 inobj->in_link = f_inobj;
819                 f_inobj = inobj;
820         }
821
822         return 0;
823 }
824
825
826 //
827 // Get line from file into buf, return NULL on EOF or ptr to the start of a
828 // null-term line
829 //
830 char * GetNextLine(void)
831 {
832         int i, j;
833         char * p, * d;
834         int readamt = -1;                                               // 0 if last read() yeilded 0 bytes
835         IFILE * fl = cur_inobj->inobj.ifile;
836
837         for(;;)
838         {
839                 // Scan for next end-of-line; handle stupid text formats by treating
840                 // \r\n the same as \n. (lone '\r' at end of buffer means we have to
841                 // check for '\n').
842                 d = &fl->ifbuf[fl->ifind];
843
844                 for(p=d, i=0, j=fl->ifcnt; i<j; i++, p++)
845                 {
846                         if (*p == '\r' || *p == '\n')
847                         {
848                                 i++;
849
850                                 if (*p == '\r')
851                                 {
852                                         if (i >= j)
853                                                 break;  // Need to read more, then look for '\n' to eat
854                                         else if (p[1] == '\n')
855                                                 i++;
856                                 }
857
858                                 // Cover up the newline with end-of-string sentinel
859                                 *p = '\0';
860
861                                 fl->ifind += i;
862                                 fl->ifcnt -= i;
863                                 return d;
864                         }
865                 }
866
867                 // Handle hanging lines by ignoring them (Input file is exhausted, no
868                 // \r or \n on last line)
869                 // Shamus: This is retarded. Never ignore any input!
870                 if (!readamt && fl->ifcnt)
871                 {
872 #if 0
873                         fl->ifcnt = 0;
874                         *p = '\0';
875                         return NULL;
876 #else
877                         // Really should check to see if we're at the end of the buffer!
878                         // :-P
879                         fl->ifbuf[fl->ifind + fl->ifcnt] = '\0';
880                         fl->ifcnt = 0;
881                         return &fl->ifbuf[fl->ifind];
882 #endif
883                 }
884
885                 // Truncate and return absurdly long lines.
886                 if (fl->ifcnt >= QUANTUM)
887                 {
888                         fl->ifbuf[fl->ifind + fl->ifcnt - 1] = '\0';
889                         fl->ifcnt = 0;
890                         return &fl->ifbuf[fl->ifind];
891                 }
892
893                 // Relocate what's left of a line to the beginning of the buffer, and
894                 // read some more of the file in; return NULL if the buffer's empty and
895                 // on EOF.
896                 if (fl->ifind != 0)
897                 {
898                         p = &fl->ifbuf[fl->ifind];
899                         d = &fl->ifbuf[fl->ifcnt & 1];
900
901                         for(i=0; i<fl->ifcnt; i++)
902                                 *d++ = *p++;
903
904                         fl->ifind = fl->ifcnt & 1;
905                 }
906
907                 readamt = read(fl->ifhandle, &fl->ifbuf[fl->ifind + fl->ifcnt], QUANTUM);
908
909                 if (readamt < 0)
910                         return NULL;
911
912                 if ((fl->ifcnt += readamt) == 0)
913                         return NULL;
914         }
915 }
916
917
918 //
919 // Tokenize a line
920 //
921 int TokenizeLine(void)
922 {
923         char * ln = NULL;                       // Ptr to current position in line
924         char * p;                                       // Random character ptr
925         TOKEN * tk;                                     // Token-deposit ptr
926         int state = 0;                          // State for keyword detector
927         int j = 0;                                      // Var for keyword detector
928         char c;                                         // Random char
929         VALUE v;                                        // Random value
930         char * nullspot = NULL;         // Spot to clobber for SYMBOL termination
931         int stuffnull;                          // 1:terminate SYMBOL '\0' at *nullspot
932         char c1;
933         int stringNum = 0;                      // Pointer to string locations in tokenized line
934
935 retry:
936
937         if (cur_inobj == NULL)                                  // Return EOF if input stack is empty
938                 return TKEOF;
939
940         // Get another line of input from the current input source: a file, a
941         // macro, or a repeat-block
942         switch (cur_inobj->in_type)
943         {
944         // Include-file:
945         // o  handle EOF;
946         // o  bump source line number;
947         // o  tag the listing-line with a space;
948         // o  kludge lines generated by Alcyon C.
949         case SRC_IFILE:
950                 if ((ln = GetNextLine()) == NULL)
951                 {
952 if (debug) printf("TokenizeLine: Calling fpop() from SRC_IFILE...\n");
953                         if (fpop() == 0)                                // Pop input level
954                                 goto retry;                                     // Try for more lines
955                         else
956                         {
957                                 ifent->if_prev = (IFENT *) - 1; //Signal Assemble() that we have reached EOF with unbalanced if/endifs
958                                 return TKEOF;
959                         }
960                 }
961
962                 curlineno++;                                            // Bump line number
963                 lntag = SPACE;
964
965                 if (as68_flag)
966                 {
967                         // AS68 compatibility, throw away all lines starting with
968                         // back-quotes, tildes, or '*'
969                         // On other lines, turn the first '*' into a semi-colon.
970                         if (*ln == '`' || *ln == '~' || *ln == '*')
971                                 *ln = ';';
972                         else
973                         {
974                                 for(p=ln; *p!=EOS; p++)
975                                 {
976                                         if (*p == '*')
977                                         {
978                                                 *p = ';';
979                                                 break;
980                                         }
981                                 }
982                         }
983                 }
984
985                 break;
986         // Macro-block:
987         // o  Handle end-of-macro;
988         // o  tag the listing-line with an at (@) sign.
989         case SRC_IMACRO:
990                 if ((ln = GetNextMacroLine()) == NULL)
991                 {
992                         if (ExitMacro() == 0)                   // Exit macro (pop args, do fpop(), etc)
993                                 goto retry;                                     // Try for more lines...
994                         else
995                                 return TKEOF;                           // Oops, we got a non zero return code, signal EOF
996                 }
997
998                 lntag = '@';
999                 break;
1000         // Repeat-block:
1001         // o  Handle end-of-repeat-block;
1002         // o  tag the listing-line with a pound (#) sign.
1003         case SRC_IREPT:
1004                 if ((ln = GetNextRepeatLine()) == NULL)
1005                 {
1006 if (debug) printf("TokenizeLine: Calling fpop() from SRC_IREPT...\n");
1007                         fpop();
1008                         goto retry;
1009                 }
1010
1011                 lntag = '#';
1012                 break;
1013         }
1014
1015         // Save text of the line.  We only do this during listings and within
1016         // macro-type blocks, since it is expensive to unconditionally copy every
1017         // line.
1018         if (lnsave)
1019                 strcpy(lnbuf, ln);
1020
1021         // General house-keeping
1022         tok = tokeol;                   // Set "tok" to EOL in case of error
1023         tk = etok;                              // Reset token ptr
1024         stuffnull = 0;                  // Don't stuff nulls
1025         totlines++;                             // Bump total #lines assembled
1026
1027         // See if the entire line is a comment. This is a win if the programmer
1028         // puts in lots of comments
1029         if (*ln == '*' || *ln == ';' || ((*ln == '/') && (*(ln + 1) == '/')))
1030                 goto goteol;
1031
1032         // Main tokenization loop;
1033         // o  skip whitespace;
1034         // o  handle end-of-line;
1035         // o  handle symbols;
1036         // o  handle single-character tokens (operators, etc.);
1037         // o  handle multiple-character tokens (constants, strings, etc.).
1038         for(; *ln!=EOS;)
1039         {
1040                 // Skip whitespace, handle EOL
1041                 while ((int)chrtab[*ln] & WHITE)
1042                         ln++;
1043
1044                 // Handle EOL, comment with ';'
1045                 if (*ln == EOS || *ln == ';'|| ((*ln == '/') && (*(ln + 1) == '/')))
1046                         break;
1047
1048                 // Handle start of symbol. Symbols are null-terminated in place. The
1049                 // termination is always one symbol behind, since there may be no place
1050                 // for a null in the case that an operator immediately follows the name.
1051                 c = chrtab[*ln];
1052
1053                 if (c & STSYM)
1054                 {
1055                         if (stuffnull)                  // Terminate old symbol from previous pass
1056                                 *nullspot = EOS;
1057
1058                         v = 0;                                  // Assume no DOT attrib follows symbol
1059                         stuffnull = 1;
1060
1061                         // In some cases, we need to check for a DOTx at the *beginning*
1062                         // of a symbol, as the "start" of the line we're currently looking
1063                         // at could be somewhere in the middle of that line!
1064                         if (*ln == '.')
1065                         {
1066                                 // Make sure that it's *only* a .[bwsl] following, and not the
1067                                 // start of a local symbol:
1068                                 if ((chrtab[*(ln + 1)] & DOT)
1069                                         && (dotxtab[*(ln + 1)] != 0)
1070                                         && !(chrtab[*(ln + 2)] & CTSYM))
1071                                 {
1072                                         // We found a legitimate DOTx construct, so add it to the
1073                                         // token stream:
1074                                         ln++;
1075                                         stuffnull = 0;
1076                                         *tk++ = (TOKEN)dotxtab[*ln++];
1077                                         continue;
1078                                 }
1079                         }
1080
1081                         p = nullspot = ln++;    // Nullspot -> start of this symbol
1082
1083                         // Find end of symbol (and compute its length)
1084                         for(j=1; (int)chrtab[*ln]&CTSYM; j++)
1085                                 ln++;
1086
1087                         // Handle "DOT" special forms (like ".b") that follow a normal
1088                         // symbol or keyword:
1089                         if (*ln == '.')
1090                         {
1091                                 *ln++ = EOS;            // Terminate symbol
1092                                 stuffnull = 0;          // And never try it again
1093
1094                                 // Character following the `.' must have a DOT attribute, and
1095                                 // the chararacter after THAT one must not have a start-symbol
1096                                 // attribute (to prevent symbols that look like, for example,
1097                                 // "zingo.barf", which might be a good idea anyway....)
1098                                 if (((chrtab[*ln] & DOT) == 0) || (dotxtab[*ln] == 0))
1099                                         return error("[bwsl] must follow '.' in symbol");
1100
1101                                 v = (VALUE)dotxtab[*ln++];
1102
1103                                 if (chrtab[*ln] & CTSYM)
1104                                         return error("misuse of '.', not allowed in symbols");
1105                         }
1106
1107                         // If the symbol is small, check to see if it's really the name of
1108                         // a register.
1109                         if (j <= KWSIZE)
1110                         {
1111                                 for(state=0; state>=0;)
1112                                 {
1113                                         j = (int)tolowertab[*p++];
1114                                         j += kwbase[state];
1115
1116                                         if (kwcheck[j] != state)
1117                                         {
1118                                                 j = -1;
1119                                                 break;
1120                                         }
1121
1122                                         if (*p == EOS || p == ln)
1123                                         {
1124                                                 j = kwaccept[j];
1125                                                 break;
1126                                         }
1127
1128                                         state = kwtab[j];
1129                                 }
1130                         }
1131                         else
1132                         {
1133                                 j = -1;
1134                         }
1135
1136                         // Make j = -1 if user tries to use a RISC register while in 68K mode
1137                         if (!(rgpu || rdsp) && ((TOKEN)j >= KW_R0 && (TOKEN)j <= KW_R31))
1138                         {
1139                                 j = -1;
1140                         }
1141
1142                         // Make j = -1 if time, date etc with no preceeding ^^
1143                         // defined, referenced, streq, macdef, date and time
1144                         switch ((TOKEN)j)
1145                         {
1146                         case 112:   // defined
1147                         case 113:   // referenced
1148                         case 118:   // streq
1149                         case 119:   // macdef
1150                         case 120:   // time
1151                         case 121:   // date
1152                                 j = -1;
1153                         }
1154
1155                         // If not tokenized keyword OR token was not found
1156                         if ((j < 0) || (state < 0))
1157                         {
1158                                 *tk++ = SYMBOL;
1159 //#warning
1160 //problem here: nullspot is a char * but TOKEN is a uint32_t. On a 64-bit
1161 //system, this will cause all kinds of mischief.
1162 #if 0
1163                                 *tk++ = (TOKEN)nullspot;
1164 #else
1165                                 string[stringNum] = nullspot;
1166                                 *tk++ = stringNum;
1167                                 stringNum++;
1168 #endif
1169                         }
1170                         else
1171                         {
1172                                 *tk++ = (TOKEN)j;
1173                                 stuffnull = 0;
1174                         }
1175
1176                         if (v)                                                  // Record attribute token (if any)
1177                                 *tk++ = (TOKEN)v;
1178
1179                         if (stuffnull)                                  // Arrange for string termination on next pass
1180                                 nullspot = ln;
1181
1182                         continue;
1183                 }
1184
1185                 // Handle identity tokens
1186                 if (c & SELF)
1187                 {
1188                         *tk++ = *ln++;
1189                         continue;
1190                 }
1191
1192                 // Handle multiple-character tokens
1193                 if (c & MULTX)
1194                 {
1195
1196                         switch (*ln++)
1197                         {
1198                         case '!':               // ! or !=
1199                                 if (*ln == '=')
1200                                 {
1201                                         *tk++ = NE;
1202                                         ++ln;
1203                                 }
1204                                 else
1205                                         *tk++ = '!';
1206
1207                                 continue;
1208                         case '\'':              // 'string'
1209                                 if (m6502)
1210                                 {
1211                                         // Hardcoded for now, maybe this will change in the future
1212                                         *tk++ = STRINGA8;
1213                                         goto dostring;
1214                                 }
1215                                 // Fall through
1216                         case '\"':              // "string"
1217                                 *tk++ = STRING;
1218 dostring:
1219                                 c1 = ln[-1];
1220                                 string[stringNum] = ln;
1221                                 *tk++ = stringNum;
1222                                 stringNum++;
1223
1224                                 for(p=ln; *ln!=EOS && *ln!=c1;)
1225                                 {
1226                                         c = *ln++;
1227
1228                                         if (c == '\\')
1229                                         {
1230                                                 switch (*ln++)
1231                                                 {
1232                                                 case EOS:
1233                                                         return(error("unterminated string"));
1234                                                 case 'e':
1235                                                         c = '\033';
1236                                                         break;
1237                                                 case 'n':
1238                                                         c = '\n';
1239                                                         break;
1240                                                 case 'b':
1241                                                         c = '\b';
1242                                                         break;
1243                                                 case 't':
1244                                                         c = '\t';
1245                                                         break;
1246                                                 case 'r':
1247                                                         c = '\r';
1248                                                         break;
1249                                                 case 'f':
1250                                                         c = '\f';
1251                                                         break;
1252                                                 case '\"':
1253                                                         c = '\"';
1254                                                         break;
1255                                                 case '\'':
1256                                                         c = '\'';
1257                                                         break;
1258                                                 case '\\':
1259                                                         c = '\\';
1260                                                         break;
1261                                                 default:
1262                                                         warn("bad backslash code in string");
1263                                                         ln--;
1264                                                         break;
1265                                                 }
1266                                         }
1267
1268                                         *p++ = c;
1269                                 }
1270
1271                                 if (*ln++ != c1)
1272                                         return error("unterminated string");
1273
1274                                 *p++ = EOS;
1275                                 continue;
1276                         case '$':               // $, hex constant
1277                                 if (chrtab[*ln] & HDIGIT)
1278                                 {
1279                                         v = 0;
1280
1281                                         // Parse the hex value
1282                                         while (hextab[*ln] >= 0)
1283                                                 v = (v << 4) + (int)hextab[*ln++];
1284
1285                                         if (*ln == '.')
1286                                         {
1287                                                 if (obj_format == BSD)
1288                                                 {
1289                                                         if ((*(ln + 1) & 0xDF) == 'B')
1290                                                         {
1291                                                                 v &= 0x000000FF;
1292                                                                 ln += 2;
1293                                                         }
1294                                                         else if ((*(ln + 1) & 0xDF) == 'W')
1295                                                         {
1296                                                                 v &= 0x0000FFFF;
1297                                                                 ln += 2;
1298                                                         }
1299                                                         else if ((*(ln + 1) & 0xDF) == 'L')
1300                                                         {
1301                                                                 ln += 2;
1302                                                         }
1303                                                 }
1304                                         }
1305
1306                                         *tk++ = CONST;
1307                                         *tk++ = v;
1308
1309                                         if (obj_format == ALCYON)
1310                                         {
1311                                                 if (*ln == '.')
1312                                                 {
1313                                                         if ((*(ln + 1) == 'w') || (*(ln + 1) == 'W'))
1314                                                         {
1315                                                                 *tk++ = DOTW;
1316                                                                 ln += 2;
1317                                                         }
1318                                                         else if ((*(ln + 1) == 'l') || (*(ln + 1) == 'L'))
1319                                                         {
1320                                                                 *tk++ = DOTL;
1321                                                                 ln += 2;
1322                                                         }
1323                                                 }
1324                                         }
1325                                 }
1326                                 else
1327                                         *tk++ = '$';
1328
1329                                 continue;
1330                         case '<':               // < or << or <> or <=
1331                                 switch (*ln)
1332                                 {
1333                                 case '<':
1334                                         *tk++ = SHL;
1335                                         ++ln;
1336                                         continue;
1337                                 case '>':
1338                                         *tk++ = NE;
1339                                         ++ln;
1340                                         continue;
1341                                 case '=':
1342                                         *tk++ = LE;
1343                                         ++ln;
1344                                         continue;
1345                                 default:
1346                                         *tk++ = '<';
1347                                         continue;
1348                                 }
1349                         case ':':               // : or ::
1350                                 if (*ln == ':')
1351                                 {
1352                                         *tk++ = DCOLON;
1353                                         ++ln;
1354                                 }
1355                                 else
1356                                         *tk++ = ':';
1357
1358                                 continue;
1359                         case '=':               // = or ==
1360                                 if (*ln == '=')
1361                                 {
1362                                         *tk++ = DEQUALS;
1363                                         ++ln;
1364                                 }
1365                                 else
1366                                         *tk++ = '=';
1367
1368                                 continue;
1369                         case '>':               // > or >> or >=
1370                                 switch (*ln)
1371                                 {
1372                                 case '>':
1373                                         *tk++ = SHR;
1374                                         ln++;
1375                                         continue;
1376                                 case '=':
1377                                         *tk++ = GE;
1378                                         ln++;
1379                                         continue;
1380                                 default:
1381                                         *tk++ = '>';
1382                                         continue;
1383                                 }
1384                         case '%':               // % or binary constant
1385                                 if (*ln < '0' || *ln > '1')
1386                                 {
1387                                         *tk++ = '%';
1388                                         continue;
1389                                 }
1390
1391                                 v = 0;
1392
1393                                 while (*ln >= '0' && *ln <= '1')
1394                                         v = (v << 1) + *ln++ - '0';
1395
1396                                 if (*ln == '.')
1397                                 {
1398                                         if ((*(ln + 1) == 'b') || (*(ln + 1) == 'B'))
1399                                         {
1400                                                 v &= 0x000000FF;
1401                                                 ln += 2;
1402                                         }
1403
1404                                         if ((*(ln + 1) == 'w') || (*(ln + 1) == 'W'))
1405                                         {
1406                                                 v &= 0x0000FFFF;
1407                                                 ln += 2;
1408                                         }
1409
1410                                         if ((*(ln + 1) == 'l') || (*(ln + 1) == 'L'))
1411                                         {
1412                                                 ln += 2;
1413                                         }
1414                                 }
1415
1416                                 *tk++ = CONST;
1417                                 *tk++ = v;
1418                                 continue;
1419                         case '@':               // @ or octal constant
1420                                 if (*ln < '0' || *ln > '7')
1421                                 {
1422                                         *tk++ = '@';
1423                                         continue;
1424                                 }
1425
1426                                 v = 0;
1427
1428                                 while (*ln >= '0' && *ln <= '7')
1429                                         v = (v << 3) + *ln++ - '0';
1430
1431                                 if (*ln == '.')
1432                                 {
1433                                         if ((*(ln+1) == 'b') || (*(ln+1) == 'B'))
1434                                         {
1435                                                 v &= 0x000000FF;
1436                                                 ln += 2;
1437                                         }
1438
1439                                         if ((*(ln+1) == 'w') || (*(ln+1) == 'W'))
1440                                         {
1441                                                 v &= 0x0000FFFF;
1442                                                 ln += 2;
1443                                         }
1444
1445                                         if ((*(ln+1) == 'l') || (*(ln+1) == 'L'))
1446                                         {
1447                                                 ln += 2;
1448                                         }
1449                                 }
1450
1451                                 *tk++ = CONST;
1452                                 *tk++ = v;
1453                                 continue;
1454                         case '^':               // ^ or ^^ <operator-name>
1455                                 if (*ln != '^')
1456                                 {
1457                                         *tk++ = '^';
1458                                         continue;
1459                                 }
1460
1461                                 if (((int)chrtab[*++ln] & STSYM) == 0)
1462                                 {
1463                                         error("invalid symbol following ^^");
1464                                         continue;
1465                                 }
1466
1467                                 p = ln++;
1468
1469                                 while ((int)chrtab[*ln] & CTSYM)
1470                                         ++ln;
1471
1472                                 for(state=0; state>=0;)
1473                                 {
1474                                         // Get char, convert to lowercase
1475                                         j = *p++;
1476
1477                                         if (j >= 'A' && j <= 'Z')
1478                                                 j += 0x20;
1479
1480                                         j += kwbase[state];
1481
1482                                         if (kwcheck[j] != state)
1483                                         {
1484                                                 j = -1;
1485                                                 break;
1486                                         }
1487
1488                                         if (*p == EOS || p == ln)
1489                                         {
1490                                                 j = kwaccept[j];
1491                                                 break;
1492                                         }
1493
1494                                         state = kwtab[j];
1495                                 }
1496
1497                                 if (j < 0 || state < 0)
1498                                 {
1499                                         error("unknown symbol following ^^");
1500                                         continue;
1501                                 }
1502
1503                                 *tk++ = (TOKEN)j;
1504                                 continue;
1505                         default:
1506                                 interror(2);    // Bad MULTX entry in chrtab
1507                                 continue;
1508                         }
1509                 }
1510
1511                 // Handle decimal constant
1512                 if (c & DIGIT)
1513                 {
1514                         v = 0;
1515
1516                         while ((int)chrtab[*ln] & DIGIT)
1517                                 v = (v * 10) + *ln++ - '0';
1518
1519                         // See if there's a .[bwl] after the constant & deal with it if so
1520                         if (*ln == '.')
1521                         {
1522                                 if ((*(ln + 1) == 'b') || (*(ln + 1) == 'B'))
1523                                 {
1524                                         v &= 0x000000FF;
1525                                         ln += 2;
1526                                 }
1527                                 else if ((*(ln + 1) == 'w') || (*(ln + 1) == 'W'))
1528                                 {
1529                                         v &= 0x0000FFFF;
1530                                         ln += 2;
1531                                 }
1532                                 else if ((*(ln + 1) == 'l') || (*(ln + 1) == 'L'))
1533                                 {
1534                                         ln += 2;
1535                                 }
1536                         }
1537
1538                         *tk++ = CONST;
1539                         *tk++ = v;
1540 //printf("CONST: %i\n", v);
1541                         continue;
1542                 }
1543
1544                 // Handle illegal character
1545                 return error("illegal character");
1546         }
1547
1548         // Terminate line of tokens and return "success."
1549
1550 goteol:
1551         tok = etok;                                                             // Set tok to beginning of line
1552
1553         if (stuffnull)                                                  // Terminate last SYMBOL
1554                 *nullspot = EOS;
1555
1556         *tk++ = EOL;
1557
1558         return OK;
1559 }
1560
1561
1562 //
1563 // .GOTO <label>        goto directive
1564 //
1565 // The label is searched for starting from the first line of the current,
1566 // enclosing macro definition. If no enclosing macro exists, an error is
1567 // generated.
1568 //
1569 // A label is of the form:
1570 //
1571 // :<name><whitespace>
1572 //
1573 // The colon must appear in column 1.  The label is stripped prior to macro
1574 // expansion, and is NOT subject to macro expansion.  The whitespace may also
1575 // be EOL.
1576 //
1577 int d_goto(WORD unused)
1578 {
1579         // Setup for the search
1580         if (*tok != SYMBOL)
1581                 return error("missing label");
1582
1583         char * sym = string[tok[1]];
1584         tok += 2;
1585
1586         if (cur_inobj->in_type != SRC_IMACRO)
1587                 return error("goto not in macro");
1588
1589         IMACRO * imacro = cur_inobj->inobj.imacro;
1590         struct LineList * defln = imacro->im_macro->lineList;
1591
1592         // Attempt to find the label, starting with the first line.
1593         for(; defln!=NULL; defln=defln->next)
1594         {
1595                 // Must start with a colon
1596                 if (defln->line[0] == ':')
1597                 {
1598                         // Compare names (sleazo string compare)
1599                         char * s1 = sym;
1600                         char * s2 = defln->line;
1601
1602                         // Either we will match the strings to EOS on both, or we will
1603                         // match EOS on string 1 to whitespace on string 2. Otherwise, we
1604                         // have no match.
1605                         while ((*s1 == *s2) || ((*s1 == EOS) && (chrtab[*s2] & WHITE)))
1606                         {
1607                                 // If we reached the end of string 1 (sym), we're done.
1608                                 // Note that we're also checking for the end of string 2 as
1609                                 // well, since we've established they're equal above.
1610                                 if (*s1 == EOS)
1611                                 {
1612                                         // Found the label, set new macro next-line and return.
1613                                         imacro->im_nextln = defln;
1614                                         return 0;
1615                                 }
1616
1617                                 s1++;
1618                                 s2++;
1619                         }
1620                 }
1621         }
1622
1623         return error("goto label not found");
1624 }
1625
1626
1627 void DumpTokenBuffer(void)
1628 {
1629         TOKEN * t;
1630         printf("Tokens [%X]: ", sloc);
1631
1632         for(t=tokbuf; *t!=EOL; t++)
1633         {
1634                 if (*t == COLON)
1635                         printf("[COLON]");
1636                 else if (*t == CONST)
1637                 {
1638                         t++;
1639                         printf("[CONST: $%X]", (uint32_t)*t);
1640                 }
1641                 else if (*t == ACONST)
1642                         printf("[ACONST]");
1643                 else if (*t == STRING)
1644                 {
1645                         t++;
1646                         printf("[STRING:\"%s\"]", string[*t]);
1647                 }
1648                 else if (*t == SYMBOL)
1649                 {
1650                         t++;
1651                         printf("[SYMBOL:\"%s\"]", string[*t]);
1652                 }
1653                 else if (*t == EOS)
1654                         printf("[EOS]");
1655                 else if (*t == TKEOF)
1656                         printf("[TKEOF]");
1657                 else if (*t == DEQUALS)
1658                         printf("[DEQUALS]");
1659                 else if (*t == SET)
1660                         printf("[SET]");
1661                 else if (*t == REG)
1662                         printf("[REG]");
1663                 else if (*t == DCOLON)
1664                         printf("[DCOLON]");
1665                 else if (*t == GE)
1666                         printf("[GE]");
1667                 else if (*t == LE)
1668                         printf("[LE]");
1669                 else if (*t == NE)
1670                         printf("[NE]");
1671                 else if (*t == SHR)
1672                         printf("[SHR]");
1673                 else if (*t == SHL)
1674                         printf("[SHL]");
1675                 else if (*t == UNMINUS)
1676                         printf("[UNMINUS]");
1677                 else if (*t == DOTB)
1678                         printf("[DOTB]");
1679                 else if (*t == DOTW)
1680                         printf("[DOTW]");
1681                 else if (*t == DOTL)
1682                         printf("[DOTL]");
1683                 else if (*t == DOTI)
1684                         printf("[DOTI]");
1685                 else if (*t == ENDEXPR)
1686                         printf("[ENDEXPR]");
1687                 else if (*t == CR_ABSCOUNT)
1688                         printf("[CR_ABSCOUNT]");
1689                 else if (*t == CR_DEFINED)
1690                         printf("[CR_DEFINED]");
1691                 else if (*t == CR_REFERENCED)
1692                         printf("[CR_REFERENCED]");
1693                 else if (*t == CR_STREQ)
1694                         printf("[CR_STREQ]");
1695                 else if (*t == CR_MACDEF)
1696                         printf("[CR_MACDEF]");
1697                 else if (*t == CR_TIME)
1698                         printf("[CR_TIME]");
1699                 else if (*t == CR_DATE)
1700                         printf("[CR_DATE]");
1701                 else if (*t >= 0x20 && *t <= 0x2F)
1702                         printf("[%c]", (char)*t);
1703                 else if (*t >= 0x3A && *t <= 0x3F)
1704                         printf("[%c]", (char)*t);
1705                 else if (*t >= 0x80 && *t <= 0x87)
1706                         printf("[D%u]", ((uint32_t)*t) - 0x80);
1707                 else if (*t >= 0x88 && *t <= 0x8F)
1708                         printf("[A%u]", ((uint32_t)*t) - 0x88);
1709                 else
1710                         printf("[%X:%c]", (uint32_t)*t, (char)*t);
1711         }
1712
1713         printf("[EOL]\n");
1714 }
1715