From 469296f144c4fa071f44a239863243627275136b Mon Sep 17 00:00:00 2001 From: g012 Date: Tue, 19 Sep 2017 00:53:37 +0200 Subject: [PATCH] Added all remaining opcodes. --- 6502.lua | 214 ++++++++++++++++++++++++++++++++++++++++++++++++------- asm.lua | 6 +- l65.lua | 64 +++++++++++++++-- 3 files changed, 250 insertions(+), 34 deletions(-) diff --git a/6502.lua b/6502.lua index 4f6d1da..d63eeae 100644 --- a/6502.lua +++ b/6502.lua @@ -391,11 +391,17 @@ M.word = function(...) table.insert(M.section_current.instructions, { data=data, size=#data*2, asbin=asbin }) end -local op,cycles_def +local op,cycles_def,xcross_def op = function(code, cycles, extra_on_crosspage) - return { opc=code, cycles=cycles or cycles_def, xcross=extra_on_crosspage or 0 } + return { opc=code, cycles=cycles or cycles_def, xcross=extra_on_crosspage or xcross_def } end -cycles_def=2 local opimp={ +local op_eval = function(late, early) + local x = early or 0 + return type(late) == 'function' and late(x) or x+late +end +local op_eval_byte = function(late, early) return byte_normalize(op_eval(late, early)) end +local op_eval_word = function(late, early) return word_normalize(op_eval(late, early)) end +cycles_def=2 xcross_def=0 local opimp={ asl=op(0x0a), brk=op(0x00,7), clc=op(0x18), cld=op(0xd8), cli=op(0x58), clv=op(0xb8), dex=op(0xca), dey=op(0x88), inx=op(0xe8), iny=op(0xc8), lsr=op(0x4a), nop=op(0xea), pha=op(0x48,3), php=op(0x08,3), pla=op(0x68,4), plp=op(0x28,4), rol=op(0x2a), ror=op(0x6a), rti=op(0x40,6), rts=op(0x60,6), sec=op(0x38), sei=op(0x78), tax=op(0xaa), tay=op(0xa8), @@ -408,22 +414,18 @@ for k,v in pairs(opimp) do table.insert(M.section_current.instructions, { size=1, cycles=v.cycles, asbin=asbin }) end end -cycles_def=2 local opimm={ +cycles_def=2 xcross_def=0 local opimm={ adc=op(0x69), ['and']=op(0x29), cmp=op(0xc9), cpx=op(0xe0), cpy=op(0xc0), eor=op(0x49), lda=op(0xa9), ldx=op(0xa2), ldy=op(0xa0), ora=op(0x09), sbc=op(0xe9), anc=op(0x0b), ane=op(0x8b), arr=op(0x6b), asr=op(0x4b), jam=op(0x12,0), lax=op(0xab), nop=op(0x80), sbx=op(0xcb), } M.opimm = opimm for k,v in pairs(opimm) do M[k .. 'imm'] = function(late, early) - local asbin = function(b) - local x = early or 0 - x = byte_normalize(type(late) == 'function' and late(x) or x+late) - b[#b+1]=v.opc b[#b+1]=x - end + local asbin = function(b) b[#b+1]=v.opc b[#b+1]=op_eval_byte(late,early) end table.insert(M.section_current.instructions, { size=2, cycles=2, asbin=asbin }) end end -cycles_def=3 local opzpg={ +cycles_def=3 xcross_def=0 local opzpg={ adc=op(0x65), ['and']=op(0x25), asl=op(0x06,5), bit=op(0x24), cmp=op(0xc5), cpx=op(0xe4), cpy=op(0xc4), dec=op(0xc6,5), eor=op(0x45), inc=op(0xe6,5), lda=op(0xa5), ldx=op(0xa6), ldy=op(0xa4), lsr=op(0x46,5), ora=op(0x05), rol=op(0x26,5), ror=op(0x66,5), sbc=op(0xe5), sta=op(0x85), stx=op(0x86), sty=op(0x84), @@ -432,15 +434,11 @@ cycles_def=3 local opzpg={ } M.opzpg = opzpg for k,v in pairs(opzpg) do M[k .. 'zpg'] = function(late, early) - local asbin = function(b) - local x = early or 0 - x = byte_normalize(type(late) == 'function' and late(x) or x+late) - b[#b+1]=v.opc b[#b+1]=x - end + local asbin = function(b) b[#b+1]=v.opc b[#b+1]=op_eval_byte(late,early) end table.insert(M.section_current.instructions, { size=2, cycles=v.cycles, asbin=asbin }) end end -cycles_def=4 local opabs={ +cycles_def=4 xcross_def=0 local opabs={ adc=op(0x6d), ['and']=op(0x2d), asl=op(0x0e,6), bit=op(0x2c), cmp=op(0xcd), cpx=op(0xec), cpy=op(0xcc), dec=op(0xce,6), eor=op(0x4d), inc=op(0xee,6), jmp=op(0x4c,3), jsr=op(0x20,6), lda=op(0xad), ldx=op(0xae), ldy=op(0xac), lsr=op(0x4e,6), ora=op(0x0d), rol=op(0x2e,6), ror=op(0x6e,6), sbc=op(0xed), sta=op(0x8d), stx=op(0x8e), sty=op(0x8c), @@ -450,12 +448,15 @@ cycles_def=4 local opabs={ for k,v in pairs(opabs) do M[k .. 'abs'] = function(late, early) local asbin = function(b) - local x = early or 0 - x = word_normalize(type(late) == 'function' and late(x) or x+late) + local x = op_eval_word(late,early) b[#b+1]=v.opc b[#b+1]=x&0xff b[#b+1]=x>>8 end table.insert(M.section_current.instructions, { size=3, cycles=v.cycles, asbin=asbin }) end +end +local opzab={} M.opabs = opabs +for k,_ in pairs(opzpg) do if opabs[k] then opzab[k]=true end end +for k,_ in pairs(opzab) do M[k .. 'zab'] = function(late, early) if type(late) ~= 'function' then local x = (early or 0) + late @@ -464,32 +465,158 @@ for k,v in pairs(opabs) do error("value out of word range: " .. x) end local eval, asbin - local ins = { size=eval, cycles=v.cycles, asbin=asbin } + local abs = opabs[k] + local ins = { size=eval, cycles=abs.cycles, asbin=asbin } eval = function() local r,x = pcall(late(early or 0)) if not r then return 3 end x = word_normalize(x) - local op = opzpg[k] - if x <= 0xff and op then + local zpg = opzpg[k] + if x <= 0xff and zpg then ins.size = 2 - ins.cycles = op.cycles - ins.asbin = function(b) b[#b+1]=op.opc b[#b+1]=x end + ins.cycles = zpg.cycles + ins.asbin = function(b) b[#b+1]=zpg.opc b[#b+1]=x end return 2 end ins.size = 3 - ins.asbin = function(b) b[#b+1]=v.opc b[#b+1]=x&0xff b[#b+1]=x>>8 end + ins.asbin = function(b) b[#b+1]=abs.opc b[#b+1]=x&0xff b[#b+1]=x>>8 end return 3 end asbin = function(b) local x = word_normalize(late(early or 0)) -- since we assumed absolute on link phase, we must generate absolute in binary if x <= 0xff and opzpg[k] then print("warning: forcing abs on zpg operand for opcode " .. k) end - b[#b+1]=v.opc b[#b+1]=x&0xff b[#b+1]=x>>8 + b[#b+1]=abs.opc b[#b+1]=x&0xff b[#b+1]=x>>8 end table.insert(M.section_current.instructions, ins) end end -cycles_def=2 local oprel={ +cycles_def=4 xcross_def=0 local opzpx={ + adc=op(0x75), ['and']=op(0x35), asl=op(0x16,6), cmp=op(0xd5), dec=op(0xd6,6), eor=op(0x55), inc=op(0xf6,6), lda=op(0xb5), + ldy=op(0xb4), lsr=op(0x56,6), ora=op(0x15), rol=op(0x36,6), ror=op(0x76,6), sbc=op(0xf5), sta=op(0x95), sty=op(0x94), + dcp=op(0xd7,6), isb=op(0xf7,6), jam=op(0x32,0), nop=op(0x14), rla=op(0x37,6), rra=op(0x77,6), slo=op(0x17,6), sre=op(0x57,6), +} M.opzpx = opzpx +for k,v in pairs(opzpx) do + M[k .. 'zpx'] = function(late, early) + local asbin = function(b) b[#b+1]=v.opc b[#b+1]=op_eval_byte(late,early) end + table.insert(M.section_current.instructions, { size=2, cycles=v.cycles, asbin=asbin }) + end +end +cycles_def=4 xcross_def=1 local opabx={ + adc=op(0x7d), ['and']=op(0x3d), asl=op(0x1e,7,0), cmp=op(0xdd), dec=op(0xde,7,0), eor=op(0x5d), inc=op(0xfe,7,0), lda=op(0xbd), + ldy=op(0xbc), lsr=op(0x5e,7,0), ora=op(0x1d), rol=op(0x3e,7,0), ror=op(0x7e,7,0), sbc=op(0xfd), sta=op(0x9d,5,0), + dcp=op(0xdf,7,0), isb=op(0xff,7,0), jam=op(0x92,0,0), nop=op(0x1c), rla=op(0x3f,7,0), rra=op(0x7f,7,0), shy=op(0x9c,5,0), slo=op(0x1f,7,0), + sre=op(0x5f,7,0), +} M.opabx = opabx +for k,v in pairs(opabx) do + M[k .. 'abx'] = function(late, early) + local asbin = function(b) + local x = op_eval_word(late,early) + b[#b+1]=v.opc b[#b+1]=x&0xff b[#b+1]=x>>8 + end + table.insert(M.section_current.instructions, { size=3, cycles=v.cycles, asbin=asbin }) + end +end +local opzax={} M.opabx = opabx +for k,_ in pairs(opzpx) do if opabx[k] then opzax[k]=true end end +for k,_ in pairs(opzax) do + M[k .. 'zax'] = function(late, early) + if type(late) ~= 'function' then + local x = (early or 0) + late + if x >= -128 and x <= 0xff then return M[k .. 'zpx'](late, early) end + if x >= -32768 and x <= 0xffff then return M[k .. 'abx'](late, early) end + error("value out of word range: " .. x) + end + local eval, asbin + local abx = opabx[k] + local ins = { size=eval, cycles=abx.cycles, asbin=asbin } + eval = function() + local r,x = pcall(late(early or 0)) + if not r then return 3 end + x = word_normalize(x) + local zpx = opzpx[k] + if x <= 0xff and zpx then + ins.size = 2 + ins.cycles = zpx.cycles + ins.asbin = function(b) b[#b+1]=zpx.opc b[#b+1]=x end + return 2 + end + ins.size = 3 + ins.asbin = function(b) b[#b+1]=abx.opc b[#b+1]=x&0xff b[#b+1]=x>>8 end + return 3 + end + asbin = function(b) + local x = word_normalize(late(early or 0)) + -- since we assumed absolute on link phase, we must generate absolute in binary + if x <= 0xff and opzpx[k] then print("warning: forcing abx on zpx operand for opcode " .. k) end + b[#b+1]=abx.opc b[#b+1]=x&0xff b[#b+1]=x>>8 + end + table.insert(M.section_current.instructions, ins) + end +end +cycles_def=4 xcross_def=0 local opzpy={ + ldx=op(0xb6), stx=op(0x96), + jam=op(0x42,0), lax=op(0xb7), sax=op(0x97), +} M.opzpy = opzpy +for k,v in pairs(opzpy) do + M[k .. 'zpy'] = function(late, early) + local asbin = function(b) b[#b+1]=v.opc b[#b+1]=op_eval_byte(late,early) end + table.insert(M.section_current.instructions, { size=2, cycles=v.cycles, asbin=asbin }) + end +end +cycles_def=4 xcross_def=1 local opaby={ + adc=op(0x79), ['and']=op(0x39), cmp=op(0xd9), eor=op(0x59), lda=op(0xb9), ldx=op(0xbe), ora=op(0x19), sbc=op(0xf9), + sta=op(0x99,5,0), + dcp=op(0xdb,7,0), isb=op(0xfb,7,0), jam=op(0xb2,0,0), las=op(0xbb), lax=op(0xbf), rla=op(0x3b,7,0), rra=op(0x7b,7,0), sha=op(0x9f,5,0), + shs=op(0x9b,5,0), shx=op(0x9e,5,0), slo=op(0x1b,7,0), sre=op(0x5b,7,0), +} M.opaby = opaby +for k,v in pairs(opaby) do + M[k .. 'aby'] = function(late, early) + local asbin = function(b) + local x = op_eval_word(late,early) + b[#b+1]=v.opc b[#b+1]=x&0xff b[#b+1]=x>>8 + end + table.insert(M.section_current.instructions, { size=3, cycles=v.cycles, asbin=asbin }) + end +end +local opzay={} M.opaby = opaby +for k,_ in pairs(opzpy) do if opaby[k] then opzay[k]=true end end +for k,_ in pairs(opzay) do + M[k .. 'zay'] = function(late, early) + if type(late) ~= 'function' then + local x = (early or 0) + late + if x >= -128 and x <= 0xff then return M[k .. 'zpy'](late, early) end + if x >= -32768 and x <= 0xffff then return M[k .. 'aby'](late, early) end + error("value out of word range: " .. x) + end + local eval, asbin + local aby = opaby[k] + local ins = { size=eval, cycles=aby.cycles, asbin=asbin } + eval = function() + local r,x = pcall(late(early or 0)) + if not r then return 3 end + x = word_normalize(x) + local zpy = opzpy[k] + if x <= 0xff and zpy then + ins.size = 2 + ins.cycles = zpy.cycles + ins.asbin = function(b) b[#b+1]=zpy.opc b[#b+1]=x end + return 2 + end + ins.size = 3 + ins.asbin = function(b) b[#b+1]=aby.opc b[#b+1]=x&0xff b[#b+1]=x>>8 end + return 3 + end + asbin = function(b) + local x = word_normalize(late(early or 0)) + -- since we assumed absolute on link phase, we must generate absolute in binary + if x <= 0xff and opzpy[k] then print("warning: forcing aby on zpy operand for opcode " .. k) end + b[#b+1]=aby.opc b[#b+1]=x&0xff b[#b+1]=x>>8 + end + table.insert(M.section_current.instructions, ins) + end +end +cycles_def=2 xcross_def=0 local oprel={ bcc=op(0x90), bcs=op(0xb0), beq=op(0xf0), bmi=op(0x30), bne=op(0xd0), bpl=op(0x10), bvc=op(0x50), bvs=op(0x70), } M.oprel = oprel for k,v in pairs(oprel) do @@ -509,5 +636,40 @@ for k,v in pairs(oprel) do table.insert(M.section_current.instructions, { size=2, cycles=2, asbin=asbin }) end end +cycles_def=5 xcross_def=0 local opind={ + jmp=op(0x6c), + jam=op(0xd2,0), +} M.opind = opind +for k,v in pairs(opind) do + M[k .. 'ind'] = function(late, early) + local asbin = function(b) + local x = op_eval_word(late,early) + b[#b+1]=v.opc b[#b+1]=x&0xff b[#b+1]=x>>8 + end + table.insert(M.section_current.instructions, { size=3, cycles=v.cycles, asbin=asbin }) + end +end +cycles_def=6 xcross_def=0 local opinx={ + adc=op(0x61), ['and']=op(0x21), cmp=op(0xc1), eor=op(0x41), lda=op(0xa1), ora=op(0x01), sbc=op(0xe1), sta=op(0x81), + dcp=op(0xc3,8), isb=op(0xe3,8), jam=op(0x52,0), lax=op(0xa3), rla=op(0x23,8), rra=op(0x63,8), sax=op(0x83), slo=op(0x03,8), + sre=op(0x43,8), +} M.opinx = opinx +for k,v in pairs(opinx) do + M[k .. 'inx'] = function(late, early) + local asbin = function(b) b[#b+1]=v.opc b[#b+1]=op_eval_byte(late,early) end + table.insert(M.section_current.instructions, { size=2, cycles=v.cycles, asbin=asbin }) + end +end +cycles_def=5 xcross_def=1 local opiny={ + adc=op(0x71), ['and']=op(0x31), cmp=op(0xd1), eor=op(0x51), lda=op(0xb1), ora=op(0x11), sbc=op(0xf1), sta=op(0x91,6), + dcp=op(0xd3,8), isb=op(0xf3,8), jam=op(0x62,0,0), lax=op(0xb3), rla=op(0x33,8), rra=op(0x73,8), sha=op(0x93,6), slo=op(0x13,8), + sre=op(0x53,8), +} +for k,v in pairs(opiny) do + M[k .. 'iny'] = function(late, early) + local asbin = function(b) b[#b+1]=v.opc b[#b+1]=op_eval_byte(late,early) end + table.insert(M.section_current.instructions, { size=2, cycles=v.cycles, asbin=asbin }) + end +end return M diff --git a/asm.lua b/asm.lua index e313e80..24300e4 100644 --- a/asm.lua +++ b/asm.lua @@ -58,10 +58,10 @@ section("waitForIntim") --alt short syntax when no other option ldazab(function(o) return o+( data) end) ldazab(function(o) return o+( data) end,5) ldazax(function(o) return o+( data) end,5) - ldazay(function(o) return o+( data) end,5) + ldaaby(function(o) return o+( data) end,5) ldazab(function(o) return o+( data+3) end,12) ldazax(function(o) return o+( data+3) end,12) - ldazay(function(o) return o+( data+3) end,12) + ldaaby(function(o) return o+( data+3) end,12) ldainx (function(o) return o+(INTIM) end,5) ldainx (function(a) return a+2 end,INTIM) ldainy (function(o) return o+(INTIM) end,5) @@ -90,7 +90,7 @@ section("waitForIntim") --alt short syntax when no other option ldazab(function(o) return o+( INTIM) end) ldaabs(function(o) return o+( INTIM) end) ldazax(function(o) return o+( INTIM) end) - ldazay(function(o) return o+( INTIM) end) + ldaaby(function(o) return o+( INTIM) end) ldainx (function(o) return o+(INTIM) end) ldainy (function(o) return o+(INTIM) end) endpage() end diff --git a/l65.lua b/l65.lua index 5742b51..94315b5 100644 --- a/l65.lua +++ b/l65.lua @@ -80,6 +80,25 @@ local opcode_immediate = lookupify{ -- illegal opcodes 'anc', 'ane', 'arr', 'asr', 'jam', 'lax', 'nop', 'sbx', } +local opcode_zeropage = lookupify{ + 'adc', 'and', 'asl', 'bit', 'cmp', 'cpy', 'cpx', 'dec', + 'eor', 'inc', 'lda', 'ldx', 'ldy', 'lsr', 'nop', 'ora', + 'rol', 'ror', 'sbc', 'sta', 'stx', 'sty', + -- illegal opcodes + 'dcp', 'isb', 'jam', 'lax', 'rla', 'rra', 'sax', 'slo', + 'sre', +} +local opcode_zeropage_x = lookupify{ + 'adc', 'and', 'asl', 'cmp', 'dec', 'eor', 'inc', 'lda', + 'ldy', 'lsr', 'ora', 'rol', 'ror', 'sbc', 'sta', 'sty', + -- illegal opcodes + 'dcp', 'isb', 'jam', 'nop', 'rla', 'rra', 'slo', 'sre', +} +local opcode_zeropage_y = lookupify{ + 'ldx', 'stx', + -- illegal opcodes + 'lax', 'sax', +} local opcode_absolute = lookupify{ 'adc', 'and', 'asl', 'bit', 'cmp', 'cpy', 'cpx', 'dec', 'eor', 'inc', 'jmp', 'jsr', 'lda', 'ldx', 'ldy', 'lsr', @@ -1348,7 +1367,9 @@ local function ParseLua(src) end end end - if opcode_absolute[op] or opcode_absolute_x[op] or opcode_absolute_y[op] then + if opcode_absolute[op] or opcode_absolute_x[op] or opcode_absolute_y[op] + or opcode_zeropage[op] or opcode_zeropage_x[op] or opcode_zeropage_y[op] + then local suffix = '' tok:Save() if tok:ConsumeSymbol('.', tokenList) then @@ -1367,17 +1388,27 @@ local function ParseLua(src) else tok:Commit() if not tok:ConsumeSymbol(',', tokenList) then - if not opcode_absolute[op] then return false, expr end suffix = suffix=='b' and "zpg" or suffix=='w' and "abs" or "zab" + if suffix == 'zab' then + if not opcode_zeropage[op] then suffix='abs' + elseif not opcode_absolute[op] then suffix='zpg' end + end + if suffix == 'zpg' and not opcode_zeropage[op] then return false, GenerateError("opcode " .. op " doesn't support zeropage addressing mode") end + if suffix == 'abs' and not opcode_absolute[op] then return false, GenerateError("opcode " .. op " doesn't support absolute addressing mode") end stat = emit_call{name=op .. suffix, args={expr}} break end if tok:Peek().Data == 'x' then - if not opcode_absolute_x[op] then return false, expr end tok:Get(tokenList) local paren_close_whites = {} for _,v in ipairs(tokenList[#tokenList-1].LeadingWhite) do table.insert(paren_close_whites, v) end for _,v in ipairs(tokenList[#tokenList].LeadingWhite) do table.insert(paren_close_whites, v) end suffix = suffix=='b' and "zpx" or suffix=='w' and "abx" or "zax" + if suffix == 'zax' then + if not opcode_zeropage_x[op] then suffix='abx' + elseif not opcode_absolute_x[op] then suffix='zpx' end + end + if suffix == 'zpx' and not opcode_zeropage_x[op] then return false, GenerateError("opcode " .. op " doesn't support zeropage,x addressing mode") end + if suffix == 'abx' and not opcode_absolute_x[op] then return false, GenerateError("opcode " .. op " doesn't support absolute,x addressing mode") end stat = emit_call{name=op .. suffix, args={expr}, paren_open_white=paren_open_whites, paren_close_white=paren_close_whites} break end if tok:Peek().Data == 'y' then @@ -1387,23 +1418,39 @@ local function ParseLua(src) for _,v in ipairs(tokenList[#tokenList-1].LeadingWhite) do table.insert(paren_close_whites, v) end for _,v in ipairs(tokenList[#tokenList].LeadingWhite) do table.insert(paren_close_whites, v) end suffix = suffix=='b' and "zpy" or suffix=='w' and "aby" or "zay" + if suffix == 'zay' then + if not opcode_zeropage_y[op] then suffix='aby' + elseif not opcode_absolute_y[op] then suffix='zpy' end + end + if suffix == 'zpy' and not opcode_zeropage_y[op] then return false, GenerateError("opcode " .. op " doesn't support zeropage,y addressing mode") end + if suffix == 'aby' and not opcode_absolute_y[op] then return false, GenerateError("opcode " .. op " doesn't support absolute,y addressing mode") end stat = emit_call{name=op .. suffix, args={expr}, paren_open_white=paren_open_whites, paren_close_white=paren_close_whites} break end commaTokenList[1] = tokenList[#tokenList] local mod_st, mod_expr = ParseExpr(scope) if not mod_st then return false, mod_expr end if not tok:ConsumeSymbol(',', tokenList) then - if not opcode_absolute[op] then return false, expr end suffix = suffix=='b' and "zpg" or suffix=='w' and "abs" or "zab" + if suffix == 'zab' then + if not opcode_zeropage[op] then suffix='abs' + elseif not opcode_absolute[op] then suffix='zpg' end + end + if suffix == 'zpg' and not opcode_zeropage[op] then return false, GenerateError("opcode " .. op " doesn't support zeropage addressing mode") end + if suffix == 'abs' and not opcode_absolute[op] then return false, GenerateError("opcode " .. op " doesn't support absolute addressing mode") end stat = emit_call{name=op .. suffix, args={expr, mod_expr}} break end if tok:Peek().Data == 'x' then - if not opcode_absolute_x[op] then return false, expr end tok:Get(tokenList) local paren_close_whites = {} for _,v in ipairs(tokenList[#tokenList-1].LeadingWhite) do table.insert(paren_close_whites, v) end for _,v in ipairs(tokenList[#tokenList].LeadingWhite) do table.insert(paren_close_whites, v) end suffix = suffix=='b' and "zpx" or suffix=='w' and "abx" or "zax" + if suffix == 'zax' then + if not opcode_zeropage_x[op] then suffix='abx' + elseif not opcode_absolute_x[op] then suffix='zpx' end + end + if suffix == 'zpx' and not opcode_zeropage_x[op] then return false, GenerateError("opcode " .. op " doesn't support zeropage,x addressing mode") end + if suffix == 'abx' and not opcode_absolute_x[op] then return false, GenerateError("opcode " .. op " doesn't support absolute,x addressing mode") end stat = emit_call{name=op .. suffix, args={expr, mod_expr}, paren_open_white=paren_open_whites, paren_close_white=paren_close_whites} break end if tok:Peek().Data == 'y' then @@ -1413,6 +1460,12 @@ local function ParseLua(src) for _,v in ipairs(tokenList[#tokenList-1].LeadingWhite) do table.insert(paren_close_whites, v) end for _,v in ipairs(tokenList[#tokenList].LeadingWhite) do table.insert(paren_close_whites, v) end suffix = suffix=='b' and "zpy" or suffix=='w' and "aby" or "zay" + if suffix == 'zay' then + if not opcode_zeropage_y[op] then suffix='aby' + elseif not opcode_absolute_y[op] then suffix='zpy' end + end + if suffix == 'zpy' and not opcode_zeropage_y[op] then return false, GenerateError("opcode " .. op " doesn't support zeropage,y addressing mode") end + if suffix == 'aby' and not opcode_absolute_y[op] then return false, GenerateError("opcode " .. op " doesn't support absolute,y addressing mode") end stat = emit_call{name=op .. suffix, args={expr, mod_expr}, paren_open_white=paren_open_whites, paren_close_white=paren_close_whites} break end @@ -1420,6 +1473,7 @@ local function ParseLua(src) end end if opcode_implied[op] then stat = emit_call{name=op .. "imp"} break end + error("internal error: unable to find addressing of valid opcode " .. op) -- should not happen end end end