78de051d7e7df3ae3281023a99f7eb65f96fe415
[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                                 if (tk != NULL)                         // arg # is in range, so expand it
456                                 {
457                                         while (*tk != EOL)
458                                         {
459                                                 // Reverse-translation from a token number to a string.
460                                                 // This is a hack. It might be better table-driven.
461                                                 d = NULL;
462
463                                                 if ((*tk >= KW_D0) && !rdsp && !rgpu)
464                                                 {
465                                                         d = regname[(int)*tk++ - KW_D0];
466                                                         goto strcopy;
467                                                 }
468                                                 else if ((*tk >= KW_R0) && (*tk <= KW_R31))
469                                                 {
470                                                         d = riscregname[(int)*tk++ - KW_R0];
471                                                         goto strcopy;
472                                                 }
473                                                 else
474                                                 {
475                                                         switch ((int)*tk++)
476                                                         {
477                                                         case SYMBOL:
478 #if 0
479 //                                                              d = (char *)*tk++;
480                                                                 d = string[*tk++];
481 #else
482                                                                 // This fix should be done for strings too
483                                                                 d = symbolString[*tk++];
484 DEBUG printf("ExM: SYMBOL=\"%s\"", d);
485 #endif
486                                                                 break;
487                                                         case STRING:
488 #if 0
489 //                                                              d = (char *)*tk++;
490                                                                 d = string[*tk++];
491 #else
492                                                                 d = symbolString[*tk++];
493 #endif
494                                                                 if (dst >= edst)
495                                                                         goto overflow;
496
497                                                                 *dst++ = '"';
498
499                                                                 while (*d != EOS)
500                                                                 {
501                                                                         if (dst >= edst)
502                                                                                 goto overflow;
503                                                                         else
504                                                                                 *dst++ = *d++;
505                                                                 }
506
507                                                                 if (dst >= edst)
508                                                                         goto overflow;
509
510                                                                 *dst++ = '"';
511                                                                 continue;
512                                                                 break;
513 // Shamus: Changing the format specifier from %lx to %ux caused
514 //         the assembler to choke on legitimate code... Need to investigate
515 //         this further before changing anything else here!
516                                                         case CONST:
517                                                                 sprintf(numbuf, "$%lx", (LONG)*tk++);
518                                                                 d = numbuf;
519                                                                 break;
520                                                         case DEQUALS:
521                                                                 d = "==";
522                                                                 break;
523                                                         case SET:
524                                                                 d = "set";
525                                                                 break;
526                                                         case COLON:
527                                                                 d = ":";
528                                                                 break;
529                                                         case DCOLON:
530                                                                 d = "::";
531                                                                 break;
532                                                         case GE:
533                                                                 d = ">=";
534                                                                 break;
535                                                         case LE:
536                                                                 d = "<=";
537                                                                 break;
538                                                         case NE:
539                                                                 d = "<>";
540                                                                 break;
541                                                         case SHR:
542                                                                 d = ">>";
543                                                                 break;
544                                                         case SHL:
545                                                                 d = "<<";
546                                                                 break;
547                                                         case DOTB:
548                                                                 d = ".b";
549                                                                 break;
550                                                         case DOTW:
551                                                                 d = ".w";
552                                                                 break;
553                                                         case DOTL:
554                                                                 d = ".l";
555                                                                 break;
556                                                         case CR_DATE:
557                                                                 d = "^^date";
558                                                                 break;
559                                                         case CR_TIME:
560                                                                 d = "^^time";
561                                                                 break;
562                                                         case CR_DEFINED:
563                                                                 d = "^^defined ";
564                                                                 break;
565                                                         case CR_REFERENCED:
566                                                                 d = "^^referenced ";
567                                                                 break;
568                                                         case CR_STREQ:
569                                                                 d = "^^streq ";
570                                                                 break;
571                                                         case CR_MACDEF:
572                                                                 d = "^^macdef ";
573                                                                 break;
574                                                         default:
575                                                                 if (dst >= edst)
576                                                                         goto overflow;
577
578                                                                 *dst++ = (char)*(tk - 1);
579                                                                 break;
580                                                         }
581                                                 }
582
583                                                 // If 'd' != NULL, copy string to destination
584                                                 if (d != NULL)
585                                                 {
586 strcopy:
587                                                         DEBUG printf("d='%s'\n", d);
588
589                                                         while (*d != EOS)
590                                                         {
591                                                                 if (dst >= edst)
592                                                                         goto overflow;
593                                                                 else
594                                                                         *dst++ = *d++;
595                                                         }
596                                                 }
597                                         }
598                                 }
599                         }
600                 }
601         }
602
603         *dst = EOS;
604         DEBUG { printf("ExM: dst=\"%s\"\n", dest); }
605         return OK;
606
607 overflow:
608         *dst = EOS;
609         DEBUG printf("*** OVERFLOW LINE ***\n%s\n", dest);
610         return fatal("line too long as a result of macro expansion");
611 }
612
613
614 //
615 // Get Next Line of Text from a Macro
616 //
617 char * GetNextMacroLine(void)
618 {
619         unsigned source_addr;
620
621         IMACRO * imacro = cur_inobj->inobj.imacro;
622 //      LONG * strp = imacro->im_nextln;
623         struct LineList * strp = imacro->im_nextln;
624
625         if (strp == NULL)                                               // End-of-macro
626                 return NULL;
627
628 //      imacro->im_nextln = (LONG *)*strp;
629         imacro->im_nextln = strp->next;
630 //      ExpandMacro((char *)(strp + 1), imacro->im_lnbuf, LNSIZ);
631         ExpandMacro(strp->line, imacro->im_lnbuf, LNSIZ);
632
633         return imacro->im_lnbuf;
634 }
635
636
637 //
638 // Get Next Line of Text from a Repeat Block
639 //
640 char * GetNextRepeatLine(void)
641 {
642
643         IREPT * irept = cur_inobj->inobj.irept;
644         LONG * strp = irept->ir_nextln;                 // initial null
645
646         // Do repeat at end of .rept block's string list
647         if (strp == NULL)
648         {
649                 DEBUG printf("back-to-top-of-repeat-block count=%d\n", (int)irept->ir_count);
650                 irept->ir_nextln = irept->ir_firstln;   // copy first line
651
652                 if (irept->ir_count-- == 0)
653                 {
654                         DEBUG printf("end-repeat-block\n");
655                         return NULL;
656                 }
657
658                 strp = irept->ir_nextln;
659         }
660
661         strcpy(irbuf, (char *)(irept->ir_nextln + 1));
662         DEBUG printf("repeat line='%s'\n", irbuf);
663         irept->ir_nextln = (LONG *)*strp;
664
665         return irbuf;
666 }
667
668
669 //
670 // Include a Source File used at the Root, and for ".include" Files
671 //
672 int include(int handle, char * fname)
673 {
674         IFILE * ifile;
675         INOBJ * inobj;
676         FILEREC * fr;
677
678         // Verbose mode
679         if (verb_flag)
680                 printf("[include: %s, cfileno=%u]\n", fname, cfileno);
681
682         // Alloc and initialize include-descriptors
683         inobj = a_inobj(SRC_IFILE);
684         ifile = inobj->inobj.ifile;
685
686         ifile->ifhandle = handle;                               // Setup file handle
687         ifile->ifind = ifile->ifcnt = 0;                // Setup buffer indices
688         ifile->ifoldlineno = curlineno;                 // Save old line number
689         ifile->ifoldfname = curfname;                   // Save old filename
690         ifile->ifno = cfileno;                                  // Save old file number
691
692 //      cfileno = filecount++;                                  // Compute new file number
693         // NB: This *must* be preincrement, we're adding one to the filecount here!
694         cfileno = ++filecount;                                  // Compute NEW file number
695         curfname = strdup(fname);                               // Set current filename (alloc storage)
696         curlineno = 0;                                                  // Start on line zero
697
698         // Add another file to the file-record
699         fr = (FILEREC *)malloc(sizeof(FILEREC));
700         fr->frec_next = NULL;
701         fr->frec_name = curfname;
702
703         if (last_fr == NULL)
704                 filerec = fr;                                           // Add first filerec 
705         else
706                 last_fr->frec_next = fr;                        // Append to list of filerecs 
707
708         last_fr = fr;
709         DEBUG printf("[include: curfname: %s, cfileno=%u]\n", curfname, cfileno);
710
711         return OK;
712 }
713
714
715 //
716 // Pop the Current Input Level
717 //
718 int fpop(void)
719 {
720         IFILE * ifile;
721         IMACRO * imacro;
722         LONG * p, * p1;
723         INOBJ * inobj = cur_inobj;
724
725         if (inobj != NULL)
726         {
727                 // Pop IFENT levels until we reach the conditional assembly context we
728                 // were at when the input object was entered.
729                 while (ifent != inobj->in_ifent)
730                         d_endif();
731
732                 tok = inobj->in_otok;                           // Restore tok and otok
733                 etok = inobj->in_etok;
734
735                 switch (inobj->in_type)
736                 {
737                 case SRC_IFILE:                                         // Pop and release an IFILE
738                         if (verb_flag)
739                                 printf("[Leaving: %s]\n", curfname);
740
741                         ifile = inobj->inobj.ifile;
742                         ifile->if_link = f_ifile;
743                         f_ifile = ifile;
744                         close(ifile->ifhandle);                 // Close source file
745 if (verb_flag) printf("[fpop (pre):  curfname=%s]\n", curfname);
746                         curfname = ifile->ifoldfname;   // Set current filename
747 if (verb_flag) printf("[fpop (post): curfname=%s]\n", curfname);
748 if (verb_flag) printf("[fpop: (pre)  cfileno=%d ifile->ifno=%d]\n", (int)cfileno, (int)ifile->ifno);
749                         curlineno = ifile->ifoldlineno; // Set current line# 
750                         DEBUG printf("cfileno=%d ifile->ifno=%d\n", (int)cfileno, (int)ifile->ifno);
751                         cfileno = ifile->ifno;                  // Restore current file number
752 if (verb_flag) printf("[fpop: (post) cfileno=%d ifile->ifno=%d]\n", (int)cfileno, (int)ifile->ifno);
753                         break;
754                 case SRC_IMACRO:                                        // Pop and release an IMACRO
755                         imacro = inobj->inobj.imacro;
756                         imacro->im_link = f_imacro;
757                         f_imacro = imacro;
758                         break;
759                 case SRC_IREPT:                                         // Pop and release an IREPT
760                         DEBUG printf("dealloc IREPT\n");
761                         p = inobj->inobj.irept->ir_firstln;
762
763                         while (p != NULL)
764                         {
765                                 p1 = (LONG *)*p;
766                                 p = p1;
767                         }
768
769                         break;
770                 }
771
772                 cur_inobj = inobj->in_link;
773                 inobj->in_link = f_inobj;
774                 f_inobj = inobj;
775         }
776
777         return 0;
778 }
779
780
781 //
782 // Get line from file into buf, return NULL on EOF or ptr to the start of a
783 // null-term line
784 //
785 char * GetNextLine(void)
786 {
787         int i, j;
788         char * p, * d;
789         int readamt = -1;                                               // 0 if last read() yeilded 0 bytes
790         IFILE * fl = cur_inobj->inobj.ifile;
791
792         for(;;)
793         {
794                 // Scan for next end-of-line; handle stupid text formats by treating
795                 // \r\n the same as \n. (lone '\r' at end of buffer means we have to
796                 // check for '\n').
797                 i = 0;
798                 j = fl->ifcnt;
799                 d = &fl->ifbuf[fl->ifind];
800
801                 for(p=d; i<j; i++, p++)
802                 {
803                         if (*p == '\r' || *p == '\n')
804                         {
805                                 i++;
806
807                                 if (*p == '\r')
808                                 {
809                                         if (i >= j)
810                                         {
811                                                 break;                          // Look for '\n' to eat 
812                                         }
813                                         else if (p[1] == '\n')
814                                         {
815                                                 i++;
816                                         }
817                                 }
818
819                                 *p = '\0';
820
821                                 fl->ifind += i;
822                                 fl->ifcnt -= i;
823                                 return d;
824                         }
825                 }
826
827                 // Handle hanging lines by ignoring them (Input file is exhausted, no
828                 // \r or \n on last line)
829                 if (!readamt && fl->ifcnt)
830                 {
831                         fl->ifcnt = 0;
832                         *p = '\0';
833                         return NULL;
834                 }
835
836                 // Truncate and return absurdly long lines.
837                 if (fl->ifcnt >= QUANTUM)
838                 {
839                         fl->ifbuf[fl->ifind + fl->ifcnt - 1] = '\0';
840                         fl->ifcnt = 0;
841                         return &fl->ifbuf[fl->ifind];
842                 }
843
844                 // Relocate what's left of a line to the beginning of the buffer, and
845                 // read some more of the file in; return NULL if the buffer's empty and
846                 // on EOF.
847                 if (fl->ifind != 0)
848                 {
849                         p = &fl->ifbuf[fl->ifind];
850                         d = &fl->ifbuf[fl->ifcnt & 1];
851
852                         for(i=0; i<fl->ifcnt; i++)
853                                 *d++ = *p++;
854
855                         fl->ifind = fl->ifcnt & 1;
856                 }
857
858                 if ((readamt = read(fl->ifhandle, &fl->ifbuf[fl->ifind + fl->ifcnt], QUANTUM)) < 0)
859                         return NULL;
860
861                 if ((fl->ifcnt += readamt) == 0)
862                         return NULL;
863         }
864 }
865
866
867 //
868 // Tokenize a Line
869 //
870 int TokenizeLine(void)
871 {
872         char * ln = NULL;                               // Ptr to current position in line
873         char * p;                                               // Random character ptr
874         TOKEN * tk;                                             // Token-deposit ptr
875         int state = 0;                                  // State for keyword detector
876         int j = 0;                                              // Var for keyword detector
877         char c;                                                 // Random char
878         VALUE v;                                                // Random value
879         char * nullspot = NULL;                 // Spot to clobber for SYMBOL terminatn
880         int stuffnull;                                  // 1:terminate SYMBOL '\0' at *nullspot
881         char c1;
882         int stringNum = 0;                              // Pointer to string locations in tokenized line
883
884 retry:
885
886         if (cur_inobj == NULL)                                  // Return EOF if input stack is empty
887                 return TKEOF;
888
889         // Get another line of input from the current input source: a file,
890         // a macro, or a repeat-block
891         switch (cur_inobj->in_type)
892         {
893         // Include-file:
894         // o  handle EOF;
895         // o  bump source line number;
896         // o  tag the listing-line with a space;
897         // o  kludge lines generated by Alcyon C.
898         case SRC_IFILE:
899                 if ((ln = GetNextLine()) == NULL)
900                 {
901 if (verb_flag) printf("TokenizeLine: Calling fpop() from SRC_IFILE...\n");
902                         fpop();                                                 // Pop input level
903                         goto retry;                                             // Try for more lines 
904                 }
905
906                 curlineno++;                                            // Bump line number
907                 lntag = SPACE;
908
909                 if (as68_flag)
910                 {
911                         // AS68 compatibility, throw away all lines starting with
912                         // back-quotes, tildes, or '*'
913                         // On other lines, turn the first '*' into a semi-colon.
914                         if (*ln == '`' || *ln == '~' || *ln == '*')
915                                 *ln = ';';
916                         else
917                         {
918                                 for(p=ln; *p!=EOS; p++)
919                                 {
920                                         if (*p == '*')
921                                         {
922                                                 *p = ';';
923                                                 break;
924                                         }
925                                 }
926                         }
927                 }
928
929                 break;
930         // Macro-block:
931         // o  Handle end-of-macro;
932         // o  tag the listing-line with an at (@) sign.
933         case SRC_IMACRO:
934                 if ((ln = GetNextMacroLine()) == NULL)
935                 {
936                         ExitMacro();                                    // Exit macro (pop args, do fpop(), etc)
937                         goto retry;                                             // Try for more lines...
938                 }
939
940                 lntag = '@';
941                 break;
942         // Repeat-block:
943         // o  Handle end-of-repeat-block;
944         // o  tag the listing-line with a pound (#) sign.
945         case SRC_IREPT:
946                 if ((ln = GetNextRepeatLine()) == NULL)
947                 {
948 if (verb_flag) printf("TokenizeLine: Calling fpop() from SRC_IREPT...\n");
949                         fpop();
950                         goto retry;
951                 }
952
953                 lntag = '#';
954                 break;
955         }
956
957         // Save text of the line.  We only do this during listings and within
958         // macro-type blocks, since it is expensive to unconditionally copy every
959         // line.
960         if (lnsave)
961                 strcpy(lnbuf, ln);
962
963         // General house-keeping
964         tok = tokeol;                                                   // Set "tok" to EOL in case of error
965         tk = etok;                                                              // Reset token ptr
966         stuffnull = 0;                                                  // Don't stuff nulls
967         totlines++;                                                             // Bump total #lines assembled
968
969         // See if the entire line is a comment. This is a win if the programmer
970         // puts in lots of comments
971         if (*ln == '*' || *ln == ';' || ((*ln == '/') && (*(ln + 1) == '/')))
972                 goto goteol;
973
974         // Main tokenization loop;
975         // o  skip whitespace;
976         // o  handle end-of-line;
977         // o  handle symbols;
978         // o  handle single-character tokens (operators, etc.);
979         // o  handle multiple-character tokens (constants, strings, etc.).
980         for(; *ln!=EOS;)
981         {
982                 // Skip whitespace, handle EOL
983                 while ((int)chrtab[*ln] & WHITE)
984                         ln++;
985
986                 // Handle EOL, comment with ';'
987                 if (*ln == EOS || *ln == ';'|| ((*ln == '/') && (*(ln + 1) == '/'))) 
988                         break;
989
990                 // Handle start of symbol. Symbols are null-terminated in place. The
991                 // termination is always one symbol behind, since there may be no place
992                 // for a null in the case that an operator immediately follows the name.
993                 c = chrtab[*ln];
994
995                 if (c & STSYM)
996                 {
997                         if (stuffnull)                                  // Terminate old symbol from previous pass
998                                 *nullspot = EOS;
999
1000                         v = 0;                                                  // Assume no DOT attrib follows symbol
1001                         stuffnull = 1;
1002                         p = nullspot = ln++;                    // Nullspot -> start of this symbol
1003
1004                         // Find end of symbol (and compute its length)
1005                         for(j=1; (int)chrtab[*ln]&CTSYM; j++)
1006                                 ln++;
1007
1008                         // Handle "DOT" special forms (like ".b") that follow a normal
1009                         // symbol or keyword:
1010                         if (*ln == '.')
1011                         {
1012                                 *ln++ = EOS;                            // Terminate symbol
1013                                 stuffnull = 0;                          // And never try it again 
1014
1015                                 // Character following the `.' must have a DOT attribute, and
1016                                 // the chararacter after THAT one must not have a start-symbol
1017                                 // attribute (to prevent symbols that look like, for example,
1018                                 // "zingo.barf", which might be a good idea anyway....)
1019                                 if ((((int)chrtab[*ln] & DOT) == 0) || ((int)dotxtab[*ln] <= 0))
1020                                         return error("[bwsl] must follow `.' in symbol");
1021
1022                                 v = (VALUE)dotxtab[*ln++];
1023
1024                                 if ((int)chrtab[*ln] & CTSYM)
1025                                         return error("misuse of `.', not allowed in symbols");
1026                         }
1027
1028                         // If the symbol is small, check to see if it's really the name of
1029                         // a register.
1030                         if (j <= KWSIZE)
1031                         {
1032                                 for(state=0; state>=0;)
1033                                 {
1034                                         j = (int)tolowertab[*p++];
1035                                         j += kwbase[state];
1036
1037                                         if (kwcheck[j] != state)
1038                                         {
1039                                                 j = -1;
1040                                                 break;
1041                                         }
1042
1043                                         if (*p == EOS || p == ln)
1044                                         {
1045                                                 j = kwaccept[j];
1046                                                 break;
1047                                         }
1048
1049                                         state = kwtab[j];
1050                                 }
1051                         }
1052                         else
1053                         {
1054                                 j = -1;
1055                         }
1056
1057                         //make j = -1 if time, date etc with no preceeding ^^
1058                         //defined, referenced, streq, macdef, date and time
1059                         switch ((TOKEN)j)
1060                         {
1061                         case 112:   // defined
1062                         case 113:   // referenced
1063                         case 118:   // streq
1064                         case 119:   // macdef
1065                         case 120:   // time
1066                         case 121:   // date
1067                                 j = -1;
1068                                 break;
1069                         }
1070
1071                         if (j < 0 || state < 0)
1072                         {
1073                                 *tk++ = SYMBOL;
1074 //#warning
1075 //problem here: nullspot is a char * but TOKEN is a uint32_t. On a 64-bit system,
1076 //this will cause all kinds of mischief.
1077 #if 0
1078                                 *tk++ = (TOKEN)nullspot;
1079 #else
1080                                 string[stringNum] = nullspot;
1081                                 *tk++ = stringNum;
1082                                 stringNum++;
1083 #endif
1084                         }
1085                         else
1086                         {
1087                                 *tk++ = (TOKEN)j;
1088                                 stuffnull = 0;
1089                         }
1090
1091                         if (v)                                                  // Record attribute token (if any)
1092                                 *tk++ = (TOKEN)v;
1093
1094                         if (stuffnull)                                  // Arrange for string termination on next pass
1095                                 nullspot = ln;
1096
1097                         continue;
1098                 }
1099
1100                 // Handle identity tokens
1101                 if (c & SELF)
1102                 {
1103                         *tk++ = *ln++;
1104                         continue;
1105                 }
1106
1107                 // Handle multiple-character tokens
1108                 if (c & MULTX)
1109                 {
1110                         switch (*ln++)
1111                         {
1112                         case '!':                                       // ! or != 
1113                                 if (*ln == '=')
1114                                 {
1115                                         *tk++ = NE;
1116                                         ++ln;
1117                                 }
1118                                 else
1119                                         *tk++ = '!';
1120
1121                                 continue;
1122                         case '\'':                                      // 'string' 
1123                         case '\"':                                      // "string" 
1124                                 c1 = ln[-1];
1125                                 *tk++ = STRING;
1126 //#warning
1127 // More char * stuffing (8 bytes) into the space of 4 (TOKEN).
1128 // Need to figure out how to fix this crap.
1129 #if 0
1130                                 *tk++ = (TOKEN)ln;
1131 #else
1132                                 string[stringNum] = ln;
1133                                 *tk++ = stringNum;
1134                                 stringNum++;
1135 #endif
1136
1137                                 for(p=ln; *ln!=EOS && *ln!=c1;)
1138                                 {
1139                                         c = *ln++;
1140
1141                                         if (c == '\\')
1142                                         {
1143                                                 switch (*ln++)
1144                                                 {
1145                                                 case EOS:
1146                                                         return(error("unterminated string"));
1147                                                 case 'e':
1148                                                         c = '\033';
1149                                                         break;
1150                                                 case 'n':
1151                                                         c = '\n';
1152                                                         break;
1153                                                 case 'b':
1154                                                         c = '\b';
1155                                                         break;
1156                                                 case 't':
1157                                                         c = '\t';
1158                                                         break;
1159                                                 case 'r':
1160                                                         c = '\r';
1161                                                         break;
1162                                                 case 'f':
1163                                                         c = '\f';
1164                                                         break;
1165                                                 case '\"':
1166                                                         c = '\"';
1167                                                         break;
1168                                                 case '\'':
1169                                                         c = '\'';
1170                                                         break;
1171                                                 case '\\':
1172                                                         c = '\\';
1173                                                         break;
1174                                                 default:
1175                                                         warn("bad backslash code in string");
1176                                                         ln--;
1177                                                         break;
1178                                                 }
1179                                         }
1180
1181                                         *p++ = c;
1182                                 }
1183
1184                                 if (*ln++ != c1)
1185                                         return error("unterminated string");
1186
1187                                 *p++ = EOS;
1188                                 continue;
1189                         case '$':                                       // $, hex constant
1190                                 if ((int)chrtab[*ln] & HDIGIT)
1191                                 {
1192                                         v = 0;
1193
1194                                         while ((int)hextab[*ln] >= 0)
1195                                                 v = (v << 4) + (int)hextab[*ln++];
1196
1197                                         if (*ln == '.')
1198                                         {
1199                                                 if ((*(ln + 1) == 'b') || (*(ln + 1) == 'B'))
1200                                                 {
1201                                                         v &= 0x000000FF;
1202                                                         ln += 2;
1203                                                 }
1204
1205                                                 if ((*(ln + 1) == 'w') || (*(ln + 1) == 'W'))
1206                                                 {
1207                                                         v &= 0x0000FFFF;
1208                                                         ln += 2;
1209                                                 }
1210
1211                                                 if ((*(ln + 1) == 'l') || (*(ln + 1) == 'L'))
1212                                                 {
1213                                                         ln += 2;
1214                                                 }
1215                                         }
1216
1217                                         *tk++ = CONST;
1218                                         *tk++ = v;
1219                                 }
1220                                 else
1221                                         *tk++ = '$';
1222
1223                                 continue;
1224                         case '<':                                       // < or << or <> or <= 
1225                                 switch (*ln)
1226                                 {
1227                                 case '<':
1228                                         *tk++ = SHL;
1229                                         ++ln;
1230                                         continue;
1231                                 case '>':
1232                                         *tk++ = NE;
1233                                         ++ln;
1234                                         continue;
1235                                 case '=':
1236                                         *tk++ = LE;
1237                                         ++ln;
1238                                         continue;
1239                                 default:
1240                                         *tk++ = '<';
1241                                         continue;
1242                                 }
1243                         case ':':                                       // : or ::
1244                                 if (*ln == ':')
1245                                 {
1246                                         *tk++ = DCOLON;
1247                                         ++ln;
1248                                 }
1249                                 else
1250                                         *tk++ = ':';
1251
1252                                 continue;
1253                         case '=':                                       // = or == 
1254                                 if (*ln == '=')
1255                                 {
1256                                         *tk++ = DEQUALS;
1257                                         ++ln;
1258                                 }
1259                                 else
1260                                         *tk++ = '=';
1261
1262                                 continue;
1263                         case '>':                                       // > or >> or >= 
1264                                 switch (*ln)
1265                                 {
1266                                 case '>':
1267                                         *tk++ = SHR;
1268                                         ln++;
1269                                         continue;
1270                                 case '=':
1271                                         *tk++ = GE;
1272                                         ln++;
1273                                         continue;
1274                                 default:
1275                                         *tk++ = '>';
1276                                         continue;
1277                                 }
1278                         case '%':                                       // % or binary constant 
1279                                 if (*ln < '0' || *ln > '1')
1280                                 {
1281                                         *tk++ = '%';
1282                                         continue;
1283                                 }
1284
1285                                 v = 0;
1286
1287                                 while (*ln >= '0' && *ln <= '1')
1288                                         v = (v << 1) + *ln++ - '0';
1289
1290                                 if (*ln == '.')
1291                                 {
1292                                         if ((*(ln + 1) == 'b') || (*(ln + 1) == 'B'))
1293                                         {
1294                                                 v &= 0x000000FF;
1295                                                 ln += 2;
1296                                         }
1297
1298                                         if ((*(ln + 1) == 'w') || (*(ln + 1) == 'W'))
1299                                         {
1300                                                 v &= 0x0000FFFF;
1301                                                 ln += 2;
1302                                         }
1303
1304                                         if ((*(ln + 1) == 'l') || (*(ln + 1) == 'L'))
1305                                         {
1306                                                 ln += 2;
1307                                         }
1308                                 }
1309
1310                                 *tk++ = CONST;
1311                                 *tk++ = v;
1312                                 continue;
1313                         case '@':                                       // @ or octal constant 
1314                                 if (*ln < '0' || *ln > '7')
1315                                 {
1316                                         *tk++ = '@';
1317                                         continue;
1318                                 }
1319
1320                                 v = 0;
1321
1322                                 while (*ln >= '0' && *ln <= '7')
1323                                         v = (v << 3) + *ln++ - '0';
1324
1325                                 if (*ln == '.')
1326                                 {
1327                                         if ((*(ln+1) == 'b') || (*(ln+1) == 'B'))
1328                                         {
1329                                                 v &= 0x000000FF;
1330                                                 ln += 2;
1331                                         }
1332
1333                                         if ((*(ln+1) == 'w') || (*(ln+1) == 'W'))
1334                                         {
1335                                                 v &= 0x0000FFFF;
1336                                                 ln += 2;
1337                                         }
1338
1339                                         if ((*(ln+1) == 'l') || (*(ln+1) == 'L'))
1340                                         {
1341                                                 ln += 2;
1342                                         }
1343                                 }
1344
1345                                 *tk++ = CONST;
1346                                 *tk++ = v;
1347                                 continue;
1348                         case '^':                                       // ^ or ^^ <operator-name>
1349                                 if (*ln != '^')
1350                                 {
1351                                         *tk++ = '^';
1352                                         continue;
1353                                 }
1354
1355                                 if (((int)chrtab[*++ln] & STSYM) == 0)
1356                                 {
1357                                         error("invalid symbol following ^^");
1358                                         continue;
1359                                 }
1360
1361                                 p = ln++;
1362
1363                                 while ((int)chrtab[*ln] & CTSYM)
1364                                         ++ln;
1365
1366                                 for(state=0; state>=0;)
1367                                 {
1368                                         // Get char, convert to lowercase 
1369                                         j = *p++;
1370
1371                                         if (j >= 'A' && j <= 'Z')
1372                                                 j += 0x20;
1373
1374                                         j += kwbase[state];
1375
1376                                         if (kwcheck[j] != state)
1377                                         {
1378                                                 j = -1;
1379                                                 break;
1380                                         }
1381
1382                                         if (*p == EOS || p == ln)
1383                                         {
1384                                                 j = kwaccept[j];
1385                                                 break;
1386                                         }
1387
1388                                         state = kwtab[j];
1389                                 }
1390
1391                                 if (j < 0 || state < 0)
1392                                 {
1393                                         error("unknown symbol following ^^");
1394                                         continue;
1395                                 }
1396
1397                                 *tk++ = (TOKEN)j;
1398                                 continue;
1399                         default:
1400                                 interror(2);                                 // Bad MULTX entry in chrtab
1401                                 continue;
1402                         }
1403                 }
1404
1405                 // Handle decimal constant
1406                 if (c & DIGIT)
1407                 {
1408                         v = 0;
1409
1410                         while ((int)chrtab[*ln] & DIGIT)
1411                                 v = (v * 10) + *ln++ - '0';
1412
1413                         // See if there's a .[bwl] after the constant, & deal with it
1414                         if (*ln == '.')
1415                         {
1416                                 if ((*(ln+1) == 'b') || (*(ln+1) == 'B'))
1417                                 {
1418                                         v &= 0x000000FF;
1419                                         ln += 2;
1420                                 }
1421
1422                                 if ((*(ln+1) == 'w') || (*(ln+1) == 'W'))
1423                                 {
1424                                         v &= 0x0000FFFF;
1425                                         ln += 2;
1426                                 }
1427
1428                                 if ((*(ln+1) == 'l') || (*(ln+1) == 'L'))
1429                                 {
1430                                         ln += 2;
1431                                 }
1432                         }
1433
1434                         *tk++ = CONST;
1435                         *tk++ = v;
1436                         continue;
1437                 }
1438
1439                 // Handle illegal character
1440                 return error("illegal character");
1441         }
1442
1443         // Terminate line of tokens and return "success."
1444
1445 goteol:
1446         tok = etok;                                                             // Set tok to beginning of line
1447
1448         if (stuffnull)                                                  // Terminate last SYMBOL
1449                 *nullspot = EOS;
1450
1451         *tk++ = EOL;
1452
1453         return OK;
1454 }
1455
1456
1457 //
1458 // .GOTO <label>        goto directive
1459 // 
1460 // The label is searched for starting from the first line of the current,
1461 // enclosing macro definition. If no enclosing macro exists, an error is
1462 // generated.
1463 // 
1464 // A label is of the form:
1465 // 
1466 // :<name><whitespace>
1467 // 
1468 // The colon must appear in column 1.  The label is stripped prior to macro
1469 // expansion, and is NOT subject to macro expansion.  The whitespace may also
1470 // be EOL.
1471 //
1472 //int d_goto(WORD siz) {
1473 //int d_goto(void)
1474 int d_goto(WORD unused)
1475 {
1476 //      char * sym;                                               // Label to search for 
1477 //      LONG * defln;                                             // Macro definition strings 
1478         char * s1;                                                // Temps for string comparison 
1479         char * s2;
1480 //      IMACRO * imacro;                                          // Macro invocation block
1481
1482         // Setup for the search
1483         if (*tok != SYMBOL)
1484                 return error("missing label");
1485
1486 //      sym = (char *)tok[1];
1487         char * sym = string[tok[1]];
1488         tok += 2;
1489
1490         if (cur_inobj->in_type != SRC_IMACRO)
1491                 return error("goto not in macro");
1492
1493         IMACRO * imacro = cur_inobj->inobj.imacro;
1494 //      defln = (LONG *)imacro->im_macro->svalue;
1495         struct LineList * defln = imacro->im_macro->lineList;
1496
1497         // Find the label, starting with the first line.
1498 //      for(; defln!=NULL; defln=(LONG *)*defln)
1499         for(; defln!=NULL; defln=defln->next)
1500         {
1501 //              if (*(char *)(defln + 1) == ':')
1502                 if (defln->line[0] == ':')
1503                 {
1504                         // Compare names (sleazo string compare)
1505                         // This string compare is not right. Doesn't check for lengths.
1506                         // (actually it does, but in a crappy, unclear way.)
1507 #warning "!!! Bad string comparison !!!"
1508                         s1 = sym;
1509 //                      s2 = (char *)(defln + 1) + 1;
1510                         s2 = defln->line;
1511
1512                         while (*s1 == *s2)
1513                         {
1514                                 if (*s1 == EOS)
1515                                         break;
1516                                 else
1517                                 {
1518                                         s1++;
1519                                         s2++;
1520                                 }
1521                         }
1522
1523                         // Found the label, set new macro next-line and return.
1524                         if ((*s2 == EOS) || ((int)chrtab[*s2] & WHITE))
1525                         {
1526                                 imacro->im_nextln = defln;
1527                                 return 0;
1528                         }
1529                 }
1530         }
1531
1532         return error("goto label not found");
1533 }
1534
1535
1536 void DumpTokenBuffer(void)
1537 {
1538         TOKEN * t;
1539         printf("Tokens [%X]: ", sloc);
1540
1541         for(t=tokbuf; *t!=EOL; t++)
1542         {
1543                 if (*t == COLON)
1544                         printf("[COLON]");
1545                 else if (*t == CONST)
1546                 {
1547                         t++;
1548                         printf("[CONST: $%X]", (uint32_t)*t);
1549                 }
1550                 else if (*t == ACONST)
1551                         printf("[ACONST]");
1552                 else if (*t == STRING)
1553 //                      printf("[STRING]");
1554                 {
1555                         t++;
1556                         printf("[STRING:\"%s\"]", string[*t]);
1557                 }
1558                 else if (*t == SYMBOL)
1559                 {
1560                         t++;
1561                         printf("[SYMBOL:\"%s\"]", string[*t]);
1562                 }
1563                 else if (*t == EOS)
1564                         printf("[EOS]");
1565                 else if (*t == TKEOF)
1566                         printf("[TKEOF]");
1567                 else if (*t == DEQUALS)
1568                         printf("[DEQUALS]");
1569                 else if (*t == SET)
1570                         printf("[SET]");
1571                 else if (*t == REG)
1572                         printf("[REG]");
1573                 else if (*t == DCOLON)
1574                         printf("[DCOLON]");
1575                 else if (*t == GE)
1576                         printf("[GE]");
1577                 else if (*t == LE)
1578                         printf("[LE]");
1579                 else if (*t == NE)
1580                         printf("[NE]");
1581                 else if (*t == SHR)
1582                         printf("[SHR]");
1583                 else if (*t == SHL)
1584                         printf("[SHL]");
1585                 else if (*t == UNMINUS)
1586                         printf("[UNMINUS]");
1587                 else if (*t == DOTB)
1588                         printf("[DOTB]");
1589                 else if (*t == DOTW)
1590                         printf("[DOTW]");
1591                 else if (*t == DOTL)
1592                         printf("[DOTL]");
1593                 else if (*t == DOTI)
1594                         printf("[DOTI]");
1595                 else if (*t == ENDEXPR)
1596                         printf("[ENDEXPR]");
1597                 else if (*t == CR_DEFINED)
1598                         printf("[CR_DEFINED]");
1599                 else if (*t == CR_REFERENCED)
1600                         printf("[CR_REFERENCED]");
1601                 else if (*t == CR_STREQ)
1602                         printf("[CR_STREQ]");
1603                 else if (*t == CR_MACDEF)
1604                         printf("[CR_MACDEF]");
1605                 else if (*t == CR_TIME)
1606                         printf("[CR_TIME]");
1607                 else if (*t == CR_DATE)
1608                         printf("[CR_DATE]");
1609                 else if (*t >= 0x20 && *t <= 0x2F)
1610                         printf("[%c]", (char)*t);
1611                 else if (*t >= 0x3A && *t <= 0x3F)
1612                         printf("[%c]", (char)*t);
1613                 else if (*t >= 0x80 && *t <= 0x87)
1614                         printf("[D%u]", ((uint32_t)*t) - 0x80);
1615                 else if (*t >= 0x88 && *t <= 0x8F)
1616                         printf("[A%u]", ((uint32_t)*t) - 0x88);
1617                 else
1618                         printf("[%X:%c]", (uint32_t)*t, (char)*t);
1619 //                      printf("[%X]", (uint32_t)*t);
1620         }
1621
1622         printf("[EOL]\n");
1623 }
1624