Version bump + cleanup for last commit; now at v2.0.19.
[rmac] / dsp56k_amode.c
1 //
2 // RMAC - Reboot's Macro Assembler for the Atari Jaguar Console System
3 // AMODE.C - DSP 56001 Addressing Modes
4 // Copyright (C) 199x Landon Dyer, 2011-2020 Reboot and Friends
5 // RMAC derived from MADMAC v1.07 Written by Landon Dyer, 1986
6 // Source utilised with the kind permission of Landon Dyer
7 //
8
9 #include "dsp56k_amode.h"
10 #include "error.h"
11 #include "token.h"
12 #include "expr.h"
13 #include "rmac.h"
14 #include "procln.h"
15 #include "sect.h"
16 #include "math.h"
17
18 #define DEF_KW
19 #include "kwtab.h"
20 #define DEF_MN
21 #include "mntab.h"
22
23 // Address-mode information
24 //int nmodes;                                           // Number of addr'ing modes found
25 int dsp_am0;                                    // Addressing mode
26 int dsp_a0reg;                                  // Register
27 TOKEN dsp_a0expr[EXPRSIZE];             // Expression
28 uint64_t dsp_a0exval;                   // Expression's value
29 WORD dsp_a0exattr;                              // Expression's attribute
30 LONG dsp_a0memspace;                    // Addressing mode's memory space (P, X, Y)
31 SYM * dsp_a0esym;                               // External symbol involved in expr
32
33 int dsp_am1;                                    // Addressing mode
34 int dsp_a1reg;                                  // Register
35 TOKEN dsp_a1expr[EXPRSIZE];             // Expression
36 uint64_t dsp_a1exval;                   // Expression's value
37 WORD dsp_a1exattr;                              // Expression's attribute
38 LONG dsp_a1memspace;                    // Addressing mode's memory space (P, X, Y)
39 SYM * dsp_a1esym;                               // External symbol involved in expr
40
41 int dsp_am2;                                    // Addressing mode
42 int dsp_a2reg;                                  // Register
43 TOKEN dsp_a2expr[EXPRSIZE];             // Expression
44 uint64_t dsp_a2exval;                   // Expression's value
45 WORD dsp_a2exattr;                              // Expression's attribute
46 SYM * dsp_a2esym;                               // External symbol involved in expr
47
48 int dsp_am3;                                    // Addressing mode
49 int dsp_a3reg;                                  // Register
50 TOKEN dsp_a3expr[EXPRSIZE];             // Expression
51 uint64_t dsp_a3exval;                   // Expression's value
52 WORD dsp_a3exattr;                              // Expression's attribute
53 SYM * dsp_a3esym;                               // External symbol involved in expr
54
55 TOKEN dspImmedEXPR[EXPRSIZE];   // Expression
56 uint64_t dspImmedEXVAL;                 // Expression's value
57 WORD  dspImmedEXATTR;                   // Expression's attribute
58 SYM * dspImmedESYM;                             // External symbol involved in expr
59 int  deposit_extra_ea;                  // Optional effective address extension
60 TOKEN dspaaEXPR[EXPRSIZE];              // Expression
61 uint64_t dspaaEXVAL;                    // Expression's value
62 WORD  dspaaEXATTR;                              // Expression's attribute
63 SYM * dspaaESYM;                                // External symbol involved in expr
64
65 LONG dsp_a0perspace;                    // Peripheral space (X, Y - used in movep)
66 LONG dsp_a1perspace;                    // Peripheral space (X, Y - used in movep)
67
68 int dsp_k;                                              // Multiplications sign
69
70 static inline LONG checkea(const uint32_t termchar, const int strings);
71
72 // ea checking error strings put into a table because I'm not sure there's an
73 // easy way to do otherwise (the messages start getting differerent in many
74 // places so it will get awkward to code those in) (I'd rather burn some RAM
75 // in order to have more helpful error messages than the other way round)
76
77 #define X_ERRORS 0
78 #define Y_ERRORS 1
79 #define L_ERRORS 2
80 #define P_ERRORS 3
81
82 const char *ea_errors[][12] = {
83         // X:
84         {
85                 "unrecognised X: parallel move syntax: expected '(' after 'X:-'",                                       // 0
86                 "unrecognised X: parallel move syntax: expected ')' after 'X:-(Rn'",                                    // 1
87                 "unrecognised X: parallel move syntax: expected R0-R7 after 'X:-('",                                    // 2
88                 "unrecognised X: parallel move syntax: expected N0-N7 after 'X:(Rn+'",                                  // 3
89                 "unrecognised X: parallel move syntax: expected same register number in Rn and Nn for 'X:(Rn+Nn)'",     // 4
90                 "unrecognised X: parallel move syntax: expected ')' after 'X:(Rn+Nn'",                                  // 5
91                 "unrecognised X: parallel move syntax: expected same register number in Rn and Nn for 'X:(Rn)+Nn'",     // 6
92                 "unrecognised X: parallel move syntax: expected N0-N7 after 'X:(Rn)+'",                                 // 7
93                 "unrecognised X: parallel move syntax: expected same register number in Rn and Nn for 'X:(Rn)-Nn'",     // 8
94                 "unrecognised X: parallel move syntax: expected N0-N7 after 'X:(Rn)-'",                                 // 9
95                 "unrecognised X: parallel move syntax: expected '+', '-' or ',' after 'X:(Rn)'",                        // 10
96                 "unrecognised X: parallel move syntax: expected '+' or ')' after 'X:(Rn'",                              // 11
97         },
98         // Y:
99         {
100                 "unrecognised Y: parallel move syntax: expected '(' after 'Y:-'",                                       // 0
101                 "unrecognised Y: parallel move syntax: expected ')' after 'Y:-(Rn'",                                    // 1
102                 "unrecognised Y: parallel move syntax: expected R0-R7 after 'Y:-('",                                    // 2
103                 "unrecognised Y: parallel move syntax: expected N0-N7 after 'Y:(Rn+'",                                  // 3
104                 "unrecognised Y: parallel move syntax: expected same register number in Rn and Nn for 'Y:(Rn+Nn)'",     // 4
105                 "unrecognised Y: parallel move syntax: expected ')' after 'Y:(Rn+Nn'",                                  // 5
106                 "unrecognised Y: parallel move syntax: expected same register number in Rn and Nn for 'Y:(Rn)+Nn'",     // 6
107                 "unrecognised Y: parallel move syntax: expected N0-N7 after 'Y:(Rn)+'",                                 // 7
108                 "unrecognised Y: parallel move syntax: expected same register number in Rn and Nn for 'Y:(Rn)-Nn'",     // 8
109                 "unrecognised Y: parallel move syntax: expected N0-N7 after 'Y:(Rn)-'",                                 // 9
110                 "unrecognised Y: parallel move syntax: expected '+', '-' or ',' after 'Y:(Rn)'",                        // 10
111                 "unrecognised Y: parallel move syntax: expected '+' or ')' after 'Y:(Rn'",                              // 11
112         },
113         // L:
114         {
115                 "unrecognised L: parallel move syntax: expected '(' after 'L:-'",                                       // 0
116                 "unrecognised L: parallel move syntax: expected ')' after 'L:-(Rn'",                                    // 1
117                 "unrecognised L: parallel move syntax: expected R0-R7 after 'L:-('",                                    // 2
118                 "unrecognised L: parallel move syntax: expected N0-N7 after 'L:(Rn+'",                                  // 3
119                 "unrecognised L: parallel move syntax: expected same register number in Rn and Nn for 'L:(Rn+Nn)'",     // 4
120                 "unrecognised L: parallel move syntax: expected ')' after 'L:(Rn+Nn'",                                  // 5
121                 "unrecognised L: parallel move syntax: expected same register number in Rn and Nn for 'L:(Rn)+Nn'",     // 6
122                 "unrecognised L: parallel move syntax: expected N0-N7 after 'L:(Rn)+'",                                 // 7
123                 "unrecognised L: parallel move syntax: expected same register number in Rn and Nn for 'L:(Rn)-Nn'",     // 8
124                 "unrecognised L: parallel move syntax: expected N0-N7 after 'L:(Rn)-'",                                 // 9
125                 "unrecognised L: parallel move syntax: expected '+', '-' or ',' after 'L:(Rn)'",                        // 10
126                 "unrecognised L: parallel move syntax: expected '+' or ')' after 'L:(Rn'",                              // 11
127         },
128         // P:
129         {
130                 "unrecognised P: effective address syntax: expected '(' after 'P:-'",                                       // 0
131                 "unrecognised P: effective address syntax: expected ')' after 'P:-(Rn'",                                    // 1
132                 "unrecognised P: effective address syntax: expected R0-R7 after 'P:-('",                                    // 2
133                 "unrecognised P: effective address syntax: expected N0-N7 after 'P:(Rn+'",                                  // 3
134                 "unrecognised P: effective address syntax: expected same register number in Rn and Nn for 'P:(Rn+Nn)'",     // 4
135                 "unrecognised P: effective address syntax: expected ')' after 'P:(Rn+Nn'",                                  // 5
136                 "unrecognised P: effective address syntax: expected same register number in Rn and Nn for 'P:(Rn)+Nn'",     // 6
137                 "unrecognised P: effective address syntax: expected N0-N7 after 'P:(Rn)+'",                                 // 7
138                 "unrecognised P: effective address syntax: expected same register number in Rn and Nn for 'P:(Rn)-Nn'",     // 8
139                 "unrecognised P: effective address syntax: expected N0-N7 after 'P:(Rn)-'",                                 // 9
140                 "unrecognised P: effective address syntax: expected '+', '-' or ',' after 'P:(Rn)'",                        // 10
141                 "unrecognised P: effective address syntax: expected '+' or ')' after 'P:(Rn'",                              // 11
142         }
143 };
144
145 enum
146 {
147         NUM_NORMAL = 0,
148         NUM_FORCE_LONG = 1,
149         NUM_FORCE_SHORT = 2
150 };
151
152
153 //
154 // Parse a single addressing mode
155 //
156 static inline int dsp_parmode(int *am, int *areg, TOKEN * AnEXPR, uint64_t * AnEXVAL, WORD * AnEXATTR, SYM ** AnESYM, LONG *memspace, LONG *perspace, const int operand)
157 {
158         if (*tok == KW_A || *tok == KW_B)
159         {
160                 *am = M_ACC56;
161                 *areg = *tok++;
162                 return OK;
163         }
164         else if (*tok == '#')
165         {
166                 tok++;
167
168                 if (*tok == '<')
169                 {
170                         // Immediate Short Addressing Mode Force Operator
171                         tok++;
172                         if (expr(AnEXPR, AnEXVAL, AnEXATTR, AnESYM) != OK)
173                                 return ERROR;
174
175                         if (*AnEXVAL > 0xFFF && *AnEXVAL < -4096)
176                                 return error("immediate short addressing mode forced but address is bigger than $FFF");
177
178                         if ((int32_t)*AnEXVAL <= 0xFF && (int32_t)*AnEXVAL > -0x100)
179                         {
180                                 *am = M_DSPIM8;
181                                 return OK;
182                         }
183
184                         *am = M_DSPIM12;
185                         return OK;
186                 }
187                 else if (*tok == '>')
188                 {
189                         // Immediate Long Addressing Mode Force Operator
190                         tok++;
191
192                         if (expr(AnEXPR, AnEXVAL, AnEXATTR, AnESYM) != OK)
193                                 return ERROR;
194
195                         if ((int32_t)*AnEXVAL > 0xFFFFFF || (int32_t)*AnEXVAL < -0xFFFFFF)
196                                 return error("long immediate is bigger than $FFFFFF");
197
198                         *am = M_DSPIM;
199                         return OK;
200                 }
201
202                 if (expr(AnEXPR, AnEXVAL, AnEXATTR, AnESYM) != OK)
203                         return ERROR;
204
205                 if (*AnEXATTR & DEFINED)
206                 {
207                         if ((int32_t)*AnEXVAL < 0x100 && (int32_t)*AnEXVAL >= -0x100)
208                         {
209                                 *AnEXVAL &= 0xFF;
210                                 *am = M_DSPIM8;
211                         }
212                         else if (*AnEXVAL < 0x1000)
213                                 *am = M_DSPIM12;
214                         else
215                                 *am = M_DSPIM;
216                 }
217                 else
218                 {
219                         // We have no clue what size our immediate will be
220                         // so we have to assume the worst
221                         *am = M_DSPIM;
222                 }
223
224                 return OK;
225         }
226         else if (*tok >= KW_X0 && *tok <= KW_Y1)
227         {
228                 *am = M_ALU24;
229                 *areg = *tok++;
230                 return OK;
231         }
232         else if (*tok == KW_X && *(tok + 1) == ':')
233         {
234                 tok = tok + 2;
235
236                 if (*tok == CONST || *tok == FCONST || *tok == SYMBOL)
237                 {
238                         if (expr(AnEXPR, AnEXVAL, AnEXATTR, AnESYM) != OK)
239                                 return ERROR;
240
241                         if (*AnEXATTR & DEFINED)
242                         {
243                                 if (*AnEXVAL > 0xFFFFFF)
244                                         return error("long address is bigger than $FFFFFF");
245
246                                 *memspace = 0 << 6;     // Mark we're on X memory space
247
248                                 // Check if value is between $FFC0 and $FFFF, AKA X:pp
249                                 uint32_t temp = (LONG)(((int32_t)(((uint32_t)*AnEXVAL) << (32 - 6))) >> (32 - 6));  // Sign extend 6 to 32 bits
250
251                                 if ((temp >= 0xFFFFFFC0                      /* Check for 32bit sign extended number */
252                                         && ((int32_t)*AnEXVAL < 0))              /* Check if 32bit signed number is negative*/
253                                         || (*AnEXVAL < 0xFFFF && *AnEXVAL >= 0x8000)) /* Check if 16bit number is negative*/
254                                 {
255                                         *AnEXVAL = temp;
256                                         *am = M_DSPPP;
257                                         *memspace = 0 << 6;          // Mark we're on X memory space
258                                         *perspace = 0 << 16;         // Mark we're on X peripheral space
259                                         *areg = *AnEXVAL & 0x3F;     // Since this is only going to get used in dsp_ea_imm5...
260                                         return OK;
261                                 }
262
263                                 // If the symbol/expression is defined then check for valid range.
264                                 // Otherwise the value had better fit or Fixups will bark!
265                                 if (*AnEXVAL > 0x3F)
266                                 {
267                                         *am = M_DSPEA;
268                                         *areg = DSP_EA_ABS;
269                                 }
270                                 else
271                                 {
272                                         *am = M_DSPAA;
273                                 }
274                         }
275                         else
276                         {
277                                 // Assume the worst
278                                 *memspace = 0 << 6;     // Mark we're on X memory space
279                                 *am = M_DSPEA;
280                                 *areg = DSP_EA_ABS;
281                         }
282
283                         return OK;
284                 }
285                 else if (*tok == '<')
286                 {
287                         // X:aa
288                         // Short Addressing Mode Force Operator in the case of '<'
289                         tok++;
290
291                         if (expr(AnEXPR, AnEXVAL, AnEXATTR, AnESYM) != OK)
292                                 return ERROR;
293
294                         // If the symbol/expression is defined then check for valid range.
295                         // Otherwise the value had better fit or Fixups will bark!
296                         if (*AnEXATTR & DEFINED)
297                         {
298                                 if (*AnEXVAL > 0x3F)
299                                         return error("short addressing mode forced but address is bigger than $3F");
300                         }
301                         else
302                         {
303                                 // Mark it as a fixup
304                                 deposit_extra_ea = DEPOSIT_EXTRA_FIXUP;
305                         }
306
307                         *am = M_DSPAA;
308                         *memspace = 0 << 6;     // Mark we're on X memory space
309                         *areg = (int)*AnEXVAL;     // Since this is only going to get used in dsp_ea_imm5...
310                         return OK;
311                 }
312                 else if (*tok == '>')
313                 {
314                         // Long Addressing Mode Force Operator
315                         tok++;
316
317                         if (*tok == CONST || *tok == FCONST || *tok == SYMBOL)
318                         {
319                                 if (expr(AnEXPR, AnEXVAL, AnEXATTR, AnESYM) != OK)
320                                         return ERROR;
321
322                                 if (*AnEXATTR&DEFINED)
323                                 {
324                                         if (*AnEXVAL > 0xFFFFFF)
325                                                 return error("long address is bigger than $FFFFFF");
326
327                                         *memspace = 0 << 6;     // Mark we're on X memory space
328                                         *am = M_DSPEA;
329                                         *areg = DSP_EA_ABS;
330                                 }
331                                 else
332                                 {
333                                         // Assume the worst
334                                         *memspace = 0 << 6;     // Mark we're on X memory space
335                                         *am = M_DSPEA;
336                                         *areg = DSP_EA_ABS;
337                                 }
338                                 return OK;
339                         }
340                 }
341                 else if (*tok == SHL)  // '<<'
342                 {
343                         // I/O Short Addressing Mode Force Operator
344                         // X:pp
345                         tok++;
346
347                         if (expr(AnEXPR, AnEXVAL, AnEXATTR, AnESYM) != OK)
348                                 return ERROR;
349
350                         // If the symbol/expression is defined then check for valid range.
351                         // Otherwise the value had better fit or Fixups will bark!
352                         if (*AnEXATTR & DEFINED)
353                         {
354                                 *AnEXVAL = (LONG)(((int32_t)(((uint32_t)*AnEXVAL) << (32 - 6))) >> (32 - 6));  // Sign extend 6 to 32 bits
355
356                                 if (*AnEXVAL < 0xFFFFFFC0)
357                                         return error("I/O Short Addressing Mode addresses must be between $FFC0 and $FFFF");
358                         }
359
360                         *am = M_DSPPP;
361                         *memspace = 0 << 6;          // Mark we're on X memory space
362                         *perspace = 0 << 16;         // Mark we're on X peripheral space
363                         *areg = *AnEXVAL & 0x3F;     // Since this is only going to get used in dsp_ea_imm5...
364                         return OK;
365                 }
366
367                 if ((*areg = checkea(0, X_ERRORS)) != ERROR)
368                 {
369                         // TODO: what if we need M_DSPAA here????
370                         *memspace = 0 << 6;     // Mark we're on X memory space
371                         *am = M_DSPEA;
372                         return OK;
373                 }
374                 else
375                         return ERROR;
376         }
377         else if (*tok == KW_Y && *(tok + 1) == ':')
378         {
379                 tok = tok + 2;
380
381                 if (*tok == CONST || *tok == FCONST || *tok == SYMBOL)
382                 {
383                         if (expr(AnEXPR, AnEXVAL, AnEXATTR, AnESYM) != OK)
384                                 return ERROR;
385
386                         if (*AnEXVAL > 0xFFFFFF)
387                                 return error("long address is bigger than $FFFFFF");
388
389                         *memspace = 1 << 6;     // Mark we're on Y memory space
390
391                         // Check if value is between $ffc0 and $ffff, AKA Y:pp
392                         uint32_t temp = (LONG)(((int32_t)(((uint32_t)*AnEXVAL) << (32 - 6))) >> (32 - 6));  // Sign extend 6 to 32 bits
393
394                         if ((temp >= 0xFFFFFFC0                         /* Check for 32bit sign extended number */
395                                 && ((int32_t)*AnEXVAL < 0))                 /* Check if 32bit signed number is negative*/
396                                 || (*AnEXVAL < 0xFFFF && *AnEXVAL >= 0x8000)) /* Check if 16bit number is negative*/
397                         {
398                                 *AnEXVAL = temp;
399                                 *am = M_DSPPP;
400                                 *perspace = 1 << 16;         // Mark we're on X peripheral space
401                                 *areg = *AnEXVAL & 0x3F;     // Since this is only going to get used in dsp_ea_imm5...
402                                 return OK;
403                         }
404
405                         // If the symbol/expression is defined then check for valid range.
406                         // Otherwise the value had better fit or Fixups will bark!
407                         if (*AnEXATTR & DEFINED)
408                         {
409                                 if (*AnEXVAL > 0x3F)
410                                 {
411                                         *am = M_DSPEA;
412                                         *areg = DSP_EA_ABS;
413                                 }
414                                 else
415                                 {
416                                         *am = M_DSPAA;
417                                 }
418                         }
419                         else
420                         {
421                                 *am = M_DSPEA;
422                                 *areg = DSP_EA_ABS;
423                         }
424
425                         return OK;
426                 }
427                 else if (*tok == '<')
428                 {
429                         // Y:aa
430                         // Short Addressing Mode Force Operator in the case of '<'
431                         tok++;
432
433                         if (expr(AnEXPR, AnEXVAL, AnEXATTR, AnESYM) != OK)
434                                 return ERROR;
435
436                         // If the symbol/expression is defined then check for valid range.
437                         // Otherwise the value had better fit or Fixups will bark!
438                         if (*AnEXATTR & DEFINED)
439                         {
440                                 if (*AnEXVAL > 0x3F)
441                                 {
442                                         if (optim_warn_flag)
443                                                 warn("short addressing mode forced but address is bigger than $3F - switching to long");
444
445                                         *am = M_DSPEA;
446                                         *memspace = 1 << 6;     // Mark we're on Y memory space
447                                         *areg = DSP_EA_ABS;
448                                         return OK;
449                                 }
450                         }
451                         else
452                         {
453                                 // Mark it as a fixup
454                                 deposit_extra_ea = DEPOSIT_EXTRA_FIXUP;
455                         }
456
457                         *am = M_DSPAA;
458                         *memspace = 1 << 6;     // Mark we're on Y memory space
459                         *areg = (int)*AnEXVAL;      // Since this is only going to get used in dsp_ea_imm5...
460                         return OK;
461                 }
462                 else if (*tok == '>')
463                 {
464                         // Long Addressing Mode Force Operator
465                         tok++;
466
467                         if (*tok == CONST || *tok == FCONST || *tok == SYMBOL)
468                         {
469                                 if (expr(AnEXPR, AnEXVAL, AnEXATTR, AnESYM) != OK)
470                                         return ERROR;
471
472                                 if (*AnEXATTR&DEFINED)
473                                 {
474                                         if (*AnEXVAL > 0xFFFFFF)
475                                                 return error("long address is bigger than $FFFFFF");
476
477                                         *memspace = 1 << 6;     // Mark we're on Y memory space
478
479                                         *am = M_DSPEA;
480                                         *areg = DSP_EA_ABS;
481                                 }
482                                 else
483                                 {
484                                         // Assume the worst
485                                         *memspace = 1 << 6;     // Mark we're on Y memory space
486                                         *am = M_DSPEA;
487                                         *areg = DSP_EA_ABS;
488                                 }
489                                 return OK;
490                         }
491                 }
492                 else if (*tok == SHL)  // '<<'
493                 {
494                         // I/O Short Addressing Mode Force Operator
495                         // Y:pp
496                         tok++;
497
498                         if (expr(AnEXPR, AnEXVAL, AnEXATTR, AnESYM) != OK)
499                                 return ERROR;
500
501                         // If the symbol/expression is defined then check for valid range.
502                         // Otherwise the value had better fit or Fixups will bark!
503                         if (*AnEXATTR & DEFINED)
504                         {
505                                 *AnEXVAL = (LONG)(((int32_t)(((uint32_t)*AnEXVAL) << (32 - 6))) >> (32 - 6));  // Sign extend 6 to 32 bits
506
507                                 if (*AnEXVAL < 0xFFFFFFC0)
508                                         return error("I/O Short Addressing Mode addresses must be between $FFE0 and $1F");
509                         }
510
511                         *am = M_DSPPP;
512                         *memspace = 1 << 6;          // Mark we're on Y memory space
513                         *perspace = 1 << 16;         // Mark we're on Y peripheral space
514                         *areg = *AnEXVAL & 0x3F;     // Since this is only going to get used in dsp_ea_imm5...
515                         return OK;
516                 }
517
518                 if ((*areg = checkea(0, X_ERRORS)) != ERROR)
519                 {
520                         *memspace = 1 << 6;     // Mark we're on Y memory space
521                         *am = M_DSPEA;
522                         return OK;
523                 }
524                 else
525                         return ERROR;
526                 // TODO: add absolute address checks
527         }
528         else if ((*tok >= KW_X) && (*tok <= KW_Y))
529         {
530                 *am = M_INP48;
531                 *areg = *tok++;
532                 return OK;
533         }
534         else if ((*tok >= KW_M0) && (*tok <= KW_M7))
535         {
536                 *am = M_DSPM;
537                 *areg = (*tok++) & 7;
538                 return OK;
539         }
540         else if ((*tok >= KW_R0) && (*tok <= KW_R7))
541         {
542                 *am = M_DSPR;
543                 *areg = (*tok++) - KW_R0;
544                 return OK;
545         }
546         else if ((*tok >= KW_N0) && (*tok <= KW_N7))
547         {
548                 *am = M_DSPN;
549                 *areg = (*tok++) & 7;
550                 return OK;
551         }
552         else if ((*tok == KW_A0) || (*tok == KW_A1) || (*tok == KW_B0)
553                 || (*tok == KW_B1))
554         {
555                 *am = M_ACC24;
556                 *areg = *tok++;
557                 return OK;
558         }
559         else if ((*tok == KW_A2) || (*tok == KW_B2))
560         {
561                 *am = M_ACC8;
562                 *areg = *tok++;
563                 return OK;
564         }
565         else if ((*tok == '-') && (*(tok + 1) == KW_X0 || *(tok + 1) == KW_X1 || *(tok + 1) == KW_Y0 || *(tok + 1) == KW_Y1))
566         {
567                 // '-X0', '-Y0', '-X1' or '-Y1', used in multiplications
568                 tok++;
569
570                 // Check to see if this is the first operand
571                 if (operand != 0)
572                         return error("-x0/-x1/-y0/-y1 only allowed in the first operand");
573
574                 *am = M_ALU24;
575                 *areg = *tok++;
576                 dsp_k = 1 << 2;
577                 return OK;
578         }
579         else if (*tok == '+' && (*(tok + 1) == KW_X0 || *(tok + 1) == KW_X1 || *(tok + 1) == KW_Y0 || *(tok + 1) == KW_Y1))
580         {
581                 // '+X0', '+Y0', '+X1' or '+Y1', used in multiplications
582                 tok++;
583
584                 // Check to see if this is the first operand
585                 if (operand != 0)
586                         return error("+x0/+x1/+y0/+y1 only allowed in the first operand");
587
588                 *am = M_ALU24;
589                 *areg = *tok++;
590                 dsp_k = 0 << 2;
591                 return OK;
592         }
593         else if (*tok == '(' || *tok == '-')
594         {
595                 // Could be either an expression or ea mode
596                 if (*tok + 1 == SYMBOL)
597                 {
598                         tok++;
599
600                         if (expr(AnEXPR, AnEXVAL, AnEXATTR, AnESYM) != OK)
601                                 return ERROR;
602
603                         *am = M_DSPIM;
604                         return OK;
605                 }
606
607                 if ((*areg = checkea(0, P_ERRORS)) != ERROR)
608                 {
609                         *am = M_DSPEA;
610                         return OK;
611                 }
612                 else
613                         return ERROR;
614
615                 // TODO: add absolute address checks
616                 return error("internal assembler error: parmode checking for '(' and '-' does not have absolute address checks yet!");
617         }
618         else if (*tok == KW_P && *(tok + 1) == ':')
619         {
620                 tok = tok + 2;
621
622                 if (*tok == CONST || *tok == FCONST || *tok == SYMBOL)
623                 {
624                         // Address
625                         if (expr(AnEXPR, AnEXVAL, AnEXATTR, AnESYM) != OK)
626                                 return ERROR;
627
628                         if (*AnEXVAL > 0xFFFFFF)
629                                 return error("long address is bigger than $FFFFFF");
630
631                         if (*AnEXVAL > 0x3F)
632                         {
633                                 *am = M_DSPEA;
634                                 *areg = DSP_EA_ABS;
635                         }
636                         else
637                         {
638                                 *areg = (int)*AnEXVAL;     // Lame, but what the hell
639                                 *am = M_DSPAA;
640                         }
641
642                         return OK;
643                 }
644                 else if (*tok == '<')
645                 {
646                         // X:aa
647                         // Short Addressing Mode Force Operator in the case of '<'
648                         tok++;
649
650                         if (expr(AnEXPR, AnEXVAL, AnEXATTR, AnESYM) != OK)
651                                 return ERROR;
652
653                         if (*AnEXVAL > 0x3F)
654                                 return error("short addressing mode forced but address is bigger than $3F");
655
656                         *am = M_DSPAA;
657                         *areg = (int)*AnEXVAL;     // Since this is only going to get used in dsp_ea_imm5...
658                         return OK;
659                 }
660                 else if (*tok == '>')
661                 {
662                         // Long Addressing Mode Force Operator
663                         tok++;
664
665                         // Immediate Short Addressing Mode Force Operator
666                         if (expr(AnEXPR, AnEXVAL, AnEXATTR, AnESYM) != OK)
667                                 return ERROR;
668
669                         if (*AnEXATTR & DEFINED)
670                         {
671                                 if (*AnEXVAL > 0xFFFFFF)
672                                         return error("long address is bigger than $FFFFFF");
673                         }
674
675                         *am = M_DSPEA;
676                         *areg = DSP_EA_ABS;
677                         return OK;
678                 }
679
680                 if ((*areg = checkea(0, P_ERRORS)) != ERROR)
681                 {
682                         *am = M_DSPEA;
683                         return OK;
684                 }
685                 else
686                         return ERROR;
687         }
688         else if (*tok == SHL)
689         {
690                 // I/O Short Addressing Mode Force Operator
691                 tok++;
692
693                 if (expr(AnEXPR, AnEXVAL, AnEXATTR, AnESYM) != OK)
694                         return ERROR;
695
696                 if (*AnEXVAL > 0xFFF)
697                         return error("I/O short addressing mode forced but address is bigger than $FFF");
698
699                 *am = M_DSPABS06;
700                 return OK;
701         }
702         else if (*tok == '<')
703         {
704                 // Short Addressing Mode Force Operator
705                 tok++;
706
707                 if (expr(AnEXPR, AnEXVAL, AnEXATTR, AnESYM) != OK)
708                         return ERROR;
709
710                 if (*AnEXATTR & DEFINED)
711                 {
712                         if (*AnEXVAL > 0xFFF)
713                                 return error("short addressing mode forced but address is bigger than $FFF");
714                 }
715
716                 *am = M_DSPABS12;
717                 return OK;
718         }
719         else if (*tok == '>')
720         {
721                 // Long Addressing Mode Force Operator
722                 tok++;
723
724                 // Immediate Short Addressing Mode Force Operator
725                 if (expr(AnEXPR, AnEXVAL, AnEXATTR, AnESYM) != OK)
726                         return ERROR;
727
728                 if (*AnEXATTR & DEFINED)
729                 {
730                         if (*AnEXVAL > 0xFFFFFF)
731                                 return error("long address is bigger than $FFFFFF");
732                 }
733
734                 *am = M_DSPEA;
735                 *areg = DSP_EA_ABS;
736                 return OK;
737         }
738         else if (*tok == KW_PC || *tok == KW_CCR || *tok == KW_SR || *tok == KW_SP || (*tok >= KW_MR&&*tok <= KW_SS))
739         {
740                 *areg = *tok++;
741                 *am = M_DSPPCU;
742                 return OK;
743         }
744         // expr
745         else
746         {
747                 if (expr(AnEXPR, AnEXVAL, AnEXATTR, AnESYM) != OK)
748                         return ERROR;
749
750                 // We'll store M_DSPEA_ABS in areg and if we have
751                 // any extra info, it'll go in am
752                 if (*AnEXATTR & DEFINED)
753                 {
754                         *areg = DSP_EA_ABS;
755
756                         if (*AnEXVAL < 0x1000)
757                                 *am = M_DSPABS12;
758                         else if (*AnEXVAL < 0x10000)
759                                 *am = M_DSPABS16;
760                         else if (*AnEXVAL < 0x1000000)
761                                 *am = M_DSPABS24;
762                         else
763                                 return error("address must be smaller than $1000000");
764
765                         return OK;
766                 }
767                 else
768                 {
769                         // Well, we have no opinion on the expression's size, so let's assume the worst
770                         *areg = DSP_EA_ABS;
771                         *am = M_DSPABS24;
772                         return OK;
773                 }
774         }
775
776         return error("internal assembler error: Please report this error message: 'reached the end of dsp_parmode' with the line of code that caused it. Thanks, and sorry for the inconvenience");   // Something bad happened
777 }
778
779
780 //
781 // Parse all addressing modes except parallel moves
782 //
783 int dsp_amode(int maxea)
784 {
785         LONG dummy;
786         // Initialize global return values
787         nmodes = dsp_a0reg = dsp_a1reg = 0;
788         dsp_am0 = dsp_am1 = M_AM_NONE;
789         dsp_a0expr[0] = dsp_a1expr[0] = ENDEXPR;
790         dsp_a0exval = 0;
791         dsp_a1exval = 0;
792         dsp_a0exattr = dsp_a1exattr = 0;
793         dsp_a0esym = dsp_a1esym = (SYM *)NULL;
794         dsp_a0memspace = dsp_a1memspace = -1;
795         dsp_a0perspace = dsp_a1perspace = -1;
796         dsp_k = 0;
797
798         // If at EOL, then no addr modes at all
799         if (*tok == EOL)
800                 return 0;
801
802         if (dsp_parmode(&dsp_am0, &dsp_a0reg, dsp_a0expr, &dsp_a0exval, &dsp_a0exattr, &dsp_a0esym, &dsp_a0memspace, &dsp_a0perspace, 0) == ERROR)
803                 return ERROR;
804
805
806         // If caller wants only one mode, return just one (ignore comma);
807         // If there is no second addressing mode (no comma), then return just one anyway.
808         nmodes = 1;
809
810         if (*tok != ',')
811         {
812                 if (dsp_k != 0)
813                         return error("-x0/-x1/-y0/-y1 only allowed in multiply operations");
814
815                 return 1;
816         }
817
818         // Eat the comma
819         tok++;
820
821         // Parse second addressing mode
822         if (dsp_parmode(&dsp_am1, &dsp_a1reg, dsp_a1expr, &dsp_a1exval, &dsp_a1exattr, &dsp_a1esym, &dsp_a1memspace, &dsp_a1perspace, 1) == ERROR)
823                 return ERROR;
824
825         if (maxea == 2 || *tok == EOL)
826         {
827                 if (dsp_k != 0)
828                         return error("-x0/-x1/-y0/-y1 only allowed in multiply operations");
829
830                 nmodes = 2;
831                 return 2;
832         }
833
834         if (*tok == ',')
835         {
836                 // Only MAC-like or jsset/clr/tst/chg instructions here
837                 tok++;
838                 if (dsp_parmode(&dsp_am2, &dsp_a2reg, dsp_a2expr, &dsp_a2exval, &dsp_a2exattr, &dsp_a2esym, &dummy, &dummy, 2) == ERROR)
839                         return ERROR;
840                 if (maxea == 3)
841                         return 3;
842                 if (*tok != EOL)
843                         return error(extra_stuff);
844                 nmodes = 3;
845                 return 3;
846
847         }
848
849         // Only Tcc instructions here, and then only those that accept 4 operands
850
851         if (dsp_parmode(&dsp_am2, &dsp_a2reg, dsp_a2expr, &dsp_a2exval, &dsp_a2exattr, &dsp_a2esym, &dummy, &dummy, 2) == ERROR)
852                 return ERROR;
853
854         if (*tok++ != ',')
855                 return error("expected 4 parameters");
856
857         if (dsp_parmode(&dsp_am3, &dsp_a3reg, dsp_a3expr, &dsp_a3exval, &dsp_a3exattr, &dsp_a3esym, &dummy, &dummy, 3) == ERROR)
858                 return ERROR;
859
860         if (*tok == EOL)
861         {
862                 if (dsp_k != 0)
863                         return error("-x0/-x1/-y0/-y1 only allowed in multiply operations");
864
865                 nmodes = 4;
866                 return 4;
867         }
868         else
869         {
870                 // Tcc instructions do not support parallel moves, so any remaining tokens are garbage
871                 return error(extra_stuff);
872         }
873
874         return error("internal assembler error: Please report this error message: 'reached the end of dsp_amode' with the line of code that caused it. Thanks, and sorry for the inconvenience");   //Something bad happened
875 }
876
877
878 //
879 // Helper function which gives us the encoding of a DSP register
880 //
881 static inline int SDreg(int reg)
882 {
883         if (reg >= KW_X0 && reg <= KW_N7)
884                 return reg & 0xFF;
885         else if (reg >= KW_A0&&reg <= KW_A2)
886                 return (8 >> (reg & 7)) | 8;
887         else //if (reg>=KW_R0&&reg<=KW_R7)
888                 return reg - KW_R0 + 16;
889         // Handy map for the above:
890         // (values are of course taken from keytab)
891         // Register | Value | Return value
892         //      x0      | 260   | 4
893         //      x1      | 261   | 5
894         //      y0      | 262   | 6
895         //      y1      | 263   | 7
896         //      b0      | 265   | 8
897         //      b2      | 267   | 9
898         //      b1      | 269   | 10
899         //      a       | 270   | 14
900         //      b       | 271   | 15
901         //      n0      | 280   | 24
902         //      n1      | 281   | 25
903         //      n2      | 282   | 26
904         //      n3      | 283   | 27
905         //      n4      | 284   | 28
906         //      n5      | 285   | 29
907         //      n6      | 286   | 30
908         //      n7      | 287   | 31
909         //      a0          | 136   | 0
910         //      a1          | 137   | 1
911         //      a2      | 138   | 2
912         //      r0          | 151   | 16
913         //      r1          | 152   | 17
914         //      r2          | 153   | 18
915         //      r3          | 154   | 19
916         //      r4          | 155   | 20
917         //      r5          | 156   | 21
918         //      r6          | 157   | 22
919         //      r7          | 158   | 23
920 }
921
922
923 //
924 // Check for X:Y: parallel mode syntax
925 //
926 static inline LONG check_x_y(LONG ea1, LONG S1)
927 {
928         LONG inst;
929         LONG eax_temp, eay_temp;
930         LONG D1, D2, S2, ea2;
931         LONG K_D1, K_D2;
932         LONG w = 1 << 7;                // S1=0, D1=1<<14
933
934         if ((ea1 & 0x38) == DSP_EA_POSTINC || (ea1 & 0x38) == DSP_EA_POSTINC1 ||
935                 (ea1 & 0x38) == DSP_EA_POSTDEC1 || (ea1 & 0x38) == DSP_EA_NOUPD)
936         {
937                 switch (ea1 & 0x38)
938                 {
939                 case DSP_EA_POSTINC:  ea1 = (ea1 & (~0x38)) | 0x8; break;
940                 case DSP_EA_POSTINC1: ea1 = (ea1 & (~0x38)) | 0x18; break;
941                 case DSP_EA_POSTDEC1: ea1 = (ea1 & (~0x38)) | 0x10; break;
942                 case DSP_EA_NOUPD:    ea1 = (ea1 & (~0x38)) | 0x00; break;
943                 }
944
945                 if (S1 == 0)
946                 {
947                         // 'X:eax,D1 Y:eay,D2', 'X:eax,D1 S2,Y:eay'
948                         // Check for D1
949                         switch (K_D1 = *tok++)
950                         {
951                         case KW_X0: D1 = 0 << 10; break;
952                         case KW_X1: D1 = 1 << 10; break;
953                         case KW_A:  D1 = 2 << 10; break;
954                         case KW_B:  D1 = 3 << 10; break;
955                         default:    return error("unrecognised X:Y: parallel move syntax: expected x0, x1, a or b after 'X:eax,'");
956                         }
957                 }
958                 else
959                 {
960                         // 'S1,X:eax Y:eay,D2' 'S1,X:eax S2,Y:eay'
961                         w = 0;
962
963                         switch (S1)
964                         {
965                         case 4:  D1 = 0 << 10; break;
966                         case 5:  D1 = 1 << 10; break;
967                         case 14: D1 = 2 << 10; break;
968                         case 15: D1 = 3 << 10; break;
969                         default: return error("unrecognised X:Y: parallel move syntax: S1 can only be x0, x1, a or b in 'S1,X:eax'");
970                         }
971                 }
972
973                 if (*tok == KW_Y)
974                 {
975                         tok++;
976                         // 'X:eax,D1 Y:eay,D2' 'S1,X:eax Y:eay,D2'
977                         if (*tok++ != ':')
978                                 return error("unrecognised X:Y: parallel move syntax: expected ':' after 'X:ea,D1/S1,X:ea Y'");
979
980                         if (*tok++ == '(')
981                         {
982                                 if (*tok >= KW_R0 && *tok <= KW_R7)
983                                 {
984                                         ea2 = (*tok++ - KW_R0);
985
986                                         if (((ea1 & 7) < 4 && ea2 < 4) || ((ea1 & 7) >= 4 && ea2 > 4))
987                                                 return error("unrecognised X:Y: parallel move syntax: eax and eay register banks must be different in 'X:ea,D1/S1,X:ea Y:eay,D2'");
988                                 }
989                                 else
990                                         return error("unrecognised X:Y: parallel move syntax: expected 'Rn' after 'X:ea,D1/S1,X:ea Y:('");
991
992                                 // If eax register is r0-r3 then eay register is r4-r7.
993                                 // Encode that to 2 bits (i.e. eay value is 0-3)
994                                 eax_temp = (ea2 & 3) << 5;  // Store register temporarily
995
996                                 if (*tok++ != ')')
997                                         return error("unrecognised X:Y: parallel move syntax: expected ')' after 'X:ea,D1/S1,X:ea Y:(Rn'");
998
999                                 if (*tok == '+')
1000                                 {
1001                                         tok++;
1002
1003                                         if (*tok == ',')
1004                                         {
1005                                                 // (Rn)+
1006                                                 ea2 = 3 << 12;
1007                                                 tok++;
1008                                         }
1009                                         else if (*tok >= KW_N0 && *tok <= KW_N7)
1010                                         {
1011                                                 // (Rn)+Nn
1012                                                 if ((*tok++ & 7) != ea2)
1013                                                         return error("unrecognised X:Y: parallel move syntax(Same register number expected for Rn, Nn in 'X:ea,D1/S1,X:ea Y:(Rn)+Nn,D')");
1014
1015                                                 ea2 = 1 << 12;
1016
1017                                                 if (*tok++ != ',')
1018                                                         return error("unrecognised X:Y: parallel move syntax: expected ',' after 'X:ea,D1/S1,X:ea Y:(Rn)+Nn'");
1019                                         }
1020                                         else
1021                                                 return error("unrecognised X:Y: parallel move syntax: expected ',' or 'Nn' after 'X:ea,D1/S1,X:ea Y:(Rn)+'");
1022
1023                                 }
1024                                 else if (*tok == '-')
1025                                 {
1026                                         // (Rn)-
1027                                         ea2 = 2 << 12;
1028                                         tok++;
1029
1030                                         if (*tok++ != ',')
1031                                                 return error("unrecognised X:Y: parallel move syntax: expected ',' after 'X:ea,D1/S1,X:ea Y:(Rn)-'");
1032                                 }
1033                                 else if (*tok++ == ',')
1034                                 {
1035                                         // (Rn)
1036                                         ea2 = 0 << 12;
1037                                 }
1038                                 else
1039                                         return error("unrecognised X:Y: parallel move syntax: expected ',' after 'X:ea,D1/S1,X:ea Y:eay'");
1040
1041                                 ea2 |= eax_temp; // OR eay back from temp
1042
1043                                 switch (K_D2 = *tok++)
1044                                 {
1045                                 case KW_Y0: D2 = 0 << 8; break;
1046                                 case KW_Y1: D2 = 1 << 8; break;
1047                                 case KW_A:  D2 = 2 << 8; break;
1048                                 case KW_B:  D2 = 3 << 8; break;
1049                                 default:    return error("unrecognised X:Y: parallel move syntax: expected y0, y1, a or b after 'X:ea,D1/S1,X:ea Y:eay,'");
1050                                 }
1051
1052                                 if (*tok != EOL)
1053                                         return error("unrecognised X:Y: parallel move syntax: expected end-of-line after 'X:ea,D1/S1,X:ea Y:eay,D'");
1054
1055                                 if (S1 == 0)
1056                                         if (K_D1 == K_D2)
1057                                                 return error("unrecognised X:Y: parallel move syntax: D1 and D2 cannot be the same in 'X:ea,D1 Y:eay,D2'");
1058
1059                                 inst = B16(11000000, 00000000) | w;
1060                                 inst |= ea1 | D1 | ea2 | D2;
1061                                 return inst;
1062                         }
1063                         else
1064                                 return error("unrecognised X:Y: parallel move syntax: expected '(Rn)', '(Rn)+', '(Rn)-', '(Rn)+Nn' after 'X:ea,D1/S1,X:ea Y:'");
1065                 }
1066                 else if (*tok == KW_Y0 || *tok == KW_Y1 || *tok == KW_A || *tok == KW_B)
1067                 {
1068                         // 'X:eax,D1 S2,Y:eay' 'S1,X:eax1 S2,Y:eay'
1069                         switch (*tok++)
1070                         {
1071                         case KW_Y0: S2 = 0 << 8; break;
1072                         case KW_Y1: S2 = 1 << 8; break;
1073                         case KW_A:  S2 = 2 << 8; break;
1074                         case KW_B:  S2 = 3 << 8; break;
1075                         default: return error("unrecognised X:Y: parallel move syntax: expected y0, y1, a or b after 'X:ea,D1/S1,X:ea Y:eay,'");
1076                         }
1077
1078                         if (*tok++ != ',')
1079                                 return error("unrecognised X:Y: parallel move syntax: expected ',' after 'X:ea,D1/S1,X:ea S2'");
1080
1081                         if (*tok++ == KW_Y)
1082                         {
1083                                 // 'X:eax,D1 Y:eay,D2' 'S1,X:eax Y:eay,D2'
1084                                 if (*tok++ != ':')
1085                                         return error("unrecognised X:Y: parallel move syntax: expected ':' after 'X:ea,D1/S1,X:ea Y'");
1086
1087                                 if (*tok++ == '(')
1088                                 {
1089                                         if (*tok >= KW_R0 && *tok <= KW_R7)
1090                                         {
1091                                                 ea2 = (*tok++ - KW_R0);
1092
1093                                                 if (((ea1 & 7) < 4 && ea2 < 4) || ((ea1 & 7) >= 4 && ea2 > 4))
1094                                                         return error("unrecognised X:Y: parallel move syntax: eax and eay register banks must be different in 'X:ea,D1/S1,X:ea S2,Y:eay'");
1095                                         }
1096                                         else
1097                                                 return error("unrecognised X:Y: parallel move syntax: expected 'Rn' after 'X:ea,D1/S1,X:ea S2,Y:('");
1098                                         // If eax register is r0-r3 then eay register is r4-r7.
1099                                         // Encode that to 2 bits (i.e. eay value is 0-3)
1100                                         eay_temp = (ea2 & 3) << 5; //Store register temporarily
1101
1102                                         if (*tok++ != ')')
1103                                                 return error("unrecognised X:Y: parallel move syntax: expected ')' after 'X:ea,D1/S1,X:ea S2,Y:(Rn'");
1104
1105                                         if (*tok == '+')
1106                                         {
1107                                                 tok++;
1108
1109                                                 if (*tok == EOL)
1110                                                         // (Rn)+
1111                                                         ea2 = 3 << 12;
1112                                                 else if (*tok >= KW_N0 && *tok <= KW_N7)
1113                                                 {
1114                                                         // (Rn)+Nn
1115                                                         if ((*tok++ & 7) != ea2)
1116                                                                 return error("unrecognised X:Y: parallel move syntax(Same register number expected for Rn, Nn in 'X:ea,D1/S1,X:ea S2,Y:(Rn)+Nn')");
1117
1118                                                         ea2 = 1 << 12;
1119
1120                                                         if (*tok != EOL)
1121                                                                 return error("unrecognised X:Y: parallel move syntax: expected end-of-line after 'X:ea,D1/S1,X:ea S2,Y:(Rn)+Nn'");
1122                                                 }
1123                                                 else
1124                                                         return error("unrecognised X:Y: parallel move syntax: expected ',' or 'Nn' after 'X:ea,D1/S1,X:ea S2,Y:(Rn)+'");
1125
1126                                         }
1127                                         else if (*tok == '-')
1128                                         {
1129                                                 // (Rn)-
1130                                                 ea2 = 2 << 12;
1131                                                 tok++;
1132                                                 if (*tok != EOL)
1133                                                         return error("unrecognised X:Y: parallel move syntax: expected end-of-line after 'X:ea,D1/S1,X:ea S2,Y:(Rn)-'");
1134                                         }
1135                                         else if (*tok == EOL)
1136                                         {
1137                                                 // (Rn)
1138                                                 ea2 = 0 << 12;
1139                                         }
1140                                         else
1141                                                 return error("unrecognised X:Y: parallel move syntax: expected end-of-line after 'X:ea,D1/S1,X:ea S2,Y:eay'");
1142
1143                                         ea2 |= eay_temp; //OR eay back from temp
1144
1145                                         inst = B16(10000000, 00000000) | w;
1146                                         inst |= (ea1 & 0x1f) | D1 | S2 | ea2;
1147                                         return inst;
1148                                 }
1149                                 else
1150                                         return error("unrecognised X:Y: parallel move syntax: expected '(Rn)', '(Rn)+', '(Rn)-', '(Rn)+Nn' after 'X:ea,D1/S1,X:ea Y:'");
1151                         }
1152                         else
1153                                 return error("unrecognised X:Y: parallel move syntax: expected '(Rn)', '(Rn)+', '(Rn)-', '(Rn)+Nn' in 'X:ea,D1/S1,X:ea'");
1154                 }
1155                 else
1156                         return error("unrecognised X:Y: or X:R parallel move syntax: expected Y:, A or B after 'X:ea,D1/S1,X:ea S2,'");
1157         }
1158
1159         return error("unrecognised X:Y: parallel move syntax: expected '(Rn)', '(Rn)+', '(Rn)-', '(Rn)+Nn' in 'X:ea,D1/S1,X:ea'");
1160 }
1161
1162 //
1163 // Parse X: addressing space parallel moves
1164 //
1165 static inline LONG parse_x(const int W, LONG inst, const LONG S1, const int check_for_x_y)
1166 {
1167         int immreg;                                     // Immediate register destination
1168         LONG S2, D1, D2;                        // Source and Destinations
1169         LONG ea1;                                       // ea bitfields
1170         uint32_t termchar = ',';        // Termination character for ea checks
1171         int force_imm = NUM_NORMAL;     // Holds forced immediate value (i.e. '<' or '>')
1172         ea1 = -1;                                       // initialise e1 (useful for some code paths)
1173
1174         if (W == 0)
1175                 termchar = EOL;
1176
1177         if (*tok == '-')
1178         {
1179                 if (tok[1] == CONST || tok[1] == FCONST)
1180                 {
1181                         tok++;
1182                         dspImmedEXVAL = *tok++;
1183                         goto x_check_immed;
1184                 }
1185
1186                 // This could be either -(Rn), -aa or -ea. Check for immediate first
1187                 if (tok[1] == SYMBOL)
1188                 {
1189                         if (expr(dspImmedEXPR, &dspImmedEXVAL, &dspImmedEXATTR, &dspImmedESYM) == OK)
1190                         {
1191                                 if (S1 != 0)
1192                                 {
1193 x_checkea_right:
1194                                         // 'S1,X:ea S2,D2', 'A,X:ea X0,A', 'B,X:ea X0,B', 'S1,X:eax Y:eay,D2', 'S1,X:eax S2,Y:eay'
1195                                         if (*tok == KW_X0 && tok[1] == ',' && tok[2] == KW_A)
1196                                         {
1197                                                 // 'A,X:ea X0,A'
1198                                                 if (ea1 == DSP_EA_ABS)
1199                                                         deposit_extra_ea = DEPOSIT_EXTRA_WORD;
1200
1201                                                 if (S1 != 14)
1202                                                         return error("unrecognised X:R parallel move syntax: S1 can only be a in 'a,X:ea x0,a'");
1203
1204                                                 if (ea1 == -1)
1205                                                         return error("unrecognised X:R parallel move syntax: absolute address not allowed in 'a,X:ea x0,a'");
1206
1207                                                 if (ea1 == B8(00110100))
1208                                                         return error("unrecognised X:R parallel move syntax: immediate data not allowed in 'a,X:ea x0,a'");
1209
1210                                                 inst = B16(00001000, 00000000) | ea1 | (0 << 8);
1211                                                 return inst;
1212                                         }
1213                                         else if (*tok == KW_X0 && tok[1] == ',' && tok[2] == KW_B)
1214                                         {
1215                                                 // 'B,X:ea X0,B'
1216                                                 if (ea1 == DSP_EA_ABS)
1217                                                         deposit_extra_ea = DEPOSIT_EXTRA_WORD;
1218
1219                                                 if (S1 != 15)
1220                                                         return error("unrecognised X:R parallel move syntax: S1 can only be b in 'b,X:ea x0,b'");
1221
1222                                                 if (ea1 == -1)
1223                                                         return error("unrecognised X:R parallel move syntax: absolute address not allowed in 'b,X:ea x0,b'");
1224
1225                                                 if (ea1 == B8(00110100))
1226                                                         return error("unrecognised X:R parallel move syntax: immediate data not allowed in 'b,X:ea x0,b'");
1227
1228                                                 inst = B16(00001001, 00000000) | ea1 | (1 << 8);
1229                                                 return inst;
1230                                         }
1231                                         else if (*tok == KW_A || *tok == KW_B)
1232                                         {
1233                                                 // 'S1,X:ea S2,D2', 'S1,X:eax S2,Y:eay'
1234                                                 switch (S1)
1235                                                 {
1236                                                 case 4:  D1 = 0 << 10; break;
1237                                                 case 5:  D1 = 1 << 10; break;
1238                                                 case 14: D1 = 2 << 10; break;
1239                                                 case 15: D1 = 3 << 10; break;
1240                                                 default: return error("unrecognised X:R parallel move syntax: S1 can only be x0, x1, a or b in 'S1,X:ea S2,D2'");
1241                                                 }
1242
1243                                                 if (tok[1] == ',' && tok[2] == KW_Y)
1244                                                 {
1245                                                         // 'S1,X:eax S2,Y:eay'
1246                                                         return check_x_y(ea1, S1);
1247                                                 }
1248
1249                                                 // 'S1,X:ea S2,D2'
1250                                                 if (ea1 == DSP_EA_ABS)
1251                                                         deposit_extra_ea = DEPOSIT_EXTRA_WORD;
1252
1253                                                 switch (*tok++)
1254                                                 {
1255                                                 case KW_A: S2 = 0 << 9; break;
1256                                                 case KW_B: S2 = 1 << 9; break;
1257                                                 default:   return error("unrecognised X:R parallel move syntax: expected a or b after 'S1,X:eax'");
1258                                                 }
1259
1260                                                 if (*tok++ != ',')
1261                                                         return error("unrecognised X:R parallel move syntax: expected ',' after 'S1,X:eax S2'");
1262
1263                                                 if (*tok == KW_Y0 || *tok == KW_Y1)
1264                                                 {
1265                                                         if (*tok++ == KW_Y0)
1266                                                                 D2 = 0 << 8;
1267                                                         else
1268                                                                 D2 = 1 << 8;
1269
1270                                                         if (*tok != EOL)
1271                                                                 return error("unrecognised X:R parallel move syntax: unexpected text after 'X:eax,D1 S2,S2'");
1272
1273                                                         inst = B16(00010000, 00000000) | (0 << 7);
1274                                                         inst |= ea1 | D1 | S2 | D2;
1275                                                         return inst;
1276                                                 }
1277                                                 else
1278                                                         return error("unrecognised X:R parallel move syntax: expected y0 or y1 after 'X:eax,D1 S2,'");
1279                                         }
1280                                         else if (*tok == KW_Y)
1281                                         {
1282                                                 // 'S1,X:eax Y:eay,D2'
1283                                                 return check_x_y(ea1, S1);
1284                                         }
1285                                         else if (*tok == KW_Y0 || *tok == KW_Y1)
1286                                         {
1287                                                 // 'S1,X:eax S2,Y:eay'
1288                                                 return check_x_y(ea1, S1);
1289                                         }
1290                                         else
1291                                                 return error("unrecognised X:Y or X:R parallel move syntax: expected y0 or y1 after 'X:eax,D1/X:ea,D1");
1292                                 }
1293                                 else
1294                                 {
1295                                         // Only check for aa if we have a defined number in our hands or we've
1296                                         // been asked to use a short number format. The former case we'll just test
1297                                         // it to see if it's small enough. The later - it's the programmer's call
1298                                         // so he'd better have a small address or the fixups will bite him/her in the arse!
1299                                         if (dspImmedEXATTR&DEFINED || force_imm == NUM_FORCE_SHORT)
1300                                         {
1301
1302                                                 // It's an immediate, so ea or eax is probably an absolute address
1303                                                 // (unless it's aa if the immediate is small enough)
1304                                                 // 'X:ea,D' or 'X:aa,D' or 'X:ea,D1 S2,D2' or 'X:eax,D1 Y:eay,D2' or 'X:eax,D1 S2,Y:eay'
1305 x_check_immed:
1306                                                 // Check for aa (which is 6 bits zero extended)
1307                                                 if (dspImmedEXVAL < 0x40 && force_imm != NUM_FORCE_LONG)
1308                                                 {
1309                                                         if (W == 1)
1310                                                         {
1311                                                                 // It might be X:aa but we're not 100% sure yet.
1312                                                                 // If it is, the only possible syntax here is 'X:aa,D'.
1313                                                                 // So check ahead to see if EOL follows D, then we're good to go.
1314                                                                 if (*tok == ',' && ((*(tok + 1) >= KW_X0 && *(tok + 1) <= KW_N7) || (*(tok + 1) >= KW_R0 && *(tok + 1) <= KW_R7) || (*(tok + 1) >= KW_A0 && *(tok + 1) <= KW_A2)) && *(tok + 2) == EOL)
1315                                                                 {
1316                                                                         // Yup, we're good to go - 'X:aa,D' it is
1317                                                                         tok++;
1318                                                                         immreg = SDreg(*tok++);
1319                                                                         inst = inst | (uint32_t)dspImmedEXVAL;
1320                                                                         inst |= ((immreg & 0x18) << (12 - 3)) + ((immreg & 7) << 8);
1321                                                                         inst |= 1 << 7; // W
1322                                                                         return inst;
1323                                                                 }
1324                                                         }
1325                                                         else
1326                                                         {
1327                                                                 if (*tok == EOL)
1328                                                                 {
1329                                                                         // 'S,X:aa'
1330                                                                         inst = inst | (uint32_t)dspImmedEXVAL;
1331                                                                         inst |= ((S1 & 0x18) << (12 - 3)) + ((S1 & 7) << 8);
1332                                                                         return inst;
1333                                                                 }
1334                                                                 else
1335                                                                 {
1336                                                                         // 'S1,X:ea S2,D2', 'A,X:ea X0,A', 'B,X:ea X0,B',
1337                                                                         // 'S1,X:eax Y:eay,D2', 'S1,X:eax S2,Y:eay'
1338                                                                         ea1 = DSP_EA_ABS;
1339                                                                         deposit_extra_ea = DEPOSIT_EXTRA_WORD;
1340                                                                         goto x_checkea_right;
1341                                                                 }
1342                                                         }
1343                                                 }
1344                                         }
1345
1346                                         // Well, that settles it - we do have an ea in our hands
1347                                         if (W == 1)
1348                                         {
1349                                                 // 'X:ea,D' [... S2,d2]
1350                                                 if (*tok++ != ',')
1351                                                         return error("unrecognised X: parallel move syntax: expected ',' after 'X:ea'");
1352
1353                                                 if ((*tok >= KW_X0 && *tok <= KW_N7) || (*tok >= KW_R0 && *tok <= KW_R7) || (*tok >= KW_A0 && *tok <= KW_A2))
1354                                                 {
1355                                                         D1 = SDreg(*tok++);
1356
1357                                                         if (*tok == EOL)
1358                                                         {
1359                                                                 // 'X:ea,D'
1360                                                                 inst = inst | B8(01000000) | (1 << 7);
1361                                                                 inst |= ((D1 & 0x18) << (12 - 3)) + ((D1 & 7) << 8);
1362                                                                 inst |= ea1;
1363
1364                                                                 if (ea1 == DSP_EA_ABS)
1365                                                                         deposit_extra_ea = DEPOSIT_EXTRA_WORD;
1366
1367                                                                 return inst;
1368                                                         }
1369                                                         else
1370                                                         {
1371                                                                 // 'X:ea,D1 S2,D2'
1372                                                                 if (*tok == KW_A || *tok == KW_B)
1373                                                                 {
1374                                                                         S2 = SDreg(*tok++);
1375
1376                                                                         if (*tok++ != ',')
1377                                                                                 return error("unrecognised X:R parallel move syntax: expected comma after X:ea,D1 S2");
1378
1379                                                                         if (*tok == KW_Y0 || *tok == KW_Y1)
1380                                                                         {
1381                                                                                 D2 = SDreg(*tok++);
1382
1383                                                                                 if (*tok != EOL)
1384                                                                                         return error("unrecognised X:R parallel move syntax: expected EOL after X:ea,D1 S2,D2");
1385
1386                                                                                 inst = B16(00010000, 00000000) | (1 << 7);
1387                                                                                 inst |= ((D1 & 0x8) << (12 - 4)) + ((D1 & 1) << 10);
1388                                                                                 inst |= (S2 & 1) << 9;
1389                                                                                 inst |= (D2 & 1) << 8;
1390                                                                                 inst |= ea1;
1391                                                                                 return inst;
1392                                                                         }
1393                                                                         else
1394                                                                                 return error("unrecognised X:R parallel move syntax: expected y0,y1 after X:ea,D1 S2,");
1395                                                                 }
1396                                                                 else
1397                                                                         return error("unrecognised X:R parallel move syntax: expected a,b after X:ea,D1");
1398                                                         }
1399                                                 }
1400                                                 else
1401                                                         return error("unrecognised X: parallel move syntax: expected x0,x1,y0,y1,a0,b0,a2,b2,a1,b1,a,b,r0-r7,n0-n7 after 'X:ea,'");
1402                                         }
1403                                         else
1404                                         {
1405                                                 if (*tok == EOL)
1406                                                 {
1407                                                         // 'S,X:ea'
1408                                                         inst = inst | B8(01000000) | (0 << 7);
1409                                                         inst |= ((S1 & 0x18) << (12 - 3)) + ((S1 & 7) << 8);
1410                                                         inst |= ea1;
1411
1412                                                         if (ea1 == DSP_EA_ABS)
1413                                                                 deposit_extra_ea = DEPOSIT_EXTRA_WORD;
1414
1415                                                         return inst;
1416                                                 }
1417                                                 else
1418                                                 {
1419                                                         // 'S1,X:ea S2,D2', 'A,X:ea X0,A', 'B,X:ea X0,B',
1420                                                         // 'S1,X:eax Y:eay,D2', 'S1,X:eax S2,Y:eay'
1421                                                         goto x_checkea_right;
1422                                                 }
1423                                         }
1424
1425                                 }
1426                         }
1427                 }
1428                 else
1429                 {
1430                         // It's not an immediate, check for '-(Rn)'
1431                         ea1 = checkea(termchar, X_ERRORS);
1432
1433                         if (ea1 == ERROR)
1434                                 return ERROR;
1435
1436                         goto x_gotea1;
1437
1438                 }
1439         }
1440         else if (*tok == '#')
1441         {
1442                 tok++;
1443
1444                 if (expr(dspImmedEXPR, &dspImmedEXVAL, &dspImmedEXATTR, &dspImmedESYM) != OK)
1445                         return ERROR;
1446
1447                 // Okay so we have immediate data - mark it down
1448                 ea1 = DSP_EA_IMM;
1449                 // Now, proceed to the main code for this branch
1450                 goto x_gotea1;
1451         }
1452         else if (*tok == '(')
1453         {
1454                 // Maybe we got an expression here, check for it
1455                 if (tok[1] == CONST || tok[1] == FCONST || tok[1] == SUNARY || tok[1] == SYMBOL || tok[1] == STRING)
1456                 {
1457                         // Evaluate the expression and go to immediate code path
1458                         expr(dspImmedEXPR, &dspImmedEXVAL, &dspImmedEXATTR, &dspImmedESYM);
1459                         goto x_check_immed;
1460                 }
1461
1462                 // Nope, let's check for ea then
1463                 ea1 = checkea(termchar, X_ERRORS);
1464
1465                 if (ea1 == ERROR)
1466                         return ERROR;
1467
1468 x_gotea1:
1469                 if (W == 1)
1470                 {
1471                         if (*tok++ != ',')
1472                                 return error("Comma expected after 'X:(Rn)')");
1473
1474                         // It might be 'X:(Rn..)..,D' but we're not 100% sure yet.
1475                         // If it is, the only possible syntax here is 'X:ea,D'.
1476                         // So check ahead to see if EOL follows D, then we're good to go.
1477                         if (((*tok >= KW_X0 && *tok <= KW_N7) || (*tok >= KW_R0 && *tok <= KW_R7) || (*tok >= KW_A0 && *tok <= KW_A2)) && *(tok + 1) == EOL)
1478                         {
1479                                 //'X:ea,D'
1480                                 D1 = SDreg(*tok++);
1481
1482                                 inst = inst | B8(01000000) | (1 << 7);
1483                                 inst |= ea1;
1484                                 inst |= ((D1 & 0x18) << (12 - 3)) + ((D1 & 7) << 8);
1485                                 return inst;
1486                         }
1487                 }
1488                 else
1489                 {
1490                         if (*tok == EOL)
1491                         {
1492                                 //'S,X:ea'
1493                                 inst = inst | B8(01000000) | (0 << 7);
1494                                 inst |= ea1;
1495                                 inst |= ((S1 & 0x18) << (12 - 3)) + ((S1 & 7) << 8);
1496                                 return inst;
1497                         }
1498                         else
1499                         {
1500                                 goto x_checkea_right;
1501                         }
1502                 }
1503
1504                 // 'X:eax,D1 Y:eay,D2', 'X:eax,D1 S2,Y:eay' or 'X:ea,D1 S2,D2'
1505                 // Check ahead for S2,D2 - if that's true then we have 'X:ea,D1 S2,D2'
1506                 if ((*tok == KW_X0 || *tok == KW_X1 || *tok == KW_A || *tok == KW_B) && (*(tok + 1) == KW_A || *(tok + 1) == KW_B) && (*(tok + 2) == ',') && (*(tok + 3) == KW_Y0 || (*(tok + 3) == KW_Y1)))
1507                 {
1508                         // 'X:ea,D1 S2,D2'
1509                         // Check if D1 is x0, x1, a or b
1510                         switch (*tok++)
1511                         {
1512                         case KW_X0: D1 = 0 << 10; break;
1513                         case KW_X1: D1 = 1 << 10; break;
1514                         case KW_A:  D1 = 2 << 10; break;
1515                         case KW_B:  D1 = 3 << 10; break;
1516                         default:    return error("unrecognised X:R parallel move syntax: expected x0, x1, a or b after 'X:eax,'");
1517                         }
1518
1519                         switch (*tok++)
1520                         {
1521                         case KW_A: S2 = 0 << 9; break;
1522                         case KW_B: S2 = 1 << 9; break;
1523                         default:   return error("unrecognised X:R parallel move syntax: expected a or b after 'X:eax,D1 '");
1524                         }
1525
1526                         if (*tok++ != ',')
1527                                 return error("unrecognised X:R parallel move syntax: expected ',' after 'X:eax,D1 S2'");
1528
1529                         if (*tok == KW_Y0 || *tok == KW_Y1)
1530                         {
1531                                 if (*tok++ == KW_Y0)
1532                                         D2 = 0 << 8;
1533                                 else
1534                                         D2 = 1 << 8;
1535
1536                                 if (*tok != EOL)
1537                                         return error("unrecognised X:R parallel move syntax: unexpected text after 'X:eax,D1 S2,S2'");
1538
1539                                 inst = B16(00010000, 00000000) | (W << 7);
1540                                 inst |= ea1 | D1 | S2 | D2;
1541                                 return inst;
1542                         }
1543                         else
1544                                 return error("unrecognised X:R parallel move syntax: expected y0 or y1 after 'X:eax,D1 S2,'");
1545                 }
1546
1547                 // Check to see if we got eax (which is a subset of ea)
1548                 if (check_for_x_y)
1549                 {
1550                         if ((inst = check_x_y(ea1, 0)) != 0)
1551                                 return inst;
1552                         else
1553                         {
1554                                 // Rewind pointer as it might be an expression and check for it
1555                                 tok--;
1556
1557                                 if (expr(dspaaEXPR, &dspaaEXVAL, &dspaaEXATTR, &dspaaESYM) != OK)
1558                                         return ERROR;
1559
1560                                 // Yes, we have an expression, so we now check for
1561                                 // 'X:ea,D' or 'X:aa,D' or 'X:ea,D1 S2,D2' or 'X:eax,D1 Y:eay,D2' or 'X:eax,D1 S2,Y:eay'
1562                                 goto x_check_immed;
1563                         }
1564                 }
1565         }
1566         else if (*tok == CONST || *tok == FCONST || *tok == SYMBOL)
1567         {
1568                 // Check for immediate address
1569                 if (expr(dspImmedEXPR, &dspImmedEXVAL, &dspImmedEXATTR, &dspImmedESYM) != OK)
1570                         return ERROR;
1571
1572                 // We set ea1 here - if it's aa instead of ea
1573                 // then it won't be used anyway
1574                 ea1 = DSP_EA_ABS;
1575
1576                 if (!(dspImmedEXATTR&DEFINED))
1577                 {
1578                         force_imm = NUM_FORCE_LONG;
1579                         deposit_extra_ea = DEPOSIT_EXTRA_WORD;
1580                 }
1581
1582                 goto x_check_immed;
1583         }
1584         else if (*tok == '>')
1585         {
1586                 // Check for immediate address forced long
1587                 tok++;
1588
1589                 if (expr(dspImmedEXPR, &dspImmedEXVAL, &dspImmedEXATTR, &dspImmedESYM) != OK)
1590                         return ERROR;
1591
1592                 if ((dspImmedEXATTR & DEFINED) && (dspImmedEXVAL > 0xFFFFFF))
1593                         return error("long address is bigger than $FFFFFF");
1594
1595                 deposit_extra_ea = DEPOSIT_EXTRA_WORD;
1596
1597                 force_imm = NUM_FORCE_LONG;
1598                 ea1 = DSP_EA_ABS;
1599                 goto x_check_immed;
1600         }
1601         else if (*tok == '<')
1602         {
1603                 // Check for immediate address forced short
1604                 tok++;
1605
1606                 if (expr(dspImmedEXPR, &dspImmedEXVAL, &dspImmedEXATTR, &dspImmedESYM) != OK)
1607                         return ERROR;
1608
1609                 force_imm = NUM_FORCE_SHORT;
1610
1611                 if (dspImmedEXATTR & DEFINED)
1612                 {
1613                         if (dspImmedEXVAL > 0x3F)
1614                         {
1615                                 if (optim_warn_flag)
1616                                         warn("short addressing mode forced but address is bigger than $3F - switching to long");
1617
1618                                 force_imm = NUM_FORCE_LONG;
1619                                 deposit_extra_ea = DEPOSIT_EXTRA_WORD;
1620                                 ea1 = DSP_EA_ABS;
1621                         }
1622                 }
1623                 else
1624                 {
1625                         // This might end up as something like 'move Y:<adr,register'
1626                         // so let's mark it as an extra aa fixup here.
1627                         // Note: we are branching to x_check_immed without a
1628                         // defined dspImmed so it's going to be 0. It probably
1629                         // doesn't harm anything.
1630                         deposit_extra_ea = DEPOSIT_EXTRA_FIXUP;
1631                 }
1632
1633                 goto x_check_immed;
1634         }
1635
1636         return error("unknown x: addressing mode");
1637 }
1638
1639
1640 //
1641 // Parse Y: addressing space parallel moves
1642 //
1643 static inline LONG parse_y(LONG inst, LONG S1, LONG D1, LONG S2)
1644 {
1645     int immreg;                                 // Immediate register destination
1646     LONG D2;                                    // Destination
1647     LONG ea1;                                   // ea bitfields
1648     int force_imm = NUM_NORMAL; // Holds forced immediate value (i.e. '<' or '>')
1649     if (*tok == '-')
1650     {
1651         if (tok[1] == CONST || tok[1] == FCONST)
1652         {
1653             tok++;
1654             dspImmedEXVAL = *tok++;
1655             goto y_check_immed;
1656         }
1657         // This could be either -(Rn), -aa or -ea. Check for immediate first
1658                 if (*tok == SYMBOL || tok[1] == SYMBOL)
1659                 {
1660                         if (expr(dspImmedEXPR, &dspImmedEXVAL, &dspImmedEXATTR, &dspImmedESYM) == OK)
1661                         {
1662                                 // Only check for aa if we have a defined number in our hands or we've
1663                                 // been asked to use a short number format. The former case we'll just test
1664                                 // it to see if it's small enough. The later - it's the programmer's call
1665                                 // so he'd better have a small address or the fixups will bite him/her in the arse!
1666                                 if (dspImmedEXATTR&DEFINED || force_imm == NUM_FORCE_SHORT)
1667                                 {
1668                                         // It's an immediate, so ea is probably an absolute address
1669                                         // (unless it's aa if the immediate is small enough)
1670                                         // 'Y:ea,D', 'Y:aa,D', 'S,Y:ea' or 'S,Y:aa'
1671                                 y_check_immed:
1672                                         // Check for aa (which is 6 bits zero extended)
1673                                         if (dspImmedEXVAL < 0x40 && force_imm != NUM_FORCE_LONG)
1674                                         {
1675                                                 // It might be Y:aa but we're not 100% sure yet.
1676                                                 // If it is, the only possible syntax here is 'Y:aa,D'/'S,Y:aa'.
1677                                                 // So check ahead to see if EOL follows D, then we're good to go.
1678                                                 if (*tok == EOL && S1 != 0)
1679                                                 {
1680                                                         // 'S,Y:aa'
1681                                                         inst = B16(01001000, 00000000);
1682                                                         inst |= dspImmedEXVAL;
1683                                                         inst |= ((S1 & 0x18) << (12 - 3)) + ((S1 & 7) << 8);
1684                                                         return inst;
1685                                                 }
1686
1687                                                 if (*tok == ',' && ((*(tok + 1) >= KW_X0 && *(tok + 1) <= KW_N7) || (*(tok + 1) >= KW_R0 && *(tok + 1) <= KW_R7) || (*(tok + 1) >= KW_A0 && *(tok + 1) <= KW_A2)) && *(tok + 2) == EOL)
1688                                                 {
1689                                                         // Yup, we're good to go - 'Y:aa,D' it is
1690                                                         tok++;
1691                                                         immreg = SDreg(*tok++);
1692                                                         inst |= dspImmedEXVAL;
1693                                                         inst |= ((immreg & 0x18) << (12 - 3)) + ((immreg & 7) << 8);
1694                                                         return inst;
1695                                                 }
1696                                         }
1697                                 }
1698                                 // Well, that settles it - we do have a ea in our hands
1699                                 if (*tok == EOL && S1 != 0)
1700                                 {
1701                                         // 'S,Y:ea'
1702                                         inst = B16(01001000, 01110000);
1703                                         inst |= ea1;
1704                                         inst |= ((S1 & 0x18) << (12 - 3)) + ((S1 & 7) << 8);
1705                                         if (ea1 == DSP_EA_ABS)
1706                                                 deposit_extra_ea = DEPOSIT_EXTRA_WORD;
1707                                         return inst;
1708                                 }
1709
1710                                 if (*tok++ != ',')
1711                                         return error("unrecognised Y: parallel move syntax: expected ',' after 'Y:ea'");
1712
1713                                 if (D1 == 0 && S1 == 0)
1714                                 {
1715                                         // 'Y:ea,D'
1716                                         if ((*tok >= KW_X0 && *tok <= KW_N7) || (*tok >= KW_R0 && *tok <= KW_R7) || (*tok >= KW_A0 && *tok <= KW_A2))
1717                                         {
1718                                                 D1 = SDreg(*tok++);
1719
1720                                                 if (*tok != EOL)
1721                                                         return error("unrecognised Y: parallel move syntax: expected EOL after 'Y:ea,D'");
1722
1723                                                 inst |= B16(00000000, 01110000);
1724                                                 inst |= ea1;
1725                                                 inst |= ((D1 & 0x18) << (12 - 3)) + ((D1 & 7) << 8);
1726                                                 if (ea1 == DSP_EA_ABS)
1727                                                         deposit_extra_ea = DEPOSIT_EXTRA_WORD;
1728                                                 return inst;
1729                                         }
1730                                         else
1731                                                 return error("unrecognised Y: parallel move syntax: expected x0,x1,y0,y1,a0,b0,a2,b2,a1,b1,a,b,r0-r7,n0-n7 after 'Y:ea,'");
1732                                 }
1733                                 else
1734                                 {
1735                                         // 'S1,D1 Y:ea,D2'
1736                                         if (*tok == KW_A || *tok == KW_B || *tok == KW_Y0 || *tok == KW_Y1)
1737                                         {
1738                                                 D2 = SDreg(*tok++);
1739                                                 inst |= ea1;
1740                                                 inst |= 1 << 7;
1741                                                 inst |= (S1 & 1) << 11;
1742                                                 inst |= (D1 & 1) << 10;
1743                                                 inst |= (D2 & 8) << (9 - 3);
1744                                                 inst |= (D2 & 1) << 8;
1745                                                 return inst;
1746                                         }
1747                                         else
1748                                                 return error("unrecognised R:Y: parallel move syntax: expected a,b after 'S1,D1 Y:ea,'");
1749                                 }
1750                         }
1751                         else
1752                                 return ERROR;
1753                 }
1754                 else
1755                 {
1756                         // It's not an immediate, check for '-(Rn)'
1757                         ea1 = checkea(',', Y_ERRORS);
1758
1759                         if (ea1 == ERROR)
1760                                 return ERROR;
1761
1762                         goto y_gotea1;
1763
1764                 }
1765         }
1766         else if (*tok == '#')
1767         {
1768                 tok++;
1769
1770                 if (expr(dspImmedEXPR, &dspImmedEXVAL, &dspImmedEXATTR, &dspImmedESYM) != OK)
1771                         return ERROR;
1772
1773                 // Okay so we have immediate data - mark it down
1774                 ea1 = DSP_EA_IMM;
1775                 // Now, proceed to the main code for this branch
1776                 goto y_gotea1;
1777         }
1778         else if (*tok == '(')
1779         {
1780                 // Maybe we got an expression here, check for it
1781                 if (tok[1] == CONST || tok[1] == FCONST || tok[1] == SUNARY || tok[1] == SYMBOL || tok[1] == STRING)
1782                 {
1783                         // Evaluate the expression and go to immediate code path
1784                         expr(dspImmedEXPR, &dspImmedEXVAL, &dspImmedEXATTR, &dspImmedESYM);
1785                         goto y_check_immed;
1786                 }
1787
1788                 // Nope, let's check for ea then
1789                 if (S1 == 0 || (S1 != 0 && D1 != 0))
1790                         ea1 = checkea(',', Y_ERRORS);
1791                 else
1792                         ea1 = checkea(EOL, Y_ERRORS);
1793
1794                 if (ea1 == ERROR)
1795                         return ERROR;
1796
1797         y_gotea1:
1798                 if (S1 != 0 && *tok == EOL)
1799                 {
1800                         // 'S,Y:ea'
1801                         inst = B16(01001000, 01000000);
1802                         inst |= ea1;
1803                         inst |= ((S1 & 0x18) << (12 - 3)) + ((S1 & 7) << 8);
1804                         return inst;
1805                 }
1806                 else if (S1 != 0 && D1 != 0 && S2 == 0)
1807                 {
1808                         // 'S1,D1 Y:ea,D2'
1809                         switch (S1)
1810                         {
1811                         case 14: S1 = 0 << 11; break; // A
1812                         case 15: S1 = 1 << 11; break; // B
1813                         default: return error("unrecognised R:Y parallel move syntax: S1 can only be A or B in 'S1,D1 Y:ea,D2'"); break;
1814                         }
1815
1816                         switch (D1)
1817                         {
1818                         case 4: D1 = 0 << 10; break; // X0
1819                         case 5: D1 = 1 << 10; break; // X1
1820                         default: return error("unrecognised R:Y parallel move syntax: D1 can only be x0 or x1 in 'S1,D1 Y:ea,D2'");break;
1821                         }
1822
1823                         if (*tok++ != ',')
1824                                 return error("unrecognised R:Y parallel move syntax: expected ',' after 'S1,D1 Y:ea'");
1825
1826                         switch (*tok++)
1827                         {
1828                         case KW_Y0: D2 = 0 << 8; break;
1829                         case KW_Y1: D2 = 1 << 8; break;
1830                         case KW_A:  D2 = 2 << 8; break;
1831                         case KW_B:  D2 = 3 << 8; break;
1832                         default: return error("unrecognised R:Y parallel move syntax: D2 can only be y0, y1, a or b after 'S1,D1 Y:ea'");
1833                         }
1834
1835                         inst = B16(00010000, 11000000);
1836                         inst |= S1 | D1 | D2;
1837                         inst |= ea1;
1838                         return inst;
1839                 }
1840
1841                 if (*tok++ != ',')
1842             return error("Comma expected after 'Y:(Rn)')");
1843
1844                 // It might be 'Y:(Rn..)..,D' but we're not 100% sure yet.
1845                 // If it is, the only possible syntax here is 'Y:ea,D'.
1846                 // So check ahead to see if EOL follows D, then we're good to go.
1847                 if (((*tok >= KW_X0 && *tok <= KW_N7) || (*tok >= KW_R0 && *tok <= KW_R7) || (*tok >= KW_A0 && *tok <= KW_A2)) && *(tok + 1) == EOL)
1848                 {
1849                         //'Y:ea,D'
1850                         D1 = SDreg(*tok++);
1851                         inst |= B16(00000000, 01000000);
1852                         inst |= ea1;
1853                         inst |= ((D1 & 0x18) << (12 - 3)) + ((D1 & 7) << 8);
1854                         return inst;
1855                 }
1856         }
1857         else if (*tok == CONST || *tok == FCONST || *tok == SYMBOL)
1858         {
1859                 // Check for immediate address
1860                 if (expr(dspImmedEXPR, &dspImmedEXVAL, &dspImmedEXATTR, &dspImmedESYM) != OK)
1861                         return ERROR;
1862
1863                 // Yes, we have an expression, so we now check for
1864                 // 'Y:ea,D' or 'Y:aa,D'
1865                 ea1 = DSP_EA_ABS; // Reluctant - but it's probably correct
1866
1867                 if (!(dspImmedEXATTR&DEFINED))
1868                 {
1869                         force_imm = NUM_FORCE_LONG;
1870                         deposit_extra_ea = DEPOSIT_EXTRA_WORD;
1871                 }
1872
1873                 goto y_check_immed;
1874         }
1875         else if (*tok == '>')
1876         {
1877                 // Check for immediate address forced long
1878                 tok++;
1879
1880                 if (expr(dspImmedEXPR, &dspImmedEXVAL, &dspImmedEXATTR, &dspImmedESYM) != OK)
1881                         return ERROR;
1882
1883                 if ((dspImmedEXATTR & DEFINED) && (dspImmedEXVAL > 0xFFFFFF))
1884                         return error("long address is bigger than $FFFFFF");
1885
1886                 deposit_extra_ea = DEPOSIT_EXTRA_WORD;
1887
1888                 force_imm = NUM_FORCE_LONG;
1889                 ea1 = DSP_EA_ABS;
1890                 goto y_check_immed;
1891         }
1892         else if (*tok == '<')
1893         {
1894                 tok++;
1895
1896                 if (S1 != 0 && D1 != 0)
1897                 {
1898                         // We're in 'S1,D1 Y:ea,D2' or 'S1,D1 S1,Y:ea'
1899                         // there's no Y:aa mode here, so we'll force long
1900                         if (optim_warn_flag)
1901                                 warn("forced short addressing in R:Y mode is not allowed - switching to long");
1902
1903                         if (expr(dspImmedEXPR, &dspImmedEXVAL, &dspImmedEXATTR, &dspImmedESYM) != OK)
1904                                 return ERROR;
1905
1906                         ea1 = DSP_EA_ABS;
1907
1908                         force_imm = NUM_FORCE_LONG;
1909                         deposit_extra_ea = DEPOSIT_EXTRA_WORD;
1910                         goto y_check_immed;
1911                 }
1912                 else
1913                 {
1914                         // Check for immediate address forced short
1915                         ea1 = DSP_EA_ABS; // Reluctant - but it's probably correct
1916
1917                         if (expr(dspImmedEXPR, &dspImmedEXVAL, &dspImmedEXATTR, &dspImmedESYM) != OK)
1918                                 return ERROR;
1919
1920                         force_imm = NUM_FORCE_SHORT;
1921
1922                         if (dspImmedEXATTR & DEFINED)
1923                         {
1924                                 if (dspImmedEXVAL > 0xFFF)
1925                                 {
1926                                         if (optim_warn_flag)
1927                                                 warn("short addressing mode forced but address is bigger than $FFF - switching to long");
1928
1929                                         ea1 = DSP_EA_ABS;
1930                                         force_imm = NUM_FORCE_LONG;
1931                                         deposit_extra_ea = DEPOSIT_EXTRA_WORD;
1932                                 }
1933                         }
1934                         else
1935                         {
1936                                 // This might end up as something like 'move Y:<adr,register'
1937                                 // so let's mark it as an extra aa fixup here.
1938                                 // Note: we are branching to y_check_immed without a
1939                                 // defined dspImmed so it's going to be 0. It probably
1940                                 // doesn't harm anything.
1941                                 deposit_extra_ea = DEPOSIT_EXTRA_FIXUP;
1942                         }
1943
1944                         goto y_check_immed;
1945                 }
1946         }
1947
1948         return error("unrecognised Y: parallel move syntax");
1949 }
1950
1951
1952 //
1953 // Parse L: addressing space parallel moves
1954 //
1955 static inline LONG parse_l(const int W, LONG inst, LONG S1)
1956 {
1957         int immreg;                                     // Immediate register destination
1958         LONG D1;                                        // Source and Destinations
1959         LONG ea1;                                       // ea bitfields
1960         int force_imm = NUM_NORMAL;     // Holds forced immediate value (i.e. '<' or '>')
1961
1962         if (*tok == '-')
1963         {
1964                 if (*tok == CONST || tok[1] == FCONST)
1965                 {
1966                         tok++;
1967                         dspImmedEXVAL = *tok++;
1968                         goto l_check_immed;
1969                 }
1970
1971                 // This could be either -(Rn), -aa or -ea. Check for immediate first
1972                 // Maybe we got an expression here, check for it
1973                 if (*tok == SYMBOL || tok[1] == SYMBOL)
1974                 {
1975                         // Evaluate the expression and go to immediate code path
1976                         if (expr(dspImmedEXPR, &dspImmedEXVAL, &dspImmedEXATTR, &dspImmedESYM) == OK)
1977                         {
1978                                 // Only check for aa if we have a defined number in our hands
1979                                 // or we've been asked to use a short number format. The
1980                                 // former case we'll just test it to see if it's small enough.
1981                                 // The later - it's the programmer's call so he'd better have
1982                                 // a small address or the fixups will bite him/her in the arse!
1983                                 if (dspImmedEXATTR&DEFINED || force_imm == NUM_FORCE_SHORT)
1984                                 {
1985                                         // It's an immediate, so ea is probably an absolute address
1986                                         // (unless it's aa if the immediate is small enough)
1987                                         // 'L:ea,D' or 'L:aa,D'
1988                                 l_check_immed:
1989                                         // Check for aa (which is 6 bits zero extended)
1990                                         if (*tok == EOL)
1991                                         {
1992                                                 // 'S,L:aa'
1993                                                 if (dspImmedEXVAL < 0x40 && force_imm != NUM_FORCE_LONG)
1994                                                 {
1995                                                         // 'S,L:aa'
1996                                                         if (S1 == KW_A)
1997                                                                 S1 = 4;
1998                                                         else if (S1 == KW_B)
1999                                                                 S1 = 5;
2000                                                         else
2001                                                                 S1 &= 7;
2002
2003                                                         inst = B16(01000000, 00000000);
2004                                                         inst |= dspImmedEXVAL;
2005                                                         inst |= ((S1 & 0x4) << (11 - 2)) + ((S1 & 3) << 8);
2006                                                         return inst;
2007                                                 }
2008                                                 else
2009                                                 {
2010                                                         // 'S,L:ea'
2011                                                         if (S1 == KW_A)
2012                                                                 S1 = 4;
2013                                                         else if (S1 == KW_B)
2014                                                                 S1 = 5;
2015                                                         else
2016                                                                 S1 &= 7;
2017
2018                                                         if (ea1 == DSP_EA_ABS)
2019                                                                 deposit_extra_ea = DEPOSIT_EXTRA_WORD;
2020
2021                                                         inst |= B16(01000000, 01110000);
2022                                                         inst |= ((S1 & 0x4) << (11 - 2)) + ((S1 & 3) << 8);
2023                                                         inst |= ea1;
2024                                                         return inst;
2025                                                 }
2026
2027                                         }
2028
2029                                         if (*tok++ != ',')
2030                                                 return error("unrecognised L: parallel move syntax: expected ',' after 'L:ea/L:aa'");
2031
2032                                         // Check for allowed registers for D (a0, b0, x, y, a, b, ab or ba)
2033                                         if (!((*tok >= KW_A10 && *(tok + 1) <= KW_BA) || (*tok >= KW_A && *tok <= KW_B)))
2034                                                 return error("unrecognised L: parallel move syntax: expected a0, b0, x, y, a, b, ab or ba after 'L:ea/L:aa'");
2035
2036                                         if (dspImmedEXVAL < (1 << 6) && (dspImmedEXATTR&DEFINED))
2037                                         {
2038                                                 // 'L:aa,D'
2039                                                 l_aa:
2040                                                 immreg = *tok++;
2041
2042                                                 if (immreg == KW_A)
2043                                                         immreg = 4;
2044                                                 else if (immreg == KW_B)
2045                                                         immreg = 5;
2046                                                 else
2047                                                         immreg &= 7;
2048
2049                                                 if (*tok != EOL)
2050                                                         return error("unrecognised L: parallel move syntax: expected End-Of-Line after L:aa,D");
2051
2052                                                 inst &= B16(11111111, 10111111);
2053                                                 inst |= dspImmedEXVAL;
2054                                                 inst |= ((immreg & 0x4) << (11 - 2)) + ((immreg & 3) << 8);
2055                                                 return inst;
2056                                         }
2057                                 }
2058
2059                                 if (deposit_extra_ea == DEPOSIT_EXTRA_FIXUP)
2060                                 {
2061                                         // Hang on, we've got a L:<aa here, let's do that instead
2062                                         goto l_aa;
2063                                 }
2064
2065                                 // Well, that settles it - we do have a ea in our hands
2066                                 // 'L:ea,D'
2067                                 D1 = *tok++;
2068
2069                                 if (D1 == KW_A)
2070                                         D1 = 4;
2071                                 else if (D1 == KW_B)
2072                                         D1 = 5;
2073                                 else
2074                                         D1 &= 7;
2075
2076                                 if (*tok != EOL)
2077                                         return error("unrecognised L: parallel move syntax: expected End-Of-Line after L:ea,D");
2078
2079                                 inst |= B16(00000000, 00110000);
2080                                 inst |= ((D1 & 0x4) << (11 - 2)) + ((D1 & 3) << 8);
2081                                 return inst;
2082                         }
2083                 }
2084                 else
2085                 {
2086                         //It's not an immediate, check for '-(Rn)'
2087                         ea1 = checkea(',', L_ERRORS);
2088
2089                         if (ea1 == ERROR)
2090                                 return ERROR;
2091
2092                         goto l_gotea1;
2093
2094                 }
2095         }
2096         else if (*tok == '(')
2097         {
2098                 // Maybe we got an expression here, check for it
2099                 if (tok[1] == CONST || tok[1] == FCONST || tok[1] == SUNARY || tok[1] == SYMBOL || tok[1] == STRING)
2100                 {
2101                         // Evaluate the expression and go to immediate code path
2102                         expr(dspImmedEXPR, &dspImmedEXVAL, &dspImmedEXATTR, &dspImmedESYM);
2103                         goto l_check_immed;
2104                 }
2105
2106                 //Nope, let's check for ea then
2107                 if (S1 == 0)
2108                         ea1 = checkea(',', L_ERRORS);
2109                 else
2110                         ea1 = checkea(EOL, L_ERRORS);
2111
2112                 if (ea1 == ERROR)
2113                         return ERROR;
2114
2115         l_gotea1:
2116                 if (*tok == EOL)
2117                 {
2118                         // 'S,L:ea'
2119                         inst = B16(01000000, 01000000);
2120
2121                         if (S1 == KW_A)
2122                                 S1 = 4;
2123                         else if (S1 == KW_B)
2124                                 S1 = 5;
2125                         else
2126                                 S1 &= 7;
2127
2128                         inst |= ea1;
2129                         inst |= ((S1 & 0x4) << (11 - 2)) + ((S1 & 3) << 8);
2130                         return inst;
2131                 }
2132                 else if (*tok++ != ',')
2133                         return error("Comma expected after 'L:(Rn)')");
2134
2135                 // It might be 'L:(Rn..)..,D' but we're not 100% sure yet.
2136                 // If it is, the only possible syntax here is 'L:ea,D'.
2137                 // So check ahead to see if EOL follows D, then we're good to go.
2138                 if (((*tok >= KW_A10 && *tok <= KW_BA) || (*tok >= KW_A && *tok <= KW_B)) && *(tok + 1) == EOL)
2139                 {
2140                         //'L:ea,D'
2141                         D1 = *tok++;
2142
2143                         if (D1 == KW_A)
2144                                 D1 = 4;
2145                         else if (D1 == KW_B)
2146                                 D1 = 5;
2147                         else
2148                                 D1 &= 7;
2149
2150                         inst |= ea1;
2151                         inst |= ((D1 & 0x4) << (11 - 2)) + ((D1 & 3) << 8);
2152                         return inst;
2153                 }
2154         }
2155         else if (*tok == CONST || *tok == FCONST || *tok == SYMBOL)
2156         {
2157                 // Check for immediate address
2158                 if (expr(dspImmedEXPR, &dspImmedEXVAL, &dspImmedEXATTR, &dspImmedESYM) != OK)
2159                         return ERROR;
2160
2161                 // We set ea1 here - if it's aa instead of ea
2162                 // then it won't be used anyway
2163                 ea1 = DSP_EA_ABS;
2164
2165                 if (!(dspImmedEXATTR & DEFINED))
2166                 {
2167                         force_imm = NUM_FORCE_LONG;
2168                         deposit_extra_ea = DEPOSIT_EXTRA_WORD;
2169                 }
2170                 else if (dspImmedEXVAL > 0x3f)
2171                 {
2172                         // Definitely no aa material, so it's going to be a long
2173                         // Mark that we need to deposit an extra word
2174                         deposit_extra_ea = DEPOSIT_EXTRA_WORD;
2175                 }
2176
2177                 // Yes, we have an expression, so we now check for
2178                 // 'L:ea,D' or 'L:aa,D'
2179                 goto l_check_immed;
2180         }
2181         else if (*tok == '>')
2182         {
2183                 // Check for immediate address forced long
2184                 tok++;
2185
2186                 if (expr(dspImmedEXPR, &dspImmedEXVAL, &dspImmedEXATTR, &dspImmedESYM) != OK)
2187                         return ERROR;
2188
2189                 if ((dspImmedEXATTR & DEFINED) && (dspImmedEXVAL > 0xFFFFFF))
2190                         return error("long address is bigger than $FFFFFF");
2191
2192                 deposit_extra_ea = DEPOSIT_EXTRA_WORD;
2193
2194                 force_imm = NUM_FORCE_LONG;
2195                 goto l_check_immed;
2196         }
2197         else if (*tok == '<')
2198         {
2199                 // Check for immediate address forced short
2200                 tok++;
2201
2202                 if (expr(dspImmedEXPR, &dspImmedEXVAL, &dspImmedEXATTR, &dspImmedESYM) != OK)
2203                         return ERROR;
2204
2205                 if (dspImmedEXATTR & DEFINED)
2206                 {
2207                         if (dspImmedEXVAL > 0xFFF)
2208                                 return error("short addressing mode forced but address is bigger than $FFF");
2209                 }
2210                 else
2211                 {
2212                         // This might end up as something like 'move Y:<adr,register'
2213                         // so let's mark it as an extra aa fixup here.
2214                         // Note: we are branching to l_check_immed without a
2215                         // defined dspImmed so it's going to be 0. It probably
2216                         // doesn't harm anything.
2217                         deposit_extra_ea = DEPOSIT_EXTRA_FIXUP;
2218                 }
2219
2220                 force_imm = NUM_FORCE_SHORT;
2221                 goto l_check_immed;
2222         }
2223
2224         return error("internal assembler error: Please report this error message: 'reached the end of parse_l' with the line of code that caused it. Thanks, and sorry for the inconvenience");
2225 }
2226
2227
2228 //
2229 // Checks for all ea cases where indexed addressing is concenred
2230 //
2231 static inline LONG checkea(const uint32_t termchar, const int strings)
2232 {
2233         LONG ea;
2234
2235         if (*tok == '-')
2236         {
2237                 // -(Rn)
2238                 tok++;
2239
2240                 if (*tok++ != '(')
2241                         return error(ea_errors[strings][0]);
2242
2243                 if (*tok >= KW_R0 && *tok <= KW_R7)
2244                 {
2245                         // We got '-(Rn' so mark it down
2246                         ea = DSP_EA_PREDEC1 | (*tok++ - KW_R0);
2247
2248                         if (*tok++ != ')')
2249                                 return error(ea_errors[strings][1]);
2250
2251                         // Now, proceed to the main code for this branch
2252                         return ea;
2253                 }
2254                 else
2255                         return error(ea_errors[strings][2]);
2256         }
2257         else if (*tok == '(')
2258         {
2259                 // Checking for ea of type (Rn)
2260                 tok++;
2261
2262                 if (*tok >= KW_R0 && *tok <= KW_R7)
2263                 {
2264                         // We're in 'X:(Rn..)..,D', 'X:(Rn..)..,D1 Y:eay,D2', 'X:(Rn..)..,D1 S2,Y:eay'
2265                         ea = *tok++ - KW_R0;
2266
2267                         if (*tok == '+')
2268                         {
2269                                 // '(Rn+Nn)'
2270                                 tok++;
2271
2272                                 if (*tok < KW_N0 || *tok > KW_N7)
2273                                         return error(ea_errors[strings][3]);
2274
2275                                 if ((*tok++ & 7) != ea)
2276                                         return error(ea_errors[strings][4]);
2277
2278                                 ea |= DSP_EA_INDEX;
2279
2280                                 if (*tok++ != ')')
2281                                         return error(ea_errors[strings][5]);
2282
2283                                 return ea;
2284                         }
2285                         else if (*tok == ')')
2286                         {
2287                                 // Check to see if we have '(Rn)+', '(Rn)-', '(Rn)-Nn', '(Rn)+Nn' or '(Rn)'
2288                                 tok++;
2289
2290                                 if (*tok == '+')
2291                                 {
2292                                         tok++;
2293
2294                                         if (termchar == ',')
2295                                         {
2296                                                 if (*tok == ',')
2297                                                 {
2298                                                         // (Rn)+
2299                                                         ea |= DSP_EA_POSTINC1;
2300                                                         return ea;
2301                                                 }
2302                                                 else if (*tok >= KW_N0 && *tok <= KW_N7)
2303                                                 {
2304                                                         // (Rn)+Nn
2305                                                         if ((*tok++ & 7) != ea)
2306                                                                 return error(ea_errors[strings][6]);
2307
2308                                                         ea |= DSP_EA_POSTINC;
2309                                                         return ea;
2310                                                 }
2311                                                 else
2312                                                         return error(ea_errors[strings][7]);
2313                                         }
2314                                         else
2315                                         {
2316                                                 if (*tok >= KW_N0 && *tok <= KW_N7)
2317                                                 {
2318                                                         // (Rn)+Nn
2319                                                         if ((*tok++ & 7) != ea)
2320                                                                 return error(ea_errors[strings][6]);
2321
2322                                                         ea |= DSP_EA_POSTINC;
2323                                                         return ea;
2324                                                 }
2325                                                 else
2326                                                 {
2327                                                         // (Rn)+
2328                                                         ea |= DSP_EA_POSTINC1;
2329                                                         return ea;
2330                                                 }
2331                                         }
2332                                 }
2333                                 else if (*tok == '-')
2334                                 {
2335                                         tok++;
2336
2337                                         if (termchar == ',')
2338                                         {
2339                                                 if (*tok == ',')
2340                                                 {
2341                                                         // (Rn)-
2342                                                         ea |= DSP_EA_POSTDEC1;
2343                                                         return ea;
2344                                                 }
2345                                                 else if (*tok >= KW_N0 && *tok <= KW_N7)
2346                                                 {
2347                                                         // (Rn)-Nn
2348                                                         if ((*tok++ & 7) != ea)
2349                                                                 return error(ea_errors[strings][8]);
2350
2351                                                         ea |= DSP_EA_POSTDEC;
2352                                                         return ea;
2353                                                 }
2354                                                 else
2355                                                         return error(ea_errors[strings][9]);
2356                                         }
2357                                         else
2358                                         {
2359                                                 if (*tok >= KW_N0 && *tok <= KW_N7)
2360                                                 {
2361                                                         // (Rn)-Nn
2362                                                         if ((*tok++ & 7) != ea)
2363                                                                 return error(ea_errors[strings][8]);
2364
2365                                                         ea |= DSP_EA_POSTDEC;
2366                                                         return ea;
2367                                                 }
2368                                                 else
2369                                                 {
2370                                                         // (Rn)-
2371                                                         ea |= DSP_EA_POSTDEC1;
2372                                                         return ea;
2373                                                 }
2374                                         }
2375                                 }
2376                                 else if (termchar == ',')
2377                                 {
2378                                         if (*tok == ',')
2379                                         {
2380                                                 // (Rn)
2381                                                 ea |= DSP_EA_NOUPD;
2382                                                 return ea;
2383                                         }
2384                                         else
2385                                                 return error(ea_errors[strings][10]);
2386                                 }
2387                                 else
2388                                 {
2389                                         // (Rn)
2390                                         ea |= DSP_EA_NOUPD;
2391                                         return ea;
2392                                 }
2393                         }
2394                         else
2395                                 return error(ea_errors[strings][11]);
2396                 }
2397         }
2398
2399         return error("internal assembler error: Please report this error message: 'reached the end of checkea' with the line of code that caused it. Thanks, and sorry for the inconvenience");
2400 }
2401
2402
2403 //
2404 // Checks for all ea cases, i.e. all addressing modes that checkea handles
2405 // plus immediate addresses included forced short/long ones.
2406 // In other words this is a superset of checkea (and in fact calls checkea).
2407 //
2408 LONG checkea_full(const uint32_t termchar, const int strings)
2409 {
2410         LONG ea1;
2411
2412         if (*tok == CONST || *tok == FCONST || *tok == SYMBOL)
2413         {
2414                 // Check for immediate address
2415                 if (expr(dspImmedEXPR, &dspImmedEXVAL, &dspImmedEXATTR, &dspImmedESYM) != OK)
2416                         return ERROR;
2417
2418                 deposit_extra_ea = DEPOSIT_EXTRA_WORD;
2419
2420                 // Yes, we have an expression
2421                 return DSP_EA_ABS;
2422         }
2423         else if (*tok == '>')
2424         {
2425                 // Check for immediate address forced long
2426                 tok++;
2427
2428                 if (expr(dspImmedEXPR, &dspImmedEXVAL, &dspImmedEXATTR, &dspImmedESYM) != OK)
2429                         return ERROR;
2430
2431                 if ((dspImmedEXATTR & DEFINED) && (dspImmedEXVAL > 0xFFFFFF))
2432                         return error("long address is bigger than $FFFFFF");
2433
2434                 deposit_extra_ea = DEPOSIT_EXTRA_WORD;
2435
2436                 // Yes, we have an expression
2437                 return DSP_EA_ABS;
2438         }
2439         else if (*tok == '<')
2440         {
2441                 // Check for immediate address forced short
2442                 tok++;
2443
2444                 if (expr(dspImmedEXPR, &dspImmedEXVAL, &dspImmedEXATTR, &dspImmedESYM) != OK)
2445                         return ERROR;
2446
2447                 if ((dspImmedEXATTR & DEFINED) && (dspImmedEXVAL > 0xFFF))
2448                         return error("short addressing mode forced but address is bigger than $FFF");
2449
2450                 // Yes, we have an expression
2451                 return DSP_EA_ABS;
2452         }
2453         else
2454         {
2455                 ea1 = checkea(termchar, strings);
2456
2457                 if (ea1 == ERROR)
2458                         return ERROR;
2459                 else
2460                         return ea1;
2461         }
2462
2463 }
2464
2465
2466 //
2467 // Main routine to check parallel move modes.
2468 // It's quite complex so it's split into a few procedures (in fact most of the
2469 // above ones). A big effort was made so this can be managable and not too
2470 // hacky, however one look at the 56001 manual regarding parallel moves and
2471 // you'll know that this is not an easy // problem to deal with!
2472 // dest=destination register from the main opcode. This must not be the same
2473 // as D1 or D2 and that even goes for stuff like dest=A, D1=A0/1/2!!!
2474 //
2475 LONG parmoves(WORD dest)
2476 {
2477         int force_imm;          // Addressing mode force operator
2478         int immreg;             // Immediate register destination
2479         LONG inst;              // 16 bit bitfield that has the parallel move opcode
2480         LONG S1, S2, D1, D2;    // Source and Destinations
2481         LONG ea1;                               // ea bitfields
2482
2483         if (*tok == EOL)
2484         {
2485                 // No parallel move
2486                 return B16(00100000, 00000000);
2487         }
2488
2489         if (*tok == '#')
2490         {
2491                 // '#xxxxxx,D', '#xx,D'
2492                 tok++;
2493                 force_imm = NUM_NORMAL;
2494
2495                 if (*tok == '>')
2496                 {
2497                         force_imm = NUM_FORCE_LONG;
2498                         tok++;
2499                 }
2500                 else if (*tok == '<')
2501                 {
2502                         force_imm = NUM_FORCE_SHORT;
2503                         tok++;
2504                 }
2505
2506                 if (expr(dspImmedEXPR, &dspImmedEXVAL, &dspImmedEXATTR, &dspImmedESYM) != OK)
2507                         return ERROR;
2508
2509                 if (*tok++ != ',')
2510                         return error("expected comma");
2511
2512                 if (!((*tok >= KW_X0 && *tok <= KW_N7) || (*tok >= KW_R0 && *tok <= KW_R7) || (*tok >= KW_A0 && *tok <= KW_A2)))
2513                         return error("expected x0,x1,y0,y1,a0,b0,a2,b2,a1,b1,a,b,r0-r7,n0-n7 after immediate");
2514
2515                 immreg = SDreg(*tok++);
2516
2517                 if (*tok == EOL)
2518                 {
2519                         if (!(dspImmedEXATTR & FLOAT))
2520                         {
2521                                 if (dspImmedEXATTR & DEFINED)
2522                                 {
2523                                         // From I parallel move:
2524                                         // "If the destination register D is X0, X1, Y0, Y1, A, or
2525                                         // B, the 8-bit immediate short operand is interpreted as
2526                                         // a signed fraction and is stored in the specified
2527                                         // destination register. That is, the 8 - bit data is
2528                                         // stored in the eight MS bits of the destination operand,
2529                                         // and the remaining bits of the destination operand D are
2530                                         // zeroed."
2531                                         // The funny bit is that Motorola assembler can parse
2532                                         // something like 'move #$FF0000,b' into an I (immediate
2533                                         // short move) - so let's do that as well then...
2534                                         if (((immreg >= 4 && immreg <= 7) || immreg == 14 || immreg == 15) && force_imm != NUM_FORCE_LONG)
2535                                         {
2536                                                 if ((dspImmedEXVAL & 0xFFFF) == 0)
2537                                                 {
2538                                                         dspImmedEXVAL >>= 16;
2539                                                 }
2540                                         }
2541
2542                                         if (force_imm == NUM_FORCE_SHORT)
2543                                         {
2544                                                 if (dspImmedEXVAL < 0xFF && (int32_t)dspImmedEXVAL > -0x100)
2545                                                 {
2546                                                         // '#xx,D'
2547                                                         // value fits in 8 bits - immediate move
2548                                                         inst = B16(00100000, 00000000) + (immreg << 8) + (uint32_t)dspImmedEXVAL;
2549                                                         return inst;
2550                                                 }
2551                                                 else
2552                                                 {
2553                                                         if (optim_warn_flag)
2554                                                                 warn("forced short immediate value doesn't fit in 8 bits - switching to long");
2555                                                         force_imm = NUM_FORCE_LONG;
2556                                                 }
2557                                         }
2558
2559                                         if (force_imm == NUM_FORCE_LONG)
2560                                         {
2561                                                 // '#xxxxxx,D'
2562                                                 // it can either be
2563                                                 // X or Y Data move. I don't think it matters much
2564                                                 // which of the two it will be, so let's use X.
2565 deposit_immediate_long_with_register:
2566                                                 inst = B16(01000000, 11110100);
2567                                                 inst |= ((immreg & 0x18) << (12 - 3)) + ((immreg & 7) << 8);
2568                                                 deposit_extra_ea = DEPOSIT_EXTRA_WORD;
2569                                                 return inst;
2570                                         }
2571
2572                                         if (((int32_t)dspImmedEXVAL < 0x100) && ((int32_t)dspImmedEXVAL >= -0x100))
2573                                         {
2574                                                 // value fits in 8 bits - immediate move
2575 deposit_immediate_short_with_register:
2576                                                 inst = B16(00100000, 00000000) + (immreg << 8) + (uint32_t)dspImmedEXVAL;
2577                                                 return inst;
2578                                         }
2579                                         else
2580                                         {
2581                                                 // value doesn't fit in 8 bits, so it can either be
2582                                                 // X or Y Data move. I don't think it matters much
2583                                                 // which of the two it will be, so let's use X:.
2584                                                 // TODO: if we're just goto'ing perhaps the logic can be simplified
2585                                                 goto deposit_immediate_long_with_register;
2586                                         }
2587                                 }
2588                                 else
2589                                 {
2590                                         if (force_imm != NUM_FORCE_SHORT)
2591                                         {
2592                                                 // '#xxxxxx,D'
2593             &nb