# old deprecated code, in the process of moving this to the new emit/... modules


class CodeGenerator:
    def _generate_goto_conditional_truthvalue(self, stmt: CallStmt) -> None:
        # the condition is just the 'truth value' of the single value,
        # this is translated into assembly by comparing the argument to zero.
        def branch_emitter_mmap(targetstr: str, is_goto: bool, target_indirect: bool) -> None:
            assert is_goto and not stmt.condition.comparison_op
            assert stmt.condition.lvalue and not stmt.condition.rvalue
            assert not target_indirect
            assert stmt.condition.ifstatus in ("true", "not", "zero")
            branch, inverse_branch = ("bne", "beq") if stmt.condition.ifstatus == "true" else ("beq", "bne")
            cv = stmt.condition.lvalue
            assert isinstance(cv, MemMappedValue)
            cv_str = cv.name or Parser.to_hex(cv.address)
            if cv.datatype == DataType.BYTE:
                self.p("\t\tsta  " + Parser.to_hex(Zeropage.SCRATCH_B1))  # need to save A, because the goto may not be taken
                self.p("\t\tlda  " + cv_str)
                self.p("\t\t{:s}  {:s}".format(branch, targetstr))
                self.p("\t\tlda  " + Parser.to_hex(Zeropage.SCRATCH_B1))  # restore A
            elif cv.datatype == DataType.WORD:
                self.p("\t\tsta  " + Parser.to_hex(Zeropage.SCRATCH_B1))  # need to save A, because the goto may not be taken
                self.p("\t\tlda  " + cv_str)
                if stmt.condition.ifstatus == "true":
                    self.p("\t\t{:s}  {:s}".format(branch, targetstr))
                    self.p("\t\tlda  {:s}+1".format(cv_str))
                    self.p("\t\t{:s}  {:s}".format(branch, targetstr))
                    self.p("\t\tlda  " + Parser.to_hex(Zeropage.SCRATCH_B1))  # restore A
                else:
                    self.p("\t\t{:s}  +".format(inverse_branch, targetstr))
                    self.p("\t\tlda  {:s}+1".format(cv_str))
                    self.p("\t\t{:s}  {:s}".format(branch, targetstr))
                    self.p("+\t\tlda  " + Parser.to_hex(Zeropage.SCRATCH_B1))  # restore A
            else:
                raise CodeError("conditions cannot yet use other types than byte or word",  # @todo comparisons of other types
                                cv.datatype, str(cv), stmt.sourceref)

        def branch_emitter_reg(targetstr: str, is_goto: bool, target_indirect: bool) -> None:
            assert is_goto and not stmt.condition.comparison_op
            assert stmt.condition.lvalue and not stmt.condition.rvalue
            assert not target_indirect
            assert stmt.condition.ifstatus in ("true", "not", "zero")
            branch, inverse_branch = ("bne", "beq") if stmt.condition.ifstatus == "true" else ("beq", "bne")
            line_after_branch = ""
            cv = stmt.condition.lvalue
            assert isinstance(cv, RegisterValue)
            if cv.register == 'A':
                self.p("\t\tcmp  #0")
            elif cv.register == 'X':
                self.p("\t\tcpx  #0")
            elif cv.register == 'Y':
                self.p("\t\tcpy  #0")
            else:
                if cv.register == 'AX':
                    line_after_branch = "+"
                    self.p("\t\tcmp  #0")
                    self.p("\t\t{:s}  {:s}".format(inverse_branch, line_after_branch))
                    self.p("\t\tcpx  #0")
                elif cv.register == 'AY':
                    line_after_branch = "+"
                    self.p("\t\tcmp  #0")
                    self.p("\t\t{:s}  {:s}".format(inverse_branch, line_after_branch))
                    self.p("\t\tcpy  #0")
                elif cv.register == 'XY':
                    line_after_branch = "+"
                    self.p("\t\tcpx  #0")
                    self.p("\t\t{:s}  {:s}".format(inverse_branch, line_after_branch))
                    self.p("\t\tcpy  #0")
                else:
                    raise CodeError("invalid register", cv.register)
            self.p("\t\t{:s}  {:s}".format(branch, targetstr))
            if line_after_branch:
                self.p(line_after_branch)

        def branch_emitter_indirect_cond(targetstr: str, is_goto: bool, target_indirect: bool) -> None:
            assert is_goto and not stmt.condition.comparison_op
            assert stmt.condition.lvalue and not stmt.condition.rvalue
            assert stmt.condition.ifstatus in ("true", "not", "zero")
            assert not target_indirect
            cv = stmt.condition.lvalue.value   # type: ignore
            if isinstance(cv, RegisterValue):
                branch = "bne" if stmt.condition.ifstatus == "true" else "beq"
                self.p("\t\tsta  " + Parser.to_hex(Zeropage.SCRATCH_B1))  # need to save A, because the goto may not be taken
                if cv.register == 'Y':
                    self.p("\t\tlda  ($00),y")
                elif cv.register == 'X':
                    self.p("\t\tstx  *+2\t; self-modify")
                    self.p("\t\tlda  $ff")
                elif cv.register == 'A':
                    self.p("\t\tsta  *+2\t; self-modify")
                    self.p("\t\tlda  $ff")
                else:
                    self.p("\t\tst{:s}  (+)+1\t; self-modify".format(cv.register[0].lower()))
                    self.p("\t\tst{:s}  (+)+2\t; self-modify".format(cv.register[1].lower()))
                    self.p("+\t\tlda  $ffff")
                self.p("\t\t{:s}  {:s}".format(branch, targetstr))
                self.p("\t\tlda  " + Parser.to_hex(Zeropage.SCRATCH_B1))  # restore A
            elif isinstance(cv, MemMappedValue):
                raise CodeError("memmapped indirect should not occur, use the variable without indirection")
            elif isinstance(cv, IntegerValue) and cv.constant:
                branch, inverse_branch = ("bne", "beq") if stmt.condition.ifstatus == "true" else ("beq", "bne")
                cv_str = cv.name or Parser.to_hex(cv.value)
                if cv.datatype == DataType.BYTE:
                    self.p("\t\tsta  " + Parser.to_hex(Zeropage.SCRATCH_B1))  # need to save A, because the goto may not be taken
                    self.p("\t\tlda  " + cv_str)
                    self.p("\t\t{:s}  {:s}".format(branch, targetstr))
                    self.p("\t\tlda  " + Parser.to_hex(Zeropage.SCRATCH_B1))  # restore A
                elif cv.datatype == DataType.WORD:
                    self.p("\t\tsta  " + Parser.to_hex(Zeropage.SCRATCH_B1))  # need to save A, because the goto may not be taken
                    self.p("\t\tlda  " + cv_str)
                    if stmt.condition.ifstatus == "true":
                        self.p("\t\t{:s}  {:s}".format(branch, targetstr))
                        self.p("\t\tlda  {:s}+1".format(cv_str))
                        self.p("\t\t{:s}  {:s}".format(branch, targetstr))
                        self.p("\t\tlda  " + Parser.to_hex(Zeropage.SCRATCH_B1))  # restore A
                    else:
                        self.p("\t\t{:s}  +".format(inverse_branch, targetstr))
                        self.p("\t\tlda  {:s}+1".format(cv_str))
                        self.p("\t\t{:s}  {:s}".format(branch, targetstr))
                        self.p("+\t\tlda  " + Parser.to_hex(Zeropage.SCRATCH_B1))  # restore A
                else:
                    raise CodeError("conditions cannot yet use other types than byte or word",  # @todo comparisons of other types
                                    cv.datatype, str(cv), stmt.sourceref)
            else:
                raise CodeError("weird indirect type", str(cv))

        cv = stmt.condition.lvalue
        if isinstance(cv, RegisterValue):
            self._generate_call_or_goto(stmt, branch_emitter_reg)
        elif isinstance(cv, MemMappedValue):
            self._generate_call_or_goto(stmt, branch_emitter_mmap)
        elif isinstance(cv, IndirectValue):
            if isinstance(cv.value, RegisterValue):
                self._generate_call_or_goto(stmt, branch_emitter_indirect_cond)
            elif isinstance(cv.value, MemMappedValue):
                self._generate_call_or_goto(stmt, branch_emitter_indirect_cond)
            elif isinstance(cv.value, IntegerValue) and cv.value.constant:
                self._generate_call_or_goto(stmt, branch_emitter_indirect_cond)
            else:
                raise CodeError("weird indirect type", str(cv))
        else:
            raise CodeError("need register, memmapped or indirect value", str(cv))

    def _generate_goto_conditional_comparison(self, stmt: CallStmt) -> None:
        # the condition is lvalue operator rvalue
        raise NotImplementedError("no comparisons yet")  # XXX comparisons
        assert stmt.condition.ifstatus in ("true", "not", "zero")
        assert stmt.condition.lvalue != stmt.condition.rvalue  # so we know we actually have to compare different things
        lv, compare_operator, rv = stmt.condition.lvalue, stmt.condition.comparison_op, stmt.condition.rvalue
        if lv.constant and not rv.constant:
            # if lv is a constant, swap the whole thing around so the constant is on the right
            lv, compare_operator, rv = stmt.condition.swap()
        if isinstance(rv, RegisterValue):
            # if rv is a register, make sure it comes first instead
            lv, compare_operator, rv = stmt.condition.swap()
        if lv.datatype != DataType.BYTE or rv.datatype != DataType.BYTE:
            raise CodeError("can only generate comparison code for byte values for now")  # @todo compare non-bytes
        if isinstance(lv, RegisterValue):
            if isinstance(rv, RegisterValue):
                self.p("\t\tst{:s}  {:s}".format(rv.register.lower(), Parser.to_hex(Zeropage.SCRATCH_B1)))
                if lv.register == "A":
                    self.p("\t\tcmp  " + Parser.to_hex(Zeropage.SCRATCH_B1))
                elif lv.register == "X":
                    self.p("\t\tcpx  " + Parser.to_hex(Zeropage.SCRATCH_B1))
                elif lv.register == "Y":
                    self.p("\t\tcpy  " + Parser.to_hex(Zeropage.SCRATCH_B1))
                else:
                    raise CodeError("wrong lvalue register")
            elif isinstance(rv, IntegerValue):
                rvstr = rv.name or Parser.to_hex(rv.value)
                if lv.register == "A":
                    self.p("\t\tcmp  #" + rvstr)
                elif lv.register == "X":
                    self.p("\t\tcpx  #" + rvstr)
                elif lv.register == "Y":
                    self.p("\t\tcpy  #" + rvstr)
                else:
                    raise CodeError("wrong lvalue register")
            elif isinstance(rv, MemMappedValue):
                rvstr = rv.name or Parser.to_hex(rv.address)
                if lv.register == "A":
                    self.p("\t\tcmp  " + rvstr)
                elif lv.register == "X":
                    self.p("\t\tcpx  #" + rvstr)
                elif lv.register == "Y":
                    self.p("\t\tcpy  #" + rvstr)
                else:
                    raise CodeError("wrong lvalue register")
            else:
                raise CodeError("invalid rvalue type in comparison", rv)
        elif isinstance(lv, MemMappedValue):
            assert not isinstance(rv, RegisterValue), "registers as rvalue should have been swapped with lvalue"
            if isinstance(rv, IntegerValue):
                self.p("\t\tsta  " + Parser.to_hex(Zeropage.SCRATCH_B1))  # need to save A, because the goto may not be taken
                self.p("\t\tlda  " + (lv.name or Parser.to_hex(lv.address)))
                self.p("\t\tcmp  #" + (rv.name or Parser.to_hex(rv.value)))
                line_after_goto = "\t\tlda  " + Parser.to_hex(Zeropage.SCRATCH_B1)  # restore A
            elif isinstance(rv, MemMappedValue):
                rvstr = rv.name or Parser.to_hex(rv.address)
                self.p("\t\tsta  " + Parser.to_hex(Zeropage.SCRATCH_B1))  # need to save A, because the goto may not be taken
                self.p("\t\tlda  " + (lv.name or Parser.to_hex(lv.address)))
                self.p("\t\tcmp  " + rvstr)
                line_after_goto = "\t\tlda  " + Parser.to_hex(Zeropage.SCRATCH_B1)  # restore A
            else:
                raise CodeError("invalid rvalue type in comparison", rv)
        else:
            raise CodeError("invalid lvalue type in comparison", lv)

    def _generate_call_or_goto(self, stmt: CallStmt, branch_emitter: Callable[[str, bool, bool], None]) -> None:
        def generate_param_assignments() -> None:
            for assign_stmt in stmt.desugared_call_arguments:
                self.generate_assignment(assign_stmt)

        def generate_result_assignments() -> None:
            for assign_stmt in stmt.desugared_output_assignments:
                self.generate_assignment(assign_stmt)

        def params_load_a() -> bool:
            for assign_stmt in stmt.desugared_call_arguments:
                for lv in assign_stmt.leftvalues:
                    if isinstance(lv, RegisterValue):
                        if lv.register == 'A':
                            return True
            return False

        def unclobber_result_registers(registers: Set[str], output_assignments: List[AssignmentStmt]) -> Set[str]:
            result = registers.copy()
            for a in output_assignments:
                for lv in a.leftvalues:
                    if isinstance(lv, RegisterValue):
                        if len(lv.register) == 1:
                            result.discard(lv.register)
                        else:
                            for r in lv.register:
                                result.discard(r)
            return result

        if stmt.target.name:
            symblock, targetdef = self.cur_block.lookup(stmt.target.name)
        else:
            symblock = None
            targetdef = None
        if isinstance(targetdef, SubroutineDef):
            if isinstance(stmt.target, MemMappedValue):
                targetstr = stmt.target.name or Parser.to_hex(stmt.address)
            else:
                raise CodeError("call sub target must be mmapped")
            if stmt.is_goto:
                generate_param_assignments()
                branch_emitter(targetstr, True, False)
                # no result assignments because it's a goto
                return
            clobbered = set()  # type: Set[str]
            if targetdef.clobbered_registers:
                if stmt.preserve_regs is not None:
                    clobbered = targetdef.clobbered_registers & stmt.preserve_regs
                    clobbered = unclobber_result_registers(clobbered, stmt.desugared_output_assignments)
            with self.preserving_registers(clobbered, loads_a_within=params_load_a(), always_preserve=stmt.preserve_regs is not None):
                generate_param_assignments()
                branch_emitter(targetstr, False, False)
                generate_result_assignments()
            return
        if isinstance(stmt.target, IndirectValue):
            if stmt.target.name:
                targetstr = stmt.target.name
            elif stmt.address is not None:
                targetstr = Parser.to_hex(stmt.address)
            elif stmt.target.value.name:
                targetstr = stmt.target.value.name
            elif isinstance(stmt.target.value, RegisterValue):
                targetstr = stmt.target.value.register
            elif isinstance(stmt.target.value, IntegerValue):
                targetstr = stmt.target.value.name or Parser.to_hex(stmt.target.value.value)
            else:
                raise CodeError("missing name", stmt.target.value)
            if stmt.is_goto:
                # no need to preserve registers for a goto
                generate_param_assignments()
                if targetstr in REGISTER_WORDS:
                    self.p("\t\tst{:s}  {:s}".format(targetstr[0].lower(), Parser.to_hex(Zeropage.SCRATCH_B1)))
                    self.p("\t\tst{:s}  {:s}".format(targetstr[1].lower(), Parser.to_hex(Zeropage.SCRATCH_B2)))
                    branch_emitter(Parser.to_hex(Zeropage.SCRATCH_B1), True, True)
                else:
                    branch_emitter(targetstr, True, True)
                # no result assignments because it's a goto
            else:
                # indirect call to subroutine
                preserve_regs = unclobber_result_registers(stmt.preserve_regs or set(), stmt.desugared_output_assignments)
                with self.preserving_registers(preserve_regs, loads_a_within=params_load_a(),
                                               always_preserve=stmt.preserve_regs is not None):
                    generate_param_assignments()
                    if targetstr in REGISTER_WORDS:
                        print("warning: {}: indirect register pair call is quite inefficient, use a jump table in memory instead?"
                              .format(stmt.sourceref))
                        if stmt.preserve_regs is not None:
                            # cannot use zp scratch because it may be used by the register backup. This is very inefficient code!
                            self.p("\t\tjsr  il65_lib.jsr_indirect_nozpuse_"+targetstr)

                        else:
                            self.p("\t\tjsr  il65_lib.jsr_indirect_"+targetstr)
                    else:
                        self.p("\t\tjsr  +")
                        self.p("\t\tjmp  ++")
                        self.p("+\t\tjmp  ({:s})".format(targetstr))
                        self.p("+")
                    generate_result_assignments()
        else:
            # call to a label or immediate address
            if stmt.target.name:
                targetstr = stmt.target.name
            elif stmt.address is not None:
                targetstr = Parser.to_hex(stmt.address)
            elif isinstance(stmt.target, IntegerValue):
                targetstr = stmt.target.name or Parser.to_hex(stmt.target.value)
            else:
                raise CodeError("missing name", stmt.target)
            if stmt.is_goto:
                # no need to preserve registers for a goto
                generate_param_assignments()
                branch_emitter(targetstr, True, False)
                # no result assignments because it's a goto
            else:
                preserve_regs = unclobber_result_registers(stmt.preserve_regs or set(), stmt.desugared_output_assignments)
                with self.preserving_registers(preserve_regs, loads_a_within=params_load_a(),
                                               always_preserve=stmt.preserve_regs is not None):
                    generate_param_assignments()
                    branch_emitter(targetstr, False, False)
                    generate_result_assignments()

    def generate_assignment(self, stmt: AssignmentStmt) -> None:
        def unwrap_indirect(iv: IndirectValue) -> MemMappedValue:
            if isinstance(iv.value, MemMappedValue):
                return iv.value
            elif iv.value.constant and isinstance(iv.value, IntegerValue):
                return MemMappedValue(iv.value.value, iv.datatype, 1, stmt.sourceref, iv.name)
            else:
                raise CodeError("cannot yet generate code for assignment: non-constant and non-memmapped indirect")  # XXX

        rvalue = stmt.right
        if isinstance(rvalue, IndirectValue):
            rvalue = unwrap_indirect(rvalue)
        self.p("\t\t\t\t\t; " + stmt.lineref)
        if isinstance(rvalue, IntegerValue):
            for lv in stmt.leftvalues:
                if isinstance(lv, RegisterValue):
                    self.generate_assign_integer_to_reg(lv.register, rvalue)
                elif isinstance(lv, MemMappedValue):
                    self.generate_assign_integer_to_mem(lv, rvalue)
                elif isinstance(lv, IndirectValue):
                    lv = unwrap_indirect(lv)
                    self.generate_assign_integer_to_mem(lv, rvalue)
                else:
                    raise CodeError("invalid assignment target (1)", str(stmt))
        elif isinstance(rvalue, RegisterValue):
            for lv in stmt.leftvalues:
                if isinstance(lv, RegisterValue):
                    self.generate_assign_reg_to_reg(lv, rvalue.register)
                elif isinstance(lv, MemMappedValue):
                    self.generate_assign_reg_to_memory(lv, rvalue.register)
                elif isinstance(lv, IndirectValue):
                    lv = unwrap_indirect(lv)
                    self.generate_assign_reg_to_memory(lv, rvalue.register)
                else:
                    raise CodeError("invalid assignment target (2)", str(stmt))
        elif isinstance(rvalue, StringValue):
            r_str = self.output_string(rvalue.value, True)
            for lv in stmt.leftvalues:
                if isinstance(lv, RegisterValue):
                    if len(rvalue.value) == 1:
                        self.generate_assign_char_to_reg(lv, r_str)
                    else:
                        self.generate_assign_string_to_reg(lv, rvalue)
                elif isinstance(lv, MemMappedValue):
                    if len(rvalue.value) == 1:
                        self.generate_assign_char_to_memory(lv, r_str)
                    else:
                        self.generate_assign_string_to_memory(lv, rvalue)
                elif isinstance(lv, IndirectValue):
                    lv = unwrap_indirect(lv)
                    if len(rvalue.value) == 1:
                        self.generate_assign_char_to_memory(lv, r_str)
                    else:
                        self.generate_assign_string_to_memory(lv, rvalue)
                else:
                    raise CodeError("invalid assignment target (2)", str(stmt))
        elif isinstance(rvalue, MemMappedValue):
            for lv in stmt.leftvalues:
                if isinstance(lv, RegisterValue):
                    self.generate_assign_mem_to_reg(lv.register, rvalue)
                elif isinstance(lv, MemMappedValue):
                    self.generate_assign_mem_to_mem(lv, rvalue)
                elif isinstance(lv, IndirectValue):
                    lv = unwrap_indirect(lv)
                    self.generate_assign_mem_to_mem(lv, rvalue)
                else:
                    raise CodeError("invalid assignment target (4)", str(stmt))
        elif isinstance(rvalue, FloatValue):
            for lv in stmt.leftvalues:
                if isinstance(lv, MemMappedValue) and lv.datatype == DataType.FLOAT:
                    self.generate_assign_float_to_mem(lv, rvalue)
                elif isinstance(lv, IndirectValue):
                    lv = unwrap_indirect(lv)
                    assert lv.datatype == DataType.FLOAT
                    self.generate_assign_float_to_mem(lv, rvalue)
                else:
                    raise CodeError("cannot assign float to ", str(lv))
        else:
            raise CodeError("invalid assignment value type", str(stmt))

    def generate_assign_float_to_mem(self, mmv: MemMappedValue,
                                     rvalue: Union[FloatValue, IntegerValue]) -> None:
        floatvalue = float(rvalue.value)
        mflpt = self.to_mflpt5(floatvalue)
        target = mmv.name or Parser.to_hex(mmv.address)
        with self.preserving_registers({'A'}):
            self.p("\t\t\t\t\t; {:s} = {}".format(target, rvalue.name or floatvalue))
            a_reg_value = None
            for i, byte in enumerate(mflpt):
                if byte != a_reg_value:
                    self.p("\t\tlda  #${:02x}".format(byte))
                    a_reg_value = byte
                self.p("\t\tsta  {:s}+{:d}".format(target, i))

    def generate_assign_reg_to_memory(self, lv: MemMappedValue, r_register: str) -> None:
        # Memory = Register
        lv_string = lv.name or Parser.to_hex(lv.address)
        if lv.datatype == DataType.BYTE:
            if len(r_register) > 1:
                raise CodeError("cannot assign register pair to single byte memory")
            self.p("\t\tst{:s}  {}".format(r_register.lower(), lv_string))
        elif lv.datatype == DataType.WORD:
            if len(r_register) == 1:
                self.p("\t\tst{:s}  {}".format(r_register.lower(), lv_string))  # lsb
                with self.preserving_registers({'A'}, loads_a_within=True):
                    self.p("\t\tlda  #0")
                    self.p("\t\tsta  {:s}+1".format(lv_string))  # msb
            else:
                self.p("\t\tst{:s}  {}".format(r_register[0].lower(), lv_string))
                self.p("\t\tst{:s}  {}+1".format(r_register[1].lower(), lv_string))
        elif lv.datatype == DataType.FLOAT:
            # assigning a register to a float requires c64 ROM routines
            if r_register in REGISTER_WORDS:
                def do_rom_calls():
                    self.p("\t\tjsr  c64flt.GIVUAYF")  # uword AY -> fac1
                    self.p("\t\tldx  #<" + lv_string)
                    self.p("\t\tldy  #>" + lv_string)
                    self.p("\t\tjsr  c64.FTOMEMXY")  # fac1 -> memory XY
                if r_register == "AY":
                    with self.preserving_registers({'A', 'X', 'Y'}):
                        do_rom_calls()
                elif r_register == "AX":
                    with self.preserving_registers({'A', 'X', 'Y'}):
                        self.p("\t\tpha\n\t\ttxa\n\t\ttay\n\t\tpla")    # X->Y (so we have AY now)
                        do_rom_calls()
                else:  # XY
                    with self.preserving_registers({'A', 'X', 'Y'}, loads_a_within=True):
                        self.p("\t\ttxa")    # X->A (so we have AY now)
                        do_rom_calls()
            elif r_register in "AXY":

                def do_rom_calls():
                    self.p("\t\tjsr  c64.FREADUY")  # ubyte Y -> fac1
                    self.p("\t\tldx  #<" + lv_string)
                    self.p("\t\tldy  #>" + lv_string)
                    self.p("\t\tjsr  c64.FTOMEMXY")  # fac1 -> memory XY

                if r_register == "A":
                    with self.preserving_registers({'A', 'X', 'Y'}):
                        self.p("\t\ttay")
                        do_rom_calls()
                elif r_register == "X":
                    with self.preserving_registers({'A', 'X', 'Y'}, loads_a_within=True):
                        self.p("\t\ttxa")
                        self.p("\t\ttay")
                        do_rom_calls()
                elif r_register == "Y":
                    with self.preserving_registers({'A', 'X', 'Y'}):
                        do_rom_calls()
            else:
                raise CodeError("invalid register to assign to float", r_register)
        else:
            raise CodeError("invalid lvalue type", lv.datatype)

    def generate_assign_reg_to_reg(self, lv: RegisterValue, r_register: str) -> None:
        if lv.register != r_register:
            if lv.register == 'A':  # x/y -> a
                self.p("\t\tt{:s}a".format(r_register.lower()))
            elif lv.register == 'Y':
                if r_register == 'A':
                    # a -> y
                    self.p("\t\ttay")
                else:
                    # x -> y, 6502 doesn't have txy
                    self.p("\t\tstx  ${0:02x}\n\t\tldy  ${0:02x}".format(Zeropage.SCRATCH_B1))
            elif lv.register == 'X':
                if r_register == 'A':
                    # a -> x
                    self.p("\t\ttax")
                else:
                    # y -> x, 6502 doesn't have tyx
                    self.p("\t\tsty  ${0:02x}\n\t\tldx  ${0:02x}".format(Zeropage.SCRATCH_B1))
            elif lv.register in REGISTER_WORDS:
                if len(r_register) == 1:
                    # assign one register to a pair, so the hi byte is zero.
                    if lv.register == "AX" and r_register == "A":
                        self.p("\t\tldx  #0")
                    elif lv.register == "AX" and r_register == "X":
                        self.p("\t\ttxa\n\t\tldx  #0")
                    elif lv.register == "AX" and r_register == "Y":
                        self.p("\t\ttya\n\t\tldx  #0")
                    elif lv.register == "AY" and r_register == "A":
                        self.p("\t\tldy  #0")
                    elif lv.register == "AY" and r_register == "X":
                        self.p("\t\ttxa\n\t\tldy  #0")
                    elif lv.register == "AY" and r_register == "Y":
                        self.p("\t\ttya\n\t\tldy  #0")
                    elif lv.register == "XY" and r_register == "A":
                        self.p("\t\ttax\n\t\tldy  #0")
                    elif lv.register == "XY" and r_register == "X":
                        self.p("\t\tldy  #0")
                    elif lv.register == "XY" and r_register == "Y":
                        self.p("\t\ttyx\n\t\tldy  #0")
                    else:
                        raise CodeError("invalid register combination", lv.register, r_register)
                elif lv.register == "AX" and r_register == "AY":
                    # y -> x, 6502 doesn't have tyx
                    self.p("\t\tsty  ${0:02x}\n\t\tldx  ${0:02x}".format(Zeropage.SCRATCH_B1))
                elif lv.register == "AX" and r_register == "XY":
                    # x -> a, y -> x, 6502 doesn't have tyx
                    self.p("\t\ttxa")
                    self.p("\t\tsty  ${0:02x}\n\t\tldx  ${0:02x}".format(Zeropage.SCRATCH_B1))
                elif lv.register == "AY" and r_register == "AX":
                    # x -> y, 6502 doesn't have txy
                    self.p("\t\tstx  ${0:02x}\n\t\tldy  ${0:02x}".format(Zeropage.SCRATCH_B1))
                elif lv.register == "AY" and r_register == "XY":
                    # x -> a
                    self.p("\t\ttxa")
                elif lv.register == "XY" and r_register == "AX":
                    # x -> y, a -> x, 6502 doesn't have txy
                    self.p("\t\tstx  ${0:02x}\n\t\tldy  ${0:02x}".format(Zeropage.SCRATCH_B1))
                    self.p("\t\ttax")
                elif lv.register == "XY" and r_register == "AY":
                    # a -> x
                    self.p("\t\ttax")
                else:
                    raise CodeError("invalid register combination", lv.register, r_register)
            else:
                raise CodeError("invalid register " + lv.register)

    def generate_assign_integer_to_mem(self, lv: MemMappedValue, rvalue: IntegerValue) -> None:
        if lv.name:
            symblock, sym = self.cur_block.lookup(lv.name)
            if not isinstance(sym, VariableDef):
                raise CodeError("invalid lvalue type " + str(sym))
            assign_target = symblock.label + '.' + sym.name if symblock is not self.cur_block else lv.name
            lvdatatype = sym.type
        else:
            assign_target = Parser.to_hex(lv.address)
            lvdatatype = lv.datatype
        r_str = rvalue.name if rvalue.name else "${:x}".format(rvalue.value)
        if lvdatatype == DataType.BYTE:
            if rvalue.value is not None and not lv.assignable_from(rvalue) or rvalue.datatype != DataType.BYTE:
                raise OverflowError("value doesn't fit in a byte")
            with self.preserving_registers({'A'}, loads_a_within=True):
                self.p("\t\tlda  #" + r_str)
                self.p("\t\tsta  " + assign_target)
        elif lvdatatype == DataType.WORD:
            if rvalue.value is not None and not lv.assignable_from(rvalue):
                raise OverflowError("value doesn't fit in a word")
            with self.preserving_registers({'A'}, loads_a_within=True):
                self.p("\t\tlda  #<" + r_str)
                self.p("\t\tsta  " + assign_target)
                self.p("\t\tlda  #>" + r_str)
                self.p("\t\tsta  {}+1".format(assign_target))
        elif lvdatatype == DataType.FLOAT:
            if rvalue.value is not None and not DataType.FLOAT.assignable_from_value(rvalue.value):
                raise CodeError("value cannot be assigned to a float")
            self.generate_assign_float_to_mem(lv, rvalue)
        else:
            raise CodeError("invalid lvalue type " + str(lvdatatype))

    def generate_assign_mem_to_reg(self, l_register: str, rvalue: MemMappedValue) -> None:
        r_str = rvalue.name if rvalue.name else "${:x}".format(rvalue.address)
        if len(l_register) == 1:
            if rvalue.datatype != DataType.BYTE:
                raise CodeError("can only assign a byte to a register")
            self.p("\t\tld{:s}  {:s}".format(l_register.lower(), r_str))
        else:
            if rvalue.datatype == DataType.BYTE:
                self.p("\t\tld{:s}  {:s}".format(l_register[0].lower(), r_str))
                self.p("\t\tld{:s}  #0".format(l_register[1].lower()))
            elif rvalue.datatype == DataType.WORD:
                self.p("\t\tld{:s}  {:s}".format(l_register[0].lower(), r_str))
                self.p("\t\tld{:s}  {:s}+1".format(l_register[1].lower(), r_str))
            else:
                raise CodeError("can only assign a byte or word to a register pair")

    def generate_assign_mem_to_mem(self, lv: MemMappedValue, rvalue: MemMappedValue) -> None:
        r_str = rvalue.name or Parser.to_hex(rvalue.address)
        l_str = lv.name or Parser.to_hex(lv.address)
        if lv.datatype == DataType.BYTE:
            if rvalue.datatype != DataType.BYTE:
                raise CodeError("can only assign a byte to a byte", str(rvalue))
            with self.preserving_registers({'A'}, loads_a_within=True):
                self.p("\t\tlda  " + r_str)
                self.p("\t\tsta  " + l_str)
        elif lv.datatype == DataType.WORD:
            if rvalue.datatype == DataType.BYTE:
                with self.preserving_registers({'A'}, loads_a_within=True):
                    self.p("\t\tlda  " + r_str)
                    self.p("\t\tsta  " + l_str)
                    self.p("\t\tlda  #0")
                    self.p("\t\tsta  {:s}+1".format(l_str))
            elif rvalue.datatype == DataType.WORD:
                with self.preserving_registers({'A'}, loads_a_within=True):
                    self.p("\t\tlda  {:s}".format(r_str))
                    self.p("\t\tsta  {:s}".format(l_str))
                    self.p("\t\tlda  {:s}+1".format(r_str))
                    self.p("\t\tsta  {:s}+1".format(l_str))
            else:
                raise CodeError("can only assign a byte or word to a word", str(rvalue))
        elif lv.datatype == DataType.FLOAT:
            if rvalue.datatype == DataType.FLOAT:
                with self.preserving_registers({'A', 'X', 'Y'}, loads_a_within=True):
                    self.p("\t\tlda  #<" + r_str)
                    self.p("\t\tsta  c64.SCRATCH_ZPWORD1")
                    self.p("\t\tlda  #>" + r_str)
                    self.p("\t\tsta  c64.SCRATCH_ZPWORD1+1")
                    self.p("\t\tldx  #<" + l_str)
                    self.p("\t\tldy  #>" + l_str)
                    self.p("\t\tjsr  c64flt.copy_mflt")
            elif rvalue.datatype == DataType.BYTE:
                with self.preserving_registers({'A', 'X', 'Y'}):
                    self.p("\t\tldy  " + r_str)
                    self.p("\t\tjsr  c64.FREADUY")  # ubyte Y -> fac1
                    self.p("\t\tldx  #<" + l_str)
                    self.p("\t\tldy  #>" + l_str)
                    self.p("\t\tjsr  c64.FTOMEMXY")  # fac1 -> memory XY
            elif rvalue.datatype == DataType.WORD:
                with self.preserving_registers({'A', 'X', 'Y'}, loads_a_within=True):
                    self.p("\t\tlda  " + r_str)
                    self.p("\t\tldy  {:s}+1".format(r_str))
                    self.p("\t\tjsr  c64flt.GIVUAYF")  # uword AY -> fac1
                    self.p("\t\tldx  #<" + l_str)
                    self.p("\t\tldy  #>" + l_str)
                    self.p("\t\tjsr  c64.FTOMEMXY")  # fac1 -> memory XY
            else:
                raise CodeError("unsupported rvalue to memfloat", str(rvalue))
        else:
            raise CodeError("invalid lvalue memmapped datatype", str(lv))

    def generate_assign_char_to_memory(self, lv: MemMappedValue, char_str: str) -> None:
        # Memory = Character
        with self.preserving_registers({'A'}, loads_a_within=True):
            self.p("\t\tlda  #" + char_str)
            if not lv.name:
                self.p("\t\tsta  " + Parser.to_hex(lv.address))
                return
            # assign char value to a memory location by symbol name
            symblock, sym = self.cur_block.lookup(lv.name)
            if isinstance(sym, VariableDef):
                assign_target = lv.name
                if symblock is not self.cur_block:
                    assign_target = symblock.label + '.' + sym.name
                if sym.type == DataType.BYTE:
                    self.p("\t\tsta  " + assign_target)
                elif sym.type == DataType.WORD:
                    self.p("\t\tsta  " + assign_target)
                    self.p("\t\tlda  #0")
                    self.p("\t\tsta  {}+1".format(assign_target))
                else:
                    raise CodeError("invalid lvalue type " + str(sym))
            else:
                raise CodeError("invalid lvalue type " + str(sym))

    def generate_assign_integer_to_reg(self, l_register: str, rvalue: IntegerValue) -> None:
        r_str = rvalue.name if rvalue.name else "${:x}".format(rvalue.value)
        if l_register in ('A', 'X', 'Y'):
            self.p("\t\tld{:s}  #{:s}".format(l_register.lower(), r_str))
        elif l_register in REGISTER_WORDS:
            self.p("\t\tld{:s}  #<{:s}".format(l_register[0].lower(), r_str))
            self.p("\t\tld{:s}  #>{:s}".format(l_register[1].lower(), r_str))
        elif l_register == "SC":
            # set/clear S carry bit
            if rvalue.value:
                self.p("\t\tsec")
            else:
                self.p("\t\tclc")
        elif l_register == "SI":
            # interrupt disable bit
            if rvalue.value:
                self.p("\t\tsei")
            else:
                self.p("\t\tcli")
        else:
            raise CodeError("invalid register in immediate integer assignment", l_register, rvalue.value)

    def generate_assign_char_to_reg(self, lv: RegisterValue, char_str: str) -> None:
        # Register = Char (string of length 1)
        if lv.register not in ('A', 'X', 'Y'):
            raise CodeError("invalid register for char assignment", lv.register)
        self.p("\t\tld{:s}  #{:s}".format(lv.register.lower(), char_str))

    def generate_assign_string_to_reg(self, lv: RegisterValue, rvalue: StringValue) -> None:
        if lv.register not in ("AX", "AY", "XY"):
            raise CodeError("need register pair AX, AY or XY for string address assignment", lv.register)
        if rvalue.name:
            self.p("\t\tld{:s}  #<{:s}".format(lv.register[0].lower(), rvalue.name))
            self.p("\t\tld{:s}  #>{:s}".format(lv.register[1].lower(), rvalue.name))
        else:
            raise CodeError("cannot assign immediate string, it must be a string variable")

    def generate_assign_string_to_memory(self, lv: MemMappedValue, rvalue: StringValue) -> None:
        if lv.datatype != DataType.WORD:
            raise CodeError("need word memory type for string address assignment")
        if rvalue.name:
            assign_target = lv.name if lv.name else Parser.to_hex(lv.address)
            self.p("\t\tlda  #<{:s}".format(rvalue.name))
            self.p("\t\tsta  " + assign_target)
            self.p("\t\tlda  #>{:s}".format(rvalue.name))
            self.p("\t\tsta  {}+1".format(assign_target))
        else:
            raise CodeError("cannot assign immediate string, it must be a string variable")