|
0
|
1 /* A09, 6809 Assembler.
|
|
|
2
|
|
|
3 created 1993,1994 by L.C. Benschop.
|
|
|
4 copyleft (c) 1994-2014 by the sbc09 team, see AUTHORS for more details.
|
|
|
5 license: GNU General Public License version 2, see LICENSE for more details.
|
|
|
6 THERE IS NO WARRANTY ON THIS PROGRAM.
|
|
|
7
|
|
|
8 Generates binary image file from the lowest to
|
|
|
9 the highest address with actually assembled data.
|
|
|
10
|
|
|
11 Machine dependencies:
|
|
|
12 char is 8 bits.
|
|
|
13 short is 16 bits.
|
|
|
14 integer arithmetic is twos complement.
|
|
|
15
|
|
|
16 syntax a09 [-o filename] [-l filename] sourcefile.
|
|
|
17
|
|
|
18 Options
|
|
|
19 -o filename name of the output file (default name minus a09 suffix)
|
|
|
20 -s filename name of the s-record output file (default its a binary file)
|
|
|
21 -l filename list file name (default no listing)
|
|
|
22 -d enable debugging
|
|
|
23
|
|
|
24 recognized pseudoops:
|
|
|
25 extern public
|
|
|
26 macro endm if else endif
|
|
|
27 org equ set setdp
|
|
|
28 fcb fcw fdb fcc rmb
|
|
|
29 end include title
|
|
|
30
|
|
|
31 Not all of these are actually IMPLEMENTED!!!!!!
|
|
|
32
|
|
|
33 Revisions:
|
|
|
34 1993-11-03 v0.1
|
|
|
35 Initial version.
|
|
|
36 1994/03/21 v0.2
|
|
|
37 Fixed PC relative addressing bug
|
|
|
38 Added SET, SETDP, INCLUDE. IF/ELSE/ENDIF
|
|
|
39 No macros yet, and no separate linkable modules.
|
|
|
40 2012-06-04 j at klasek at
|
|
|
41 New: debugging parameter/option.
|
|
|
42 Fixed additional possible issue PC relative addressing.
|
|
|
43 Compatibility: Octal number prefix "&".
|
|
|
44 2014-07-15 j at klasek at
|
|
|
45 Fixed usage message.
|
|
|
46 */
|
|
|
47
|
|
|
48 #include <stdlib.h>
|
|
|
49 #include <stdio.h>
|
|
|
50 #include <string.h>
|
|
|
51 #include <ctype.h>
|
|
|
52
|
|
|
53 #define NLABELS 2048
|
|
|
54 #define MAXIDLEN 16
|
|
|
55 #define MAXLISTBYTES 8
|
|
|
56 #define FNLEN 30
|
|
|
57 #define LINELEN 128
|
|
|
58
|
|
|
59 static int debug=0;
|
|
|
60
|
|
|
61 struct oprecord{char * name;
|
|
|
62 unsigned char cat;
|
|
|
63 unsigned short code;};
|
|
|
64
|
|
|
65 /* Instruction categories:
|
|
|
66 0 one byte oprcodes NOP
|
|
|
67 1 two byte opcodes SWI2
|
|
|
68 2 opcodes w. imm byte ANDCC
|
|
|
69 3 LEAX etc.
|
|
|
70 4 short branches. BGE
|
|
|
71 5 long branches 2byte opc LBGE
|
|
|
72 6 long branches 1byte opc LBRA
|
|
|
73 7 accumulator instr. ADDA
|
|
|
74 8 double reg instr 1byte opc LDX
|
|
|
75 9 double reg instr 2 byte opc LDY
|
|
|
76 10 single address instrs NEG
|
|
|
77 11 TFR, EXG
|
|
|
78 12 push,pull
|
|
|
79 13 pseudoops
|
|
|
80 */
|
|
|
81
|
|
|
82 struct oprecord optable[]={
|
|
|
83 {"ABX",0,0x3a},{"ADCA",7,0x89},{"ADCB",7,0xc9},
|
|
|
84 {"ADDA",7,0x8b},{"ADDB",7,0xcb},{"ADDD",8,0xc3},
|
|
|
85 {"ANDA",7,0X84},{"ANDB",7,0xc4},{"ANDCC",2,0x1c},
|
|
|
86 {"ASL",10,0x08},{"ASLA",0,0x48},{"ASLB",0,0x58},
|
|
|
87 {"ASR",10,0x07},{"ASRA",0,0x47},{"ASRB",0,0x57},
|
|
|
88 {"BCC",4,0x24},{"BCS",4,0x25},{"BEQ",4,0x27},
|
|
|
89 {"BGE",4,0x2c},{"BGT",4,0x2e},{"BHI",4,0x22},
|
|
|
90 {"BHS",4,0x24},{"BITA",7,0x85},{"BITB",7,0xc5},
|
|
|
91 {"BLE",4,0x2f},{"BLO",4,0x25},{"BLS",4,0x23},
|
|
|
92 {"BLT",4,0x2d},{"BMI",4,0x2b},{"BNE",4,0x26},
|
|
|
93 {"BPL",4,0x2a},{"BRA",4,0x20},{"BRN",4,0x21},
|
|
|
94 {"BSR",4,0x8d},
|
|
|
95 {"BVC",4,0x28},{"BVS",4,0x29},
|
|
|
96 {"CLC",1,0x1cfe},{"CLF",1,0x1cbf},{"CLI",1,0x1cef},
|
|
|
97 {"CLIF",1,0x1caf},
|
|
|
98 {"CLR",10,0x0f},{"CLRA",0,0x4f},{"CLRB",0,0x5f},
|
|
|
99 {"CLV",1,0x1cfd},
|
|
|
100 {"CMPA",7,0x81},{"CMPB",7,0xc1},{"CMPD",9,0x1083},
|
|
|
101 {"CMPS",9,0x118c},{"CMPU",9,0x1183},{"CMPX",8,0x8c},
|
|
|
102 {"CMPY",9,0x108c},
|
|
|
103 {"COM",10,0x03},{"COMA",0,0x43},{"COMB",0,0x53},
|
|
|
104 {"CWAI",2,0x3c},{"DAA",0,0x19},
|
|
|
105 {"DEC",10,0x0a},{"DECA",0,0x4a},{"DECB",0,0x5a},
|
|
|
106 {"DES",1,0x327f},{"DEU",1,0x335f},{"DEX",1,0x301f},
|
|
|
107 {"DEY",1,0x313f},
|
|
|
108 {"ELSE",13,1},
|
|
|
109 {"EMOD",13,25},
|
|
|
110 {"END",13,2},
|
|
|
111 {"ENDC",13,3},
|
|
|
112 {"ENDIF",13,3},
|
|
|
113 {"ENDM",13,4},
|
|
|
114 {"EORA",7,0x88},{"EORB",7,0xc8},
|
|
|
115 {"EQU",13,5},{"EXG",11,0x1e},{"EXTERN",13,6},
|
|
|
116 {"FCB",13,7},{"FCC",13,8},
|
|
|
117 {"FCS",13,23},
|
|
|
118 {"FCW",13,9},
|
|
|
119 {"FDB",13,9},
|
|
|
120 {"IF",13,10},
|
|
|
121 {"IFEQ",13,29},
|
|
|
122 {"IFGT",13,30},
|
|
|
123 {"IFNE",13,28},
|
|
|
124 {"IFP1",13,21},
|
|
|
125 {"INC",10,0x0c},{"INCA",0,0x4c},{"INCB",0,0x5c},
|
|
|
126 {"INCLUDE",13,16},
|
|
|
127 {"INS",1,0x3261},{"INU",1,0x3341},{"INX",1,0x3001},
|
|
|
128 {"INY",1,0x3121},{"JMP",10,0x0e},{"JSR",8,0x8d},
|
|
|
129 {"LBCC",5,0x1024},{"LBCS",5,0x1025},{"LBEQ",5,0x1027},
|
|
|
130 {"LBGE",5,0x102c},{"LBGT",5,0x102e},{"LBHI",5,0x1022},
|
|
|
131 {"LBHS",5,0x1024},
|
|
|
132 {"LBLE",5,0x102f},{"LBLO",5,0x1025},{"LBLS",5,0x1023},
|
|
|
133 {"LBLT",5,0x102d},{"LBMI",5,0x102b},{"LBNE",5,0x1026},
|
|
|
134 {"LBPL",5,0x102a},{"LBRA",6,0x16},{"LBRN",5,0x1021},
|
|
|
135 {"LBSR",6,0x17},
|
|
|
136 {"LBVC",5,0x1028},{"LBVS",5,0x1029},
|
|
|
137 {"LDA",7,0x86},{"LDB",7,0xc6},{"LDD",8,0xcc},
|
|
|
138 {"LDS",9,0x10ce},{"LDU",8,0xce},{"LDX",8,0x8e},
|
|
|
139 {"LDY",9,0x108e},{"LEAS",3,0x32},
|
|
|
140 {"LEAU",3,0x33},{"LEAX",3,0x30},{"LEAY",3,0x31},
|
|
|
141 {"LSL",10,0x08},{"LSLA",0,0x48},{"LSLB",0,0x58},
|
|
|
142 {"LSR",10,0x04},{"LSRA",0,0x44},{"LSRB",0,0x54},
|
|
|
143 {"MACRO",13,11},
|
|
|
144 {"MOD",13,24},
|
|
|
145 {"MUL",0,0x3d},
|
|
|
146 {"NAM",13,26},
|
|
|
147 {"NEG",10,0x00},{"NEGA",0,0x40},{"NEGB",0,0x50},
|
|
|
148 {"NOP",0,0x12},
|
|
|
149 {"OPT",13,19},
|
|
|
150 {"ORA",7,0x8a},{"ORB",7,0xca},{"ORCC",2,0x1a},
|
|
|
151 {"ORG",13,12},
|
|
|
152 {"OS9",13,32},
|
|
|
153 {"PAG",13,20}, {"PAGE",13,20},
|
|
|
154 {"PSHS",12,0x34},{"PSHU",12,0x36},{"PUBLIC",13,13},
|
|
|
155 {"PULS",12,0x35},{"PULU",12,0x37},{"RMB",13,0},
|
|
|
156 {"ROL",10,0x09},{"ROLA",0,0x49},{"ROLB",0,0x59},
|
|
|
157 {"ROR",10,0x06},{"RORA",0,0x46},{"RORB",0,0x56},
|
|
|
158 {"RTI",0,0x3b},{"RTS",0,0x39},
|
|
|
159 {"SBCA",7,0x82},{"SBCB",7,0xc2},
|
|
|
160 {"SEC",1,0x1a01},{"SEF",1,0x1a40},{"SEI",1,0x1a10},
|
|
|
161 {"SEIF",1,0x1a50},{"SET",13,15},
|
|
|
162 {"SETDP",13,14},{"SEV",1,0x1a02},{"SEX",0,0x1d},
|
|
|
163 {"STA",7,0x87},{"STB",7,0xc7},{"STD",8,0xcd},
|
|
|
164 {"STS",9,0x10cf},{"STU",8,0xcf},{"STX",8,0x8f},
|
|
|
165 {"STY",9,0x108f},
|
|
|
166 {"SUBA",7,0x80},{"SUBB",7,0xc0},{"SUBD",8,0x83},
|
|
|
167 {"SWI",0,0x3f},{"SWI2",1,0x103f},{"SWI3",1,0x113f},
|
|
|
168 {"SYNC",0,0x13},{"TFR",11,0x1f},
|
|
|
169 {"TITLE",13,18},
|
|
|
170 {"TST",10,0x0d},{"TSTA",0,0x4d},{"TSTB",0,0x5d},
|
|
|
171 {"TTL",13,18},
|
|
|
172 {"USE",13,27},
|
|
|
173 };
|
|
|
174
|
|
|
175 struct symrecord{char name[MAXIDLEN+1];
|
|
|
176 char cat;
|
|
|
177 unsigned short value;
|
|
|
178 };
|
|
|
179
|
|
|
180 int symcounter=0;
|
|
3
|
181 int os9 = 0; // os9 flag
|
|
0
|
182
|
|
|
183 /* Symbol categories.
|
|
|
184 0 Constant value (from equ).
|
|
|
185 1 Variable value (from set)
|
|
|
186 2 Address within program module (label).
|
|
|
187 3 Variable containing address.
|
|
|
188 4 Adress in other program module (extern)
|
|
|
189 5 Variable containing external address.
|
|
|
190 6 Unresolved address.
|
|
|
191 7 Variable containing unresolved address.
|
|
|
192 8 Public label.
|
|
|
193 9 Macro definition.
|
|
|
194 10 Public label (yet undefined).
|
|
|
195 11 parameter name.
|
|
|
196 12 local label.
|
|
|
197 13 empty.
|
|
|
198 */
|
|
|
199
|
|
|
200 struct symrecord symtable[NLABELS];
|
|
|
201
|
|
|
202 void processfile(char *name);
|
|
|
203
|
|
|
204 struct oprecord * findop(char * nm)
|
|
|
205 /* Find operation (mnemonic) in table using binary search */
|
|
|
206 {
|
|
|
207 int lo,hi,i,s;
|
|
|
208 lo=0;hi=sizeof(optable)/sizeof(optable[0])-1;
|
|
|
209 do {
|
|
|
210 i=(lo+hi)/2;
|
|
|
211 s=strcmp(optable[i].name,nm);
|
|
|
212 if(s<0) lo=i+1;
|
|
|
213 else if(s>0) hi=i-1;
|
|
|
214 else break;
|
|
|
215 } while(hi>=lo);
|
|
|
216 if (s) return NULL;
|
|
|
217 return optable+i;
|
|
|
218 }
|
|
|
219
|
|
|
220 struct symrecord * findsym(char * nm)
|
|
|
221 /* finds symbol table record; inserts if not found
|
|
|
222 uses binary search, maintains sorted table */
|
|
|
223 {
|
|
|
224 int lo,hi,i,j,s;
|
|
|
225 lo=0;hi=symcounter-1;
|
|
|
226 s=1;i=0;
|
|
|
227 while (hi>=lo) {
|
|
|
228 i=(lo+hi)/2;
|
|
|
229 s=strcmp(symtable[i].name,nm);
|
|
|
230 if(s<0) lo=i+1;
|
|
|
231 else if(s>0) hi=i-1;
|
|
|
232 else break;
|
|
|
233 }
|
|
|
234 if(s) {
|
|
|
235 i=(s<0?i+1:i);
|
|
|
236 if(symcounter==NLABELS) {
|
|
|
237 fprintf(stderr,"Sorry, no storage for symbols!!!");
|
|
|
238 exit(4);
|
|
|
239 }
|
|
|
240 for(j=symcounter;j>i;j--) symtable[j]=symtable[j-1];
|
|
|
241 symcounter++;
|
|
|
242 strcpy(symtable[i].name,nm);
|
|
|
243 symtable[i].cat=13;
|
|
|
244 }
|
|
|
245 return symtable+i;
|
|
|
246 }
|
|
|
247
|
|
|
248 FILE *listfile,*objfile;
|
|
|
249 char *listname,*objname,*srcname,*curname;
|
|
|
250 int lineno;
|
|
|
251
|
|
|
252 void
|
|
|
253 outsymtable()
|
|
|
254 {
|
|
|
255 int i,j=0;
|
|
|
256 fprintf(listfile,"\nSYMBOL TABLE");
|
|
|
257 for(i=0;i<symcounter;i++)
|
|
|
258 if(symtable[i].cat!=13) {
|
|
|
259 if(j%4==0)fprintf(listfile,"\n");
|
|
|
260 fprintf(listfile,"%10s %02d %04x",symtable[i].name,symtable[i].cat,
|
|
|
261 symtable[i].value);
|
|
|
262 j++;
|
|
|
263 }
|
|
|
264 fprintf(listfile,"\n");
|
|
|
265 }
|
|
|
266
|
|
|
267 struct regrecord{char *name;unsigned char tfr,psh;};
|
|
|
268 struct regrecord regtable[]=
|
|
|
269 {{"D",0x00,0x06},{"X",0x01,0x10},{"Y",0x02,0x20},
|
|
|
270 {"U",0x03,0x40},{"S",0x04,0x40},{"PC",0x05,0x80},
|
|
|
271 {"A",0x08,0x02},{"B",0x09,0x04},{"CC",0x0a,0x01},
|
|
|
272 {"CCR",0x0a,0x01},{"DP",0x0b,0x08},{"DPR",0x0b,0x08}};
|
|
|
273
|
|
|
274 struct regrecord * findreg(char *nm)
|
|
|
275 {
|
|
|
276 int i;
|
|
|
277 for(i=0;i<12;i++) {
|
|
|
278 if(strcmp(regtable[i].name,nm)==0) return regtable+i;
|
|
|
279 }
|
|
|
280 return 0;
|
|
|
281 }
|
|
|
282
|
|
|
283
|
|
|
284 char pass; /* Assembler pass=1 or 2 */
|
|
|
285 char listing; /* flag to indicate listing */
|
|
|
286 char relocatable; /* flag to indicate relocatable object. */
|
|
|
287 char terminate; /* flag to indicate termination. */
|
|
|
288 char generating; /* flag to indicate that we generate code */
|
|
|
289 unsigned short loccounter,oldlc; /* Location counter */
|
|
|
290
|
|
|
291 char inpline[128]; /* Current input line (not expanded)*/
|
|
|
292 char srcline[128]; /* Current source line */
|
|
|
293 char * srcptr; /* Pointer to line being parsed */
|
|
|
294
|
|
|
295 char unknown; /* flag to indicate value unknown */
|
|
|
296 char certain; /* flag to indicate value is certain at pass 1*/
|
|
|
297 int error; /* flags indicating errors in current line. */
|
|
|
298 int errors; /* number of errors */
|
|
|
299 char exprcat; /* category of expression being parsed, eg.
|
|
|
300 label or constant, this is important when
|
|
|
301 generating relocatable object code. */
|
|
|
302
|
|
|
303
|
|
|
304 char namebuf[MAXIDLEN+1];
|
|
|
305
|
|
|
306 void
|
|
|
307 err(int er) {
|
|
|
308 error |= er ;
|
|
|
309 }
|
|
|
310
|
|
|
311 void
|
|
|
312 scanname()
|
|
|
313 {
|
|
|
314 int i=0;
|
|
|
315 char c;
|
|
|
316 while(1) {
|
|
|
317 c=*srcptr++;
|
|
|
318 if(c>='a'&&c<='z')c-=32;
|
|
|
319 if(c!='.'&&c!='$'&&(c<'0'||c>'9')&&(c<'A'||c>'Z'))break;
|
|
|
320 if(i<MAXIDLEN)namebuf[i++]=c;
|
|
|
321 }
|
|
|
322 namebuf[i]=0;
|
|
|
323 srcptr--;
|
|
|
324 }
|
|
|
325
|
|
|
326 void
|
|
|
327 skipspace()
|
|
|
328 {
|
|
|
329 char c;
|
|
|
330 do {
|
|
|
331 c=*srcptr++;
|
|
|
332 } while(c==' '||c=='\t');
|
|
|
333 srcptr--;
|
|
|
334 }
|
|
|
335
|
|
|
336 short scanexpr(int);
|
|
|
337
|
|
|
338 short scandecimal()
|
|
|
339 {
|
|
|
340 char c;
|
|
|
341 short t=0;
|
|
|
342 c=*srcptr++;
|
|
|
343 while(isdigit(c)) {
|
|
|
344 t=t*10+c-'0';
|
|
|
345 c=*srcptr++;
|
|
|
346 }
|
|
|
347 srcptr--;
|
|
|
348 return t;
|
|
|
349 }
|
|
|
350
|
|
|
351 short scanhex()
|
|
|
352 {
|
|
|
353 short t=0,i=0;
|
|
|
354 srcptr++;
|
|
|
355 scanname();
|
|
|
356 while(namebuf[i]>='0'&&namebuf[i]<='F') {
|
|
|
357 t=t*16+namebuf[i]-'0';
|
|
|
358 if(namebuf[i]>'9')t-=7;
|
|
|
359 i++;
|
|
|
360 }
|
|
|
361 if(i==0)error|=1;
|
|
|
362 return t;
|
|
|
363 }
|
|
|
364
|
|
|
365 short scanchar()
|
|
|
366 {
|
|
|
367 short t;
|
|
|
368 srcptr++;
|
|
|
369 t=*srcptr;
|
|
|
370 if(t)srcptr++;
|
|
|
371 if (*srcptr=='\'')srcptr++;
|
|
|
372 return t;
|
|
|
373 }
|
|
|
374
|
|
|
375 short scanbin()
|
|
|
376 {
|
|
|
377 char c;
|
|
|
378 short t=0;
|
|
|
379 srcptr++;
|
|
|
380 c=*srcptr++;
|
|
|
381 while(c=='0'||c=='1') {
|
|
|
382 t=t*2+c-'0';
|
|
|
383 c=*srcptr++;
|
|
|
384 }
|
|
|
385 srcptr--;
|
|
|
386 return t;
|
|
|
387 }
|
|
|
388
|
|
|
389 short scanoct()
|
|
|
390 {
|
|
|
391 char c;
|
|
|
392 short t=0;
|
|
|
393 srcptr++;
|
|
|
394 c=*srcptr++;
|
|
|
395 while(c>='0'&&c<='7') {
|
|
|
396 t=t*8+c-'0';
|
|
|
397 c=*srcptr++;
|
|
|
398 }
|
|
|
399 srcptr--;
|
|
|
400 return t;
|
|
|
401 }
|
|
|
402
|
|
|
403
|
|
|
404 short scanlabel()
|
|
|
405 {
|
|
|
406 struct symrecord * p;
|
|
|
407 scanname();
|
|
|
408 p=findsym(namebuf);
|
|
|
409 if(p->cat==13) {
|
|
|
410 p->cat=6;
|
|
|
411 p->value=0;
|
|
|
412 }
|
|
|
413 if(p->cat==9||p->cat==11)error|=1;
|
|
|
414 exprcat=p->cat&14;
|
|
|
415 if(exprcat==6||exprcat==10)unknown=1;
|
|
|
416 if(((exprcat==2||exprcat==8)
|
|
|
417 && (unsigned short)(p->value)>(unsigned short)loccounter)||
|
|
|
418 exprcat==4)
|
|
|
419 certain=0;
|
|
|
420 if(exprcat==8||exprcat==6||exprcat==10)exprcat=2;
|
|
|
421 return p->value;
|
|
|
422 }
|
|
|
423
|
|
|
424 /* expression categories...
|
|
|
425 all zeros is ordinary constant.
|
|
|
426 bit 1 indicates address within module.
|
|
|
427 bit 2 indicates external address.
|
|
|
428 bit 4 indicates this can't be relocated if it's an address.
|
|
|
429 bit 5 indicates address (if any) is negative.
|
|
|
430 */
|
|
|
431
|
|
|
432
|
|
|
433
|
|
|
434 short scanfactor()
|
|
|
435 {
|
|
|
436 char c;
|
|
|
437 short t;
|
|
|
438 skipspace();
|
|
|
439 c=*srcptr;
|
|
|
440 if(isalpha(c))return scanlabel();
|
|
|
441 else if(isdigit(c))return scandecimal();
|
|
|
442 else switch(c) {
|
|
|
443 case '.' :
|
|
|
444 case '*' : srcptr++;exprcat|=2;return loccounter;
|
|
|
445 case '$' : return scanhex();
|
|
|
446 case '%' : return scanbin();
|
|
|
447 case '&' : /* compatibility */
|
|
|
448 case '@' : return scanoct();
|
|
|
449 case '\'' : return scanchar();
|
|
|
450 case '(' : srcptr++;t=scanexpr(0);skipspace();
|
|
|
451 if(*srcptr==')')srcptr++;else error|=1;
|
|
|
452 return t;
|
|
|
453 case '-' : srcptr++;exprcat^=32;return -scanfactor();
|
|
|
454 case '+' : srcptr++;return scanfactor();
|
|
|
455 case '!' : srcptr++;exprcat|=16;return !scanfactor();
|
|
|
456 case '^' :
|
|
|
457 case '~' : srcptr++;exprcat|=16;return ~scanfactor();
|
|
|
458 }
|
|
|
459 error|=1;
|
|
|
460 return 0;
|
|
|
461 }
|
|
|
462
|
|
|
463 #define EXITEVAL {srcptr--;return t;}
|
|
|
464
|
|
|
465 #define RESOLVECAT if((oldcat&15)==0)oldcat=0;\
|
|
|
466 if((exprcat&15)==0)exprcat=0;\
|
|
|
467 if((exprcat==2&&oldcat==34)||(exprcat==34&&oldcat==2)) {\
|
|
|
468 exprcat=0;\
|
|
|
469 oldcat=0;}\
|
|
|
470 exprcat|=oldcat;\
|
|
|
471 /* resolve such cases as constant added to address or difference between
|
|
|
472 two addresses in same module */
|
|
|
473
|
|
|
474
|
|
|
475 short scanexpr(int level) /* This is what you call _recursive_ descent!!!*/
|
|
|
476 {
|
|
|
477 short t,u;
|
|
|
478 char oldcat,c;
|
|
|
479 exprcat=0;
|
|
|
480 if(level==10)return scanfactor();
|
|
|
481 t=scanexpr(level+1);
|
|
|
482 while(1) {
|
|
|
483 skipspace();
|
|
|
484 c=*srcptr++;
|
|
|
485 switch(c) {
|
|
|
486 case '*':oldcat=exprcat;
|
|
|
487 t*=scanexpr(10);
|
|
|
488 exprcat|=oldcat|16;
|
|
|
489 break;
|
|
|
490 case '/':oldcat=exprcat;
|
|
|
491 u=scanexpr(10);
|
|
|
492 if(u)t/=u;else error|=1;
|
|
|
493 exprcat|=oldcat|16;
|
|
|
494 break;
|
|
|
495 case '%':oldcat=exprcat;
|
|
|
496 u=scanexpr(10);
|
|
|
497 if(u)t%=u;else error|=1;
|
|
|
498 exprcat|=oldcat|16;
|
|
|
499 break;
|
|
|
500 case '+':if(level==9)EXITEVAL
|
|
|
501 oldcat=exprcat;
|
|
|
502 t+=scanexpr(9);
|
|
|
503 RESOLVECAT
|
|
|
504 break;
|
|
|
505 case '-':if(level==9)EXITEVAL
|
|
|
506 oldcat=exprcat;
|
|
|
507 t-=scanexpr(9);
|
|
|
508 exprcat^=32;
|
|
|
509 RESOLVECAT
|
|
|
510 break;
|
|
|
511 case '<':if(*(srcptr)=='<') {
|
|
|
512 if(level>=8)EXITEVAL
|
|
|
513 srcptr++;
|
|
|
514 oldcat=exprcat;
|
|
|
515 t<<=scanexpr(8);
|
|
|
516 exprcat|=oldcat|16;
|
|
|
517 break;
|
|
|
518 } else if(*(srcptr)=='=') {
|
|
|
519 if(level>=7)EXITEVAL
|
|
|
520 srcptr++;
|
|
|
521 oldcat=exprcat;
|
|
|
522 t=t<=scanexpr(7);
|
|
|
523 exprcat|=oldcat|16;
|
|
|
524 break;
|
|
|
525 } else {
|
|
|
526 if(level>=7)EXITEVAL
|
|
|
527 oldcat=exprcat;
|
|
|
528 t=t<scanexpr(7);
|
|
|
529 exprcat|=oldcat|16;
|
|
|
530 break;
|
|
|
531 }
|
|
|
532 case '>':if(*(srcptr)=='>') {
|
|
|
533 if(level>=8)EXITEVAL
|
|
|
534 srcptr++;
|
|
|
535 oldcat=exprcat;
|
|
|
536 t>>=scanexpr(8);
|
|
|
537 exprcat|=oldcat|16;
|
|
|
538 break;
|
|
|
539 } else if(*(srcptr)=='=') {
|
|
|
540 if(level>=7)EXITEVAL
|
|
|
541 srcptr++;
|
|
|
542 oldcat=exprcat;
|
|
|
543 t=t>=scanexpr(7);
|
|
|
544 exprcat|=oldcat|16;
|
|
|
545 break;
|
|
|
546 } else {
|
|
|
547 if(level>=7)EXITEVAL
|
|
|
548 oldcat=exprcat;
|
|
|
549 t=t>scanexpr(7);
|
|
|
550 exprcat|=oldcat|16;
|
|
|
551 break;
|
|
|
552 }
|
|
|
553 case '!':if(level>=6||*srcptr!='=')EXITEVAL
|
|
|
554 srcptr++;
|
|
|
555 oldcat=exprcat;
|
|
|
556 t=t!=scanexpr(6);
|
|
|
557 exprcat|=oldcat|16;
|
|
|
558 break;
|
|
|
559 case '=':if(level>=6)EXITEVAL
|
|
|
560 if(*srcptr=='=')srcptr++;
|
|
|
561 oldcat=exprcat;
|
|
|
562 t=t==scanexpr(6);
|
|
|
563 exprcat|=oldcat|16;
|
|
|
564 break;
|
|
|
565 case '&':if(level>=5)EXITEVAL
|
|
|
566 oldcat=exprcat;
|
|
|
567 t&=scanexpr(5);
|
|
|
568 exprcat|=oldcat|16;
|
|
|
569 break;
|
|
|
570 case '^':if(level>=4)EXITEVAL
|
|
|
571 oldcat=exprcat;
|
|
|
572 t^=scanexpr(4);
|
|
|
573 exprcat|=oldcat|16;
|
|
|
574 break;
|
|
|
575 case '|':if(level>=3)EXITEVAL
|
|
|
576 oldcat=exprcat;
|
|
|
577 t|=scanexpr(3);
|
|
|
578 exprcat|=oldcat|16;
|
|
|
579 default: EXITEVAL
|
|
|
580 }
|
|
|
581 }
|
|
|
582 }
|
|
|
583
|
|
|
584 char mode; /* addressing mode 0=immediate,1=direct,2=extended,3=postbyte
|
|
|
585 4=pcrelative(with postbyte) 5=indirect 6=pcrel&indirect*/
|
|
|
586 char opsize; /*desired operand size 0=dunno,1=5,2=8,3=16*/
|
|
|
587 short operand;
|
|
|
588 unsigned char postbyte;
|
|
|
589
|
|
|
590 int dpsetting;
|
|
|
591
|
|
|
592
|
|
|
593 int scanindexreg()
|
|
|
594 {
|
|
|
595 char c;
|
|
|
596 c=*srcptr;
|
|
|
597 if(islower(c))c-=32;
|
|
|
598 if (debug) fprintf(stderr,"DEBUG: scanindexreg: indexreg=%d, mode=%d, opsize=%d, error=%d, postbyte=%02X\n",c,mode,opsize,error,postbyte);
|
|
|
599 switch(c) {
|
|
|
600 case 'X':return 1;
|
|
|
601 case 'Y':postbyte|=0x20;return 1;
|
|
|
602 case 'U':postbyte|=0x40;return 1;
|
|
|
603 case 'S':postbyte|=0x60;return 1;
|
|
|
604 default: return 0;
|
|
|
605 }
|
|
|
606 }
|
|
|
607
|
|
|
608 void
|
|
|
609 set3()
|
|
|
610 {
|
|
|
611 if(mode<3)mode=3;
|
|
|
612 }
|
|
|
613
|
|
|
614 void
|
|
|
615 scanspecial()
|
|
|
616 {
|
|
|
617 set3();
|
|
|
618 skipspace();
|
|
|
619 if(*srcptr=='-') {
|
|
|
620 srcptr++;
|
|
|
621 if(*srcptr=='-') {
|
|
|
622 srcptr++;
|
|
|
623 postbyte=0x83;
|
|
|
624 } else postbyte=0x82;
|
|
|
625 if(!scanindexreg())error|=2;else srcptr++;
|
|
|
626 } else {
|
|
|
627 postbyte=0x80;
|
|
|
628 if(!scanindexreg())error|=2;else srcptr++;
|
|
|
629 if(*srcptr=='+') {
|
|
|
630 srcptr++;
|
|
|
631 if(*srcptr=='+') {
|
|
|
632 srcptr++;
|
|
|
633 postbyte+=1;
|
|
|
634 }
|
|
|
635 } else postbyte+=4;
|
|
|
636 }
|
|
|
637 }
|
|
|
638
|
|
|
639 void
|
|
|
640 scanindexed()
|
|
|
641 {
|
|
|
642 set3();
|
|
|
643 postbyte=0;
|
|
|
644 if(scanindexreg()) {
|
|
|
645 srcptr++;
|
|
|
646 if(opsize==0) {
|
|
|
647 if(unknown||!certain)opsize=3;
|
|
|
648 else if(operand>=-16&&operand<16&&mode==3)opsize=1;
|
|
|
649 else if(operand>=-128&&operand<128)opsize=2;
|
|
|
650 else opsize=3;
|
|
|
651 }
|
|
|
652 switch(opsize) {
|
|
|
653 case 1:postbyte+=(operand&31);opsize=0;break;
|
|
|
654 case 2:postbyte+=0x88;break;
|
|
|
655 case 3:postbyte+=0x89;break;
|
|
|
656 }
|
|
|
657 } else { /*pc relative*/
|
|
|
658 if(toupper(*srcptr)!='P')error|=2;
|
|
|
659 else {
|
|
|
660 srcptr++;
|
|
|
661 if(toupper(*srcptr)!='C')error|=2;
|
|
|
662 else {
|
|
|
663 srcptr++;
|
|
|
664 if(toupper(*srcptr)=='R')srcptr++;
|
|
|
665 }
|
|
|
666 }
|
|
|
667 mode++;postbyte+=0x8c;
|
|
|
668 if(opsize==1)opsize=2;
|
|
|
669 }
|
|
|
670 }
|
|
|
671
|
|
|
672 #define RESTORE {srcptr=oldsrcptr;c=*srcptr;goto dodefault;}
|
|
|
673
|
|
|
674 void
|
|
|
675 scanoperands()
|
|
|
676 {
|
|
|
677 char c,d,*oldsrcptr;
|
|
|
678 unknown=0;
|
|
|
679 opsize=0;
|
|
|
680 certain=1;
|
|
|
681 skipspace();
|
|
|
682 c=*srcptr;
|
|
|
683 mode=0;
|
|
|
684 if(c=='[') {
|
|
|
685 srcptr++;
|
|
|
686 c=*srcptr;
|
|
|
687 mode=5;
|
|
|
688 }
|
|
|
689 if (debug) fprintf(stderr,"DEBUG: scanoperands: c=%c (%02X)\n",c,c);
|
|
|
690 switch(c) {
|
|
|
691 case 'D': case 'd':
|
|
|
692 oldsrcptr=srcptr;
|
|
|
693 srcptr++;
|
|
|
694 skipspace();
|
|
|
695 if(*srcptr!=',')RESTORE else {
|
|
|
696 postbyte=0x8b;
|
|
|
697 srcptr++;
|
|
|
698 if(!scanindexreg())RESTORE else {srcptr++;set3();}
|
|
|
699 }
|
|
|
700 break;
|
|
|
701 case 'A': case 'a':
|
|
|
702 oldsrcptr=srcptr;
|
|
|
703 srcptr++;
|
|
|
704 skipspace();
|
|
|
705 if(*srcptr!=',')RESTORE else {
|
|
|
706 postbyte=0x86;
|
|
|
707 srcptr++;
|
|
|
708 if(!scanindexreg())RESTORE else {srcptr++;set3();}
|
|
|
709 }
|
|
|
710 break;
|
|
|
711 case 'B': case 'b':
|
|
|
712 oldsrcptr=srcptr;
|
|
|
713 srcptr++;
|
|
|
714 skipspace();
|
|
|
715 if(*srcptr!=',')RESTORE else {
|
|
|
716 postbyte=0x85;
|
|
|
717 srcptr++;
|
|
|
718 if (debug) fprintf(stderr,"DEBUG: scanoperands: breg preindex: c=%c (%02X)\n",*srcptr,*srcptr);
|
|
|
719 if(!scanindexreg())RESTORE else {srcptr++;set3();}
|
|
|
720 if (debug) fprintf(stderr,"DEBUG: scanoperands: breg: postindex c=%c (%02X)\n",*srcptr,*srcptr);
|
|
|
721 }
|
|
|
722 break;
|
|
|
723 case ',':
|
|
|
724 srcptr++;
|
|
|
725 scanspecial();
|
|
|
726 break;
|
|
|
727 case '#':
|
|
|
728 if(mode==5)error|=2;else mode=0;
|
|
|
729 srcptr++;
|
|
|
730 operand=scanexpr(0);
|
|
|
731 break;
|
|
|
732 case '<':
|
|
|
733 srcptr++;
|
|
|
734 if(*srcptr=='<') {
|
|
|
735 srcptr++;
|
|
|
736 opsize=1;
|
|
|
737 } else opsize=2;
|
|
|
738 goto dodefault;
|
|
|
739 case '>':
|
|
|
740 srcptr++;
|
|
|
741 opsize=3;
|
|
|
742 default: dodefault:
|
|
|
743 operand=scanexpr(0);
|
|
|
744 skipspace();
|
|
|
745 if(*srcptr==',') {
|
|
|
746 srcptr++;
|
|
|
747 scanindexed();
|
|
|
748 } else {
|
|
|
749 if(opsize==0) {
|
|
|
750 if(unknown||!certain||dpsetting==-1||
|
|
|
751 (unsigned short)(operand-dpsetting*256)>=256)
|
|
|
752 opsize=3; else opsize=2;
|
|
|
753 }
|
|
|
754 if(opsize==1)opsize=2;
|
|
|
755 if(mode==5){
|
|
|
756 postbyte=0x8f;
|
|
|
757 opsize=3;
|
|
|
758 } else mode=opsize-1;
|
|
|
759 }
|
|
|
760 }
|
|
|
761 if (debug) fprintf(stderr,"DEBUG: scanoperands: mode=%d, error=%d, postbyte=%02X\n",mode,error,postbyte);
|
|
|
762 if(mode>=5) {
|
|
|
763 skipspace();
|
|
|
764 postbyte|=0x10;
|
|
|
765 if(*srcptr!=']')error|=2;else srcptr++;
|
|
|
766 }
|
|
|
767 if(pass==2&&unknown)error|=4;
|
|
|
768 }
|
|
|
769
|
|
|
770 unsigned char codebuf[128];
|
|
|
771 int codeptr; /* byte offset within instruction */
|
|
|
772 int suppress; /* 0=no suppress 1=until ENDIF 2=until ELSE 3=until ENDM */
|
|
|
773 int ifcount; /* count of nested IFs within suppressed text */
|
|
|
774
|
|
|
775 unsigned char outmode; /* 0 is binary, 1 is s-records */
|
|
|
776
|
|
|
777 unsigned short hexaddr;
|
|
|
778 int hexcount;
|
|
|
779 unsigned char hexbuffer[16];
|
|
|
780 unsigned int chksum;
|
|
|
781
|
|
|
782 extern int os9crc(unsigned char c, int crcp);
|
|
|
783 int crc;
|
|
|
784
|
|
|
785 void
|
|
|
786 reset_crc()
|
|
|
787 {
|
|
|
788 crc = -1;
|
|
|
789 }
|
|
|
790
|
|
|
791
|
|
|
792 void
|
|
|
793 flushhex()
|
|
|
794 {
|
|
|
795 int i;
|
|
|
796 if(hexcount){
|
|
|
797 fprintf(objfile,"S1%02X%04X",(hexcount+3)&0xff,hexaddr&0xffff);
|
|
|
798 for(i=0;i<hexcount;i++)fprintf(objfile,"%02X",hexbuffer[i]);
|
|
|
799 chksum+=(hexaddr&0xff)+((hexaddr>>8)&0xff)+hexcount+3;
|
|
|
800 fprintf(objfile,"%02X\n",0xff-(chksum&0xff));
|
|
|
801 hexaddr+=hexcount;
|
|
|
802 hexcount=0;
|
|
|
803 chksum=0;
|
|
|
804 }
|
|
|
805 }
|
|
|
806
|
|
|
807 void
|
|
|
808 outhex(unsigned char x)
|
|
|
809 {
|
|
|
810 if(hexcount==16)flushhex();
|
|
|
811 hexbuffer[hexcount++]=x;
|
|
|
812 chksum+=x;
|
|
|
813 }
|
|
|
814
|
|
|
815 void
|
|
|
816 outbuffer()
|
|
|
817 {
|
|
|
818 int i;
|
|
|
819 for(i=0;i<codeptr;i++) {
|
|
|
820 crc = os9crc(codebuf[i],crc);
|
|
|
821 if(!outmode)fputc(codebuf[i],objfile);else outhex(codebuf[i]);
|
|
|
822 }
|
|
|
823 }
|
|
|
824
|
|
|
825 char *errormsg[]={"Error in expression",
|
|
|
826 "Illegal addressing mode",
|
|
|
827 "Undefined label",
|
|
|
828 "Multiple definitions of label",
|
|
|
829 "Relative branch out of range",
|
|
|
830 "Missing label",
|
|
|
831 "","","","","","","","","",
|
|
|
832 "Illegal mnemonic"
|
|
|
833 };
|
|
|
834
|
|
|
835 void
|
|
|
836 report()
|
|
|
837 {
|
|
|
838 int i;
|
|
|
839 fprintf(stderr,"File %s, line %d:%s\n",curname,lineno,srcline);
|
|
|
840 for(i=0;i<16;i++) {
|
|
|
841 if(error&1) {
|
|
|
842 fprintf(stderr,"%s\n",errormsg[i]);
|
|
|
843 if(pass==2&&listing)fprintf(listfile,"**** %s\n",errormsg[i]);
|
|
|
844 }
|
|
|
845 error>>=1;
|
|
|
846 }
|
|
|
847 errors++;
|
|
|
848 }
|
|
|
849
|
|
|
850 void
|
|
|
851 outlist()
|
|
|
852 {
|
|
|
853 int i;
|
|
|
854 fprintf(listfile,"%04X: ",oldlc);
|
|
|
855 for(i=0;i<codeptr&&i<MAXLISTBYTES;i++)
|
|
|
856 fprintf(listfile,"%02X",codebuf[i]);
|
|
|
857 for(;i<=MAXLISTBYTES;i++)
|
|
|
858 fprintf(listfile," ");
|
|
|
859 fprintf(listfile,"%s\n",srcline);
|
|
|
860 while(i<codeptr) {
|
|
|
861 fprintf(listfile,"%04X: ",oldlc + i);
|
|
|
862 for(int j=0;i<codeptr&&j<MAXLISTBYTES;j++) {
|
|
|
863 fprintf(listfile,"%02X",codebuf[i]); i++;
|
|
|
864 }
|
|
|
865 fprintf(listfile,"\n");
|
|
|
866 }
|
|
|
867 }
|
|
|
868
|
|
|
869 void
|
|
|
870 setlabel(struct symrecord * lp)
|
|
|
871 {
|
|
|
872 if(lp) {
|
|
|
873 if(lp->cat!=13&&lp->cat!=6) {
|
|
|
874 if(lp->cat!=2||lp->value!=loccounter)
|
|
|
875 error|=8;
|
|
|
876 } else {
|
|
|
877 lp->cat=2;
|
|
|
878 lp->value=loccounter;
|
|
|
879 }
|
|
|
880 }
|
|
|
881 }
|
|
|
882
|
|
|
883 void
|
|
|
884 putbyte(unsigned char b)
|
|
|
885 {
|
|
|
886 codebuf[codeptr++]=b;
|
|
|
887 }
|
|
|
888
|
|
|
889 void
|
|
|
890 putword(unsigned short w)
|
|
|
891 {
|
|
|
892 codebuf[codeptr++]=w>>8;
|
|
|
893 codebuf[codeptr++]=w&0x0ff;
|
|
|
894 }
|
|
|
895
|
|
|
896 void
|
|
|
897 doaddress() /* assemble the right addressing bytes for an instruction */
|
|
|
898 {
|
|
|
899 int offs;
|
|
|
900 switch(mode) {
|
|
|
901 case 0: if(opsize==2)putbyte(operand);else putword(operand);break;
|
|
|
902 case 1: putbyte(operand);break;
|
|
|
903 case 2: putword(operand);break;
|
|
|
904 case 3: case 5: putbyte(postbyte);
|
|
|
905 switch(opsize) {
|
|
|
906 case 2: putbyte(operand);break;
|
|
|
907 case 3: putword(operand);
|
|
|
908 }
|
|
|
909 break;
|
|
|
910 case 4: case 6: offs=(unsigned short)operand-loccounter-codeptr-2;
|
|
|
911 if(offs<-128||offs>=128||opsize==3||unknown||!certain) {
|
|
|
912 if((!unknown)&&opsize==2&&(offs<-128||offs>=128) )
|
|
|
913 error|=16;
|
|
|
914 offs--;
|
|
|
915 opsize=3;
|
|
|
916 postbyte++;
|
|
|
917 }
|
|
|
918 putbyte(postbyte);
|
|
|
919 if (debug) fprintf(stderr,"DEBUG: doaddress: mode=%d, opsize=%d, error=%d, postbyte=%02X, operand=%04X offs=%d\n",mode,opsize,error,postbyte,operand,offs);
|
|
|
920 if(opsize==3)putword(offs);
|
|
|
921 else putbyte(offs);
|
|
|
922 }
|
|
|
923 }
|
|
|
924
|
|
|
925 void
|
|
|
926 onebyte(int co)
|
|
|
927 {
|
|
|
928 putbyte(co);
|
|
|
929 }
|
|
|
930
|
|
|
931 void
|
|
|
932 twobyte(int co)
|
|
|
933 {
|
|
|
934 putword(co);
|
|
|
935 }
|
|
|
936
|
|
|
937 void
|
|
|
938 oneimm(int co)
|
|
|
939 {
|
|
|
940 scanoperands();
|
|
|
941 if(mode>=3)error|=2;
|
|
|
942 putbyte(co);
|
|
|
943 putbyte(operand);
|
|
|
944 }
|
|
|
945
|
|
|
946 void
|
|
|
947 lea(int co)
|
|
|
948 {
|
|
|
949 putbyte(co);
|
|
|
950 scanoperands();
|
|
|
951 if(mode==0) error|=2;
|
|
|
952 if(mode<3) {
|
|
|
953 opsize=3;
|
|
|
954 postbyte=0x8f;
|
|
|
955 mode=3;
|
|
|
956 }
|
|
|
957 if (debug) fprintf(stderr,"DEBUG: lea: mode=%d, opsize=%d, error=%d, postbyte=%02X, *src=%c\n",mode,opsize,error,postbyte,*srcptr);
|
|
|
958 doaddress();
|
|
|
959 }
|
|
|
960
|
|
|
961 void
|
|
|
962 sbranch(int co)
|
|
|
963 {
|
|
|
964 int offs;
|
|
|
965 scanoperands();
|
|
|
966 if(mode!=1&&mode!=2)error|=2;
|
|
|
967 offs=(unsigned short)operand-loccounter-2;
|
|
|
968 if(!unknown&&(offs<-128||offs>=128))error|=16;
|
|
|
969 if(pass==2&&unknown)error|=4;
|
|
|
970 putbyte(co);
|
|
|
971 putbyte(offs);
|
|
|
972 }
|
|
|
973
|
|
|
974 void
|
|
|
975 lbra(int co)
|
|
|
976 {
|
|
|
977 scanoperands();
|
|
|
978 if(mode!=1&&mode!=2)error|=2;
|
|
|
979 putbyte(co);
|
|
|
980 putword(operand-loccounter-3);
|
|
|
981 }
|
|
|
982
|
|
|
983 void
|
|
|
984 lbranch(int co)
|
|
|
985 {
|
|
|
986 scanoperands();
|
|
|
987 if(mode!=1&&mode!=2)error|=2;
|
|
|
988 putword(co);
|
|
|
989 putword(operand-loccounter-4);
|
|
|
990 }
|
|
|
991
|
|
|
992 void
|
|
|
993 arith(int co)
|
|
|
994 {
|
|
|
995 scanoperands();
|
|
|
996 switch(mode) {
|
|
|
997 case 0:opsize=2;putbyte(co);break;
|
|
|
998 case 1:putbyte(co+0x010);break;
|
|
|
999 case 2:putbyte(co+0x030);break;
|
|
|
1000 default:putbyte(co+0x020);
|
|
|
1001 }
|
|
|
1002 doaddress();
|
|
|
1003 }
|
|
|
1004
|
|
|
1005 void
|
|
|
1006 darith(int co)
|
|
|
1007 {
|
|
|
1008 scanoperands();
|
|
|
1009 switch(mode) {
|
|
|
1010 case 0:opsize=3;putbyte(co);break;
|
|
|
1011 case 1:putbyte(co+0x010);break;
|
|
|
1012 case 2:putbyte(co+0x030);break;
|
|
|
1013 default:putbyte(co+0x020);
|
|
|
1014 }
|
|
|
1015 doaddress();
|
|
|
1016 }
|
|
|
1017
|
|
|
1018 void
|
|
|
1019 d2arith(int co)
|
|
|
1020 {
|
|
|
1021 scanoperands();
|
|
|
1022 switch(mode) {
|
|
|
1023 case 0:opsize=3;putword(co);break;
|
|
|
1024 case 1:putword(co+0x010);break;
|
|
|
1025 case 2:putword(co+0x030);break;
|
|
|
1026 default:putword(co+0x020);
|
|
|
1027 }
|
|
|
1028 doaddress();
|
|
|
1029 }
|
|
|
1030
|
|
|
1031 void
|
|
|
1032 oneaddr(int co)
|
|
|
1033 {
|
|
|
1034 scanoperands();
|
|
|
1035 switch(mode) {
|
|
|
1036 case 0: error|=2;break;
|
|
|
1037 case 1: putbyte(co);break;
|
|
|
1038 case 2: putbyte(co+0x70);break;
|
|
|
1039 default: putbyte(co+0x60);break;
|
|
|
1040 }
|
|
|
1041 doaddress();
|
|
|
1042 }
|
|
|
1043
|
|
|
1044 void
|
|
|
1045 tfrexg(int co)
|
|
|
1046 {
|
|
|
1047 struct regrecord * p;
|
|
|
1048 putbyte(co);
|
|
|
1049 skipspace();
|
|
|
1050 scanname();
|
|
|
1051 if((p=findreg(namebuf))==0)error|=2;
|
|
|
1052 else postbyte=(p->tfr)<<4;
|
|
|
1053 skipspace();
|
|
|
1054 if(*srcptr==',')srcptr++;else error|=2;
|
|
|
1055 skipspace();
|
|
|
1056 scanname();
|
|
|
1057 if((p=findreg(namebuf))==0)error|=2;
|
|
|
1058 else postbyte|=p->tfr;
|
|
|
1059 putbyte(postbyte);
|
|
|
1060 }
|
|
|
1061
|
|
|
1062 void
|
|
|
1063 pshpul(int co)
|
|
|
1064 {
|
|
|
1065 struct regrecord *p;
|
|
|
1066 putbyte(co);
|
|
|
1067 postbyte=0;
|
|
|
1068 do {
|
|
|
1069 if(*srcptr==',')srcptr++;
|
|
|
1070 skipspace();
|
|
|
1071 scanname();
|
|
|
1072 if((p=findreg(namebuf))==0)error|=2;
|
|
|
1073 else postbyte|=p->psh;
|
|
|
1074 skipspace();
|
|
|
1075 }while (*srcptr==',');
|
|
|
1076 putbyte(postbyte);
|
|
|
1077 }
|
|
|
1078
|
|
|
1079 void
|
|
|
1080 skipComma()
|
|
|
1081 {
|
|
|
1082 while(*srcptr && *srcptr!='\n' && *srcptr!=',')srcptr++;
|
|
|
1083 if (*srcptr==',') {
|
|
|
1084 srcptr++;
|
|
|
1085 } else {
|
|
|
1086 error|=1;
|
|
|
1087 }
|
|
|
1088 }
|
|
|
1089
|
|
|
1090 int modStart;
|
|
|
1091
|
|
|
1092 void os9begin()
|
|
|
1093 {
|
|
|
1094 generating=1;
|
|
3
|
1095 os9=1; // contiguous code generation ( i.e. ignore org nor rmb )
|
|
0
|
1096 modStart = loccounter;
|
|
|
1097 reset_crc();
|
|
|
1098 putword(0x87cd);
|
|
|
1099 putword(scanexpr(0)-loccounter); // module size
|
|
|
1100 skipComma();
|
|
|
1101 putword(scanexpr(0)-loccounter); // offset to module name
|
|
|
1102 skipComma();
|
|
|
1103 putbyte(scanexpr(0)); // type / language
|
|
|
1104 skipComma();
|
|
|
1105 putbyte(scanexpr(0)); // attribute
|
|
|
1106 int parity=0;
|
|
|
1107 for(int i=0; i< 8; i++) parity^=codebuf[i];
|
|
|
1108 putbyte(parity^0xff); // header parity
|
|
|
1109 skipspace();
|
|
|
1110 while (*srcptr==',') { // there are some more
|
|
|
1111 srcptr++;
|
|
|
1112 putword(scanexpr(0));
|
|
|
1113 skipspace();
|
|
|
1114 }
|
|
|
1115 }
|
|
|
1116
|
|
|
1117 void os9end()
|
|
|
1118 {
|
|
|
1119 crc = crc ^ 0xffffff;
|
|
|
1120
|
|
|
1121 putbyte((crc>>16)&0xff);
|
|
|
1122 putbyte((crc>>8)&0xff);
|
|
|
1123 putbyte(crc&0xff);
|
|
|
1124 }
|
|
|
1125
|
|
|
1126
|
|
|
1127 void
|
|
|
1128 pseudoop(int co,struct symrecord * lp)
|
|
|
1129 {
|
|
|
1130 int i;
|
|
|
1131 char c;
|
|
|
1132 char *fname;
|
|
|
1133 int locsave;
|
|
|
1134
|
|
|
1135 switch(co) {
|
|
|
1136 case 0:/* RMB */
|
|
3
|
1137 // in OS9 mode, this generates no data
|
|
|
1138 // loccounter will be reset after any code to the current code generation
|
|
0
|
1139 setlabel(lp);
|
|
|
1140 operand=scanexpr(0);
|
|
|
1141 if(unknown)error|=4;
|
|
|
1142 loccounter+=operand;
|
|
|
1143 if(generating&&pass==2) {
|
|
3
|
1144 if(!outmode || os9 )for(i=0;i<operand;i++) {
|
|
1
|
1145 fputc(0,objfile);
|
|
|
1146 } else flushhex();
|
|
0
|
1147 }
|
|
|
1148 hexaddr=loccounter;
|
|
|
1149 break;
|
|
|
1150 case 5:/* EQU */
|
|
|
1151 operand=scanexpr(0);
|
|
|
1152 if(!lp)error|=32;
|
|
|
1153 else {
|
|
|
1154 if(lp->cat==13||lp->cat==6||
|
|
|
1155 (lp->value==(unsigned short)operand&&pass==2)) {
|
|
|
1156 if(exprcat==2)lp->cat=2;
|
|
|
1157 else lp->cat=0;
|
|
|
1158 lp->value=operand;
|
|
|
1159 } else error|=8;
|
|
|
1160 }
|
|
|
1161 break;
|
|
|
1162 case 7:/* FCB */
|
|
|
1163 setlabel(lp);
|
|
|
1164 generating=1;
|
|
|
1165 do {
|
|
|
1166 if(*srcptr==',')srcptr++;
|
|
|
1167 skipspace();
|
|
|
1168 if(*srcptr=='\"') {
|
|
|
1169 srcptr++;
|
|
|
1170 while(*srcptr!='\"'&&*srcptr)
|
|
|
1171 putbyte(*srcptr++);
|
|
|
1172 if(*srcptr=='\"')srcptr++;
|
|
|
1173 } else {
|
|
|
1174 putbyte(scanexpr(0));
|
|
|
1175 if(unknown&&pass==2)error|=4;
|
|
|
1176 }
|
|
|
1177 skipspace();
|
|
|
1178 } while(*srcptr==',');
|
|
|
1179 break;
|
|
|
1180 case 8:/* FCC */
|
|
3
|
1181 generating=1;
|
|
0
|
1182 setlabel(lp);
|
|
|
1183 skipspace();
|
|
|
1184 c=*srcptr++;
|
|
|
1185 while(*srcptr!=c&&*srcptr)
|
|
|
1186 putbyte(*srcptr++);
|
|
|
1187 if(*srcptr==c)srcptr++;
|
|
|
1188 break;
|
|
|
1189 case 9:/* FDB */
|
|
3
|
1190 generating=1;
|
|
0
|
1191 setlabel(lp);
|
|
|
1192 do {
|
|
|
1193 if(*srcptr==',')srcptr++;
|
|
|
1194 skipspace();
|
|
|
1195 putword(scanexpr(0));
|
|
|
1196 if(unknown&&pass==2)error|=4;
|
|
|
1197 skipspace();
|
|
|
1198 } while(*srcptr==',');
|
|
|
1199 break;
|
|
|
1200 case 23 :/* FCS */
|
|
3
|
1201 generating=1;
|
|
0
|
1202 setlabel(lp);
|
|
|
1203 skipspace();
|
|
|
1204 int sep = *srcptr;
|
|
|
1205 if(sep=='\"' || sep=='/') {
|
|
|
1206 srcptr++;
|
|
|
1207 while(*srcptr!=sep&&*srcptr)
|
|
|
1208 putbyte(*srcptr++);
|
|
|
1209 if(*srcptr==sep)srcptr++;
|
|
|
1210 codebuf[codeptr-1] |= 0x80; // os9 string termination
|
|
|
1211 }
|
|
|
1212 break;
|
|
|
1213 case 1: /* ELSE */
|
|
|
1214 suppress=1;
|
|
|
1215 break;
|
|
|
1216 case 21: /* IFP1 */
|
|
|
1217 if(pass==2)suppress=2;
|
|
|
1218 break;
|
|
|
1219 case 29: /* IFGT */
|
|
|
1220 operand=scanexpr(0);
|
|
|
1221 if(unknown)error|=4;
|
|
|
1222 if(operand>0)suppress=2;
|
|
|
1223 break;
|
|
|
1224 case 31: /* IFLT */
|
|
|
1225 operand=scanexpr(0);
|
|
|
1226 if(unknown)error|=4;
|
|
|
1227 if(operand<0)suppress=2;
|
|
|
1228 break;
|
|
3
|
1229 case 30: /* IFEQ */
|
|
0
|
1230 operand=scanexpr(0);
|
|
|
1231 if(unknown)error|=4;
|
|
|
1232 if(operand==0)suppress=2;
|
|
|
1233 break;
|
|
3
|
1234 case 28: /* IFNE */
|
|
0
|
1235 case 10: /* IF */
|
|
|
1236 operand=scanexpr(0);
|
|
|
1237 if(unknown)error|=4;
|
|
|
1238 if(!operand)suppress=2;
|
|
|
1239 break;
|
|
|
1240 case 12: /* ORG */
|
|
|
1241 operand=scanexpr(0);
|
|
|
1242 if(unknown)error|=4;
|
|
3
|
1243 if(generating&&pass==2&&!outmode&&!os9) {
|
|
0
|
1244 for(i=0;i<(unsigned short)operand-loccounter;i++)
|
|
3
|
1245 fputc(0,objfile);
|
|
|
1246 } else flushhex();
|
|
0
|
1247 loccounter=operand;
|
|
|
1248 hexaddr=loccounter;
|
|
|
1249 break;
|
|
|
1250 case 14: /* SETDP */
|
|
|
1251 operand=scanexpr(0);
|
|
|
1252 if(unknown)error|=4;
|
|
|
1253 if(!(operand&255))operand=(unsigned short)operand>>8;
|
|
|
1254 if((unsigned)operand>255)operand=-1;
|
|
|
1255 dpsetting=operand;
|
|
|
1256 break;
|
|
|
1257 case 15: /* SET */
|
|
|
1258 operand=scanexpr(0);
|
|
|
1259 if(!lp)error|=32;
|
|
|
1260 else {
|
|
|
1261 if(lp->cat&1||lp->cat==6) {
|
|
|
1262 if(exprcat==2)lp->cat=3;
|
|
|
1263 else lp->cat=1;
|
|
|
1264 lp->value=operand;
|
|
|
1265 } else error|=8;
|
|
|
1266 }
|
|
|
1267 break;
|
|
|
1268 case 2: /* END */
|
|
|
1269 terminate=1;
|
|
|
1270 break;
|
|
|
1271 case 27: /* USE */
|
|
|
1272 locsave = loccounter ;
|
|
|
1273 case 16: /* INCLUDE */
|
|
|
1274 skipspace();
|
|
|
1275 if(*srcptr=='"')srcptr++;
|
|
|
1276 i = 0;
|
|
|
1277 for(i=0; !(srcptr[i]==0||srcptr[i]=='"'); i++);
|
|
|
1278 int len = i;
|
|
|
1279 fname = calloc(1,len);
|
|
|
1280 for(i=0;i<len;i++) {
|
|
|
1281 if(*srcptr==0||*srcptr=='"')break;
|
|
|
1282 fname[i]=*srcptr++;
|
|
|
1283 }
|
|
|
1284 fname[i]=0;
|
|
|
1285 processfile(fname);
|
|
|
1286 codeptr=0;
|
|
|
1287 srcline[0]=0;
|
|
3
|
1288 // if (co==27) loccounter = locsave;
|
|
0
|
1289 break;
|
|
|
1290 case 24: /* MOD */
|
|
|
1291 loccounter = 0;
|
|
|
1292 setlabel(lp);
|
|
|
1293 os9begin();
|
|
|
1294 break;
|
|
|
1295 case 25: /* EMOD */
|
|
|
1296 os9end();
|
|
|
1297 break;
|
|
|
1298 case 32: /* OS9 */
|
|
3
|
1299 generating = 1;
|
|
0
|
1300 setlabel(lp);
|
|
3
|
1301 putword(0x103f); // SWI2
|
|
0
|
1302 putbyte(scanexpr(0));
|
|
|
1303 break;
|
|
|
1304 case 18: /* TTL */
|
|
|
1305 break;
|
|
|
1306 case 19: /* OPT */
|
|
|
1307 case 26: /* NAM */
|
|
|
1308 case 20: /* PAG */
|
|
|
1309 case 3: /* ENDIF/ENDC */
|
|
|
1310 break;
|
|
|
1311 }
|
|
|
1312 }
|
|
|
1313
|
|
|
1314
|
|
|
1315 void
|
|
|
1316 processline()
|
|
|
1317 {
|
|
|
1318 struct symrecord * lp;
|
|
|
1319 struct oprecord * op;
|
|
|
1320 int co;
|
|
|
1321 char c;
|
|
|
1322 srcptr=srcline;
|
|
|
1323 oldlc=loccounter;
|
|
|
1324 error=0;
|
|
|
1325 unknown=0;certain=1;
|
|
|
1326 lp=0;
|
|
|
1327 codeptr=0;
|
|
|
1328 if(isalnum(*srcptr)) {
|
|
|
1329 scanname();lp=findsym(namebuf);
|
|
|
1330 if(*srcptr==':') srcptr++;
|
|
|
1331 }
|
|
|
1332 skipspace();
|
|
|
1333 if(isalnum(*srcptr)) {
|
|
|
1334 scanname();
|
|
|
1335 op=findop(namebuf);
|
|
|
1336 if(op) {
|
|
|
1337 if(op->cat!=13){
|
|
|
1338 setlabel(lp);
|
|
|
1339 generating=1;
|
|
|
1340 }
|
|
|
1341 co=op->code;
|
|
|
1342 switch(op->cat) {
|
|
|
1343 case 0:onebyte(co);break;
|
|
|
1344 case 1:twobyte(co);break;
|
|
|
1345 case 2:oneimm(co);break;
|
|
|
1346 case 3:lea(co);break;
|
|
|
1347 case 4:sbranch(co);break;
|
|
|
1348 case 5:lbranch(co);break;
|
|
|
1349 case 6:lbra(co);break;
|
|
|
1350 case 7:arith(co);break;
|
|
|
1351 case 8:darith(co);break;
|
|
|
1352 case 9:d2arith(co);break;
|
|
|
1353 case 10:oneaddr(co);break;
|
|
|
1354 case 11:tfrexg(co);break;
|
|
|
1355 case 12:pshpul(co);break;
|
|
|
1356 case 13:pseudoop(co,lp);
|
|
|
1357 }
|
|
|
1358 c=*srcptr;
|
|
|
1359 if (debug) fprintf(stderr,"DEBUG: processline: mode=%d, opsize=%d, error=%d, postbyte=%02X c=%c\n",mode,opsize,error,postbyte,c);
|
|
|
1360 if(c!=' '&&*(srcptr-1)!=' '&&c!=0&&c!=';')error|=2;
|
|
|
1361 }
|
|
|
1362 else error|=0x8000;
|
|
|
1363 }else setlabel(lp);
|
|
|
1364 if(pass==2) {
|
|
|
1365 outbuffer();
|
|
|
1366 if(listing)outlist();
|
|
|
1367 }
|
|
|
1368 if(error)report();
|
|
|
1369 loccounter+=codeptr;
|
|
|
1370 }
|
|
|
1371
|
|
|
1372 void
|
|
|
1373 suppressline()
|
|
|
1374 {
|
|
|
1375 struct oprecord * op;
|
|
|
1376 srcptr=srcline;
|
|
|
1377 oldlc=loccounter;
|
|
|
1378 codeptr=0;
|
|
|
1379 if(isalnum(*srcptr)) {
|
|
|
1380 scanname();
|
|
|
1381 if(*srcptr==':')srcptr++;
|
|
|
1382 }
|
|
|
1383 skipspace();
|
|
|
1384 scanname();op=findop(namebuf);
|
|
|
1385 if(op && op->cat==13) {
|
|
|
1386 if(op->code==10||op->code==13||op->code==29||op->code==28||op->code==21||op->code==30) ifcount++;
|
|
|
1387 else if(op->code==3) {
|
|
|
1388 if(ifcount>0)ifcount--;else if(suppress==1|suppress==2)suppress=0;
|
|
|
1389 } else if(op->code==1) {
|
|
|
1390 if(ifcount==0 && suppress==2)suppress=0;
|
|
|
1391 }
|
|
|
1392 }
|
|
|
1393 if(pass==2&&listing)outlist();
|
|
|
1394 }
|
|
|
1395
|
|
|
1396 void
|
|
|
1397 usage(char*nm)
|
|
|
1398 {
|
|
|
1399 fprintf(stderr,"Usage: %s [-o objname] [-l listname] [-s srecord-file] srcname\n",nm);
|
|
|
1400 exit(2);
|
|
|
1401 }
|
|
|
1402
|
|
|
1403 char *
|
|
|
1404 strconcat(char *s,int spos,char *d)
|
|
|
1405 {
|
|
|
1406 int slen = strlen(s);
|
|
|
1407 int dlen = strlen(d);
|
|
|
1408 if ( spos == 0) spos = slen;
|
|
|
1409 char *out = calloc(1,spos+dlen+1);
|
|
|
1410 int i = 0;
|
|
|
1411 for(; i< spos; i++ ) out[i] = s[i];
|
|
|
1412 for(; i< spos+dlen+1; i++ ) out[i] = *d++;
|
|
|
1413 return out;
|
|
|
1414 }
|
|
|
1415
|
|
|
1416
|
|
|
1417 void
|
|
|
1418 getoptions(int c,char*v[])
|
|
|
1419 {
|
|
|
1420 int i=0;
|
|
|
1421 if(c==1)usage(v[0]);
|
|
|
1422 if(strcmp(v[1],"-d")==0) {
|
|
|
1423 debug=1;
|
|
|
1424 i++;
|
|
|
1425 }
|
|
|
1426 if(strcmp(v[1],"-o")==0) {
|
|
|
1427 if(c<4)usage(v[0]);
|
|
|
1428 objname = v[2];
|
|
|
1429 i+=2;
|
|
|
1430 }
|
|
|
1431 if(strcmp(v[i+1],"-s")==0) {
|
|
|
1432 if(c<4+i)usage(v[0]);
|
|
|
1433 objname=v[i+2];
|
|
|
1434 outmode=1;
|
|
|
1435 i+=2;
|
|
|
1436 }
|
|
|
1437 if(strcmp(v[i+1],"-l")==0) {
|
|
|
1438 if(c<4+i)usage(v[0]);
|
|
|
1439 listname=v[2+i];
|
|
|
1440 i+=2;
|
|
|
1441 }
|
|
|
1442 srcname=v[1+i];
|
|
|
1443 if(objname==0) {
|
|
|
1444 for(i=0;srcname[i]!='.' && srcname[i]!=0 ;i++) ;
|
|
|
1445 objname = strconcat(srcname,i,".b");
|
|
|
1446 }
|
|
|
1447 listing=(listname!=0);
|
|
|
1448 }
|
|
|
1449
|
|
|
1450 void
|
|
|
1451 expandline()
|
|
|
1452 {
|
|
|
1453 int i=0,j=0,k,j1;
|
|
|
1454 for(i=0;i<128&&j<128;i++)
|
|
|
1455 {
|
|
|
1456 if(inpline[i]=='\n') {
|
|
|
1457 srcline[j]=0;break;
|
|
|
1458 }
|
|
|
1459 if(inpline[i]=='\t') {
|
|
|
1460 j1=j;
|
|
|
1461 for(k=0;k<8-j1%8 && j<128;k++)srcline[j++]=' ';
|
|
|
1462 }else srcline[j++]=inpline[i];
|
|
|
1463 }
|
|
|
1464 srcline[127]=0;
|
|
|
1465 }
|
|
|
1466
|
|
|
1467
|
|
|
1468 void
|
|
|
1469 processfile(char *name)
|
|
|
1470 {
|
|
|
1471 char *oldname;
|
|
|
1472 int oldno;
|
|
|
1473 FILE *srcfile;
|
|
|
1474 oldname=curname;
|
|
|
1475 curname=name;
|
|
|
1476 oldno=lineno;
|
|
|
1477 lineno=0;
|
|
|
1478 if((srcfile=fopen(name,"r"))==0) {
|
|
|
1479 int i = strlen(oldname);
|
|
|
1480 while(i>0 && oldname[i]!='/') i--;
|
|
|
1481 if (i>0) {
|
|
|
1482 char *next = strconcat(oldname,i+1,name);
|
|
|
1483 if((srcfile=fopen(next,"r"))==0) {
|
|
|
1484 fprintf(stderr,"Cannot open source file %s\n",next);
|
|
|
1485 exit(4);
|
|
|
1486 }
|
|
|
1487 curname = next;
|
|
|
1488 } else {
|
|
|
1489 fprintf(stderr,"Cannot open source file %s\n",name);
|
|
|
1490 exit(4);
|
|
|
1491 }
|
|
|
1492 }
|
|
|
1493 while(!terminate&&fgets(inpline,128,srcfile)) {
|
|
|
1494 expandline();
|
|
|
1495 lineno++;
|
|
|
1496 srcptr=srcline;
|
|
|
1497 if(suppress)suppressline(); else processline();
|
|
|
1498 }
|
|
|
1499 fclose(srcfile);
|
|
|
1500 if(suppress) {
|
|
|
1501 fprintf(stderr,"improperly nested IF statements in %s",curname);
|
|
|
1502 errors++;
|
|
|
1503 suppress=0;
|
|
|
1504 }
|
|
|
1505 lineno=oldno;
|
|
|
1506 curname=oldname;
|
|
|
1507 }
|
|
|
1508
|
|
|
1509 int
|
|
|
1510 main(int argc,char *argv[])
|
|
|
1511 {
|
|
|
1512 char c;
|
|
|
1513 getoptions(argc,argv);
|
|
|
1514 pass=1;
|
|
|
1515 errors=0;
|
|
|
1516 generating=0;
|
|
|
1517 terminate=0;
|
|
|
1518 processfile(srcname);
|
|
|
1519 if(errors) {
|
|
|
1520 fprintf(stderr,"%d Pass 1 Errors, Continue?",errors);
|
|
|
1521 c=getchar();
|
|
|
1522 if(c=='n'||c=='N') exit(3);
|
|
|
1523 }
|
|
|
1524 pass=2;
|
|
|
1525 loccounter=0;
|
|
|
1526 errors=0;
|
|
|
1527 generating=0;
|
|
|
1528 terminate=0;
|
|
|
1529 if(listing&&((listfile=fopen(listname,"w"))==0)) {
|
|
|
1530 fprintf(stderr,"Cannot open list file");
|
|
|
1531 exit(4);
|
|
|
1532 }
|
|
|
1533 if((objfile=fopen(objname,outmode?"w":"wb"))==0) {
|
|
|
1534 fprintf(stderr,"Cannot write object file\n");
|
|
|
1535 exit(4);
|
|
|
1536 }
|
|
|
1537 processfile(srcname);
|
|
|
1538 fprintf(stderr,"%d Pass 2 errors.\n",errors);
|
|
|
1539 if(listing) {
|
|
|
1540 fprintf(listfile,"%d Pass 2 errors.\n",errors);
|
|
|
1541 outsymtable();
|
|
|
1542 fclose(listfile);
|
|
|
1543 }
|
|
|
1544 if(outmode){
|
|
|
1545 flushhex();
|
|
|
1546 fprintf(objfile,"S9030000FC\n");
|
|
|
1547 }
|
|
|
1548 fclose(objfile);
|
|
|
1549 return 0;
|
|
|
1550 }
|
|
|
1551
|
