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