Shamusworld >> Repos - rmac/blob - token.c

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