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