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

   1 //
   2 // RMAC - Reboot's Macro Assembler for the Atari Jaguar Console System
   3 // DIRECT.C - Directive Handling
   4 // Copyright (C) 199x Landon Dyer, 2011 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 "direct.h"
  10 #include "sect.h"
  11 #include "risca.h"
  12 #include "error.h"
  13 #include "token.h"
  14 #include "procln.h"
  15 #include "expr.h"
  16 #include "mach.h"
  17 #include "listing.h"
  18 #include "mark.h"
  19 #include "symbol.h"
  20
  21 #define DEF_KW
  22 #include "kwtab.h"
  23
  24 TOKEN exprbuf[128];                                         // Expression buffer
  25
  26 // Directive handler table
  27 int (*dirtab[])() = {
  28    d_org,                                                   // 0 org
  29    d_even,                                                  // 1 even
  30    d_unimpl,                                                // 2 .6502
  31    d_68000,                                                 // 3 .68000
  32    d_bss,                                                   // 4 bss
  33    d_data,                                                  // 5 data
  34    d_text,                                                  // 6 text
  35    d_abs,                                                   // 7 abs
  36    d_comm,                                                  // 8 comm
  37    d_init,                                                  // 9 init
  38    d_cargs,                                                 // 10 cargs
  39    d_goto,                                                  // 11 goto
  40    d_dc,                                                    // 12 dc
  41    d_ds,                                                    // 13 ds
  42    d_undmac,                                                // 14 undefmac
  43    d_gpu,                                                   // 15 .gpu
  44    d_dsp,                                                   // 16 .dsp
  45    d_dcb,                                                   // 17 dcb
  46    d_unimpl,                                                // 18* set
  47    d_unimpl,                                                // 19* reg
  48    d_unimpl,                                                // 20 dump
  49    d_incbin,                                                // 21 .incbin //load
  50    d_unimpl,                                                // 22 disable
  51    d_unimpl,                                                // 23 enable
  52    d_globl,                                                 // 24 globl
  53    d_regbank0,                                              // 25 .regbank0
  54    d_regbank1,                                              // 26 .regbank1
  55    d_unimpl,                                                // 27 xdef
  56    d_assert,                                                // 28 assert
  57    d_unimpl,                                                // 29* if
  58    d_unimpl,                                                // 30* endif
  59    d_unimpl,                                                // 31* endc
  60    d_unimpl,                                                // 32* iif
  61    d_include,                                               // 33 include
  62    fpop,                                                    // 34 end
  63    d_unimpl,                                                // 35* macro
  64    exitmac,                                                 // 36* exitm
  65    d_unimpl,                                                // 37* endm
  66    d_list,                                                  // 38 list
  67    d_nlist,                                                 // 39 nlist
  68    d_long,                                                  // 40* rept
  69    d_phrase,                                                // 41* endr
  70    d_dphrase,                                               // 42 struct
  71    d_qphrase,                                               // 43 ends
  72    d_title,                                                 // 44 title
  73    d_subttl,                                                // 45 subttl
  74    eject,                                                   // 46 eject
  75    d_unimpl,                                                // 47 error
  76    d_unimpl,                                                // 48 warn
  77    d_noclear,                                               // 49 .noclear
  78    d_equrundef,                                             // 50 .equrundef/.regundef
  79    d_ccundef,                                               // 51 .ccundef
  80    d_print,                                                 // 52 .print
  81    d_gpumain,                                               // 53 .gpumain
  82    d_jpad,                                                  // 54 .jpad
  83    d_nojpad,                                                // 55 .nojpad
  84    d_fail,                                                  // 56 .fail
  85 };
  86
  87 //
  88 // --- .org - Set origin  ---------------------------------------------------------------------------
  89 //
  90
  91 int d_fail(void) {
  92    fatal("user abort");
  93    return(0);
  94 }
  95
  96 //
  97 // --- .org - Set origin  ---------------------------------------------------------------------------
  98 //
  99
 100 int d_org(void) {
 101    VALUE address;
 102
 103    if(!rgpu && !rdsp)
 104       return(error(".org permitted only in gpu/dsp section"));
 105
 106    orgaddr = 0;
 107
 108    if(abs_expr(&address) == ERROR) {
 109       error("cannot determine org'd address");
 110       return(ERROR);
 111    }
 112
 113    orgaddr = address;
 114    orgactive = 1;
 115
 116    return(0);
 117 }
 118
 119 //
 120 // --- NOP Padding Directive -----------------------------------------------------------------------
 121 //
 122
 123 int d_jpad(void) {
 124    jpad = 1;
 125    return(0);
 126 }
 127
 128 int d_nojpad(void) {
 129    jpad = 0;
 130    return(0);
 131 }
 132
 133 //
 134 // --- Print Directive -----------------------------------------------------------------------------
 135 //
 136
 137 int d_print(void) {
 138    char prntstr[LNSIZ];                                     // String for PRINT directive
 139    char format[LNSIZ];                                      // Format for PRINT directive
 140    int formatting = 0;                                      // Formatting on/off
 141    int wordlong = 0;                                        // WORD = 0, LONG = 1
 142    int outtype = 0;                                         // 0:hex, 1:decimal, 2:unsigned
 143
 144    VALUE eval;                                              // Expression value
 145    WORD eattr;                                              // Expression attributes
 146    SYM *esym;                                               // External symbol involved in expr.
 147    TOKEN r_expr[EXPRSIZE];
 148
 149    while(*tok != EOL) {
 150       switch(*tok) {
 151          case STRING:
 152             sprintf(prntstr, "%s", (char*)tok[1]);
 153             printf("%s", prntstr);
 154             if(list_fd)
 155                write(list_fd, prntstr, (LONG)strlen(prntstr));
 156             tok+=2;
 157             break;
 158          case '/':
 159             formatting = 1;
 160             if(tok[1] != SYMBOL) goto token_err;
 161             strcpy(prntstr, (char*)tok[2]);
 162             switch(prntstr[0]) {
 163                case 'l': case 'L': wordlong = 1; break;
 164                case 'w': case 'W': wordlong = 0; break;
 165                case 'x': case 'X': outtype  = 0; break;
 166                case 'd': case 'D': outtype  = 1; break;
 167                case 'u': case 'U': outtype  = 2; break;
 168                default:
 169                   error("unknown print format flag");
 170                   return(ERROR);
 171             }
 172             tok += 3;
 173             break;
 174          case ',':
 175             tok++;
 176             break;
 177          default:
 178             if(expr(r_expr, &eval, &eattr, &esym) != OK)
 179                goto token_err;
 180             else {
 181                switch(outtype) {
 182                   case 0: strcpy(format, "%X"); break;
 183                   case 1: strcpy(format, "%d" ); break;
 184                   case 2: strcpy(format, "%u" ); break;
 185                }
 186                if(wordlong) sprintf(prntstr, format, eval);
 187                else sprintf(prntstr, format, eval & 0xFFFF);
 188                printf("%s", prntstr);
 189                if(list_fd)
 190                   write(list_fd, prntstr, (LONG)strlen(prntstr));
 191                formatting = 0;
 192                wordlong = 0;
 193                outtype = 0;
 194             }
 195             break;
 196       }
 197    }
 198
 199    printf("\n");
 200    println("\n");
 201
 202    return(0);
 203
 204    token_err:
 205    error("illegal print token");
 206    return(ERROR);
 207 }
 208
 209 //
 210 // --- Undefine an Equated Condition Code ----------------------------------------------------------
 211 //
 212
 213 int d_ccundef(void) {
 214    SYM *ccname;
 215
 216    if(!rgpu && !rdsp) {                                     // Check that we are in a RISC section
 217       error(".ccundef must be defined in .gpu/.dsp section");
 218       return(ERROR);
 219    }
 220    if(*tok != SYMBOL) {
 221       error(syntax_error);
 222       return(ERROR);
 223    }
 224    ccname = lookup((char *)tok[1], LABEL, 0);
 225    if(!ccname || !(ccname->sattre & EQUATEDCC)) {           // Make sure symbol is a valid ccdef
 226       error("invalid equated condition name specified");
 227       return(ERROR);
 228    }
 229
 230    ccname->sattre |= UNDEF_CC;
 231
 232    return(0);
 233 }
 234
 235 //
 236 // --- Undefine an Equated Register ----------------------------------------------------------------
 237 //
 238
 239 int d_equrundef(void) {
 240    SYM *regname;
 241
 242    if(!rgpu && !rdsp) {                                     // Check that we are in a RISC section
 243       error(".equrundef/.regundef must be defined in .gpu/.dsp section");
 244       return(ERROR);
 245    }
 246
 247    while(*tok != EOL) {
 248       if(*tok == ',') tok++;                                // Skip preceeding or seperating commas
 249
 250       if(*tok != SYMBOL) {                                  // Check we are dealing with a symbol
 251          error(syntax_error);
 252          return(ERROR);
 253       }
 254
 255       regname = lookup((char *)tok[1], LABEL, 0);           // Lookup and undef if equated register
 256       if(regname && (regname->sattre & EQUATEDREG))
 257          regname->sattre |= UNDEF_EQUR;
 258
 259       tok += 2;                                             // Skip over symbol token and address
 260    }
 261
 262    return(0);
 263 }
 264
 265 //
 266 // --- Do Not Allow the Use of the CLR.L Opcode ----------------------------------------------------
 267 //
 268
 269 int d_noclear(void) {
 270    return(0);
 271 }
 272
 273 //
 274 // --- Include Binary File -------------------------------------------------------------------------
 275 //
 276
 277 int d_incbin(void) {
 278    int i, j;
 279    int bytes = 0;
 280    long pos, size;
 281    char buf;
 282
 283    if(*tok != STRING) {
 284       error(syntax_error);
 285       return(ERROR);
 286    }
 287
 288    if((j = open((char *)tok[1],  _OPEN_INC)) >= 0) {
 289       size = lseek(j, 0L, SEEK_END);
 290       chcheck(size);
 291       pos = lseek(j, 0L, SEEK_SET);
 292
 293       for(i = 0; i < size; i++) {
 294          buf = '\0';
 295          bytes = read(j, &buf, 1);
 296          D_byte(buf);
 297       }
 298
 299    } else {
 300       errors("cannot open include binary file (%s)", (char*)tok[1]);
 301       return(ERROR);
 302    }
 303
 304    close(j);
 305    return(0);
 306 }
 307
 308 //
 309 // --- Set RISC Register Banks ---------------------------------------------------------------------
 310 //
 311
 312 int d_regbank0(void) {
 313    regbank = BANK_0;                                        // Set active register bank zero
 314    return(0);
 315 }
 316
 317 int d_regbank1(void) {
 318    regbank = BANK_1;                                        // Set active register bank one
 319    return(0);
 320 }
 321
 322 //
 323 // --- Adjust Location to an EVEN Value ------------------------------------------------------------
 324 //
 325
 326 int d_even(void) {
 327    if(sloc & 1) {
 328       if((scattr & SBSS) == 0) {
 329          chcheck(1);
 330          D_byte(0);
 331       } else {
 332          ++sloc;
 333       }
 334    }
 335
 336    return(0);
 337 }
 338
 339 //
 340 // --- Adjust Location to an LONG Value ------------------------------------------------------------
 341 //
 342
 343 int d_long(void) {
 344    unsigned i;
 345    unsigned val = 4;
 346
 347    i = sloc & ~(val - 1);
 348    if(i != sloc) val = val - (sloc - i);
 349    else val = 0;
 350
 351    if(val) {
 352       if((scattr & SBSS) == 0) {
 353          chcheck(val);
 354          for(i = 0; i < val; i++)
 355             D_byte(0);
 356       } else {
 357          sloc += val;
 358       }
 359    }
 360
 361    return(0);
 362 }
 363
 364 //
 365 // --- Adjust Location to an PHRASE Value ----------------------------------------------------------
 366 //
 367
 368 int d_phrase(void) {
 369    unsigned i;
 370    unsigned val = 8;
 371
 372    i = sloc & ~(val - 1);
 373    if(i != sloc) val = val - (sloc - i);
 374    else val = 0;
 375
 376    if(val) {
 377       if((scattr & SBSS) == 0) {
 378          chcheck(val);
 379          for(i = 0; i < val; i++)
 380             D_byte(0);
 381       } else {
 382          sloc += val;
 383       }
 384    }
 385
 386    return(0);
 387 }
 388
 389 //
 390 // --- Adjust Location to an DPHRASE Value ---------------------------------------------------------
 391 //
 392
 393 int d_dphrase(void) {
 394    unsigned i;
 395    unsigned val = 16;
 396
 397    i = sloc & ~(val - 1);
 398    if(i != sloc) val = val - (sloc - i);
 399    else val = 0;
 400
 401    if(val) {
 402       if((scattr & SBSS) == 0) {
 403          chcheck(val);
 404          for(i = 0; i < val; i++)
 405             D_byte(0);
 406       } else {
 407          sloc += val;
 408       }
 409    }
 410
 411    return(0);
 412 }
 413
 414 //
 415 // --- Adjust Location to an QPHRASE Value ---------------------------------------------------------
 416 //
 417
 418 int d_qphrase(void) {
 419    unsigned i;
 420    unsigned val = 32;
 421
 422    i = sloc & ~(val - 1);
 423    if(i != sloc) val = val - (sloc - i);
 424    else val = 0;
 425
 426    if(val) {
 427       if((scattr & SBSS) == 0) {
 428          savsect();
 429          chcheck(val);
 430          for(i = 0; i < val; i++)
 431             D_byte(0);
 432       } else {
 433          sloc += val;
 434       }
 435    }
 436
 437    return(0);
 438 }
 439
 440 //
 441 // -------------------------------------------------------------------------------------------------
 442 // Do auto-even.  This must be called ONLY if 'sloc' is odd.
 443 //
 444 // This is made hairy because, if there was a label on the line, we also have to adjust its value.
 445 // This won't work with more than one label on the line, which is OK since multiple labels are only
 446 // allowed in AS68 kludge mode, and the C compiler is VERY paranoid and uses ".even" whenever it can
 447 // -------------------------------------------------------------------------------------------------
 448 //
 449
 450 void auto_even(void) {
 451    if(scattr & SBSS)
 452       ++sloc;                                               // Bump BSS section
 453    else {
 454       D_byte(0)                                             // Deposit 0.b in non-BSS
 455    }
 456
 457    if(lab_sym != NULL)                                      // Bump label if we have to
 458       ++lab_sym->svalue;
 459 }
 460
 461 //
 462 // --- Unimplemened Directive Error ----------------------------------------------------------------
 463 //
 464
 465 int d_unimpl(void) {
 466    return(error("unimplemented directive"));
 467 }
 468
 469 //
 470 // --- Return absolute (not TDB) and defined expression or return an error -------------------------
 471 //
 472
 473 int abs_expr(VALUE *a_eval) {
 474    WORD eattr;
 475
 476    if(expr(exprbuf, a_eval, &eattr, NULL) < 0)
 477       return(ERROR);
 478    if(!(eattr & DEFINED))
 479       return(error(undef_error));
 480    if(eattr & TDB)
 481       return(error(rel_error));
 482
 483    return(OK);
 484 }
 485
 486 //
 487 // --- Hand symbols in a symbol-list to a function (kind of like mapcar...) ------------------------
 488 //
 489
 490 int symlist(int(*func)()) {
 491    char *em = "symbol list syntax";
 492
 493    for(;;) {
 494       if(*tok != SYMBOL) return(error(em));
 495       if((*func)(tok[1]) != OK) break;
 496       tok += 2;
 497       if(*tok == EOL) break;
 498       if(*tok != ',') return(error(em));
 499       ++tok;
 500    }
 501
 502    return(0);
 503 }
 504
 505 //
 506 // --- .include "filename" -------------------------------------------------------------------------
 507 //
 508
 509 int d_include(void) {
 510    int j;
 511    int i;
 512    char *fn;
 513    char buf[128];
 514    char buf1[128];
 515
 516    if(*tok == STRING)                                       // Leave strings ALONE
 517       fn = (char *)*++tok;
 518    else if(*tok == SYMBOL) {                                // Try to append ".s" to symbols
 519       strcpy(buf, (char *)*++tok);
 520       fext(buf, ".s", 0);
 521       fn = &buf[0];
 522    } else                                                   // Punt if no STRING or SYMBOL
 523       return(error("missing filename"));
 524
 525    // Make sure the user didn't try anything like:
 526    // .include equates.s
 527    if(*++tok != EOL) return(error("extra stuff after filename -- enclose it in quotes"));
 528
 529    // Attempt to open the include file in the current directory, then (if that failed) try list
 530    // of include files passed in the enviroment string or by the "-d" option.
 531    if((j = open(fn, 0)) < 0) {
 532       for(i = 0; nthpath("RMACPATH", i, buf1) != 0; ++i) {
 533          j = strlen(buf1);
 534          if(j > 0 && buf1[j-1] != SLASHCHAR)                // Append path char if necessary
 535             strcat(buf1, SLASHSTRING);
 536          strcat(buf1, fn);
 537          if((j = open(buf1, 0)) >= 0)
 538             goto allright;
 539       }
 540
 541       return(errors("cannot open: \"%s\"", fn));
 542    }
 543
 544    allright:
 545
 546    include(j, fn);
 547    return(0);
 548 }
 549
 550 //
 551 // --- .assert expression [, expression...] --------------------------------------------------------
 552 //
 553
 554 int d_assert(void) {
 555    WORD eattr;
 556    VALUE eval;
 557
 558    for(; expr(exprbuf, &eval, &eattr, NULL) == OK; ++tok) {
 559       if(!(eattr & DEFINED))
 560          return(error("forward or undefined .assert"));
 561       if(!eval)
 562          return(error("assert failure"));
 563       if(*tok != ',')
 564          break;
 565    }
 566    at_eol();
 567    return(0);
 568 }
 569
 570 //
 571 // --- .globl symbol [, symbol] <<<cannot make local symbols global>>> -----------------------------
 572 //
 573
 574 int globl1(char *p) {
 575    SYM *sy;
 576
 577    if(*p == '.')
 578       return(error("cannot .globl local symbol"));
 579    if((sy = lookup(p, LABEL, 0)) == NULL) {
 580       sy = newsym(p, LABEL, 0);
 581       sy->svalue = 0;
 582       sy->sattr = GLOBAL;
 583    } else
 584       sy->sattr |= GLOBAL;
 585
 586    return(OK);
 587 }
 588
 589 int d_globl(void) {
 590    symlist(globl1);
 591    return(0);
 592 }
 593
 594 //
 595 // --- .abs [expression] ---------------------------------------------------------------------------
 596 //
 597
 598 int d_abs(void) {
 599    VALUE eval;
 600
 601    savsect();
 602    if(*tok == EOL)
 603       eval = 0;
 604    else
 605       if(abs_expr(&eval) != OK)
 606          return(0);
 607
 608    switchsect(ABS);
 609    sloc = eval;
 610    return(0);
 611 }
 612
 613 //
 614 // --- Switch Segments -----------------------------------------------------------------------------
 615 //
 616
 617 int d_text(void) {
 618    if(rgpu || rdsp)
 619       return(error("directive forbidden in gpu/dsp mode"));
 620
 621    if(cursect != TEXT) {
 622       savsect();
 623       switchsect(TEXT);
 624    }
 625    return(0);
 626 }
 627
 628 int d_data(void) {
 629    if(rgpu || rdsp)
 630       return(error("directive forbidden in gpu/dsp mode"));
 631
 632    if(cursect != DATA) {
 633       savsect();
 634       switchsect(DATA);
 635    }
 636    return(0);
 637 }
 638
 639 int d_bss(void) {
 640    if(rgpu || rdsp)
 641       return(error("directive forbidden in gpu/dsp mode"));
 642
 643    if(cursect != BSS) {
 644       savsect();
 645       switchsect(BSS);
 646    }
 647    return(0);
 648 }
 649
 650 //
 651 // --- .ds[.size] expression -----------------------------------------------------------------------
 652 //
 653
 654 int d_ds(WORD siz) {
 655    VALUE eval;
 656
 657    // This gets kind of stupid.  This directive is disallowed in normal 68000 mode ("for your own
 658    // good!"), but is permitted for 6502 and Alcyon-compatibility modes.
 659    // For obvious reasons, no auto-even is done in 8-bit processor modes.
 660    if(as68_flag == 0 && (scattr & SBSS) == 0)
 661       return(error(".ds permitted only in BSS"));
 662
 663    if(siz != SIZB && (sloc & 1))                            // Automatic .even
 664       auto_even();
 665
 666    if(abs_expr(&eval) != OK) return(0);
 667
 668    // In non-TDB section (BSS, ABS and M6502) just advance the location counter appropriately.
 669    // In TDB sections, deposit (possibly large) chunks of zeroed memory....
 670    if((scattr & SBSS)) {
 671       listvalue(eval);
 672       eval *= siz;
 673       sloc += eval;
 674       just_bss = 1;                                         // No data deposited (8-bit CPU mode)
 675    } else {
 676       dep_block(eval, siz, (VALUE)0, (WORD)(DEFINED|ABS), NULL);
 677    }
 678
 679    at_eol();
 680    return(0);
 681 }
 682
 683 //
 684 // --- dc.b, dc.w / dc, dc.l -----------------------------------------------------------------------
 685 //
 686
 687 int d_dc(WORD siz) {
 688    WORD eattr;
 689    VALUE eval;
 690    WORD tdb;
 691    WORD defined;
 692    LONG i;
 693    char *p;
 694    int movei = 0; // movei flag for dc.i
 695
 696    if((scattr & SBSS) != 0)
 697       return(error("illegal initialization of section"));
 698
 699    if((siz != SIZB) && (sloc & 1))
 700       auto_even();
 701
 702    for(;; ++tok) {
 703       // dc.b 'string' [,] ...
 704       if (siz == SIZB && *tok == STRING && (tok[2] == ',' || tok[2] == EOL)) {
 705          i = strlen((const char*)tok[1]);
 706          if((challoc - ch_size) < i)
 707             chcheck(i);
 708          for(p = (char *)tok[1]; *p != EOS; ++p)
 709             D_byte(*p);
 710          tok += 2;
 711          goto comma;
 712       }
 713
 714       if(*tok == 'I') {
 715          movei = 1;
 716          tok++;
 717          siz = SIZL;
 718       }
 719
 720       // dc.x <expression>
 721       if(expr(exprbuf, &eval, &eattr, NULL) != OK)
 722          return(0);
 723       tdb = (WORD)(eattr & TDB);
 724       defined = (WORD)(eattr & DEFINED);
 725       if((challoc - ch_size) < 4)
 726          chcheck(4L);
 727
 728       switch(siz) {
 729          case SIZB:
 730             if(!defined) {
 731                fixup(FU_BYTE|FU_SEXT, sloc, exprbuf);
 732                D_byte(0);
 733             } else {
 734                if(tdb)
 735                   return(error("non-absolute byte value"));
 736                if(eval + 0x100 >= 0x200)
 737                   return(error(range_error));
 738                D_byte(eval);
 739             }
 740             break;
 741          case SIZW:
 742          case SIZN:
 743             if(!defined) {
 744                fixup(FU_WORD|FU_SEXT, sloc, exprbuf);
 745                D_word(0);
 746             } else {
 747                if(tdb)
 748                   rmark(cursect, sloc, tdb, MWORD, NULL);
 749                if(eval + 0x10000 >= 0x20000)
 750                   return(error(range_error));
 751                // Deposit 68000 or 6502 (byte-reversed) word
 752                D_word(eval);
 753             }
 754             break;
 755          case SIZL:
 756             if(!defined) {
 757                if(movei)
 758                   fixup(FU_LONG|FU_MOVEI, sloc, exprbuf);
 759                else
 760                   fixup(FU_LONG, sloc, exprbuf);
 761                D_long(0);
 762             } else {
 763                if(tdb)
 764                   rmark(cursect, sloc, tdb, MLONG, NULL);
 765                if(movei)
 766                   eval = ((eval >> 16) & 0x0000FFFF) | ((eval << 16) & 0xFFFF0000);
 767                D_long(eval);
 768             }
 769             break;
 770       }
 771
 772       comma:
 773
 774       if(*tok != ',')
 775          break;
 776    }
 777
 778    at_eol();
 779    return(0);
 780 }
 781
 782 //
 783 // --- dcb[.siz] expr1,expr2 - Make 'expr1' copies of 'expr2' --------------------------------------
 784 //
 785
 786 int d_dcb(WORD siz) {
 787    VALUE evalc, eval;
 788    WORD eattr;
 789
 790    if((scattr & SBSS) != 0)
 791       return(error("illegal initialization of section"));
 792
 793    if(abs_expr(&evalc) != OK)
 794       return(0);
 795
 796    if(*tok++ != ',')
 797       return(error("missing comma"));
 798
 799    if(expr(exprbuf, &eval, &eattr, NULL) < 0)
 800       return(0);
 801
 802    if((siz != SIZB) && (sloc & 1))
 803       auto_even();
 804
 805    dep_block(evalc, siz, eval, eattr, exprbuf);
 806    return(0);
 807 }
 808
 809 //
 810 // -------------------------------------------------------------------------------------------------
 811 // Generalized initialization directive
 812 //
 813 // .init[.siz] [#count,] expression [.size] , ...
 814 //
 815 // The size suffix on the ".init" directive becomes the default size of the objects to deposit.
 816 // If an item is preceeded with a sharp (immediate) sign and an expression, it specifies a repeat
 817 // count.  The value to be deposited may be followed by a size suffix, which overrides the
 818 // default size.
 819 // -------------------------------------------------------------------------------------------------
 820 //
 821
 822 int d_init(WORD def_siz) {
 823    VALUE count;
 824    VALUE eval;
 825    WORD eattr;
 826    WORD siz;
 827
 828    if((scattr & SBSS) != 0)
 829       return(error(".init not permitted in BSS or ABS"));
 830
 831    if(rgpu || rdsp)
 832       return(error("directive forbidden in gpu/dsp mode"));
 833
 834    for(;;) {
 835       // Get repeat count (defaults to 1)
 836       if(*tok == '#') {
 837          ++tok;
 838          if(abs_expr(&count) != OK)
 839             return(0);
 840          if(*tok++ != ',')
 841             return(error(comma_error));
 842       } else
 843          count = 1;
 844
 845       // Evaluate expression to deposit
 846       if(expr(exprbuf, &eval, &eattr, NULL) < 0)
 847          return(0);
 848
 849       switch((int)*tok++) {                                 // Determine size of object to deposit
 850          case DOTB: siz = SIZB; break;
 851          case DOTW: siz = SIZB; break;
 852          case DOTL: siz = SIZL; break;
 853          default:
 854             siz = def_siz;
 855             --tok;
 856             break;
 857       }
 858
 859       dep_block(count, siz, eval, eattr, exprbuf);
 860
 861       switch((int)*tok) {
 862          case EOL:
 863             return(0);
 864          case ',':
 865             ++tok;
 866             continue;
 867          default:
 868             return(error(comma_error));
 869       }
 870    }
 871 }
 872
 873 //
 874 // --- Deposit 'count' values of size 'siz' in the current (non-BSS) segment -----------------------
 875 //
 876
 877 int dep_block(VALUE count, WORD siz, VALUE eval, WORD eattr, TOKEN *exprbuf) {
 878    WORD tdb;
 879    WORD defined;
 880
 881    tdb = (WORD)(eattr & TDB);
 882    defined = (WORD)(eattr & DEFINED);
 883
 884    while(count--) {
 885       if((challoc - ch_size) < 4)
 886          chcheck(4L);
 887
 888       switch(siz) {
 889          case SIZB:
 890             if(!defined) {
 891                fixup(FU_BYTE|FU_SEXT, sloc, exprbuf);
 892                D_byte(0);
 893             } else {
 894                if(tdb)
 895                   return(error("non-absolute byte value"));
 896                if(eval + 0x100 >= 0x200)
 897                   return(error(range_error));
 898                D_byte(eval);
 899             }
 900             break;
 901          case SIZW:
 902          case SIZN:
 903             if(!defined) {
 904                fixup(FU_WORD|FU_SEXT, sloc, exprbuf);
 905                D_word(0);
 906             } else {
 907                if(tdb)
 908                   rmark(cursect, sloc, tdb, MWORD, NULL);
 909                if(eval + 0x10000 >= 0x20000)
 910                   return(error(range_error));
 911
 912                // Deposit 68000 or 6502 (byte-reversed) word
 913                D_word(eval);
 914             }
 915             break;
 916          case SIZL:
 917             if(!defined) {
 918                fixup(FU_LONG, sloc, exprbuf);
 919                D_long(0);
 920             } else {
 921                if(tdb)
 922                   rmark(cursect, sloc, tdb, MLONG, NULL);
 923                D_long(eval);
 924             }
 925             break;
 926       }
 927    }
 928    return(0);
 929 }
 930
 931 //
 932 // --- .comm symbol, size --------------------------------------------------------------------------
 933 //
 934
 935 int d_comm(void) {
 936    SYM *sym;
 937    char *p;
 938    VALUE eval;
 939
 940    if(*tok != SYMBOL)
 941       return(error("missing symbol"));
 942    p = (char *)tok[1];
 943    tok += 2;
 944
 945    if(*p == '.')                                            // Cannot .comm a local symbol
 946       return(error(locgl_error));
 947
 948    if((sym = lookup(p, LABEL, 0)) == NULL)
 949       sym = newsym(p, LABEL, 0);
 950    else {
 951       if(sym->sattr & DEFINED)
 952          return(error(".comm symbol already defined"));
 953    }
 954
 955    sym->sattr = GLOBAL|COMMON|BSS;
 956    if(*tok++ != ',')
 957       return(error(comma_error));
 958
 959    if(abs_expr(&eval) != OK)                                // Parse size of common region
 960       return(0);
 961    sym->svalue = eval;                                      // Install common symbol's size
 962    at_eol();
 963    return(0);
 964 }
 965
 966 //
 967 // --- .list - Turn listing on  --------------------------------------------------------------------
 968 //
 969
 970 int d_list(void) {
 971    if(list_flag)
 972       ++listing;
 973    return(0);
 974 }
 975
 976 //
 977 // --- .nlist - Turn listing off -------------------------------------------------------------------
 978 //
 979
 980 int d_nlist(void) {
 981    if(list_flag)
 982       --listing;
 983    return(0);
 984 }
 985
 986 //
 987 // --- .68000 - Back to 68000 TEXT segment ---------------------------------------------------------
 988 //
 989
 990 int d_68000(void) {
 991    rgpu = rdsp = 0;
 992    in_main = 0;
 993    // Switching from gpu/dsp sections should reset any ORG'd Address
 994    orgactive = 0;
 995    orgwarning = 0;
 996    savsect();
 997    switchsect(TEXT);
 998    return(0);
 999 }
1000
1001 //
1002 // --- .gpu - Switch to GPU Assembler --------------------------------------------------------------
1003 //
1004
1005 int d_gpu(void) {
1006    if((cursect != TEXT) && (cursect != DATA)) {
1007       error(".gpu can only be used in the TEXT or DATA segments");
1008       return(ERROR);
1009    }
1010    // If previous section was dsp or 68000 then we need to reset ORG'd Addresses
1011    if(!rgpu) {
1012       orgactive = 0;
1013       orgwarning = 0;
1014    }
1015    rgpu = 1;                                                // Set GPU assembly
1016    rdsp = 0;                                                // Unset DSP assembly
1017    regbank = BANK_N;                                        // Set no default register bank
1018    in_main = 0;
1019    jpad = 0;
1020    return(0);
1021 }
1022
1023 //
1024 // --- GPU Main Code Directive ---------------------------------------------------------------------
1025 //
1026
1027 int d_gpumain(void) {
1028    if((cursect != TEXT) && (cursect != DATA)) {
1029       error(".gpumain can only be used in the TEXT or DATA segments");
1030       return(ERROR);
1031    }
1032    // If previous section was dsp or 68000 then we need to reset ORG'd Addresses
1033    if(!rgpu) {
1034       orgactive = 0;
1035       orgwarning = 0;
1036    }
1037    rgpu = 1;                                                // Set GPU assembly
1038    rdsp = 0;                                                // Unset DSP assembly
1039    regbank = BANK_N;                                        // Set no default register bank
1040    in_main = 1;                                             // Enable main code execution rules
1041    jpad = 0;
1042    return(0);
1043 }
1044
1045 //
1046 // --- .dsp - Switch to DSP Assembler --------------------------------------------------------------
1047 //
1048
1049 int d_dsp(void) {
1050    if((cursect != TEXT) && (cursect != DATA)) {
1051       error(".dsp can only be used in the TEXT or DATA segments");
1052       return(ERROR);
1053    }
1054    // If previous section was gpu or 68000 then we need to reset ORG'd Addresses
1055    if(!rdsp) {
1056       orgactive = 0;
1057       orgwarning = 0;
1058    }
1059    rdsp = 1;                                                // Set DSP assembly
1060    rgpu = 0;                                                // Unset GPU assembly
1061    regbank = BANK_N;                                        // Set no default register bank
1062    in_main = 0;
1063    jpad = 0;
1064    return(0);
1065 }
1066
1067 //
1068 // -------------------------------------------------------------------------------------------------
1069 // .cargs [#offset], symbol[.size], ...
1070 //
1071 // Lists of registers may also be mentioned; they just take up space.  Good for "documentation"
1072 // purposes.
1073 //
1074 // .cargs a6,.arg1, .arg2, .arg3...
1075 //
1076 // The symbols are ABS and EQUATED.
1077 // -------------------------------------------------------------------------------------------------
1078 //
1079
1080 int d_cargs(void) {
1081    VALUE eval;
1082    WORD rlist;
1083    SYM *sy;
1084    char *p;
1085    int env;
1086    int i;
1087
1088    if(rgpu || rdsp)
1089       return(error("directive forbidden in gpu/dsp mode"));
1090
1091    if(*tok == '#') {
1092       ++tok;
1093       if(abs_expr(&eval) != OK)
1094          return(0);
1095       if(*tok == ',')                                       // Eat comma if it's there
1096          ++tok;
1097    } else
1098       eval = 4;
1099
1100    for(;;) {
1101       if(*tok == SYMBOL) {
1102          p = (char *)tok[1];
1103          if(*p == '.')
1104             env = curenv;
1105          else
1106             env = 0;
1107
1108          sy = lookup(p, LABEL, env);
1109          if(sy == NULL) {
1110             sy = newsym(p, LABEL, env);
1111             sy->sattr = 0;
1112          } else
1113             if(sy->sattr & DEFINED)
1114                return(errors("multiply-defined label '%s'", p));
1115
1116          // Put symbol in "order of definition" list
1117          if(!(sy->sattr & SDECLLIST)) sym_decl(sy);
1118
1119          sy->sattr |= ABS|DEFINED|EQUATED;
1120          sy->svalue = eval;
1121          tok += 2;
1122
1123          switch((int)*tok) {
1124             case DOTL:
1125                eval += 2;
1126             case DOTB:
1127             case DOTW:
1128                ++tok;
1129          }
1130          eval += 2;
1131       } else
1132          if(*tok >= KW_D0 && *tok <= KW_A7) {
1133             if(reglist(&rlist) < 0)
1134                return(0);
1135             for(i = 0; i++ < 16; rlist >>= 1)
1136                if(rlist & 1)
1137                   eval += 4;
1138          } else
1139             switch((int)*tok) {
1140                case KW_USP:
1141                case KW_SSP:
1142                case KW_PC:
1143                   eval += 2;
1144                   // FALLTHROUGH
1145                case KW_SR:
1146                case KW_CCR:
1147                   eval += 2;
1148                   ++tok;
1149                   break;
1150                case EOL:
1151                   return(0);
1152                default:
1153                   return(error(".cargs syntax"));
1154             }
1155
1156          if(*tok == ',')
1157             ++tok;
1158    }
1159 }
1160
1161 //
1162 // --- Undefine a macro - .undefmac macname [, macname...] -----------------------------------------
1163 //
1164
1165 int undmac1(char *p) {
1166    SYM *sy;
1167
1168    // If the macro symbol exists, cause it to dissappear
1169    if((sy = lookup(p, MACRO, 0)) != NULL) sy->stype = (BYTE)SY_UNDEF;
1170       return(OK);
1171 }
1172
1173 int d_undmac(void) {
1174    symlist(undmac1);
1175    return(0);
1176 }