Fix a small buglet in the last patch. :-)
[rmac] / direct.c
1 //
2 // RMAC - Reboot's Macro Assembler for all Atari computers
3 // DIRECT.C - Directive Handling
4 // Copyright (C) 199x Landon Dyer, 2011-2020 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 "6502.h"
11 #include "amode.h"
12 #include "dsp56k.h"
13 #include "error.h"
14 #include "expr.h"
15 #include "fltpoint.h"
16 #include "listing.h"
17 #include "mach.h"
18 #include "macro.h"
19 #include "mark.h"
20 #include "procln.h"
21 #include "riscasm.h"
22 #include "sect.h"
23 #include "symbol.h"
24 #include "token.h"
25
26 #define DEF_KW
27 #include "kwtab.h"
28
29
30 TOKEN exprbuf[128];                     // Expression buffer
31 SYM * symbolPtr[1000000];       // Symbol pointers table
32 static long unused;                     // For supressing 'write' warnings
33 char buffer[256];                       // Scratch buffer for messages
34 int largestAlign[3] = { 2, 2, 2 };      // Largest alignment value seen per section
35
36 // Function prototypes
37 int d_unimpl(void);
38 int d_68000(void);
39 int d_68020(void);
40 int d_68030(void);
41 int d_68040(void);
42 int d_68060(void);
43 int d_68881(void);
44 int d_68882(void);
45 int d_56001(void);
46 int d_nofpu(void);
47 int d_bss(void);
48 int d_data(void);
49 int d_text(void);
50 int d_abs(void);
51 int d_comm(void);
52 int d_dc(WORD);
53 int d_ds(WORD);
54 int d_dsm(WORD);
55 int d_dcb(WORD);
56 int d_globl(void);
57 int d_gpu(void);
58 int d_dsp(void);
59 int d_assert(void);
60 int d_include(void);
61 int d_list(void);
62 int d_nlist(void);
63 int d_error(char *);
64 int d_warn(char *);
65 int d_org(void);
66 int d_init(WORD);
67 int d_cargs(void);
68 int d_undmac(void);
69 int d_regbank0(void);
70 int d_regbank1(void);
71 int d_incbin(void);
72 int d_noclear(void);
73 int d_equrundef(void);
74 int d_ccundef(void);
75 int d_print(void);
76 int d_gpumain(void);
77 int d_jpad(void);
78 int d_nojpad(void);
79 int d_fail(void);
80 int d_cstruct(void);
81 int d_prgflags(void);
82 int d_opt(void);
83 int d_dsp(void);
84 int d_objproc(void);
85 void SetLargestAlignment(int);
86
87 // Directive handler table
88 int (*dirtab[])() = {
89         d_org,                          // 0 org
90         d_even,                         // 1 even
91         d_6502,                         // 2 .6502
92         d_68000,                        // 3 .68000
93         d_bss,                          // 4 bss
94         d_data,                         // 5 data
95         d_text,                         // 6 text
96         d_abs,                          // 7 abs
97         d_comm,                         // 8 comm
98         (void *)d_init,         // 9 init
99         d_cargs,                        // 10 cargs
100         (void *)d_goto,         // 11 goto
101         (void *)d_dc,           // 12 dc
102         (void *)d_ds,           // 13 ds
103         d_undmac,                       // 14 undefmac
104         d_gpu,                          // 15 .gpu
105         d_dsp,                          // 16 .dsp
106         (void *)d_dcb,          // 17 dcb
107         d_unimpl,                       // 18* set
108         d_unimpl,                       // 19* reg
109         d_unimpl,                       // 20 dump
110         d_incbin,                       // 21 .incbin //load
111         d_unimpl,                       // 22 disable
112         d_unimpl,                       // 23 enable
113         d_globl,                        // 24 globl
114         d_regbank0,                     // 25 .regbank0
115         d_regbank1,                     // 26 .regbank1
116         d_unimpl,                       // 27 xdef
117         d_assert,                       // 28 assert
118         d_unimpl,                       // 29* if
119         d_unimpl,                       // 30* endif
120         d_unimpl,                       // 31* endc
121         d_unimpl,                       // 32* iif
122         d_include,                      // 33 include
123         fpop,                           // 34 end
124         d_unimpl,                       // 35* macro
125         ExitMacro,                      // 36* exitm
126         d_unimpl,                       // 37* endm
127         d_list,                         // 38 list
128         d_nlist,                        // 39 nlist
129         d_long,                         // 40* rept
130         d_phrase,                       // 41* endr
131         d_dphrase,                      // 42 struct
132         d_qphrase,                      // 43 ends
133         d_title,                        // 44 title
134         d_subttl,                       // 45 subttl
135         eject,                          // 46 eject
136         d_error,                        // 47 error
137         d_warn,                         // 48 warn
138         d_noclear,                      // 49 .noclear
139         d_equrundef,            // 50 .equrundef/.regundef
140         d_ccundef,                      // 51 .ccundef
141         d_print,                        // 52 .print
142         d_cstruct,                      // 53 .cstruct
143         d_jpad,                         // 54 .jpad (deprecated)
144         d_nojpad,                       // 55 .nojpad (deprecated)
145         d_gpumain,                      // 56 .gpumain (deprecated)
146         d_prgflags,                     // 57 .prgflags
147         d_68020,                        // 58 .68020
148         d_68030,                        // 59 .68030
149         d_68040,                        // 60 .68040
150         d_68060,                        // 61 .68060
151         d_68881,                        // 62 .68881
152         d_68882,                        // 63 .68882
153         d_56001,                        // 64 .56001
154         d_nofpu,                        // 65 nofpu
155         d_opt,                          // 66 .opt
156         d_objproc,                      // 67 .objproc
157         (void *)d_dsm,                  // 68 .dsm
158 };
159
160
161 //
162 // Set the largest alignment seen in the current section
163 //
164 void SetLargestAlignment(int size)
165 {
166         if ((scattr & TEXT) && (largestAlign[0] < size))
167                 largestAlign[0] = size;
168         else if ((scattr & DATA) && (largestAlign[1] < size))
169                 largestAlign[1] = size;
170         else if ((scattr & BSS) && (largestAlign[2] < size))
171                 largestAlign[2] = size;
172 }
173
174
175 //
176 // .error - Abort compilation, printing an error message
177 //
178 int d_error(char *str)
179 {
180         if (*tok == EOL)
181                 return error("error directive encountered - aborting assembling");
182         else
183         {
184                 switch(*tok)
185                 {
186                 case STRING:
187                         return error(string[tok[1]]);
188                         break;
189                 default:
190                         return error("error directive encountered--aborting assembly");
191                 }
192         }
193 }
194
195
196 //
197 // .warn - Just display a warning on screen
198 //
199 int d_warn(char *str)
200 {
201         if (*tok == EOL)
202                 return warn("WARNING WARNING WARNING");
203         else
204         {
205                 switch(*tok)
206                 {
207                 case STRING:
208                         return warn(string[tok[1]]);
209                         break;
210                 default:
211                         return warn("WARNING WARNING WARNING");
212                 }
213         }
214 }
215
216
217 //
218 // .org - Set origin
219 //
220 int d_org(void)
221 {
222         uint64_t address;
223
224         if (!rgpu && !rdsp && !robjproc && !m6502 && !dsp56001 && !(obj_format == RAW))
225                 return error(".org permitted only in GPU/DSP/OP, 56001, 6502 and 68k (with -fr switch) sections");
226
227         // M56K can leave the expression off the org for some reason :-/
228         // (It's because the expression is non-standard, and so we have to look at
229         // it in isolation)
230         if (!dsp56001 && (abs_expr(&address) == ERROR))
231         {
232                 error("cannot determine org'd address");
233                 return ERROR;
234         }
235
236         if (rgpu | rdsp | robjproc)
237         {
238                 orgaddr = address;
239                 orgactive = 1;
240         }
241         else if (m6502)
242         {
243                 // 6502.  We also kludge 'lsloc' so the listing generator doesn't try
244                 // to spew out megabytes.
245                 if (address > 0xFFFF)
246                         return error(range_error);
247
248                 if (sloc != currentorg[0])
249                 {
250                         currentorg[1] = sloc;
251                         currentorg += 2;
252                 }
253
254                 currentorg[0] = address;
255                 ch_size = 0;
256                 lsloc = sloc = address;
257                 chptr = scode->chptr + address;
258                 orgaddr = address;
259                 orgactive = 1;
260         }
261         else if (dsp56001)
262         {
263                 // Only mark segments we actually wrote something
264                 if (chptr != dsp_currentorg->start && dsp_written_data_in_current_org)
265                 {
266                         dsp_currentorg->end = chptr;
267                         dsp_currentorg++;
268                 }
269
270                 // Maybe we switched from a non-DSP section (TEXT, DATA, etc) and
271                 // scode isn't initialised yet. Not that it's going to be a valid
272                 // scenario, but if we try it anyhow it's going to lead to a crash. So
273                 // let's fudge a value of 0 and get on with it.
274                 orgaddr = (scode != NULL ? sloc : 0);
275                 SaveSection();
276
277                 if (tok[1] != ':')
278                         return error(syntax_error);
279
280                 int sectionToSwitch = 0;
281
282                 switch (tok[0])
283                 {
284                 case KW_X:
285                         dsp_currentorg->memtype = ORG_X;
286                         sectionToSwitch = M56001X;
287                         break;
288
289                 case KW_Y:
290                         dsp_currentorg->memtype = ORG_Y;
291                         sectionToSwitch = M56001Y;
292                         break;
293
294                 case KW_P:
295                         dsp_currentorg->memtype = ORG_P;
296                         sectionToSwitch = M56001P;
297                         break;
298
299                 case KW_L:
300                         dsp_currentorg->memtype = ORG_L;
301                         sectionToSwitch = M56001L;
302                         break;
303
304                 default:
305                         return error("unknown type in ORG");
306                 }
307
308                 if ((obj_format == LOD) || (obj_format == P56))
309                         SwitchSection(sectionToSwitch);
310
311                 tok += 2;
312                 chcheck(3); // Ensure we got a valid address to write
313                 dsp_currentorg->chunk = scode;  // Mark down which chunk this org starts from (will be needed when outputting)
314
315                 if (*tok == EOL)
316                 {
317                         // Well, the user didn't specify an address at all so we'll have to
318                         // use the last used address of that section (or 0 if there wasn't one)
319                         address = orgaddr;
320                         dsp_currentorg->start = chptr;
321                         dsp_currentorg->orgadr = orgaddr;
322                 }
323                 else
324                 {
325                         if (abs_expr(&address) == ERROR)
326                         {
327                                 error("cannot determine org'd address");
328                                 return ERROR;
329                         }
330
331                         dsp_currentorg->start = chptr;
332                         dsp_currentorg->orgadr = (uint32_t)address;
333                         sect[cursect].orgaddr = (uint32_t)address;
334                 }
335
336                 if (address > DSP_MAX_RAM)
337                 {
338                         return error(range_error);
339                 }
340
341                 dsp_written_data_in_current_org = 0;
342
343                 // Copied from 6502 above: kludge `lsloc' so the listing generator
344                 // doesn't try to spew out megabytes.
345                 lsloc = sloc = (int32_t)address;
346 // N.B.: It seems that by enabling this, even though it works elsewhere, will cause symbols to royally fuck up.  Will have to do some digging to figure out why.
347 //              orgactive = 1;
348         }
349         else
350         {
351                 // If we get here we assume it's 68k with RAW output, so this is allowed
352                 if (orgactive)
353                 {
354                         return error("In 68k mode only one .org statement is allowed");
355                 }
356
357                 org68k_address = address;
358                 org68k_active = 1;
359         }
360
361         ErrorIfNotAtEOL();
362         return 0;
363 }
364
365
366 //
367 // Print directive
368 //
369 int d_print(void)
370 {
371         char prntstr[LNSIZ];            // String for PRINT directive
372         char format[LNSIZ];                     // Format for PRINT directive
373         int formatting = 0;                     // Formatting on/off
374         int wordlong = 0;                       // WORD = 0, LONG = 1
375         int outtype = 0;                        // 0:hex, 1:decimal, 2:unsigned
376
377         uint64_t eval;                          // Expression value
378         WORD eattr;                                     // Expression attributes
379         SYM * esym;                                     // External symbol involved in expr.
380         TOKEN r_expr[EXPRSIZE];
381
382         while (*tok != EOL)
383         {
384                 switch (*tok)
385                 {
386                 case STRING:
387                         sprintf(prntstr, "%s", string[tok[1]]);
388                         printf("%s", prntstr);
389
390                         if (list_fd)
391                                 unused = write(list_fd, prntstr, (LONG)strlen(prntstr));
392
393                         tok += 2;
394                         break;
395                 case '/':
396                         formatting = 1;
397
398                         // "X" & "L" get tokenized now... :-/ Probably should look into preventing this kind of thing from happening (was added with DSP56K code)
399                         if ((tok[1] != SYMBOL) && (tok[1] != KW_L) && (tok[1] != KW_X))
400                                 goto token_err;
401
402                         if (tok[1] == KW_L)
403                         {
404                                 wordlong = 1;
405                                 tok += 2;
406                         }
407                         else if (tok[1] == KW_X)
408                         {
409                                 outtype = 0;
410                                 tok += 2;
411                         }
412                         else
413                         {
414                                 strcpy(prntstr, string[tok[2]]);
415
416                                 switch (prntstr[0])
417                                 {
418                                 case 'l': case 'L': wordlong = 1; break;
419                                 case 'w': case 'W': wordlong = 0; break;
420                                 case 'x': case 'X': outtype  = 0; break;
421                                 case 'd': case 'D': outtype  = 1; break;
422                                 case 'u': case 'U': outtype  = 2; break;
423                                 default:
424                                         error("unknown print format flag");
425                                         return ERROR;
426                                 }
427
428                                 tok += 3;
429                         }
430
431                         break;
432                 case ',':
433                         tok++;
434                         break;
435                 default:
436                         if (expr(r_expr, &eval, &eattr, &esym) != OK)
437                                 goto token_err;
438                         else
439                         {
440                                 switch(outtype)
441                                 {
442                                 case 0: strcpy(format, "%X"); break;
443                                 case 1: strcpy(format, "%d" ); break;
444                                 case 2: strcpy(format, "%u" ); break;
445                                 }
446
447                                 if (wordlong)
448                                         sprintf(prntstr, format, eval);
449                                 else
450                                         sprintf(prntstr, format, eval & 0xFFFF);
451
452                                 printf("%s", prntstr);
453
454                                 if (list_fd)
455                                         unused = write(list_fd, prntstr, (LONG)strlen(prntstr));
456
457                                 formatting = 0;
458                                 wordlong = 0;
459                                 outtype = 0;
460                         }
461
462                         break;
463                 }
464         }
465
466         printf("\n");
467
468         return 0;
469
470 token_err:
471         error("illegal print token [@ '%s']", prntstr);
472         return ERROR;
473 }
474
475
476 //
477 // Undefine an equated condition code
478 //
479 int d_ccundef(void)
480 {
481         SYM * ccname;
482
483         // Check that we are in a RISC section
484         if (!rgpu && !rdsp)
485         {
486                 error(".ccundef must be defined in .gpu/.dsp section");
487                 return ERROR;
488         }
489
490         if (*tok != SYMBOL)
491         {
492                 error("syntax error; expected symbol");
493                 return ERROR;
494         }
495
496         ccname = lookup(string[tok[1]], LABEL, 0);
497
498         // Make sure symbol is a valid ccdef
499         if (!ccname || !(ccname->sattre & EQUATEDCC))
500         {
501                 error("invalid equated condition name specified");
502                 return ERROR;
503         }
504
505         ccname->sattre |= UNDEF_CC;
506
507         return 0;
508 }
509
510
511 //
512 // Undefine an equated register
513 //
514 int d_equrundef(void)
515 {
516         SYM * regname;
517
518         // Check that we are in a RISC section
519         if (!rgpu && !rdsp)
520                 return error(".equrundef/.regundef must be defined in .gpu/.dsp section");
521
522         while (*tok != EOL)
523         {
524                 // Skip preceeding or seperating commas (if any)
525                 if (*tok == ',')
526                         tok++;
527
528                 // Check we are dealing with a symbol
529                 if (*tok != SYMBOL)
530                         return error("syntax error; expected symbol");
531
532                 // Lookup and undef if equated register
533                 regname = lookup(string[tok[1]], LABEL, 0);
534
535                 if (regname && (regname->sattre & EQUATEDREG))
536                 {
537                         // Reset the attributes of this symbol...
538                         regname->sattr = 0;
539                         regname->sattre &= ~(EQUATEDREG | BANK_0 | BANK_1);
540                         regname->sattre |= UNDEF_EQUR;
541                 }
542
543                 // Skip over symbol token and address
544                 tok += 2;
545         }
546
547         return 0;
548 }
549
550
551 //
552 // Do not allow use of the CLR.L opcode
553 //
554 int d_noclear(void)
555 {
556         warn("CLR.L opcode ignored...");
557         return 0;
558 }
559
560
561 //
562 // Include binary file (can add addition size & position params, comma separated)
563 //
564 int d_incbin(void)
565 {
566         int fd;
567         int bytes = 0;
568         uint64_t pos, size, bytesRead;
569         char buf1[256];
570         int i;
571
572         // Check to see if we're in BSS, and, if so, throw an error
573         if (scattr & SBSS)
574         {
575                 error("cannot include binary file \"%s\" in BSS section", string[tok[1]]);
576                 return ERROR;
577         }
578
579         if (*tok != STRING)
580         {
581                 error("syntax error; file to include missing");
582                 return ERROR;
583         }
584
585         // Attempt to open the include file in the current directory, then (if that
586         // failed) try list of include files passed in the enviroment string or by
587         // the "-d" option.
588         TOKEN filename = tok[1];
589
590         if ((fd = open(string[filename], _OPEN_INC)) < 0)
591         {
592                 for(i=0; nthpath("RMACPATH", i, buf1)!=0; i++)
593                 {
594                         fd = strlen(buf1);
595
596                         // Append path char if necessary
597                         if (fd > 0 && buf1[fd - 1] != SLASHCHAR)
598                                 strcat(buf1, SLASHSTRING);
599
600                         strcat(buf1, string[filename]);
601
602                         if ((fd = open(buf1, _OPEN_INC)) >= 0)
603                                 goto allright;
604                 }
605
606                 return error("cannot open: \"%s\"", string[filename]);
607         }
608
609 allright:
610
611         tok += 2;
612
613         if (*tok != EOL)
614         {
615                 // Check size parameter (can be omitted)
616                 if (*tok++ == ',')
617                 {
618                         if (*tok != ',')
619                         {
620                                 if (abs_expr(&size) != OK)
621                                 {
622                                         close(fd);
623                                         return ERROR;
624                                 }
625                         }
626                         else
627                                 size = lseek(fd, 0L, SEEK_END);
628                 }
629
630                 // Check offset parameter (can be omitted)
631                 if (*tok != EOL)
632                 {
633                         if (*tok++ == ',')
634                         {
635                                 if (*tok != EOL)
636                                 {
637                                         if (abs_expr(&pos) != OK)
638                                         {
639                                                 close(fd);
640                                                 return ERROR;
641                                         }
642
643                                         lseek(fd, pos, SEEK_SET);
644                                         size -= pos;
645                                 }
646                                 else
647                                 {
648                                         // offset parameter omitted, so it's 0
649                                         pos = lseek(fd, 0L, SEEK_SET);
650                                 }
651                         }
652                         else
653                                 return error(comma_error);
654                 }
655                 else
656                         pos = lseek(fd, 0L, SEEK_SET);
657         }
658         else
659         {
660                 // size & pos not given, so assume offset of 0 and all of the binary
661                 size = lseek(fd, 0L, SEEK_END);
662                 pos = lseek(fd, 0L, SEEK_SET);
663         }
664
665         chcheck(size);
666
667         DEBUG { printf("INCBIN: File '%s' is %li bytes.\n", string[filename], size); }
668
669         char * fileBuffer = (char *)malloc(size);
670         bytesRead = read(fd, fileBuffer, size);
671
672         if (bytesRead != size)
673         {
674                 error("was only able to read %li bytes from binary file (%s, %li bytes)", bytesRead, string[filename], size);
675                 return ERROR;
676         }
677
678         memcpy(chptr, fileBuffer, size);
679         chptr += size;
680         sloc += size;
681         ch_size += size;
682
683         if (orgactive)
684                 orgaddr += size;
685
686         free(fileBuffer);
687         close(fd);
688         return 0;
689 }
690
691
692 //
693 // Set RISC register banks
694 //
695 int d_regbank0(void)
696 {
697         // Set active register bank zero
698         regbank = BANK_0;
699         return 0;
700 }
701
702
703 int d_regbank1(void)
704 {
705         // Set active register bank one
706         regbank = BANK_1;
707         return 0;
708 }
709
710
711 //
712 // Helper function, to cut down on mistakes & typing
713 //
714 static inline void SkipBytes(unsigned bytesToSkip)
715 {
716         if (!bytesToSkip)
717                 return;
718
719         if ((scattr & SBSS) == 0)
720         {
721                 chcheck(bytesToSkip);
722                 D_ZEROFILL(bytesToSkip);
723         }
724         else
725         {
726                 sloc += bytesToSkip;
727
728                 if (orgactive)
729                         orgaddr += bytesToSkip;
730         }
731 }
732
733
734 //
735 // Adjust location to an EVEN value
736 //
737 int d_even(void)
738 {
739         if (m6502)
740                 return error(in_6502mode);
741
742         unsigned skip = (rgpu || rdsp ? orgaddr : sloc) & 0x01;
743
744         if (skip)
745         {
746                 if ((scattr & SBSS) == 0)
747                 {
748                         chcheck(1);
749                         D_byte(0);
750                 }
751                 else
752                 {
753                         sloc++;
754
755                         if (orgactive)
756                                 orgaddr++;
757                 }
758         }
759
760         return 0;
761 }
762
763
764 //
765 // Adjust location to a LONG value
766 //
767 int d_long(void)
768 {
769         unsigned lower2Bits = (rgpu || rdsp ? orgaddr : sloc) & 0x03;
770         unsigned bytesToSkip = (0x04 - lower2Bits) & 0x03;
771         SkipBytes(bytesToSkip);
772         SetLargestAlignment(4);
773
774         return 0;
775 }
776
777
778 //
779 // Adjust location to a PHRASE value
780 //
781 // N.B.: We have to handle the GPU/DSP cases separately because you can embed
782 //       RISC code in the middle of a regular 68K section. Also note that all
783 //       of the alignment pseudo-ops will have to be fixed this way.
784 //
785 // This *must* behave differently when in a RISC section, as following sloc
786 // (instead of orgaddr) will fuck things up royally. Note that we do it this
787 // way because you can embed RISC code in a 68K section, and have the origin
788 // pointing to a different alignment in the RISC section than the 68K section.
789 //
790 int d_phrase(void)
791 {
792         unsigned lower3Bits = (rgpu || rdsp ? orgaddr : sloc) & 0x07;
793         unsigned bytesToSkip = (0x08 - lower3Bits) & 0x07;
794         SkipBytes(bytesToSkip);
795         SetLargestAlignment(8);
796
797         return 0;
798 }
799
800
801 //
802 // Adjust location to a DPHRASE value
803 //
804 int d_dphrase(void)
805 {
806         unsigned lower4Bits = (rgpu || rdsp ? orgaddr : sloc) & 0x0F;
807         unsigned bytesToSkip = (0x10 - lower4Bits) & 0x0F;
808         SkipBytes(bytesToSkip);
809         SetLargestAlignment(16);
810
811         return 0;
812 }
813
814
815 //
816 // Adjust location to a QPHRASE value
817 //
818 int d_qphrase(void)
819 {
820         unsigned lower5Bits = (rgpu || rdsp ? orgaddr : sloc) & 0x1F;
821         unsigned bytesToSkip = (0x20 - lower5Bits) & 0x1F;
822         SkipBytes(bytesToSkip);
823         SetLargestAlignment(32);
824
825         return 0;
826 }
827
828
829 //
830 // Do auto-even.  This must be called ONLY if 'sloc' is odd.
831 //
832 // This is made hairy because, if there was a label on the line, we also have
833 // to adjust its value. This won't work with more than one label on the line,
834 // which is OK since multiple labels are only allowed in AS68 kludge mode, and
835 // the C compiler is VERY paranoid and uses ".even" whenever it can
836 //
837 // N.B.: This probably needs the same fixes as above...
838 //
839 void auto_even(void)
840 {
841         if (cursect != M6502)
842         {
843                 if (scattr & SBSS)
844                         sloc++;                         // Bump BSS section
845                 else
846                         D_byte(0);                      // Deposit 0.b in non-BSS
847
848                 if (lab_sym != NULL)    // Bump label if we have to
849                         lab_sym->svalue++;
850         }
851 }
852
853
854 //
855 // Unimplemened directive error
856 //
857 int d_unimpl(void)
858 {
859         return error("unimplemented directive");
860 }
861
862
863 //
864 // Return absolute (not TDB) and defined expression or return an error
865 //
866 int abs_expr(uint64_t * a_eval)
867 {
868         WORD eattr;
869
870         if (expr(exprbuf, a_eval, &eattr, NULL) < 0)
871                 return ERROR;
872
873         if (!(eattr & DEFINED))
874                 return error(undef_error);
875
876         if (eattr & TDB)
877                 return error(rel_error);
878
879         return OK;
880 }
881
882
883 //
884 // Hand symbols in a symbol-list to a function (kind of like mapcar...)
885 //
886 int symlist(int(* func)())
887 {
888         const char * em = "symbol list syntax";
889
890         for(;;)
891         {
892                 if (*tok != SYMBOL)
893                         return error(em);
894
895                 if ((*func)(string[tok[1]]) != OK)
896                         break;
897
898                 tok += 2;
899
900                 if (*tok == EOL)
901                         break;
902
903                 if (*tok != ',')
904                         return error(em);
905
906                 tok++;
907         }
908
909         return 0;
910 }
911
912
913 //
914 // .include "filename"
915 //
916 int d_include(void)
917 {
918         int j;
919         int i;
920         char * fn;
921         char buf[128];
922         char buf1[128];
923
924         if (*tok == STRING)                     // Leave strings ALONE
925                 fn = string[*++tok];
926         else if (*tok == SYMBOL)        // Try to append ".s" to symbols
927         {
928                 strcpy(buf, string[*++tok]);
929                 fext(buf, ".s", 0);
930                 fn = &buf[0];
931         }
932         else                                            // Punt if no STRING or SYMBOL
933                 return error("missing filename");
934
935         // Make sure the user didn't try anything like:
936         // .include equates.s
937         if (*++tok != EOL)
938                 return error("extra stuff after filename--enclose it in quotes");
939
940         // Attempt to open the include file in the current directory, then (if that
941         // failed) try list of include files passed in the enviroment string or by
942         // the "-i" option.
943         if ((j = open(fn, 0)) < 0)
944         {
945                 for(i=0; nthpath("RMACPATH", i, buf1)!=0; i++)
946                 {
947                         j = strlen(buf1);
948
949                         // Append path char if necessary
950                         if (j > 0 && buf1[j - 1] != SLASHCHAR)
951                                 strcat(buf1, SLASHSTRING);
952
953                         strcat(buf1, fn);
954
955                         if ((j = open(buf1, 0)) >= 0)
956                                 goto allright;
957                 }
958
959                 return error("cannot open: \"%s\"", fn);
960         }
961
962 allright:
963         include(j, fn);
964         return 0;
965 }
966
967
968 //
969 // .assert expression [, expression...]
970 //
971 int d_assert(void)
972 {
973         WORD eattr;
974         uint64_t eval;
975
976         for(; expr(exprbuf, &eval, &eattr, NULL)==OK; ++tok)
977         {
978                 if (!(eattr & DEFINED))
979                         return error("forward or undefined .assert");
980
981                 if (!eval)
982                         return error("assert failure");
983
984                 if (*tok != ',')
985                         break;
986         }
987
988         ErrorIfNotAtEOL();
989         return 0;
990 }
991
992
993 //
994 // .globl symbol [, symbol] <<<cannot make local symbols global>>>
995 //
996 int globl1(char * p)
997 {
998         SYM * sy;
999
1000         if (*p == '.')
1001                 return error("cannot .globl local symbol");
1002
1003         if ((sy = lookup(p, LABEL, 0)) == NULL)
1004         {
1005                 sy = NewSymbol(p, LABEL, 0);
1006                 sy->svalue = 0;
1007                 sy->sattr = GLOBAL;
1008 //printf("glob1: Making global symbol: attr=%04X, eattr=%08X, %s\n", sy->sattr, sy->sattre, sy->sname);
1009         }
1010         else
1011                 sy->sattr |= GLOBAL;
1012
1013         return OK;
1014 }
1015
1016
1017 int d_globl(void)
1018 {
1019         if (m6502)
1020                 return error(in_6502mode);
1021
1022         symlist(globl1);
1023         return 0;
1024 }
1025
1026
1027 //
1028 // .prgflags expression
1029 //
1030 int d_prgflags(void)
1031 {
1032         uint64_t eval;
1033
1034         if (*tok == EOL)
1035                 return error("PRGFLAGS requires value");
1036         else if (abs_expr(&eval) == OK)
1037         {
1038                 PRGFLAGS = (uint32_t)eval;
1039                 return 0;
1040         }
1041         else
1042         {
1043                 return error("PRGFLAGS requires value");
1044         }
1045 }
1046
1047
1048 //
1049 // .abs [expression]
1050 //
1051 int d_abs(void)
1052 {
1053         uint64_t eval;
1054
1055         if (m6502)
1056                 return error(in_6502mode);
1057
1058         SaveSection();
1059
1060         if (*tok == EOL)
1061                 eval = 0;
1062         else if (abs_expr(&eval) != OK)
1063                 return 0;
1064
1065         SwitchSection(ABS);
1066         sloc = (uint32_t)eval;
1067         return 0;
1068 }
1069
1070
1071 //
1072 // Switch segments
1073 //
1074 int d_text(void)
1075 {
1076         if (rgpu || rdsp)
1077                 return error("directive forbidden in gpu/dsp mode");
1078         else if (m6502)
1079                 return error(in_6502mode);
1080
1081         if (cursect != TEXT)
1082         {
1083                 SaveSection();
1084                 SwitchSection(TEXT);
1085         }
1086
1087         return 0;
1088 }
1089
1090
1091 int d_data(void)
1092 {
1093         if (rgpu || rdsp)
1094                 return error("directive forbidden in gpu/dsp mode");
1095         else if (m6502)
1096                 return error(in_6502mode);
1097
1098         if (cursect != DATA)
1099         {
1100                 SaveSection();
1101                 SwitchSection(DATA);
1102         }
1103
1104         return 0;
1105 }
1106
1107
1108 int d_bss(void)
1109 {
1110         if (rgpu || rdsp)
1111                 return error("directive forbidden in gpu/dsp mode");
1112         else if (m6502)
1113                 return error(in_6502mode);
1114
1115         if (cursect != BSS)
1116         {
1117                 SaveSection();
1118                 SwitchSection(BSS);
1119         }
1120
1121         return 0;
1122 }
1123
1124
1125 //
1126 // .ds[.size] expression
1127 //
1128 int d_ds(WORD siz)
1129 {
1130         DEBUG { printf("Directive: .ds.[size] = %u, sloc = $%X\n", siz, sloc); }
1131
1132         uint64_t eval;
1133
1134         if ((cursect & (M6502 | M56KPXYL)) == 0)
1135         {
1136                 if ((siz != SIZB) && (sloc & 1))        // Automatic .even
1137                         auto_even();
1138         }
1139
1140         if (abs_expr(&eval) != OK)
1141                 return 0;
1142
1143         // Check to see if the value being passed in is negative (who the hell does
1144         // that?--nobody does; it's the code gremlins, or rum, what does it)
1145         // N.B.: Since 'eval' is of type uint64_t, if it goes negative, it will
1146         //       have its high bit set.
1147         if (eval & 0x8000000000000000)
1148                 return error("negative sizes not allowed in DS");
1149
1150         // In non-TDB section (BSS, ABS and M6502) just advance the location
1151         // counter appropriately. In TDB sections, deposit (possibly large) chunks
1152         // of zeroed memory....
1153         if ((scattr & SBSS) || cursect == M6502)
1154         {
1155                 listvalue((uint32_t)eval);
1156                 eval *= siz;
1157                 sloc += (uint32_t)eval;
1158
1159                 if (cursect == M6502)
1160                         chptr += eval;
1161
1162                 just_bss = 1;                                   // No data deposited (8-bit CPU mode)
1163         }
1164         else if (cursect & M56KPXYL)
1165         {
1166                 // Change segment instead of marking blanks.
1167                 // Only mark segments we actually wrote something
1168                 if (chptr != dsp_currentorg->start && dsp_written_data_in_current_org)
1169                 {
1170                         dsp_currentorg->end = chptr;
1171                         dsp_currentorg++;
1172                         dsp_currentorg->memtype = dsp_currentorg[-1].memtype;
1173                 }
1174
1175                 listvalue((uint32_t)eval);
1176                 sloc += (uint32_t)eval;
1177
1178                 // And now let's create a new segment
1179                 dsp_currentorg->start = chptr;
1180                 dsp_currentorg->chunk = scode;  // Mark down which chunk this org starts from (will be needed when outputting)
1181                 sect[cursect].orgaddr = sloc;
1182                 dsp_currentorg->orgadr = sloc;
1183                 dsp_written_data_in_current_org = 0;
1184
1185                 just_bss = 1;                                   // No data deposited
1186         }
1187         else
1188         {
1189                 dep_block(eval, siz, 0, (DEFINED | ABS), NULL);
1190         }
1191
1192         ErrorIfNotAtEOL();
1193         return OK;
1194 }
1195
1196
1197 //
1198 // dsm[.siz] expression
1199 // Define modulo storage
1200 // Quoting the Motorola assembler manual:
1201 // "The DSM directive reserves a block of memory the length of which in words is equal to
1202 // the value of <expression>.If the runtime location counter is not zero, this directive first
1203 // advances the runtime location counter to a base address that is a multiple of 2k, where
1204 // 2k >= <expression>."
1205 // The kicker of course is written a few sentences after:
1206 // "<label>, if present, will be assigned the value of the runtime location counter after a valid
1207 // base address has been established."
1208 //
1209 int d_dsm(WORD siz)
1210 {
1211         TOKEN * tok_current = tok;  // Keep track of where tok was when we entered this procedure
1212         uint64_t eval;
1213
1214         if (abs_expr(&eval) != OK)
1215                 return 0;
1216
1217         // Round up to the next highest power of 2
1218         // Nicked from https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
1219         eval--;
1220         eval |= eval >> 1;
1221         eval |= eval >> 2;
1222         eval |= eval >> 4;
1223         eval |= eval >> 8;
1224         eval |= eval >> 16;
1225
1226         int units_to_skip;
1227         units_to_skip = eval + 1 - sloc;
1228         sloc += units_to_skip;          // Bump up sloc - TODO: check if this goes over the RAM limits?
1229
1230         // If a label has been defined in the same line as dsm, its value also needs to be adjusted
1231         if (label_defined)
1232         {
1233                 SYM * label = lookup(label_defined, LABEL, 0);
1234                 label->svalue += units_to_skip;
1235         }
1236
1237         tok = tok_current;              // Rewind tok back to where it was
1238         return d_ds(siz);               // And let d_ds take over from here
1239 }
1240
1241
1242 //
1243 // dc.b, dc.w / dc, dc.l, dc.i, dc.q, dc.d, dc.s, dc.x
1244 //
1245 int d_dc(WORD siz)
1246 {
1247         WORD eattr;
1248         uint64_t eval;
1249         uint8_t * p;
1250
1251         if ((scattr & SBSS) != 0)
1252                 return error("illegal initialization of section");
1253
1254         // Do an auto_even if it's not BYTE sized (hmm, should we be doing this???)
1255         if ((cursect != M6502) && (cursect != M56001P) && (cursect != M56001X)
1256                 && (cursect != M56001Y) && (cursect != M56001L)
1257                 && (siz != SIZB) && (sloc & 1))
1258                 auto_even();
1259
1260         // Check to see if we're trying to set LONGS on a non 32-bit aligned
1261         // address in a GPU or DSP section, in their local RAM
1262         if ((siz == SIZL) && (orgaddr & 0x03)
1263                 && ((rgpu && (orgaddr >= 0xF03000) && (orgaddr <= 0xF03FFFF))
1264                 || (rdsp && (orgaddr >= 0xF1B000) && (orgaddr <= 0xF1CFFFF))))
1265                 warn("depositing LONGs on a non-long address in local RAM");
1266
1267         for(;; tok++)
1268         {
1269                 // dc.b 'string' [,] ...
1270                 if (siz == SIZB && (*tok == STRING || *tok == STRINGA8) && (tok[2] == ',' || tok[2] == EOL))
1271                 {
1272                         uint32_t i = strlen(string[tok[1]]);
1273
1274                         if ((challoc - ch_size) < i)
1275                                 chcheck(i);
1276
1277                         if (*tok == STRING)
1278                         {
1279                                 for(p=string[tok[1]]; *p!=EOS; p++)
1280                                         D_byte(*p);
1281                         }
1282                         else if (*tok == STRINGA8)
1283                         {
1284                                 for(p=string[tok[1]]; *p!=EOS; p++)
1285                                         D_byte(strtoa8[*p]);
1286                         }
1287                         else
1288                         {
1289                                 error("String format not supported... yet");
1290                         }
1291
1292                         tok += 2;
1293                         goto comma;
1294                 }
1295
1296                 int movei = 0; // MOVEI flag for dc.i
1297
1298                 if (*tok == DOTI)
1299                 {
1300                         movei = 1;
1301                         tok++;
1302                         siz = SIZL;
1303                 }
1304
1305                 // dc.x <expression>
1306                 SYM * esym = 0;
1307
1308                 if (expr(exprbuf, &eval, &eattr, &esym) != OK)
1309                         return 0;
1310
1311                 uint16_t tdb = eattr & TDB;
1312                 uint16_t defined = eattr & DEFINED;
1313
1314 // N.B.: This is awful.  This needs better handling, rather than just bodging something in that, while works, is basically an ugly wart on the assembler.  !!! FIX !!!
1315                 if (dsp56001)
1316                 {
1317                         if (cursect != M56001L)
1318                         {
1319                                 if (!defined)
1320                                 {
1321                                         AddFixup(FU_DSPIMM24 | FU_SEXT, sloc, exprbuf);
1322                                         D_dsp(0);
1323                                 }
1324                                 else
1325                                 {
1326                                         if (eattr & FLOAT)
1327                                         {
1328                                                 double fval = *(double *)&eval;
1329                                                 eval = DoubleToDSPFloat(fval);
1330                                         }
1331                                         else
1332                                         {
1333                                                 if ((uint32_t)eval + 0x1000000 >= 0x2000000)
1334                                                         return error(range_error);
1335                                         }
1336
1337                                         // Deposit DSP word (24-bit)
1338                                         D_dsp(eval);
1339                                 }
1340                         }
1341                         else
1342                         {
1343                                 // In L: we deposit stuff to both X: and Y: instead
1344                                 // We will be a bit lazy and require that there is a 2nd value
1345                                 // in the same source line. (Motorola's assembler can parse
1346                                 // 12-digit hex values, which we can't do at the moment) This
1347                                 // of course requires to parse 2 values in one pass. If there
1348                                 // isn't another value in this line, assume X: value is 0.
1349                                 int secondword = 0;
1350                                 uint32_t evaly;
1351 l_parse_loop:
1352
1353                                 if (!defined)
1354                                 {
1355                                         AddFixup(FU_DSPIMM24 | FU_SEXT, sloc, exprbuf);
1356                                         D_dsp(0);
1357                                 }
1358                                 else
1359                                 {
1360                                         if (eattr & FLOAT)
1361                                         {
1362                                                 float fval = *(float *)&eval;
1363                                                 eval = DoubleToDSPFloat(fval);
1364                                         }
1365                                         else
1366                                         {
1367                                                 if (eval + 0x1000000 >= 0x2000000)
1368                                                         return error(range_error);
1369                                         }
1370
1371                                         // Parse 2nd value if we didn't do this yet
1372                                         if (secondword == 0)
1373                                         {
1374                                                 evaly = (uint32_t)eval;
1375                                                 secondword = 1;
1376
1377                                                 if (*tok != ':')
1378                                                 {
1379                                                         // If we don't have a : then we're probably at EOL,
1380                                                         // which means the X: value will be 0
1381                                                         eval = 0;
1382                                                         ErrorIfNotAtEOL();
1383                                                 }
1384                                                 else
1385                                                 {
1386                                                         tok++; // Eat the comma;
1387
1388                                                         if (expr(exprbuf, &eval, &eattr, NULL) != OK)
1389                                                                 return 0;
1390
1391                                                         defined = (WORD)(eattr & DEFINED);
1392                                                         goto l_parse_loop;
1393                                                 }
1394                                         }
1395
1396                                         // Deposit DSP words (24-bit)
1397                                         D_dsp(eval);
1398                                         D_dsp(evaly);
1399                                         sloc--; // We do write 2 DSP words but as far as L: space is concerned we actually advance our counter by one
1400                                 }
1401
1402                         }
1403
1404                         goto comma;
1405                 }
1406
1407                 switch (siz)
1408                 {
1409                 case SIZB:
1410                         if (!defined)
1411                         {
1412                                 AddFixup(FU_BYTE | FU_SEXT, sloc, exprbuf);
1413                                 D_byte(0);
1414                         }
1415                         else
1416                         {
1417                                 if (tdb)
1418                                         return error("non-absolute byte value");
1419
1420                                 if (eval + 0x100 >= 0x200)
1421                                         return error("%s (value = $%X)", range_error, eval);
1422
1423                                 D_byte(eval);
1424                         }
1425
1426                         break;
1427
1428                 case SIZW:
1429                 case SIZN:
1430                         if (!defined)
1431                         {
1432                                 AddFixup(FU_WORD | FU_SEXT, sloc, exprbuf);
1433                                 D_word(0);
1434                         }
1435                         else
1436                         {
1437                                 if (eval + 0x10000 >= 0x20000)
1438                                         return error(range_error);
1439
1440                                 if (tdb)
1441                                         MarkRelocatable(cursect, sloc, tdb, MWORD, NULL);
1442
1443                                 // Deposit 68000 or 6502 (byte-reversed) word
1444                                 if (cursect != M6502)
1445                                         D_word(eval)
1446                                 else
1447                                         D_rword(eval)
1448                         }
1449
1450                         break;
1451
1452                 case SIZL:
1453                         // Shamus: Why can't we do longs in 6502 mode?
1454                         if (m6502)
1455                                 return error(in_6502mode);
1456
1457                         if (!defined)
1458                         {
1459                                 AddFixup(FU_LONG | (movei ? FU_MOVEI : 0), sloc, exprbuf);
1460                                 D_long(0);
1461                         }
1462                         else
1463                         {
1464                                 if (tdb)
1465                                         MarkRelocatable(cursect, sloc, tdb, MLONG, NULL);
1466
1467                                 if (movei)
1468                                         eval = WORDSWAP32(eval);
1469
1470                                 D_long(eval);
1471                         }
1472
1473                         break;
1474
1475                 case SIZQ:
1476                         // 64-bit size
1477                         if (m6502)
1478                                 return error(in_6502mode);
1479
1480                         // DEFINITELY NEED FIXUPS HERE!
1481                         if (!defined)
1482                         {
1483                                 AddFixup(FU_QUAD, sloc, exprbuf);
1484                                 eval = 0;
1485                         }
1486
1487                         D_quad(eval);
1488                         break;
1489
1490                 case SIZS:
1491                         // 32-bit float size
1492                         if (m6502)
1493                                 return error(in_6502mode);
1494
1495 /* Seems to me that if something is undefined here, then that should be an error.  Likewise for the D & X variants. */
1496                         if (!defined)
1497                         {
1498 //                              AddFixup(FU_FLOATSING, sloc, exprbuf);
1499 //                              D_long(0);
1500                                 return error("labels not allowed in floating point expressions");
1501                         }
1502                         else
1503                         {
1504 //Would this *ever* happen?
1505 //                              if (tdb)
1506 //                                      MarkRelocatable(cursect, sloc, tdb, MSINGLE, NULL);
1507
1508                                 PTR ptr;
1509                                 ptr.u64 = &eval;
1510                                 uint32_t ieee754 = FloatToIEEE754((float)*ptr.dp);
1511                                 D_long(ieee754);
1512                         }
1513
1514                         break;
1515
1516                 case SIZD:
1517                         // 64-bit double size
1518                         if (m6502)
1519                                 return error(in_6502mode);
1520
1521                         if (!defined)
1522                         {
1523 //                              AddFixup(FU_FLOATDOUB, sloc, exprbuf);
1524 //                              D_quad(0LL);
1525                                 return error("labels not allowed in floating point expressions");
1526                         }
1527                         else
1528                         {
1529 //Would this *ever* happen?
1530 //                              if (tdb)
1531 //                                      MarkRelocatable(cursect, sloc, tdb, MDOUBLE, NULL);
1532
1533                                 PTR ptr;
1534                                 ptr.u64 = &eval;
1535                                 uint64_t ieee754 = DoubleToIEEE754(*ptr.dp);
1536                                 D_quad(ieee754);
1537                         }
1538
1539                         break;
1540
1541                 case SIZX:
1542                         if (m6502)
1543                                 return error(in_6502mode);
1544
1545                         uint8_t extDbl[12];
1546                         memset(extDbl, 0, 12);
1547
1548                         if (!defined)
1549                         {
1550 //                              AddFixup(FU_FLOATEXT, sloc, exprbuf);
1551 //                              D_extend(extDbl);
1552                                 return error("labels not allowed in floating point expressions");
1553                         }
1554                         else
1555                         {
1556 //Would this *ever* happen?
1557 //                              if (tdb)
1558 //                                      MarkRelocatable(cursect, sloc, tdb, MEXTEND, NULL);
1559
1560                                 PTR ptr;
1561                                 ptr.u64 = &eval;
1562                                 DoubleToExtended(*ptr.dp, extDbl);
1563                                 D_extend(extDbl);
1564                         }
1565
1566                         break;
1567                 }
1568
1569 comma:
1570                 if (*tok != ',')
1571                         break;
1572         }
1573
1574         ErrorIfNotAtEOL();
1575         return 0;
1576 }
1577
1578
1579 //
1580 // dcb[.siz] expr1,expr2 - Make 'expr1' copies of 'expr2'
1581 //
1582 int d_dcb(WORD siz)
1583 {
1584         uint64_t evalc, eval;
1585         WORD eattr;
1586
1587         DEBUG { printf("dcb: section is %s%s%s (scattr=$%X)\n", (cursect & TEXT ? "TEXT" : ""), (cursect & DATA ? " DATA" : ""), (cursect & BSS ? "BSS" : ""), scattr); }
1588
1589         if ((scattr & SBSS) != 0)
1590                 return error("illegal initialization of section");
1591
1592         if (abs_expr(&evalc) != OK)
1593                 return 0;
1594
1595         if (*tok++ != ',')
1596                 return error("missing comma");
1597
1598         if (expr(exprbuf, &eval, &eattr, NULL) < 0)
1599                 return 0;
1600
1601         if (cursect != M6502 && (siz != SIZB) && (sloc & 1))
1602                 auto_even();
1603
1604         dep_block((uint32_t)evalc, siz, (uint32_t)eval, eattr, exprbuf);
1605         return 0;
1606 }
1607
1608
1609 //
1610 // Generalized initialization directive
1611 //
1612 // .init[.siz] [#count,] expression [.size] , ...
1613 //
1614 // The size suffix on the ".init" directive becomes the default size of the
1615 // objects to deposit. If an item is preceeded with a sharp (immediate) sign
1616 // and an expression, it specifies a repeat count. The value to be deposited
1617 // may be followed by a size suffix, which overrides the default size.
1618 //
1619 int d_init(WORD def_siz)
1620 {
1621         uint64_t count;
1622         uint64_t eval;
1623         WORD eattr;
1624         WORD siz;
1625
1626         if ((scattr & SBSS) != 0)
1627                 return error(".init not permitted in BSS or ABS");
1628
1629         if (rgpu || rdsp)
1630                 return error("directive forbidden in gpu/dsp mode");
1631
1632         for(;;)
1633         {
1634                 // Get repeat count (defaults to 1)
1635                 if (*tok == '#')
1636                 {
1637                         tok++;
1638
1639                         if (abs_expr(&count) != OK)
1640                                 return 0;
1641
1642                         if (*tok++ != ',')
1643                                 return error(comma_error);
1644                 }
1645                 else
1646                         count = 1;
1647
1648                 // Evaluate expression to deposit
1649                 if (expr(exprbuf, &eval, &eattr, NULL) < 0)
1650                         return 0;
1651
1652                 switch (*tok++)
1653                 {                                 // Determine size of object to deposit
1654                 case DOTB: siz = SIZB; break;
1655                 case DOTW: siz = SIZB; break;
1656                 case DOTL: siz = SIZL; break;
1657                 default:
1658                         siz = def_siz;
1659                         tok--;
1660                         break;
1661                 }
1662
1663                 dep_block((uint32_t)count, siz, (uint32_t)eval, eattr, exprbuf);
1664
1665                 switch (*tok)
1666                 {
1667                 case EOL:
1668                         return 0;
1669                 case ',':
1670                         tok++;
1671                         continue;
1672                 default:
1673                         return error(comma_error);
1674                 }
1675         }
1676 }
1677
1678
1679 //
1680 // Deposit 'count' values of size 'siz' in the current (non-BSS) segment
1681 //
1682 int dep_block(uint32_t count, WORD siz, uint32_t eval, WORD eattr, TOKEN * exprbuf)
1683 {
1684         WORD tdb = eattr & TDB;
1685         WORD defined = eattr & DEFINED;
1686
1687         while (count--)
1688         {
1689                 if ((challoc - ch_size) < 4)
1690                         chcheck(4L);
1691
1692                 switch(siz)
1693                 {
1694                 case SIZB:
1695                         if (!defined)
1696                         {
1697                                 AddFixup(FU_BYTE | FU_SEXT, sloc, exprbuf);
1698                                 D_byte(0);
1699                         }
1700                         else
1701                         {
1702                                 if (tdb)
1703                                         return error("non-absolute byte value");
1704
1705                                 if (eval + 0x100 >= 0x200)
1706                                         return error(range_error);
1707
1708                                 D_byte(eval);
1709                         }
1710
1711                         break;
1712                 case SIZW:
1713                 case SIZN:
1714                         if (!defined)
1715                         {
1716                                 AddFixup(FU_WORD | FU_SEXT, sloc, exprbuf);
1717                                 D_word(0);
1718                         }
1719                         else
1720                         {
1721                                 if (tdb)
1722                                         MarkRelocatable(cursect, sloc, tdb, MWORD, NULL);
1723
1724                                 if (eval + 0x10000 >= 0x20000)
1725                                         return error(range_error);
1726
1727                                 // Deposit 68000 or 6502 (byte-reversed) word
1728                                 if (cursect != M6502)
1729                                         D_word(eval)
1730                                 else
1731                                         D_rword(eval)
1732
1733                         }
1734
1735                         break;
1736                 case SIZL:
1737                         if (m6502)
1738                                 return error(in_6502mode);
1739
1740                         if (!defined)
1741                         {
1742                                 AddFixup(FU_LONG, sloc, exprbuf);
1743                                 D_long(0);
1744                         }
1745                         else
1746                         {
1747                                 if (tdb)
1748                                         MarkRelocatable(cursect, sloc, tdb, MLONG, NULL);
1749
1750                                 D_long(eval);
1751                         }
1752
1753                         break;
1754                 }
1755         }
1756
1757         return 0;
1758 }
1759
1760
1761 //
1762 // .comm symbol, size
1763 //
1764 int d_comm(void)
1765 {
1766         SYM * sym;
1767         char * p;
1768         uint64_t eval;
1769
1770         if (m6502)
1771                 return error(in_6502mode);
1772
1773         if (*tok != SYMBOL)
1774                 return error("missing symbol");
1775
1776         p = string[tok[1]];
1777         tok += 2;
1778
1779         if (*p == '.')                                          // Cannot .comm a local symbol
1780                 return error(locgl_error);
1781
1782         if ((sym = lookup(p, LABEL, 0)) == NULL)
1783                 sym = NewSymbol(p, LABEL, 0);
1784         else
1785         {
1786                 if (sym->sattr & DEFINED)
1787                         return error(".comm symbol already defined");
1788         }
1789
1790         sym->sattr = GLOBAL | COMMON | BSS;
1791
1792         if (*tok++ != ',')
1793                 return error(comma_error);
1794
1795         if (abs_expr(&eval) != OK)                      // Parse size of common region
1796                 return 0;
1797
1798         sym->svalue = eval;                                     // Install common symbol's size
1799         ErrorIfNotAtEOL();
1800         return 0;
1801 }
1802
1803
1804 //
1805 // .list - Turn listing on
1806 //
1807 int d_list(void)
1808 {
1809         if (list_flag)
1810                 listing++;
1811
1812         return 0;
1813 }
1814
1815
1816 //
1817 // .nlist - Turn listing off
1818 //
1819 int d_nlist(void)
1820 {
1821         if (list_flag)
1822                 listing--;
1823
1824         return 0;
1825 }
1826
1827
1828 //
1829 // .68000 - Back to 68000 TEXT segment
1830 //
1831 int d_68000(void)
1832 {
1833         rgpu = rdsp = robjproc = dsp56001 = 0;
1834         // Switching from gpu/dsp sections should reset any ORG'd Address
1835         orgactive = 0;
1836         orgwarning = 0;
1837         SaveSection();
1838         SwitchSection(TEXT);
1839         activecpu = CPU_68000;
1840         return 0;
1841 }
1842
1843
1844 //
1845 // .68020 - Back to 68000 TEXT segment and select 68020
1846 //
1847 int d_68020(void)
1848 {
1849         d_68000();
1850         activecpu = CPU_68020;
1851         return 0;
1852 }
1853
1854
1855 //
1856 // .68030 - Back to 68000 TEXT segment and select 68030
1857 //
1858 int d_68030(void)
1859 {
1860         d_68000();
1861         activecpu = CPU_68030;
1862         return 0;
1863 }
1864
1865
1866 //
1867 // .68040 - Back to 68000 TEXT segment and select 68040
1868 //
1869 int d_68040(void)
1870 {
1871         d_68000();
1872         activecpu = CPU_68040;
1873         activefpu = FPU_68040;
1874         return 0;
1875 }
1876
1877
1878 //
1879 // .68060 - Back to 68000 TEXT segment and select 68060
1880 //
1881 int d_68060(void)
1882 {
1883         d_68000();
1884         activecpu = CPU_68060;
1885         activefpu = FPU_68060;
1886         return 0;
1887 }
1888
1889
1890 //
1891 // .68881 - Back to 680x0 TEXT segment and select 68881 FPU
1892 //
1893 int d_68881(void)
1894 {
1895         //d_68000();
1896         activefpu = FPU_68881;
1897         return 0;
1898 }
1899
1900
1901 //
1902 // .68882 - Back to 680x0 TEXT segment and select 68882 FPU
1903 //
1904 int d_68882(void)
1905 {
1906         //d_68000();
1907         activefpu = FPU_68882;
1908         return 0;
1909 }
1910
1911
1912 //
1913 // nofpu - Deselect FPUs.
1914 //
1915 int d_nofpu(void)
1916 {
1917         activefpu = FPU_NONE;
1918         return 0;
1919 }
1920
1921
1922 //
1923 // .56001 - Switch to DSP56001 assembler
1924 //
1925 int d_56001(void)
1926 {
1927         dsp56001 = 1;
1928         rgpu = rdsp = robjproc = 0;
1929         SaveSection();
1930
1931         if ((obj_format == LOD) || (obj_format == P56))
1932                 SwitchSection(M56001P);
1933
1934         return 0;
1935 }
1936
1937
1938 //
1939 // .gpu - Switch to GPU assembler
1940 //
1941 int d_gpu(void)
1942 {
1943         if ((cursect != TEXT) && (cursect != DATA))
1944         {
1945                 error(".gpu can only be used in the TEXT or DATA segments");
1946                 return ERROR;
1947         }
1948
1949         // If previous section was DSP or 68000 then we need to reset ORG'd Addresses
1950         if (!rgpu)
1951         {
1952                 orgactive = 0;
1953                 orgwarning = 0;
1954         }
1955
1956         rgpu = 1;                       // Set GPU assembly
1957         rdsp = 0;                       // Unset DSP assembly
1958         robjproc = 0;           // Unset OP assembly
1959         dsp56001 = 0;           // Unset 56001 assembly
1960         regbank = BANK_N;       // Set no default register bank
1961         return 0;
1962 }
1963
1964
1965 //
1966 // .dsp - Switch to DSP assembler
1967 //
1968 int d_dsp(void)
1969 {
1970         if ((cursect != TEXT) && (cursect != DATA))
1971         {
1972                 error(".dsp can only be used in the TEXT or DATA segments");
1973                 return ERROR;
1974         }
1975
1976         // If previous section was gpu or 68000 then we need to reset ORG'd Addresses
1977         if (!rdsp)
1978         {
1979                 orgactive = 0;
1980                 orgwarning = 0;
1981         }
1982
1983         rdsp = 1;                       // Set DSP assembly
1984         rgpu = 0;                       // Unset GPU assembly
1985         robjproc = 0;           // Unset OP assembly
1986         dsp56001 = 0;           // Unset 56001 assembly
1987         regbank = BANK_N;       // Set no default register bank
1988         return 0;
1989 }
1990
1991
1992 //
1993 // .cargs [#offset], symbol[.size], ...
1994 //
1995 // Lists of registers may also be mentioned; they just take up space. Good for
1996 // "documentation" purposes:
1997 //
1998 // .cargs a6, .arg1, .arg2, .arg3...
1999 //
2000 // Symbols thus created are ABS and EQUATED.
2001 //
2002 int d_cargs(void)
2003 {
2004         uint64_t eval = 4;      // Default to 4 if no offset specified (to account for
2005                                                 // return address)
2006         WORD rlist;
2007         SYM * symbol;
2008         char * p;
2009         int env;
2010         int i;
2011
2012         if (rgpu || rdsp)
2013                 return error("directive forbidden in gpu/dsp mode");
2014
2015         if (*tok == '#')
2016         {
2017                 tok++;
2018
2019                 if (abs_expr(&eval) != OK)
2020                         return 0;
2021
2022                 // Eat the comma, if it's there
2023                 if (*tok == ',')
2024                         tok++;
2025         }
2026
2027         for(;;)
2028         {
2029                 if (*tok == SYMBOL)
2030                 {
2031                         p = string[tok[1]];
2032
2033                         // Set env to either local (dot prefixed) or global scope
2034                         env = (*p == '.' ? curenv : 0);
2035                         symbol = lookup(p, LABEL, env);
2036
2037                         if (symbol == NULL)
2038                         {
2039                                 symbol = NewSymbol(p, LABEL, env);
2040                                 symbol->sattr = 0;
2041                         }
2042                         else if (symbol->sattr & DEFINED)
2043                                 return error("multiply-defined label '%s'", p);
2044
2045                         // Put symbol in "order of definition" list
2046                         AddToSymbolDeclarationList(symbol);
2047
2048                         symbol->sattr |= (ABS | DEFINED | EQUATED);
2049                         symbol->svalue = eval;
2050                         tok += 2;
2051
2052                         // What this does is eat any dot suffixes attached to a symbol. If
2053                         // it's a .L, it adds 4 to eval; if it's .W or .B, it adds 2. If
2054                         // there is no dot suffix, it assumes a size of 2.
2055                         switch ((int)*tok)
2056                         {
2057                         case DOTL:
2058                                 eval += 2;
2059                         case DOTB:
2060                         case DOTW:
2061                                 tok++;
2062                         }
2063
2064                         eval += 2;
2065                 }
2066                 else if (*tok >= KW_D0 && *tok <= KW_A7)
2067                 {
2068                         if (reglist(&rlist) < 0)
2069                                 return 0;
2070
2071                         for(i=0; i<16; i++, rlist>>=1)
2072                         {
2073                                 if (rlist & 1)
2074                                         eval += 4;
2075                         }
2076                 }
2077                 else
2078                 {
2079                         switch ((int)*tok)
2080                         {
2081                         case KW_USP:
2082                         case KW_SSP:
2083                         case KW_PC:
2084                                 eval += 2;
2085                                 // FALLTHROUGH
2086                         case KW_SR:
2087                         case KW_CCR:
2088                                 eval += 2;
2089                                 tok++;
2090                                 break;
2091                         case EOL:
2092                                 return 0;
2093                         default:
2094                                 return error(".cargs syntax");
2095                         }
2096                 }
2097
2098                 // Eat commas in between each argument, if they exist
2099                 if (*tok == ',')
2100                         tok++;
2101         }
2102 }
2103
2104
2105 //
2106 // .cstruct [#offset], symbol[.size], ...
2107 //
2108 // Lists of registers may also be mentioned; they just take up space. Good for
2109 // "documentation" purposes:
2110 //
2111 // .cstruct a6, .arg1, .arg2, .arg3...
2112 //
2113 // Symbols thus created are ABS and EQUATED. Note that this is for
2114 // compatibility with VBCC and the Remover's library. Thanks to GroovyBee for
2115 // the suggestion.
2116 //
2117 int d_cstruct(void)
2118 {
2119         uint64_t eval = 0;      // Default, if no offset specified, is zero
2120         WORD rlist;
2121         SYM * symbol;
2122         char * symbolName;
2123         int env;
2124         int i;
2125
2126         if (rgpu || rdsp)
2127                 return error("directive forbidden in gpu/dsp mode");
2128
2129         if (*tok == '#')
2130         {
2131                 tok++;
2132
2133                 if (abs_expr(&eval) != OK)
2134                         return 0;
2135
2136                 // Eat the comma, if it's there
2137                 if (*tok == ',')
2138                         tok++;
2139         }
2140
2141         for(;;)
2142         {
2143                 if (*tok == SYMBOL)
2144                 {
2145                         symbolName = string[tok[1]];
2146
2147                         // Set env to either local (dot prefixed) or global scope
2148                         env = (symbolName[0] == '.' ? curenv : 0);
2149                         symbol = lookup(symbolName, LABEL, env);
2150
2151                         // If the symbol wasn't found, then define it. Otherwise, throw an
2152                         // error.
2153                         if (symbol == NULL)
2154                         {
2155                                 symbol = NewSymbol(symbolName, LABEL, env);
2156                                 symbol->sattr = 0;
2157                         }
2158                         else if (symbol->sattr & DEFINED)
2159                                 return error("multiply-defined label '%s'", symbolName);
2160
2161                         // Put symbol in "order of definition" list
2162                         AddToSymbolDeclarationList(symbol);
2163
2164                         tok += 2;
2165
2166                         // Adjust label start address if it's a word or a long, as a byte
2167                         // label might have left us on an odd address.
2168                         switch ((int)*tok)
2169                         {
2170                         case DOTW:
2171                         case DOTL:
2172                                 eval += eval & 0x01;
2173                         }
2174
2175                         symbol->sattr |= (ABS | DEFINED | EQUATED);
2176                         symbol->svalue = eval;
2177
2178                         // Check for dot suffixes and adjust space accordingly (longs and
2179                         // words on an odd boundary get bumped to the next word aligned
2180                         // address). If no suffix, then throw an error.
2181                         switch ((int)*tok)
2182                         {
2183                         case DOTL:
2184                                 eval += 4;
2185                                 break;
2186                         case DOTW:
2187                                 eval += 2;
2188                                 break;
2189                         case DOTB:
2190                                 eval += 1;
2191                                 break;
2192                         default:
2193                                 return error("Symbol missing dot suffix in .cstruct construct");
2194                         }
2195
2196                         tok++;
2197                 }
2198                 else if (*tok >= KW_D0 && *tok <= KW_A7)
2199                 {
2200                         if (reglist(&rlist) < 0)
2201                                 return 0;
2202
2203                         for(i=0; i<16; i++, rlist>>=1)
2204                         {
2205                                 if (rlist & 1)
2206                                         eval += 4;
2207                         }
2208                 }
2209                 else
2210                 {
2211                         switch ((int)*tok)
2212                         {
2213                         case KW_USP:
2214                         case KW_SSP:
2215                         case KW_PC:
2216                                 eval += 2;
2217                                 // FALLTHROUGH
2218                         case KW_SR:
2219                         case KW_CCR:
2220                                 eval += 2;
2221                                 tok++;
2222                                 break;
2223                         case EOL:
2224                                 return 0;
2225                         default:
2226                                 return error(".cstruct syntax");
2227                         }
2228                 }
2229
2230                 // Eat commas in between each argument, if they exist
2231                 if (*tok == ',')
2232                         tok++;
2233         }
2234 }
2235
2236
2237 //
2238 // Define start of OP object list (allows the use of ORG)
2239 //
2240 int d_objproc(void)
2241 {
2242         if ((cursect != TEXT) && (cursect != DATA))
2243         {
2244                 error(".objproc can only be used in the TEXT or DATA segments");
2245                 return ERROR;
2246         }
2247
2248         // If previous section was DSP or 68000 then we need to reset ORG'd
2249         // Addresses
2250         if (!robjproc)
2251         {
2252                 orgactive = 0;
2253                 orgwarning = 0;
2254         }
2255
2256         robjproc = 1;           // Set OP assembly
2257         rgpu = 0;                       // Unset GPU assembly
2258         rdsp = 0;                       // Unset DSP assembly
2259         dsp56001 = 0;           // Unset 56001 assembly
2260         return OK;
2261 }
2262
2263
2264 //
2265 // Undefine a macro - .undefmac macname [, macname...]
2266 //
2267 int undmac1(char * p)
2268 {
2269         SYM * symbol = lookup(p, MACRO, 0);
2270
2271         // If the macro symbol exists, cause it to disappear
2272         if (symbol != NULL)
2273                 symbol->stype = (BYTE)SY_UNDEF;
2274
2275         return OK;
2276 }
2277
2278
2279 int d_undmac(void)
2280 {
2281         symlist(undmac1);
2282         return 0;
2283 }
2284
2285
2286 int d_jpad(void)
2287 {
2288         warn("JPAD directive is deprecated/non-functional");
2289         return OK;
2290 }
2291
2292
2293 int d_nojpad(void)
2294 {
2295         warn("NOJPAD directive is deprecated/non-functional");
2296         return OK;
2297 }
2298
2299
2300 int d_gpumain(void)
2301 {
2302         return error("What the hell? Do you think we adhere to the Goof standard?");
2303 }
2304
2305
2306 //
2307 // .opt - turn a specific (or all) optimisation on or off
2308 //
2309 int d_opt(void)
2310 {
2311         while (*tok != EOL)
2312         {
2313                 if (*tok == STRING)
2314                 {
2315                         tok++;
2316                         char * tmpstr = string[*tok++];
2317
2318                         if (ParseOptimization(tmpstr) != OK)
2319                                 return error("unknown optimization flag '%s'", tmpstr);
2320                 }
2321                 else
2322                         return error(".opt directive needs every switch enclosed inside quotation marks");
2323         }
2324
2325         return OK;
2326 }
2327
2328
2329 //
2330 // .if, Start conditional assembly
2331 //
2332 int d_if(void)
2333 {
2334         WORD eattr;
2335         uint64_t eval;
2336         SYM * esym;
2337         IFENT * rif = f_ifent;
2338
2339         // Alloc an IFENTRY
2340         if (rif == NULL)
2341                 rif = (IFENT *)malloc(sizeof(IFENT));
2342         else
2343                 f_ifent = rif->if_prev;
2344
2345         rif->if_prev = ifent;
2346         ifent = rif;
2347
2348         if (!disabled)
2349         {
2350                 if (expr(exprbuf, &eval, &eattr, &esym) != OK)
2351                         return 0;
2352
2353                 if ((eattr & DEFINED) == 0)
2354                         return error(undef_error);
2355
2356                 disabled = !eval;
2357         }
2358
2359         rif->if_state = (WORD)disabled;
2360         return 0;
2361 }
2362
2363
2364 //
2365 // .else, Do alternate case for .if
2366 //
2367 int d_else(void)
2368 {
2369         IFENT * rif = ifent;
2370
2371         if (rif->if_prev == NULL)
2372                 return error("mismatched .else");
2373
2374         if (disabled)
2375                 disabled = rif->if_prev->if_state;
2376         else
2377                 disabled = 1;
2378
2379         rif->if_state = (WORD)disabled;
2380         return 0;
2381 }
2382
2383
2384 //
2385 // .endif, End of conditional assembly block
2386 // This is also called by fpop() to pop levels of IFENTs in case a macro or
2387 // include file exits early with `exitm' or `end'.
2388 //
2389 int d_endif(void)
2390 {
2391         IFENT * rif = ifent;
2392
2393         if (rif->if_prev == NULL)
2394                 return error("mismatched .endif");
2395
2396         ifent = rif->if_prev;
2397         disabled = rif->if_prev->if_state;
2398         rif->if_prev = f_ifent;
2399         f_ifent = rif;
2400         return 0;
2401 }
2402