31852c8e2f9213c3a3a0e3735406aa9c57b95fab
[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 "riscasm.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
25 TOKEN exprbuf[128];                     // Expression buffer 
26 SYM * symbolPtr[1000000];       // Symbol pointers table
27 static long unused;                     // For supressing 'write' warnings
28
29
30 // Directive handler table
31 int (*dirtab[])() = {
32         d_org,                          // 0 org
33         d_even,                         // 1 even
34         d_unimpl,                       // 2 .6502
35         d_68000,                        // 3 .68000 
36         d_bss,                          // 4 bss
37         d_data,                         // 5 data 
38         d_text,                         // 6 text 
39         d_abs,                          // 7 abs 
40         d_comm,                         // 8 comm 
41         d_init,                         // 9 init 
42         d_cargs,                        // 10 cargs 
43         d_goto,                         // 11 goto 
44         d_dc,                           // 12 dc 
45         d_ds,                           // 13 ds 
46         d_undmac,                       // 14 undefmac 
47         d_gpu,                          // 15 .gpu
48         d_dsp,                          // 16 .dsp
49         d_dcb,                          // 17 dcb 
50         d_unimpl,                       // 18* set 
51         d_unimpl,                       // 19* reg 
52         d_unimpl,                       // 20 dump 
53         d_incbin,                       // 21 .incbin //load 
54         d_unimpl,                       // 22 disable 
55         d_unimpl,                       // 23 enable 
56         d_globl,                        // 24 globl 
57         d_regbank0,                     // 25 .regbank0
58         d_regbank1,                     // 26 .regbank1
59         d_unimpl,                       // 27 xdef 
60         d_assert,                       // 28 assert 
61         d_unimpl,                       // 29* if 
62         d_unimpl,                       // 30* endif 
63         d_unimpl,                       // 31* endc 
64         d_unimpl,                       // 32* iif 
65         d_include,                      // 33 include 
66         fpop,                           // 34 end 
67         d_unimpl,                       // 35* macro 
68         ExitMacro,                      // 36* exitm 
69         d_unimpl,                       // 37* endm 
70         d_list,                         // 38 list 
71         d_nlist,                        // 39 nlist 
72         d_long,                         // 40* rept 
73         d_phrase,                       // 41* endr 
74         d_dphrase,                      // 42 struct 
75         d_qphrase,                      // 43 ends 
76         d_title,                        // 44 title 
77         d_subttl,                       // 45 subttl 
78         eject,                          // 46 eject 
79         d_unimpl,                       // 47 error 
80         d_unimpl,                       // 48 warn 
81         d_noclear,                      // 49 .noclear
82         d_equrundef,            // 50 .equrundef/.regundef
83         d_ccundef,                      // 51 .ccundef
84         d_print,                        // 52 .print
85         d_cstruct,                      // 53 .cstruct
86         d_jpad,                         // 54 .jpad (deprecated)
87         d_nojpad,                       // 55 .nojpad (deprecated)
88 };
89
90
91 //
92 // .org - Set origin
93 //
94 int d_org(void)
95 {
96         VALUE address;
97
98         if (!rgpu && !rdsp) 
99                 return error(".org permitted only in gpu/dsp section");
100
101         orgaddr = 0;
102
103         if (abs_expr(&address) == ERROR)
104         {
105                 error("cannot determine org'd address");
106                 return ERROR;
107         }
108
109         orgaddr = address;
110         orgactive = 1;  
111
112         return 0;
113 }
114
115
116 //
117 // Print Directive
118 //
119 int d_print(void)
120 {
121         char prntstr[LNSIZ];                                     // String for PRINT directive
122         char format[LNSIZ];                                      // Format for PRINT directive
123         int formatting = 0;                                      // Formatting on/off
124         int wordlong = 0;                                        // WORD = 0, LONG = 1
125         int outtype = 0;                                         // 0:hex, 1:decimal, 2:unsigned
126
127         VALUE eval;                                              // Expression value
128         WORD eattr;                                              // Expression attributes
129         SYM * esym;                                              // External symbol involved in expr.
130         TOKEN r_expr[EXPRSIZE];
131
132         while (*tok != EOL)
133         {
134                 switch(*tok)
135                 {
136                 case STRING:
137 //                      sprintf(prntstr, "%s", (char *)tok[1]);
138                         sprintf(prntstr, "%s", string[tok[1]]);
139                         printf("%s", prntstr);
140
141                         if (list_fd) 
142                                 unused = write(list_fd, prntstr, (LONG)strlen(prntstr));
143
144                         tok += 2;
145                         break;
146                 case '/':
147                         formatting = 1;
148
149                         if (tok[1] != SYMBOL)
150                                 goto token_err;
151
152 //                      strcpy(prntstr, (char *)tok[2]);
153                         strcpy(prntstr, string[tok[2]]);
154
155                         switch(prntstr[0])
156                         {
157                         case 'l': case 'L': wordlong = 1; break;
158                         case 'w': case 'W': wordlong = 0; break;
159                         case 'x': case 'X': outtype  = 0; break;
160                         case 'd': case 'D': outtype  = 1; break;
161                         case 'u': case 'U': outtype  = 2; break;
162                         default:
163                                 error("unknown print format flag");
164                                 return ERROR;
165                         }
166
167                         tok += 3;
168                         break;
169                 case ',':
170                         tok++;
171                         break;
172                 default:
173                         if (expr(r_expr, &eval, &eattr, &esym) != OK)
174                                 goto token_err;
175                         else
176                         {
177                                 switch(outtype)
178                                 {
179                                 case 0: strcpy(format, "%X"); break; 
180                                 case 1: strcpy(format, "%d" ); break; 
181                                 case 2: strcpy(format, "%u" ); break; 
182                                 }
183
184                                 if (wordlong)
185                                         sprintf(prntstr, format, eval);
186                                 else
187                                         sprintf(prntstr, format, eval & 0xFFFF);
188
189                                 printf("%s", prntstr);
190
191                                 if (list_fd) 
192                                         unused = write(list_fd, prntstr, (LONG)strlen(prntstr));
193
194                                 formatting = 0;
195                                 wordlong = 0;
196                                 outtype = 0;
197                         }
198
199                         break;
200                 }
201         }
202
203         printf("\n");
204         println("\n");
205
206         return 0;
207
208 token_err:
209         error("illegal print token");
210         return ERROR;
211 }
212
213
214 //
215 // Undefine an Equated Condition Code
216 //
217 int d_ccundef(void)
218 {
219         SYM * ccname;
220
221         // Check that we are in a RISC section
222         if (!rgpu && !rdsp)
223         {
224                 error(".ccundef must be defined in .gpu/.dsp section");
225                 return ERROR;
226         }
227
228         if (*tok != SYMBOL)
229         {
230                 error(syntax_error);
231                 return ERROR;
232         }
233
234 //      ccname = lookup((char *)tok[1], LABEL, 0);
235         ccname = lookup(string[tok[1]], LABEL, 0);
236
237         // Make sure symbol is a valid ccdef
238         if (!ccname || !(ccname->sattre & EQUATEDCC))
239         {
240                 error("invalid equated condition name specified");
241                 return ERROR;
242         }
243
244         ccname->sattre |= UNDEF_CC;
245
246         return 0;
247 }
248
249
250 //
251 // Undefine an Equated Register
252 //
253 int d_equrundef(void)
254 {
255         SYM * regname;
256
257         // Check that we are in a RISC section
258         if (!rgpu && !rdsp)
259         {
260                 error(".equrundef/.regundef must be defined in .gpu/.dsp section");
261                 return ERROR;
262         }
263
264         while (*tok != EOL)
265         {
266                 // Skip preceeding or seperating commas (if any)
267                 if (*tok == ',')
268                         tok++;
269
270                 // Check we are dealing with a symbol
271                 if (*tok != SYMBOL)
272                 {
273                         error(syntax_error);
274                         return ERROR;
275                 }
276
277                 // Lookup and undef if equated register
278 //              regname = lookup((char *)tok[1], LABEL, 0);
279                 regname = lookup(string[tok[1]], LABEL, 0);
280
281                 if (regname && (regname->sattre & EQUATEDREG))
282                         regname->sattre |= UNDEF_EQUR;
283
284                 // Skip over symbol token and address
285                 tok += 2;
286         }
287
288         return 0;
289 }
290
291
292 //
293 // Do Not Allow the Use of the CLR.L Opcode
294 //
295 int d_noclear(void)
296 {
297         return 0;
298 }
299
300
301 // 
302 // Include Binary File
303 //
304 int d_incbin(void)
305 {
306         int fd;
307         int bytes = 0;
308         long pos, size, bytesRead;
309         char msg[256];
310
311         // Check to see if we're in BSS, and, if so, throw an error
312         if (scattr & SBSS)
313         {
314                 errors("cannot include binary file \"%s\" in BSS section", string[tok[1]]);
315                 return ERROR;
316         }
317
318         if (*tok != STRING)
319         {
320                 error(syntax_error);
321                 return ERROR;
322         }
323
324         if ((fd = open(string[tok[1]],  _OPEN_INC)) < 0)
325         {
326                 errors("cannot open include binary file (%s)", string[tok[1]]);
327                 return ERROR;
328         }
329
330         size = lseek(fd, 0L, SEEK_END);
331         pos = lseek(fd, 0L, SEEK_SET);
332         chcheck(size);
333
334         DEBUG { printf("INCBIN: File '%s' is %li bytes.\n", string[tok[1]], size); }
335
336         char * fileBuffer = (char *)malloc(size);
337         bytesRead = read(fd, fileBuffer, size);
338
339         if (bytesRead != size)
340         {
341                 sprintf(msg, "was only able to read %li bytes from binary file (%s, %li bytes)", bytesRead, string[tok[1]], size);
342                 error(msg);
343                 return ERROR;
344         }
345
346 //#define D_byte(b)    {*chptr++=(char)b; ++sloc; ++ch_size; if(orgactive) ++orgaddr;}
347         memcpy(chptr, fileBuffer, size);
348         chptr += size;
349         sloc += size;
350         ch_size += size;
351
352         if (orgactive)
353                 orgaddr += size;
354
355         free(fileBuffer);
356         close(fd);
357         return 0;
358 }
359
360
361 // 
362 // Set RISC Register Banks
363 //
364 int d_regbank0(void)
365 {
366         // Set active register bank zero
367         regbank = BANK_0;
368         return 0;
369 }
370
371
372 int d_regbank1(void)
373 {
374         // Set active register bank one
375         regbank = BANK_1;
376         return 0;
377 }
378
379
380 //
381 // Adjust Location to an EVEN Value
382 //
383 int d_even(void)
384 {
385         if (sloc & 1)
386         {
387                 if ((scattr & SBSS) == 0)
388                 {
389                         chcheck(1);
390                         D_byte(0);
391                 }
392                 else
393                 {
394                         ++sloc;
395                 }
396         }
397
398         return 0;
399 }
400
401
402 //
403 // Adjust Location to an LONG Value
404 //
405 int d_long(void)
406 {
407         unsigned i;
408         unsigned val = 4;
409                         
410         i = sloc & ~(val - 1);
411
412         if (i != sloc)
413                 val = val - (sloc - i); 
414         else
415                 val = 0;
416
417         if (val)
418         {
419                 if ((scattr & SBSS) == 0)
420                 {
421                         chcheck(val);
422
423                         for(i=0; i<val; i++) 
424                                 D_byte(0);
425                 }
426                 else
427                 {
428                         sloc += val;
429                 }
430         }
431
432         return 0;
433 }
434
435
436 //
437 // Adjust Location to an PHRASE Value
438 //
439 int d_phrase(void)
440 {
441         unsigned i;
442         unsigned val = 8;
443                         
444         i = sloc & ~(val - 1);
445
446         if (i != sloc)
447                 val = val - (sloc - i); 
448         else
449                 val = 0;
450
451         if (val)
452         {
453                 if ((scattr & SBSS) == 0)
454                 {
455                         chcheck(val);
456
457                         for(i=0; i<val; i++) 
458                                 D_byte(0);
459                 }
460                 else
461                 {
462                         sloc += val;
463                 }
464         }
465
466         return 0;
467 }
468
469
470 //
471 // Adjust Location to an DPHRASE Value
472 //
473 int d_dphrase(void)
474 {
475         unsigned i;
476         unsigned val = 16;
477                         
478         i = sloc & ~(val - 1);
479
480         if (i != sloc)
481                 val = val - (sloc - i); 
482         else
483                 val = 0;
484
485         if (val)
486         {
487                 if ((scattr & SBSS) == 0)
488                 {
489                         chcheck(val);
490
491                         for(i=0; i<val; i++) 
492                                 D_byte(0);
493                 }
494                 else
495                 {
496                         sloc += val;
497                 }
498         }
499
500         return 0;
501 }
502
503
504 //
505 // Adjust Location to an QPHRASE Value
506 //
507 int d_qphrase(void)
508 {
509         unsigned i;
510         unsigned val = 32;
511                         
512         i = sloc & ~(val - 1);
513
514         if (i != sloc)
515                 val = val - (sloc - i); 
516         else
517                 val = 0;
518
519         if (val)
520         {
521                 if ((scattr & SBSS) == 0)
522                 {
523                         savsect();
524                         chcheck(val);
525
526                         for(i=0; i<val; i++) 
527                                 D_byte(0);
528                 }
529                 else
530                 {
531                         sloc += val;
532                 }
533         }
534
535         return 0;
536 }
537
538
539 //
540 // Do auto-even.  This must be called ONLY if 'sloc' is odd.
541 //
542 // This is made hairy because, if there was a label on the line, we also have
543 // to adjust its value. This won't work with more than one label on the line,
544 // which is OK since multiple labels are only allowed in AS68 kludge mode, and
545 // the C compiler is VERY paranoid and uses ".even" whenever it can
546 //
547 void auto_even(void)
548 {
549         if (scattr & SBSS)
550                 ++sloc;                                               // Bump BSS section
551         else
552                 D_byte(0)                                             // Deposit 0.b in non-BSS
553
554         if (lab_sym != NULL)                                      // Bump label if we have to
555                 ++lab_sym->svalue;
556 }
557
558
559 //
560 // Unimplemened Directive Error
561 //
562 int d_unimpl(void)
563 {
564         return error("unimplemented directive");
565 }
566
567
568 // 
569 // Return absolute (not TDB) and defined expression or return an error
570 //
571 int abs_expr(VALUE * a_eval)
572 {
573         WORD eattr;
574
575         if (expr(exprbuf, a_eval, &eattr, NULL) < 0)
576                 return ERROR;
577
578         if (!(eattr & DEFINED))
579                 return error(undef_error);
580
581         if (eattr & TDB)
582                 return error(rel_error);
583
584         return OK;
585 }
586
587
588 //
589 // Hand symbols in a symbol-list to a function (kind of like mapcar...)
590 //
591 int symlist(int(* func)())
592 {
593         char * em = "symbol list syntax";
594
595         for(;;)
596         {
597                 if (*tok != SYMBOL)
598                         return error(em);
599
600 #if 0
601                 if ((*func)(tok[1]) != OK)
602 #else
603                 if ((*func)(string[tok[1]]) != OK)
604 #endif
605                         break;
606
607                 tok += 2;
608
609                 if (*tok == EOL)
610                         break;
611
612                 if (*tok != ',')
613                         return error(em);
614
615                 ++tok;
616         }
617
618         return 0;
619 }
620
621
622 //
623 // .include "filename"
624 //
625 int d_include(void)
626 {
627         int j;
628         int i;
629         char * fn;
630         char buf[128];
631         char buf1[128];
632
633         if (*tok == STRING)                                                     // Leave strings ALONE 
634 #if 0
635                 fn = (char *)*++tok;
636 #else
637                 fn = string[*++tok];
638 #endif
639         else if (*tok == SYMBOL)                                        // Try to append ".s" to symbols
640         {
641 #if 0
642                 strcpy(buf, (char *)*++tok);
643 #else
644                 strcpy(buf, string[*++tok]);
645 #endif
646                 fext(buf, ".s", 0);
647                 fn = &buf[0];
648         }
649         else                                                                            // Punt if no STRING or SYMBOL 
650                 return error("missing filename");
651
652         // Make sure the user didn't try anything like:
653         // .include equates.s
654         if (*++tok != EOL)
655                 return error("extra stuff after filename -- enclose it in quotes");
656
657         // Attempt to open the include file in the current directory, then (if that
658         // failed) try list of include files passed in the enviroment string or by
659         // the "-d" option.
660         if ((j = open(fn, 0)) < 0)
661         {
662                 for(i=0; nthpath("RMACPATH", i, buf1)!=0; i++)
663                 {
664                         j = strlen(buf1);
665
666                         if (j > 0 && buf1[j - 1] != SLASHCHAR)  // Append path char if necessary 
667                                 strcat(buf1, SLASHSTRING);
668
669                         strcat(buf1, fn);
670
671                         if ((j = open(buf1, 0)) >= 0)
672                                 goto allright;
673                 }
674
675                 return errors("cannot open: \"%s\"", fn);
676         }
677
678 allright:
679         include(j, fn);
680         return 0;
681 }
682
683
684 //
685 // .assert expression [, expression...]
686 //
687 int d_assert(void)
688 {
689         WORD eattr;
690         VALUE eval;
691
692         for(; expr(exprbuf, &eval, &eattr, NULL)==OK; ++tok)
693         {
694                 if (!(eattr & DEFINED))
695                         return error("forward or undefined .assert");
696
697                 if (!eval)
698                         return error("assert failure");
699
700                 if (*tok != ',')
701                         break;
702         }
703
704         at_eol();
705         return 0;
706 }
707
708
709 //
710 // .globl symbol [, symbol] <<<cannot make local symbols global>>>
711 //
712 int globl1(char * p)
713 {
714         SYM *sy;
715
716         if (*p == '.')
717                 return error("cannot .globl local symbol");
718
719         if ((sy = lookup(p, LABEL, 0)) == NULL)
720         {
721                 sy = NewSymbol(p, LABEL, 0);
722                 sy->svalue = 0;
723                 sy->sattr = GLOBAL;
724         }
725         else 
726                 sy->sattr |= GLOBAL;
727
728         return OK;
729 }
730
731
732 int d_globl(void)
733 {
734         symlist(globl1);
735         return 0;
736 }
737
738
739 //
740 // .abs [expression]
741 //
742 int d_abs(void)
743 {
744         VALUE eval;
745
746         savsect();
747
748         if (*tok == EOL)
749                 eval = 0;
750         else if (abs_expr(&eval) != OK)
751                 return 0;
752
753         switchsect(ABS);
754         sloc = eval;
755         return 0;
756 }
757
758
759 //
760 // Switch Segments
761 //
762
763 int d_text(void)
764 {
765         if (rgpu || rdsp)
766                 return error("directive forbidden in gpu/dsp mode");
767
768         if (cursect != TEXT)
769         {
770                 savsect();
771                 switchsect(TEXT);
772         }
773
774         return 0;
775 }
776
777
778 int d_data(void)
779 {
780         if (rgpu || rdsp)
781                 return error("directive forbidden in gpu/dsp mode");
782
783         if (cursect != DATA)
784         {
785                 savsect();
786                 switchsect(DATA);
787         }
788
789         return 0;
790 }
791
792
793 int d_bss(void)
794 {
795         if (rgpu || rdsp)
796                 return error("directive forbidden in gpu/dsp mode");
797
798         if (cursect != BSS)
799         {
800                 savsect();
801                 switchsect(BSS);
802         }
803
804         return 0;
805 }
806
807
808 //
809 // .ds[.size] expression
810 //
811 int d_ds(WORD siz)
812 {
813 if (verb_flag)
814         printf("Directive: .ds.[size] = %u, sloc = $%X\n", siz, sloc);
815
816         VALUE eval;
817
818         // This gets kind of stupid.  This directive is disallowed in normal 68000
819         // mode ("for your own good!"), but is permitted for 6502 and Alcyon-
820         // compatibility modes. For obvious reasons, no auto-even is done in 8-bit
821         // processor modes.
822         if (as68_flag == 0 && (scattr & SBSS) == 0)
823                 return error(".ds permitted only in BSS");
824
825         if (siz != SIZB && (sloc & 1))                            // Automatic .even 
826                 auto_even();
827
828         if (abs_expr(&eval) != OK)
829                 return 0;
830
831         // In non-TDB section (BSS, ABS and M6502) just advance the location
832         // counter appropriately. In TDB sections, deposit (possibly large) chunks
833         //of zeroed memory....
834         if (scattr & SBSS)
835         {
836                 listvalue(eval);
837                 eval *= siz;
838                 sloc += eval;
839                 just_bss = 1;                                         // No data deposited (8-bit CPU mode)
840         }
841         else
842         {
843                 dep_block(eval, siz, (VALUE)0, (WORD)(DEFINED | ABS), NULL);
844         }
845
846         at_eol();
847         return 0;
848 }
849
850
851 //
852 // dc.b, dc.w / dc, dc.l
853 //
854 int d_dc(WORD siz)
855 {
856         WORD eattr;
857         VALUE eval;
858         WORD tdb;
859         WORD defined;
860         LONG i;
861         char * p;
862         int movei = 0; // movei flag for dc.i
863
864         if ((scattr & SBSS) != 0)
865                 return error("illegal initialization of section");
866
867         if ((siz != SIZB) && (sloc & 1))
868                 auto_even();
869
870         for(;; ++tok)
871         {
872                 // dc.b 'string' [,] ...
873                 if (siz == SIZB && *tok == STRING && (tok[2] == ',' || tok[2] == EOL))
874                 {
875 //                      i = strlen((const char*)tok[1]);
876                         i = strlen(string[tok[1]]);
877
878                         if ((challoc - ch_size) < i) 
879                                 chcheck(i);
880
881                         for(p=string[tok[1]]; *p!=EOS; ++p)
882                                 D_byte(*p);
883
884                         tok += 2;
885                         goto comma;
886                 }
887
888                 if (*tok == 'I')
889                 {
890                         movei = 1;
891                         tok++;
892                         siz = SIZL;
893                 }
894
895                 // dc.x <expression>
896                 if (expr(exprbuf, &eval, &eattr, NULL) != OK)
897                         return 0;
898
899                 tdb = (WORD)(eattr & TDB);
900                 defined = (WORD)(eattr & DEFINED);
901
902                 if ((challoc - ch_size) < 4)
903                         chcheck(4);
904
905                 switch (siz)
906                 {
907                 case SIZB:
908                         if (!defined)
909                         {
910                                 fixup(FU_BYTE | FU_SEXT, sloc, exprbuf);
911                                 D_byte(0);
912                         }
913                         else
914                         {
915                                 if (tdb)
916                                         return error("non-absolute byte value");
917
918                                 if (eval + 0x100 >= 0x200)
919                                         return error(range_error);
920
921                                 D_byte(eval);
922                         }
923
924                         break;
925                 case SIZW:
926                 case SIZN:
927                         if (!defined)
928                         {
929                                 fixup(FU_WORD | FU_SEXT, sloc, exprbuf);
930                                 D_word(0);
931                         }
932                         else
933                         {
934                                 if (tdb)
935                                         rmark(cursect, sloc, tdb, MWORD, NULL);
936
937                                 if (eval + 0x10000 >= 0x20000)
938                                         return error(range_error);
939
940                                 // Deposit 68000 or 6502 (byte-reversed) word 
941                                 D_word(eval);
942                         }
943
944                         break;
945                 case SIZL:
946                         if (!defined)
947                         {
948                                 if (movei)
949                                         fixup(FU_LONG | FU_MOVEI, sloc, exprbuf);
950                                 else
951                                         fixup(FU_LONG, sloc, exprbuf);
952
953                                 D_long(0);
954                         }
955                         else
956                         {
957                                 if (tdb)
958                                         rmark(cursect, sloc, tdb, MLONG, NULL);
959
960                                 if (movei) 
961                                         eval = ((eval >> 16) & 0x0000FFFF) | ((eval << 16) & 0xFFFF0000);
962
963                                 D_long(eval);
964                         }
965                         break;
966                 }
967                 
968 comma:
969                 if (*tok != ',')
970                         break;
971         }
972
973         at_eol();
974         return 0;
975 }
976
977
978 //
979 // dcb[.siz] expr1,expr2 - Make 'expr1' copies of 'expr2'
980 //
981 int d_dcb(WORD siz)
982 {
983         VALUE evalc, eval;
984         WORD eattr;
985
986         if ((scattr & SBSS) != 0)
987                 return error("illegal initialization of section");
988
989         if (abs_expr(&evalc) != OK)
990                 return 0;
991
992         if (*tok++ != ',')
993                 return error("missing comma");
994
995         if (expr(exprbuf, &eval, &eattr, NULL) < 0)
996                 return 0;
997
998         if ((siz != SIZB) && (sloc & 1))
999                 auto_even();
1000
1001         dep_block(evalc, siz, eval, eattr, exprbuf);
1002         return 0;
1003 }
1004
1005
1006 //
1007 // Generalized initialization directive
1008 // 
1009 // .init[.siz] [#count,] expression [.size] , ...
1010 // 
1011 // The size suffix on the ".init" directive becomes the default size of the
1012 // objects to deposit. If an item is preceeded with a sharp (immediate) sign
1013 // and an expression, it specifies a repeat count. The value to be deposited
1014 // may be followed by a size suffix, which overrides the default size.
1015 //
1016 int d_init(WORD def_siz)
1017 {
1018         VALUE count;
1019         VALUE eval;
1020         WORD eattr;
1021         WORD siz;
1022
1023         if ((scattr & SBSS) != 0)
1024                 return error(".init not permitted in BSS or ABS");
1025
1026         if (rgpu || rdsp)
1027                 return error("directive forbidden in gpu/dsp mode");
1028
1029         for(;;)
1030         {
1031                 // Get repeat count (defaults to 1)
1032                 if (*tok == '#')
1033                 {
1034                         ++tok;
1035
1036                         if (abs_expr(&count) != OK)
1037                                 return 0;
1038
1039                         if (*tok++ != ',')
1040                                 return error(comma_error);
1041                 }
1042                 else
1043                         count = 1;
1044
1045                 // Evaluate expression to deposit
1046                 if (expr(exprbuf, &eval, &eattr, NULL) < 0)
1047                         return 0;
1048
1049                 switch ((int)*tok++)
1050                 {                                 // Determine size of object to deposit
1051                 case DOTB: siz = SIZB; break;
1052                 case DOTW: siz = SIZB; break;
1053                 case DOTL: siz = SIZL; break;
1054                 default: 
1055                         siz = def_siz;
1056                         --tok;
1057                         break;
1058                 }
1059
1060                 dep_block(count, siz, eval, eattr, exprbuf);
1061
1062                 switch ((int)*tok)
1063                 {
1064                 case EOL:
1065                         return 0;
1066                 case ',':
1067                         ++tok;
1068                         continue;
1069                 default:
1070                         return error(comma_error);
1071                 }
1072         }
1073 }
1074
1075
1076 //
1077 // Deposit 'count' values of size 'siz' in the current (non-BSS) segment
1078 //
1079 int dep_block(VALUE count, WORD siz, VALUE eval, WORD eattr, TOKEN * exprbuf)
1080 {
1081         WORD tdb;
1082         WORD defined;
1083
1084         tdb = (WORD)(eattr & TDB);
1085         defined = (WORD)(eattr & DEFINED);
1086
1087         while (count--)
1088         {
1089                 if ((challoc - ch_size) < 4)
1090                         chcheck(4L);
1091
1092                 switch(siz)
1093                 {
1094                 case SIZB:
1095                         if (!defined)
1096                         {
1097                                 fixup(FU_BYTE | FU_SEXT, sloc, exprbuf);
1098                                 D_byte(0);
1099                         }
1100                         else
1101                         {
1102                                 if (tdb)
1103                                         return error("non-absolute byte value");
1104
1105                                 if (eval + 0x100 >= 0x200)
1106                                         return error(range_error);
1107
1108                                 D_byte(eval);
1109                         }
1110
1111                         break;
1112                 case SIZW:
1113                 case SIZN:
1114                         if (!defined)
1115                         {
1116                                 fixup(FU_WORD | FU_SEXT, sloc, exprbuf);
1117                                 D_word(0);
1118                         }
1119                         else
1120                         {
1121                                 if (tdb)
1122                                         rmark(cursect, sloc, tdb, MWORD, NULL);
1123
1124                                 if (eval + 0x10000 >= 0x20000)
1125                                         return error(range_error);
1126
1127                                 // Deposit 68000 or 6502 (byte-reversed) word
1128                                 D_word(eval);
1129                         }
1130
1131                         break;
1132                 case SIZL:
1133                         if (!defined)
1134                         {
1135                                 fixup(FU_LONG, sloc, exprbuf);
1136                                 D_long(0);
1137                         }
1138                         else
1139                         {
1140                                 if (tdb)
1141                                         rmark(cursect, sloc, tdb, MLONG, NULL);
1142
1143                                 D_long(eval);
1144                         }
1145
1146                         break;
1147                 }
1148         }
1149
1150         return 0;
1151 }
1152
1153
1154 //
1155 // .comm symbol, size
1156 //
1157 int d_comm(void)
1158 {
1159         SYM * sym;
1160         char * p;
1161         VALUE eval;
1162
1163         if (*tok != SYMBOL)
1164                 return error("missing symbol");
1165
1166 //      p = (char *)tok[1];
1167         p = string[tok[1]];
1168         tok += 2;
1169
1170         if (*p == '.')                                                  // Cannot .comm a local symbol
1171                 return error(locgl_error);
1172
1173         if ((sym = lookup(p, LABEL, 0)) == NULL)
1174                 sym = NewSymbol(p, LABEL, 0);
1175         else
1176         {
1177                 if (sym->sattr & DEFINED)
1178                         return error(".comm symbol already defined");
1179         }
1180
1181         sym->sattr = GLOBAL | COMMON | BSS;
1182
1183         if (*tok++ != ',')
1184                 return error(comma_error);
1185
1186         if (abs_expr(&eval) != OK)                              // Parse size of common region
1187                 return 0;
1188
1189         sym->svalue = eval;                                             // Install common symbol's size
1190         at_eol();
1191         return 0;
1192 }
1193
1194
1195 //
1196 // .list - Turn listing on
1197 //
1198 int d_list(void)
1199 {
1200         if (list_flag)
1201                 listing++;
1202
1203         return 0;
1204 }
1205
1206
1207 //
1208 // .nlist - Turn listing off
1209 //
1210 int d_nlist(void)
1211 {
1212         if (list_flag)
1213                 listing--;
1214
1215         return 0;
1216 }
1217
1218
1219 //
1220 // .68000 - Back to 68000 TEXT segment
1221 //
1222 int d_68000(void)
1223 {
1224         rgpu = rdsp = 0;
1225         // Switching from gpu/dsp sections should reset any ORG'd Address
1226         orgactive = 0;                               
1227         orgwarning = 0;
1228         savsect();
1229         switchsect(TEXT);
1230         return 0;
1231 }
1232
1233
1234 //
1235 // .gpu - Switch to GPU Assembler
1236 //
1237 int d_gpu(void)
1238 {
1239         if ((cursect != TEXT) && (cursect != DATA))
1240         {
1241                 error(".gpu can only be used in the TEXT or DATA segments");
1242                 return ERROR;
1243         }
1244
1245         // If previous section was dsp or 68000 then we need to reset ORG'd Addresses
1246         if (!rgpu)
1247         {
1248                 orgactive = 0;
1249                 orgwarning = 0;
1250         }
1251
1252         rgpu = 1;                       // Set GPU assembly
1253         rdsp = 0;                       // Unset DSP assembly
1254         regbank = BANK_N;       // Set no default register bank
1255         return 0;
1256 }
1257
1258
1259 //
1260 // .dsp - Switch to DSP Assembler
1261 //
1262 int d_dsp(void)
1263 {
1264         if ((cursect != TEXT) && (cursect != DATA))
1265         {
1266                 error(".dsp can only be used in the TEXT or DATA segments");
1267                 return ERROR;
1268         }
1269
1270         // If previous section was gpu or 68000 then we need to reset ORG'd Addresses
1271         if (!rdsp)
1272         {
1273                 orgactive = 0;
1274                 orgwarning = 0;
1275         }
1276
1277         rdsp = 1;                       // Set DSP assembly
1278         rgpu = 0;                       // Unset GPU assembly
1279         regbank = BANK_N;       // Set no default register bank
1280         return 0;
1281 }
1282
1283
1284 //
1285 // .cargs [#offset], symbol[.size], ...
1286 // 
1287 // Lists of registers may also be mentioned; they just take up space. Good for
1288 // "documentation" purposes:
1289 // 
1290 // .cargs a6, .arg1, .arg2, .arg3...
1291 // 
1292 // Symbols thus created are ABS and EQUATED.
1293 //
1294 int d_cargs(void)
1295 {
1296         VALUE eval = 4;         // Default to 4 if no offset specified (to account for
1297                                                 // return address)
1298         WORD rlist;
1299         SYM * symbol;
1300         char * p;
1301         int env;
1302         int i;
1303
1304         if (rgpu || rdsp)
1305                 return error("directive forbidden in gpu/dsp mode");
1306
1307         if (*tok == '#')
1308         {
1309                 tok++;
1310
1311                 if (abs_expr(&eval) != OK)
1312                         return 0;
1313
1314                 // Eat the comma, if it's there
1315                 if (*tok == ',')
1316                         tok++;
1317         }
1318
1319         for(;;)
1320         {
1321                 if (*tok == SYMBOL)
1322                 {
1323 //                      p = (char *)tok[1];
1324                         p = string[tok[1]];
1325
1326 #if 0
1327                         if (*p == '.')
1328                                 env = curenv;                   // Label is local
1329                         else
1330                                 env = 0;                                // Label is global
1331 #else
1332                         // Set env to either local (dot prefixed) or global scope
1333                         env = (*p == '.' ? curenv : 0);
1334 #endif
1335                         symbol = lookup(p, LABEL, env);
1336
1337                         if (symbol == NULL)
1338                         {
1339                                 symbol = NewSymbol(p, LABEL, env);
1340                                 symbol->sattr = 0;
1341                         }
1342                         else if (symbol->sattr & DEFINED)
1343                                 return errors("multiply-defined label '%s'", p);
1344
1345                         // Put symbol in "order of definition" list
1346                         if (!(symbol->sattr & SDECLLIST))
1347                                 sym_decl(symbol);
1348
1349                         symbol->sattr |= (ABS | DEFINED | EQUATED);
1350                         symbol->svalue = eval;
1351                         tok += 2;
1352
1353                         // What this does is eat any dot suffixes attached to a symbol. If
1354                         // it's a .L, it adds 4 to eval; if it's .W or .B, it adds 2. If
1355                         // there is no dot suffix, it assumes a size of 2.
1356                         switch ((int)*tok)
1357                         {
1358                         case DOTL:
1359                                 eval += 2;
1360                         case DOTB:
1361                         case DOTW:
1362                                 tok++;
1363                         }
1364
1365                         eval += 2;
1366                 }
1367                 else if (*tok >= KW_D0 && *tok <= KW_A7)
1368                 {
1369                         if (reglist(&rlist) < 0)
1370                                 return 0;
1371
1372 //                      for(i=0; i++<16; rlist>>=1)
1373                         for(i=0; i<16; i++, rlist>>=1)
1374                         {
1375                                 if (rlist & 1)
1376                                         eval += 4;
1377                         }
1378                 }
1379                 else
1380                 {
1381                         switch ((int)*tok)
1382                         {
1383                         case KW_USP:
1384                         case KW_SSP:
1385                         case KW_PC:
1386                                 eval += 2;
1387                                 // FALLTHROUGH
1388                         case KW_SR:
1389                         case KW_CCR:
1390                                 eval += 2;
1391                                 tok++;
1392                                 break;
1393                         case EOL:
1394                                 return 0;
1395                         default:
1396                                 return error(".cargs syntax");
1397                         }
1398                 }
1399
1400                 // Eat commas in between each argument, if they exist
1401                 if (*tok == ',')
1402                         tok++;
1403         }
1404 }
1405
1406
1407 //
1408 // .cstruct [#offset], symbol[.size], ...
1409 // 
1410 // Lists of registers may also be mentioned; they just take up space. Good for
1411 // "documentation" purposes:
1412 // 
1413 // .cstruct a6, .arg1, .arg2, .arg3...
1414 // 
1415 // Symbols thus created are ABS and EQUATED. Note that this is for
1416 // compatibility with VBCC and the Remover's library. Thanks to GroovyBee for
1417 // the suggestion.
1418 //
1419 int d_cstruct(void)
1420 {
1421         VALUE eval = 0;         // Default, if no offset specified, is zero
1422         WORD rlist;
1423         SYM * symbol;
1424         char * symbolName;
1425         int env;
1426         int i;
1427
1428         if (rgpu || rdsp)
1429                 return error("directive forbidden in gpu/dsp mode");
1430
1431         if (*tok == '#')
1432         {
1433                 tok++;
1434
1435                 if (abs_expr(&eval) != OK)
1436                         return 0;
1437
1438                 // Eat the comma, if it's there
1439                 if (*tok == ',')
1440                         tok++;
1441         }
1442
1443         for(;;)
1444         {
1445                 if (*tok == SYMBOL)
1446                 {
1447                         symbolName = string[tok[1]];
1448
1449                         // Set env to either local (dot prefixed) or global scope
1450                         env = (symbolName[0] == '.' ? curenv : 0);
1451                         symbol = lookup(symbolName, LABEL, env);
1452
1453                         // If the symbol wasn't found, then define it. Otherwise, throw an
1454                         // error.
1455                         if (symbol == NULL)
1456                         {
1457                                 symbol = NewSymbol(symbolName, LABEL, env);
1458                                 symbol->sattr = 0;
1459                         }
1460                         else if (symbol->sattr & DEFINED)
1461                                 return errors("multiply-defined label '%s'", symbolName);
1462
1463                         // Put symbol in "order of definition" list
1464                         if (!(symbol->sattr & SDECLLIST))
1465                                 sym_decl(symbol);
1466
1467                         tok += 2;
1468
1469                         // Adjust label start address if it's a word or a long, as a byte
1470                         // label might have left us on an odd address.
1471                         switch ((int)*tok)
1472                         {
1473                         case DOTW:
1474                         case DOTL:
1475                                 eval += eval & 0x01;
1476                         }
1477
1478                         symbol->sattr |= (ABS | DEFINED | EQUATED);
1479                         symbol->svalue = eval;
1480
1481                         // Check for dot suffixes and adjust space accordingly (longs and
1482                         // words on an odd boundary get bumped to the next word aligned
1483                         // address). If no suffix, then throw an error.
1484                         switch ((int)*tok)
1485                         {
1486                         case DOTL:
1487                                 eval += 4;
1488                                 break;
1489                         case DOTW:
1490                                 eval += 2;
1491                                 break;
1492                         case DOTB:
1493                                 eval += 1;
1494                                 break;
1495                         default:
1496                                 return error("Symbol missing dot suffix in .cstruct construct");
1497                         }
1498
1499                         tok++;
1500                 }
1501                 else if (*tok >= KW_D0 && *tok <= KW_A7)
1502                 {
1503                         if (reglist(&rlist) < 0)
1504                                 return 0;
1505
1506                         for(i=0; i<16; i++, rlist>>=1)
1507                         {
1508                                 if (rlist & 1)
1509                                         eval += 4;
1510                         }
1511                 }
1512                 else
1513                 {
1514                         switch ((int)*tok)
1515                         {
1516                         case KW_USP:
1517                         case KW_SSP:
1518                         case KW_PC:
1519                                 eval += 2;
1520                                 // FALLTHROUGH
1521                         case KW_SR:
1522                         case KW_CCR:
1523                                 eval += 2;
1524                                 tok++;
1525                                 break;
1526                         case EOL:
1527                                 return 0;
1528                         default:
1529                                 return error(".cstruct syntax");
1530                         }
1531                 }
1532
1533                 // Eat commas in between each argument, if they exist
1534                 if (*tok == ',')
1535                         tok++;
1536         }
1537 }
1538
1539
1540 //
1541 // Undefine a macro - .undefmac macname [, macname...]
1542 //
1543 int undmac1(char * p)
1544 {
1545         SYM * symbol = lookup(p, MACRO, 0);
1546
1547         // If the macro symbol exists, cause it to disappear
1548 //      if ((sy = lookup(p, MACRO, 0)) != NULL)
1549         if (symbol != NULL)
1550                 symbol->stype = (BYTE)SY_UNDEF;
1551
1552         return OK;
1553 }
1554
1555
1556 int d_undmac(void)
1557 {
1558         symlist(undmac1);
1559         return 0;
1560 }
1561
1562
1563 int d_jpad(void)
1564 {
1565         warn("JPAD directive is deprecated/non-functional");
1566         return OK;
1567 }
1568
1569
1570 int d_nojpad(void)
1571 {
1572         warn("NOJPAD directive is deprecated/non-functional");
1573         return OK;
1574 }
1575