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