X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?p=rmac;a=blobdiff_plain;f=parmode.h;h=0c5ca2c0818e01b9ab248016127482dc41c456ce;hp=b116427da7cff908d2a3269bdb58651de4ce8677;hb=f3c7d186a15b89c39e360b9cc89545a0d24bd6a4;hpb=5f23454f7155f0c77ea1bede3f9e60b39da99fa8 diff --git a/parmode.h b/parmode.h index b116427..0c5ca2c 100644 --- a/parmode.h +++ b/parmode.h @@ -1,7 +1,7 @@ // -// RMAC - Reboot's Macro Assembler for the Atari Jaguar Console System +// RMAC - Reboot's Macro Assembler for all Atari computers // PARMODE.C - Addressing Modes Parser Include -// Copyright (C) 199x Landon Dyer, 2017 Reboot and Friends +// Copyright (C) 199x Landon Dyer, 2011-2017 Reboot and Friends // RMAC derived from MADMAC v1.07 Written by Landon Dyer, 1986 // Source utilised with the kind permission of Landon Dyer // @@ -12,19 +12,19 @@ // Dn // An // # expression - if ((*tok >= KW_D0) && (*tok <= KW_D7)) + if ((*tok.u32 >= KW_D0) && (*tok.u32 <= KW_D7)) { AMn = DREG; - AnREG = *tok++ & 7; + AnREG = *tok.u32++ & 7; } - else if ((*tok >= KW_A0) && (*tok <= KW_A7)) + else if ((*tok.u32 >= KW_A0) && (*tok.u32 <= KW_A7)) { AMn = AREG; - AnREG = *tok++ & 7; + AnREG = *tok.u32++ & 7; } - else if (*tok == '#') + else if (*tok.u32 == '#') { - tok++; + tok.u32++; if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK) return ERROR; @@ -48,21 +48,21 @@ // ([bd,An,Xn],od) // ([bd,PC],Xn,od) // ([bd,PC,Xn],od) - else if (*tok == '(') + else if (*tok.u32 == '(') { - tok++; + tok.u32++; - if ((*tok >= KW_A0) && (*tok <= KW_A7)) + if ((*tok.u32 >= KW_A0) && (*tok.u32 <= KW_A7)) { - AnREG = *tok++ & 7; + AnREG = *tok.u32++ & 7; - if (*tok == ')') + if (*tok.u32 == ')') { - tok++; + tok.u32++; - if (*tok == '+') + if (*tok.u32 == '+') { - tok++; + tok.u32++; AMn = APOSTINC; } else @@ -74,36 +74,37 @@ AMn = AINDEXED; goto AMn_IX0; // Handle ",Xn[.siz][*scale])" } - else if ((*tok >= KW_D0) && (*tok <= KW_D7)) + else if ((*tok.u32 >= KW_D0) && (*tok.u32 <= KW_D7)) { //Since index register isn't used here, store register number in this field - AnIXREG = *tok++ & 7; // (Dn) - if (*tok == ')') + AnIXREG = *tok.u32++ & 7; // (Dn) + + if (*tok.u32 == ')') { - tok++; + tok.u32++; AnEXTEN |= EXT_FULLWORD; // Definitely using full extension format, so set bit 8 AnEXTEN |= EXT_BS; // Base register suppressed AnEXTEN |= EXT_BDSIZE0; // Base displacement null AnEXTEN |= EXT_IISPOSN; // Indirect Postindexed with Null Outer Displacement - AMn= MEMPOST; + AMn = MEMPOST; AnREG = 6 << 3; // stuff 110 to mode field goto AnOK; } - else if (*tok == 'L') + else if (*tok.u32 == 'L') { // TODO: does DINDL gets used at all? - //AMn=DINDL; // (Dn.l) - //AnEXTEN = 1 << 1; // Long index size - //tok++; + AMn = DINDL; // (Dn.l) + AnEXTEN = 1 << 1; // Long index size + tok.u32++; } - else if (*tok == 'W') // (Dn.w) + else if (*tok.u32 == 'W') // (Dn.w) { // TODO: does DINDW gets used at all? - //AMn=DINDW; - //AnEXTEN = 1 << 1; // Word index size - //tok++; + AMn = DINDW; + AnEXTEN = 1 << 1; // Word index size + tok.u32++; } - else if (*tok == ',') + else if (*tok.u32 == ',') { // ([bd,An],Xn..) without bd, An // Base displacement is suppressed @@ -111,15 +112,66 @@ AnEXTEN |= EXT_BS; // Base register suppressed AnEXTEN |= EXT_BDSIZE0; AnREG = 6 << 3; // stuff 110 to mode field - tok++; + tok.u32++; goto CHECKODn; } else + { return error("(Dn) error"); + } - if (*tok == ')') + if (*tok.u32 == '*') + { // scale: *1, *2, *4, *8 + tok.u32++; + + if (*tok.u32 == SYMBOL) + { + if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK) + return error("scale factor expression must evaluate"); + + switch (AnEXVAL) + { + case 1: + break; + case 2: + AnIXSIZ |= TIMES2; + break; + case 4: + AnIXSIZ |= TIMES4; + break; + case 8: + AnIXSIZ |= TIMES8; + break; + default: + goto badmode; + } + } + else if (*tok.u32++ != CONST || *tok.u32 > 8) + goto badmode; + else + { + switch ((int)*tok.u32++) + { + case 1: + break; + case 2: + AnIXSIZ |= TIMES2; + break; + case 4: + AnIXSIZ |= TIMES4; + break; + case 8: + AnIXSIZ |= TIMES8; + break; + default: + goto badmode; + } + } + } + + if (*tok.u32 == ')') { - tok++; + tok.u32++; AnEXTEN |= EXT_FULLWORD; // Definitely using full extension format, so set bit 8 AnEXTEN |= EXT_BS; // Base register suppressed AnEXTEN |= EXT_BDSIZE0; // Base displacement null @@ -128,12 +180,21 @@ AMn = MEMPOST; goto AnOK; } + else if (*tok.u32 == ',') + { + tok.u32++; // eat the comma + // It might be (Dn[.wl][*scale],od) + // Maybe this is wrong and we have to write some code here + // instead of reusing that path... + AnEXTEN |= EXT_BDSIZE0; // Base displacement null - suppressed + goto CHECKODn; + } else return error("unhandled so far"); } - else if (*tok == KW_PC) + else if (*tok.u32 == KW_PC) { // (PC,Xn[.siz][*scale]) - tok++; + tok.u32++; AMn = PCINDEXED; // Common index handler; enter here with 'tok' pointing at the @@ -146,100 +207,129 @@ AMn_IXN: // Handle any indexed (tok -> a comma) - if (*tok++ != ',') + if (*tok.u32++ != ',') goto badmode; - if (*tok < KW_D0 || *tok > KW_A7) + if (*tok.u32 < KW_D0 || *tok.u32 > KW_A7) goto badmode; - AnIXREG = *tok++ & 15; + AnIXREG = *tok.u32++ & 15; - switch ((int)*tok) + switch ((int)*tok.u32) { // Index reg size: | .W | .L case DOTW: - tok++; + tok.u32++; default: AnIXSIZ = 0; break; case DOTL: AnIXSIZ = 0x0800; - tok++; + tok.u32++; break; case DOTB: // .B not allowed here... goto badmode; } - if (*tok == '*') + if (*tok.u32 == '*') { // scale: *1, *2, *4, *8 - tok++; + tok.u32++; - if (*tok++ != CONST || *tok > 8) - goto badmode; - - switch ((int)*tok++) + if (*tok.u32 == SYMBOL) { - case 1: - break; - case 2: - AnIXSIZ |= TIMES2; - break; - case 4: - AnIXSIZ |= TIMES4; - break; - case 8: - AnIXSIZ |= TIMES8; - break; - default: + if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK) + return error("scale factor expression must evaluate"); + switch (AnEXVAL) + { + case 1: + break; + case 2: + AnIXSIZ |= TIMES2; + break; + case 4: + AnIXSIZ |= TIMES4; + break; + case 8: + AnIXSIZ |= TIMES8; + break; + default: + goto badmode; + } + } + else if (*tok.u32++ != CONST || *tok.u32 > 8) goto badmode; + else + { + switch ((int)*tok.u32++) + { + case 1: + break; + case 2: + AnIXSIZ |= TIMES2; + break; + case 4: + AnIXSIZ |= TIMES4; + break; + case 8: + AnIXSIZ |= TIMES8; + break; + default: + goto badmode; + } } } - if (*tok++ != ')') // final ")" + if (*tok.u32 == ',') + { + // If we got here we didn't get any [] stuff + // so let's suppress base displacement before + // branching off + tok.u32++; + AnEXTEN |= EXT_BDSIZE0; // Base displacement null - suppressed + goto CHECKODn; + } + if (*tok.u32++ != ')') // final ")" goto badmode; goto AnOK; } - else if (*tok == '[') + else if (*tok.u32 == '[') { // ([... - tok++; - AnEXTEN|=EXT_FULLWORD; //Definitely using full extension format, so set bit 8 + tok.u32++; + AnEXTEN |= EXT_FULLWORD; // Definitely using full extension format, so set bit 8 + // Check to see if base displacement is present - //WARNING("expr will return a bad expression error here but this is expected, it needs to be silenced!"); - if (*tok!=CONST && *tok !=SYMBOL) - //if (expr(AnBEXPR, &AnBEXVAL, &AnBEXATTR, &AnESYM) != OK) + if (*tok.u32 != CONST && *tok.u32 != SYMBOL) { - AnEXTEN|=EXT_BDSIZE0; - //tok++; - //tok--; //Rewind tok since expr advances it forward + AnEXTEN |= EXT_BDSIZE0; } else { expr(AnBEXPR, &AnBEXVAL, &AnBEXATTR, &AnESYM); - if (optim_flags[OPT_BASE_DISP] && AnBEXVAL==0 && AnEXATTR!=0) + if (CHECK_OPTS(OPT_BASE_DISP) && AnBEXVAL == 0 && AnEXATTR != 0) { // bd=0 so let's optimise it out AnEXTEN|=EXT_BDSIZE0; } - else if (*tok==DOTL) - { // ([bd.l,... - AnEXTEN|=EXT_BDSIZEL; - tok++; + else if (*tok.u32 == DOTL) + { // ([bd.l,... + AnEXTEN |= EXT_BDSIZEL; + tok.u32++; } else - { // ([bd[.w],... or ([bd,... + { // ([bd[.w],... or ([bd,... // Is .W forced here? - if (*tok == DOTW) + if (*tok.u32 == DOTW) { - AnEXTEN|=EXT_BDSIZEW; - tok++; + AnEXTEN |= EXT_BDSIZEW; + tok.u32++; } else { // Defined, absolute values from $FFFF8000..$00007FFF get optimized // to absolute short - if (optim_flags[OPT_ABS_SHORT] + if (CHECK_OPTS(OPT_ABS_SHORT) && ((AnBEXATTR & (TDB | DEFINED)) == DEFINED) - && ((AnBEXVAL + 0x8000) < 0x10000)) + && (((uint32_t)AnBEXVAL + 0x8000) < 0x10000)) { AnEXTEN |= EXT_BDSIZEW; warn("absolute value in base displacement ranging $FFFF8000..$00007FFF optimised to absolute short"); @@ -251,8 +341,8 @@ } } - if (*tok == ',') - tok++; + if (*tok.u32 == ',') + tok.u32++; //else // return error("Comma expected after base displacement"); } @@ -260,79 +350,102 @@ // Check for address register or PC, suppress base register // otherwise - if (*tok == KW_PC) + if (*tok.u32 == KW_PC) { // ([bd,PC,... AnREG = (7 << 3) | 3; // PC is special case - stuff 011 to register field and 111 to the mode field - tok++; + tok.u32++; } - else if ((*tok >= KW_A0) && (*tok <= KW_A7)) + else if ((*tok.u32 >= KW_A0) && (*tok.u32 <= KW_A7)) { // ([bd,An,... - AnREG = (6<<3)|*tok & 7; - tok++; + AnREG = (6 << 3) | *tok.u32 & 7; + tok.u32++; } - else if ((*tok >= KW_D0) && (*tok <= KW_D7)) + else if ((*tok.u32 >= KW_D0) && (*tok.u32 <= KW_D7)) { // ([bd,Dn,... AnREG = (6 << 3); - AnEXTEN |= ((*tok & 7) << 12); + AnEXTEN |= ((*tok.u32 & 7) << 12); AnEXTEN |= EXT_D; AnEXTEN |= EXT_BS; // Oh look, a data register! Which means that base register is suppressed - tok++; + tok.u32++; // Check for size { - // ([bd,An/PC],Xn.W/L...) - switch ((int)*tok) - { - // Index reg size: | .W | .L - case DOTW: - tok++; - break; - default: - break; - case DOTL: - AnEXTEN |= EXT_L; - tok++; - break; - case DOTB: - // .B not allowed here... - goto badmode; - } + // ([bd,An/PC],Xn.W/L...) + switch ((int)*tok.u32) + { + // Index reg size: | .W | .L + case DOTW: + tok.u32++; + break; + default: + break; + case DOTL: + AnEXTEN |= EXT_L; + tok.u32++; + break; + case DOTB: + // .B not allowed here... + goto badmode; + } } // Check for scale - if (*tok == '*') // ([bd,An/PC],Xn*...) - { - tok++; - - if (*tok == CONST) // TODO: I suppose the scale is stored as a CONST and nothing else? So prolly the if is not needed? - tok++; + if (*tok.u32 == '*') // ([bd,An/PC],Xn*...) + { // scale: *1, *2, *4, *8 + tok.u32++; - switch ((int)*tok++) + if (*tok.u32 == SYMBOL) { - case 1: - break; - case 2: - AnEXTEN |= EXT_TIMES2; - break; - case 4: - AnEXTEN |= EXT_TIMES4; - break; - case 8: - AnEXTEN |= EXT_TIMES8; - break; - default: + if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK) + return error("scale factor expression must evaluate"); + + switch (AnEXVAL) + { + case 1: + break; + case 2: + AnIXSIZ |= TIMES2; + break; + case 4: + AnIXSIZ |= TIMES4; + break; + case 8: + AnIXSIZ |= TIMES8; + break; + default: + goto badmode; + } + } + else if (*tok.u32++ != CONST || *tok.u32 > 8) goto badmode; + else + { + switch ((int)*tok.u32++) + { + case 1: + break; + case 2: + AnIXSIZ |= TIMES2; + break; + case 4: + AnIXSIZ |= TIMES4; + break; + case 8: + AnIXSIZ |= TIMES8; + break; + default: + goto badmode; + } } } - - if (*tok == ']') // ([bd,Dn]... + if (*tok.u32 == ']') // ([bd,Dn]... { - tok++; + tok.u32++; goto IS_SUPPRESSEDn; } } - else if (*tok == ']') + else if (*tok.u32 == ']') { // PC and Xn is suppressed AnREG = 6 << 3; // stuff 110 to mode field @@ -345,59 +458,59 @@ } // At a crossroads here. We can accept either ([bd,An/PC],... or ([bd,An/PC,Xn*scale],... - if (*tok == ']') + if (*tok.u32 == ']') { //([bd,An/PC],Xn,od) // Check for Xn - tok++; + tok.u32++; - if (*tok == ')') + if (*tok.u32 == ')') { //Xn and od are non existent, get out of jail free card + tok.u32++; AMn = MEMPRE; // ([bc,An,Xn],od) with no Xn and od AnEXTEN |= EXT_IS | EXT_IISPREN; //Suppress Xn and od - tok++; goto AnOK; } - else if (*tok != ',') + else if (*tok.u32 != ',') return error("comma expected after ]"); else - tok++; // eat the comma + tok.u32++; // eat the comma - if ((*tok >= KW_A0) && (*tok <= KW_A7)) + if ((*tok.u32 >= KW_A0) && (*tok.u32 <= KW_A7)) { - AnIXREG = ((*tok & 7) << 12); + AnIXREG = ((*tok.u32 & 7) << 12); AnEXTEN |= EXT_A; - tok++; + tok.u32++; } - else if ((*tok >= KW_D0) && (*tok <= KW_D7)) + else if ((*tok.u32 >= KW_D0) && (*tok.u32 <= KW_D7)) { - AnEXTEN |= ((*tok & 7) << 12); + AnEXTEN |= ((*tok.u32 & 7) << 12); AnEXTEN |= EXT_D; - tok++; + tok.u32++; } else { //No index found, suppress it AnEXTEN |= EXT_IS; - tok--; // Rewind tok to point to the comma - goto IS_SUPPRESSEDn; // https://xkcd.com/292/ - what does he know anyway? + tok.u32--; // Rewind tok to point to the comma + goto IS_SUPPRESSEDn; // https://xkcd.com/292/ - what does he know anyway? } // Check for size { // ([bd,An/PC],Xn.W/L...) - switch ((int)*tok) + switch ((int)*tok.u32) { // Index reg size: | .W | .L case DOTW: - tok++; + tok.u32++; break; default: break; case DOTL: AnEXTEN |= EXT_L; - tok++; + tok.u32++; break; case DOTB: // .B not allowed here... @@ -406,72 +519,95 @@ } // Check for scale - if (*tok == '*') - { - // ([bd,An/PC],Xn*...) - tok++; - - if (*tok == CONST) // TODO: I suppose the scale is stored as a CONST and nothing else? So prolly the if is not needed? - tok++; + if (*tok.u32 == '*') // ([bd,An/PC],Xn*...) + { // scale: *1, *2, *4, *8 + tok.u32++; - switch ((int)*tok++) + if (*tok.u32 == SYMBOL) { - case 1: - break; - case 2: - AnEXTEN |= EXT_TIMES2; - break; - case 4: - AnEXTEN |= EXT_TIMES4; - break; - case 8: - AnEXTEN |= EXT_TIMES8; - break; - default: + if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK) + return error("scale factor expression must evaluate"); + + switch (AnEXVAL) + { + case 1: + break; + case 2: + AnIXSIZ |= TIMES2; + break; + case 4: + AnIXSIZ |= TIMES4; + break; + case 8: + AnIXSIZ |= TIMES8; + break; + default: + goto badmode; + } + } + else if (*tok.u32++ != CONST || *tok.u32 > 8) goto badmode; + else + { + switch ((int)*tok.u32++) + { + case 1: + break; + case 2: + AnIXSIZ |= TIMES2; + break; + case 4: + AnIXSIZ |= TIMES4; + break; + case 8: + AnIXSIZ |= TIMES8; + break; + default: + goto badmode; + } } } // Check for od - if (*tok == ')') // ([bd,An/PC],Xn) + if (*tok.u32 == ')') // ([bd,An/PC],Xn) { //od is non existant, get out of jail free card AMn = MEMPOST; // let's say it's ([bd,An],Xn,od) with od=0 then AnEXTEN |= EXT_IISPOSN; // No outer displacement - tok++; + tok.u32++; goto AnOK; } - else if (*tok!=',') + else if (*tok.u32 != ',') return error("comma expected"); else - tok++; // eat the comma + tok.u32++; // eat the comma CHECKODn: - if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK) goto badmode; - if (optim_flags[OPT_BASE_DISP] && (AnEXVAL == 0)) + if (CHECK_OPTS(OPT_BASE_DISP) && (AnEXVAL == 0)) { // od=0 so optimise it out AMn = MEMPOST; // let's say it's ([bd,An],Xn,od) with od=0 then AnEXTEN |= EXT_IISPOSN; // No outer displacement - tok++; + tok.u32++; goto AnOK; } // ([bd,An/PC],Xn,od) - if (*tok == DOTL) + if (*tok.u32 == DOTL) { // expr.L AnEXTEN |= EXT_IISPOSL; // Long outer displacement AMn = MEMPOST; + tok.u32++; // Defined, absolute values from $FFFF8000..$00007FFF get // optimized to absolute short - if (optim_flags[OPT_ABS_SHORT] + if (CHECK_OPTS(OPT_ABS_SHORT) && ((AnEXATTR & (TDB | DEFINED)) == DEFINED) - && ((AnEXVAL + 0x8000) < 0x10000)) + && (((uint32_t)AnEXVAL + 0x8000) < 0x10000)) { AnEXTEN |= EXT_IISPOSW; // Word outer displacement AMn = MEMPOST; @@ -486,56 +622,56 @@ AMn = MEMPOST; // Is .W forced here? - if (*tok == DOTW) + if (*tok.u32 == DOTW) { - tok++; + tok.u32++; } } // Check for final closing parenthesis - if (*tok == ')') + if (*tok.u32 == ')') { - tok++; + tok.u32++; goto AnOK; } else return error("Closing parenthesis missing on addressing mode"); - IS_SUPPRESSEDn: +IS_SUPPRESSEDn: // Check for od - if (*tok == ')') // ([bd,An/PC],Xn) + if (*tok.u32 == ')') // ([bd,An/PC],Xn) { //od is non existant, get out of jail free card AMn = MEMPOST; // let's say it's ([bd,An],Xn,od) with od=0 then AnEXTEN |= EXT_IISNOIN; // No outer displacement - tok++; + tok.u32++; goto AnOK; } - else if (*tok!=',') + else if (*tok.u32!=',') return error("comma expected"); else - tok++; // eat the comma + tok.u32++; // eat the comma - if ((*tok != CONST) && (*tok != SYMBOL)) + if ((*tok.u32 != CONST) && (*tok.u32 != SYMBOL)) goto badmode; expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM); - if (optim_flags[OPT_BASE_DISP] && (AnEXVAL == 0)) + if (CHECK_OPTS(OPT_BASE_DISP) && (AnEXVAL == 0)) { // od=0 so optimise it out AMn = MEMPOST; // let's say it's ([bd,An],Xn,od) with od=0 then AnEXTEN |= EXT_IISNOIN; // No outer displacement - tok++; + tok.u32++; goto AnOK; } // ([bd,An/PC],Xn,od) - if (*tok == DOTL) + if (*tok.u32 == DOTL) { // expr.L - tok++; + tok.u32++; AMn = MEMPOST; AnEXTEN |= EXT_IISNOIL; // Long outer displacement with IS suppressed } @@ -545,18 +681,17 @@ AnEXTEN |= EXT_IISNOIW; // Word outer displacement with IS suppressed AMn = MEMPRE; - if (*tok == DOTW) + if (*tok.u32 == DOTW) { //AnEXTEN|=EXT_IISNOIW; // Word outer displacement AMn = MEMPOST; - tok++; + tok.u32++; } - // Defined, absolute values from $FFFF8000..$00007FFF get // optimized to absolute short - else if (optim_flags[OPT_BASE_DISP] + else if (CHECK_OPTS(OPT_BASE_DISP) && ((AnEXATTR & (TDB | DEFINED)) == DEFINED) - && ((AnEXVAL + 0x8000) < 0x10000)) + && (((uint32_t)AnEXVAL + 0x8000) < 0x10000)) { //AnEXTEN|=EXT_IISNOIW; // Word outer displacement with IS suppressed warn("outer displacement absolute value from $FFFF8000..$00007FFF optimised to absolute short"); @@ -564,149 +699,181 @@ } // Check for final closing parenthesis - if (*tok == ')') + if (*tok.u32 == ')') { - tok++; + tok.u32++; goto AnOK; } else return error("Closing parenthesis missing on addressing mode"); } - else if (*tok == ',') + else if (*tok.u32 == ',') { - *tok++; // ([bd,An,Xn.size*scale],od) + *tok.u32++; // ([bd,An,Xn.size*scale],od) //Check for Xn - if ((*tok >= KW_A0) && (*tok <= KW_A7)) + if ((*tok.u32 >= KW_A0) && (*tok.u32 <= KW_A7)) { - AnEXTEN |= ((*tok & 7) << 12); + AnEXTEN |= ((*tok.u32 & 7) << 12); AnEXTEN |= EXT_A; - tok++; + tok.u32++; } - else if ((*tok >= KW_D0) && (*tok <= KW_D7)) + else if ((*tok.u32 >= KW_D0) && (*tok.u32 <= KW_D7)) { - AnEXTEN |= ((*tok & 7) << 12); + AnEXTEN |= ((*tok.u32 & 7) << 12); AnEXTEN |= EXT_D; - tok++; + tok.u32++; } // Check for size { - // ([bd,An/PC],Xn.W/L...) - switch ((int)*tok) - { - // Index reg size: | .W | .L - case DOTW: - tok++; - break; - default: - break; - case DOTL: - tok++; - AnEXTEN |= EXT_L; - break; - case DOTB: - // .B not allowed here... - goto badmode; - } + // ([bd,An/PC],Xn.W/L...) + switch ((int)*tok.u32) + { + // Index reg size: | .W | .L + case DOTW: + tok.u32++; + break; + default: + break; + case DOTL: + tok.u32++; + AnEXTEN |= EXT_L; + break; + case DOTB: + // .B not allowed here... + goto badmode; + } } // Check for scale - if (*tok == '*') // ([bd,An/PC],Xn*...) - { - tok++; - - if (*tok == CONST) // TODO: I suppose the scale is stored as a CONST and nothing else? So prolly the if is not needed? - tok++; + if (*tok.u32 == '*') // ([bd,An/PC],Xn*...) + { // scale: *1, *2, *4, *8 + tok.u32++; - switch ((int)*tok++) + if (*tok.u32 == SYMBOL) { - case 1: - break; - case 2: - AnEXTEN |= EXT_TIMES2; - break; - case 4: - AnEXTEN |= EXT_TIMES4; - break; - case 8: - AnEXTEN |= EXT_TIMES8; - break; - default: + if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK) + return error("scale factor expression must evaluate"); + switch (AnEXVAL) + { + case 1: + break; + case 2: + AnIXSIZ |= TIMES2; + break; + case 4: + AnIXSIZ |= TIMES4; + break; + case 8: + AnIXSIZ |= TIMES8; + break; + default: + goto badmode; + } + } + else if (*tok.u32++ != CONST || *tok.u32 > 8) goto badmode; + else + { + switch ((int)*tok.u32++) + { + case 1: + break; + case 2: + AnIXSIZ |= TIMES2; + break; + case 4: + AnIXSIZ |= TIMES4; + break; + case 8: + AnIXSIZ |= TIMES8; + break; + default: + goto badmode; + } } } //Check for ] - if (*tok != ']') + if (*tok.u32 != ']') return error("Expected closing bracket ]"); - - tok++; // Eat the bracket + tok.u32++; // Eat the bracket //Check for od - if (*tok == ')') // ([bd,An/PC,Xn]... + if (*tok.u32 == ')') // ([bd,An/PC,Xn]... { //od is non existant, get out of jail free card //AnEXVAL=0; // zero outer displacement AMn = MEMPRE; // let's say it's ([bd,An,Xn],od) with od suppressed then AnEXTEN |= EXT_IISPREN; // No outer displacement - tok++; + tok.u32++; goto AnOK; } - else if (*tok++!=',') + else if (*tok.u32++ != ',') return error("comma expected after ]"); - WARNING(Put symbol and constant checks here!) - - if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK) - goto badmode; - - if (optim_flags[OPT_BASE_DISP] && (AnEXVAL == 0)) + if (*tok.u32 == SYMBOL || *tok.u32 == CONST) { - // od=0 so optimise it out - AMn = MEMPRE; // let's say it's ([bd,An],Xn,od) with od=0 then - AnEXTEN |= EXT_IISPRE0; // No outer displacement - tok++; - goto AnOK; + if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK) + goto badmode; + + if (CHECK_OPTS(OPT_BASE_DISP) && (AnEXVAL == 0) && (AnEXATTR & DEFINED)) + { + // od=0 so optimise it out + AMn = MEMPRE; // let's say it's ([bd,An],Xn,od) with od=0 then + AnEXTEN |= EXT_IISPRE0; // No outer displacement + tok.u32++; + goto AnOK; + } } // ([bd,An/PC,Xn],od) - if (*tok == DOTL) + if (*tok.u32 == DOTL) { // expr.L AMn = MEMPRE; - tok++; + tok.u32++; AnEXTEN |= EXT_IISPREL; } else { // expr.[W] - //tok++; - - AnEXTEN |= EXT_IISPREW; AMn = MEMPRE; + int expr_size = EXT_IISPREW; // Assume we have a .w value - // Is .W forced here? - if (*tok == DOTW) + if ((AnEXVAL + 0x8000) > 0x10000) { - tok++; + // Long value, so mark it as such for now + expr_size = EXT_IISPREL; + + // Defined, absolute values from $FFFF8000..$00007FFF + // get optimized to absolute short + if (CHECK_OPTS(OPT_BASE_DISP) + && ((AnEXATTR & (TDB | DEFINED)) == DEFINED) + && (((uint32_t)AnEXVAL + 0x8000) < 0x10000)) + { + expr_size = EXT_IISPREW; + warn("outer displacement absolute value from $FFFF8000..$00007FFF optimised to absolute short"); + } } - // Defined, absolute values from $FFFF8000..$00007FFF get optimized - // to absolute short - else if (optim_flags[OPT_BASE_DISP] - && ((AnEXATTR & (TDB | DEFINED)) == DEFINED) - && ((AnEXVAL + 0x8000) < 0x10000)) + AnEXTEN |= expr_size; // Assume we have a .w value + + // Is .W forced here? + if (*tok.u32 == DOTW) { - AnEXTEN |= EXT_IISPREW; - warn("outer displacement absolute value from $FFFF8000..$00007FFF optimised to absolute short"); + tok.u32++; + + if (expr_size == EXT_IISPREL) + return error("outer displacement value does not fit in .w size"); } } // Check for final closing parenthesis - if (*tok == ')') + if (*tok.u32 == ')') { - tok++; + tok.u32++; goto AnOK; } else @@ -723,46 +890,46 @@ // It could be that this is really just an expression prefixing a // register as a displacement... - if (*tok == ')') + if (*tok.u32 == ')') { - tok++; + tok.u32++; goto CHK_FOR_DISPn; } // Otherwise, check for PC & etc displacements... - if (*tok++ != ',') + if (*tok.u32++ != ',') goto badmode; - if ((*tok >= KW_A0) && (*tok <= KW_A7)) + if ((*tok.u32 >= KW_A0) && (*tok.u32 <= KW_A7)) { - AnREG = *tok & 7; - tok++; + AnREG = *tok.u32 & 7; + tok.u32++; - if (*tok == ',') + if (*tok.u32 == ',') { AMn = AINDEXED; goto AMn_IXN; } - else if (*tok == ')') + else if (*tok.u32 == ')') { AMn = ADISP; - tok++; + tok.u32++; goto AnOK; } else goto badmode; } - else if (*tok == KW_PC) + else if (*tok.u32 == KW_PC) { - if (*++tok == ',') + if (*++tok.u32 == ',') { // expr(PC,Xn...) AMn = PCINDEXED; goto AMn_IXN; } - else if (*tok == ')') + else if (*tok.u32 == ')') { - AMn = PCDISP; // expr(PC) - tok++; + AMn = PCDISP; // expr(PC) + tok.u32++; goto AnOK; } else @@ -772,57 +939,56 @@ goto badmode; } } - else if (*tok == '-' && tok[1] == '(' && ((tok[2] >= KW_A0) && (tok[2] <= KW_A7)) && tok[3] == ')') + else if (*tok.u32 == '-' && tok.u32[1] == '(' && ((tok.u32[2] >= KW_A0) && (tok.u32[2] <= KW_A7)) && tok.u32[3] == ')') { AMn = APREDEC; - AnREG = tok[2] & 7; - tok += 4; + AnREG = tok.u32[2] & 7; + tok.u32 += 4; } - else if (*tok == KW_CCR) + else if (*tok.u32 == KW_CCR) { AMn = AM_CCR; - tok++; + tok.u32++; goto AnOK; } - else if (*tok == KW_SR) + else if (*tok.u32 == KW_SR) { AMn = AM_SR; - tok++; + tok.u32++; goto AnOK; } - else if (*tok == KW_USP) + else if (*tok.u32 == KW_USP) { AMn = AM_USP; - tok++; + tok.u32++; AnREG = 2; //Added this for the case of USP used in movec (see CREGlut in mach.c). Hopefully nothing gets broken! goto AnOK; } - else if ((*tok >= KW_IC40) && (*tok <= KW_BC40)) + else if ((*tok.u32 >= KW_IC40) && (*tok.u32 <= KW_BC40)) { AMn = CACHES; - AnREG = *tok++ - KW_IC40; + AnREG = *tok.u32++ - KW_IC40; // After a cache keyword only a comma or EOL is allowed - if ((*tok != ',') && (*tok != EOL)) + if ((*tok.u32 != ',') && (*tok.u32 != EOL)) return ERROR; - goto AnOK; } - else if ((*tok >= KW_SFC) && (*tok <= KW_CRP)) + else if ((*tok.u32 >= KW_SFC) && (*tok.u32 <= KW_CRP)) { AMn = CREG; - AnREG = (*tok++) - KW_SFC; + AnREG = (*tok.u32++) - KW_SFC; goto AnOK; } - else if ((*tok >= KW_FP0) && (*tok <= KW_FP7)) + else if ((*tok.u32 >= KW_FP0) && (*tok.u32 <= KW_FP7)) { AMn = FREG; - AnREG = (*tok++ & 7); + AnREG = (*tok.u32++ & 7); } - else if ((*tok >= KW_FPIAR) && (*tok <= KW_FPCR)) + else if ((*tok.u32 >= KW_FPIAR) && (*tok.u32 <= KW_FPCR)) { AMn = FPSCR; - AnREG = (1 << ((*tok++) - KW_FPIAR + 10)); + AnREG = (1 << ((*tok.u32++) - KW_FPIAR + 10)); } // expr // expr.w @@ -837,10 +1003,10 @@ return ERROR; CHK_FOR_DISPn: - if (*tok == DOTW) + if (*tok.u32 == DOTW) { // expr.W - tok++; + tok.u32++; AMn = ABSW; if (((AnEXATTR & (TDB | DEFINED)) == DEFINED) && (AnEXVAL < 0x10000)) @@ -848,16 +1014,16 @@ CHK_FOR_DISPn: goto AnOK; } - else if (*tok != '(') + else if (*tok.u32 != '(') { // expr[.L] AMn = ABSL; // Defined, absolute values from $FFFF8000..$00007FFF get optimized // to absolute short - if (optim_flags[OPT_ABS_SHORT] + if (CHECK_OPTS(OPT_ABS_SHORT) && ((AnEXATTR & (TDB | DEFINED)) == DEFINED) - && ((AnEXVAL + 0x8000) < 0x10000)) + && (((uint32_t)AnEXVAL + 0x8000) < 0x10000)) { AMn = ABSW; @@ -866,43 +1032,44 @@ CHK_FOR_DISPn: } // Is .L forced here? - if (*tok == DOTL) + if (*tok.u32 == DOTL) { - tok++; + tok.u32++; AMn = ABSL; } goto AnOK; } - tok++; + tok.u32++; - if ((*tok >= KW_A0) && (*tok <= KW_A7)) + if ((*tok.u32 >= KW_A0) && (*tok.u32 <= KW_A7)) { - AnREG = *tok++ & 7; + AnREG = *tok.u32++ & 7; - if (*tok == ')') + if (*tok.u32 == ')') { AMn = ADISP; - tok++; + tok.u32++; goto AnOK; } AMn = AINDEXED; goto AMn_IXN; } - else if (*tok == KW_PC) + else if (*tok.u32 == KW_PC) { - if (*++tok == ')') + if (*++tok.u32 == ')') { AMn = PCDISP; - tok++; + tok.u32++; goto AnOK; } AMn = PCINDEXED; goto AMn_IXN; } + goto badmode; }