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