Commit 24f093b1dbf42cac4a1807ed3b8b16f6aa4eb4ef - SixtyPical

Make all serialize() methods take addr() as an arg, not kwarg. Chris Pressey 6 years ago

3 changed file(s) with 36 addition(s) and 36 deletion(s). Raw diff Collapse all Expand all

-1

bin/sixtypical less more

110	110	# If we are outputting a .PRG, we output the load address first.
111	111	# We don't use the Emitter for this b/c not part of addr space.
112	112	if options.output_format in ('prg', 'c64-basic-prg', 'vic20-basic-prg'):
113		fh.write(bytearray(Word(start_addr).serialize()))
	113	fh.write(bytearray(Word(start_addr).serialize(0)))
114	114
115	115	emitter = Emitter(start_addr)
116	116	for byte in prelude:

+22

-20

src/sixtypical/emitter.py less more

7	7	raise NotImplementedError
8	8
9	9	def serialize(self, addr):
10		"""Should return an array of unsigned bytes (integers from 0 to 255.)"""
	10	"""Should return an array of unsigned bytes (integers from 0 to 255.)
	11	`addr` is the address the value is being serialized at; for most objects
	12	it makes no difference, but some objects (like relative branches) do care."""
11	13	raise NotImplementedError
12	14
13	15

24	26	def size(self):
25	27	return 1
26	28
27		def serialize(self, addr=None):
	29	def serialize(self, addr):
28	30	return [self.value]
29	31
30	32	def __repr__(self):

39	41	def size(self):
40	42	return 2
41	43
42		def serialize(self, addr=None):
	44	def serialize(self, addr):
43	45	word = self.value
44	46	low = word & 255
45	47	high = (word >> 8) & 255

59	61	def size(self):
60	62	return self._size
61	63
62		def serialize(self, addr=None):
	64	def serialize(self, addr):
63	65	buf = []
64	66	for emittable in self.value:
65		buf.extend(emittable.serialize())
	67	buf.extend(emittable.serialize(addr)) # FIXME: addr + offset
66	68	while len(buf) < self.size():
67	69	buf.append(0)
68	70	return buf

86	88	def size(self):
87	89	return 2
88	90
89		def serialize(self, addr=None, offset=0):
	91	def serialize(self, addr, offset=0):
90	92	assert self.addr is not None, "unresolved label: %s" % self.name
91		return Word(self.addr + offset).serialize()
	93	return Word(self.addr + offset).serialize(addr)
92	94
93	95	def serialize_relative_to(self, addr):
94	96	assert self.addr is not None, "unresolved label: %s" % self.name
95		return Byte(self.addr - (addr + 2)).serialize()
96
97		def serialize_as_zero_page(self, offset=0):
	97	return Byte(self.addr - (addr + 2)).serialize(addr)
	98
	99	def serialize_as_zero_page(self, addr, offset=0):
98	100	assert self.addr is not None, "unresolved label: %s" % self.name
99		return Byte(self.addr + offset).serialize()
	101	return Byte(self.addr + offset).serialize(addr)
100	102
101	103	def __repr__(self):
102	104	addr_s = ', addr=%r' % self.addr if self.addr is not None else ''

113	115	def size(self):
114	116	self.label.size()
115	117
116		def serialize(self, addr=None):
117		return self.label.serialize(offset=self.offset)
118
119		def serialize_as_zero_page(self, offset=0):
120		return self.label.serialize_as_zero_page(offset=self.offset)
	118	def serialize(self, addr):
	119	return self.label.serialize(addr, offset=self.offset)
	120
	121	def serialize_as_zero_page(self, addr, offset=0):
	122	return self.label.serialize_as_zero_page(addr, offset=self.offset)
121	123
122	124	def __repr__(self):
123	125	return "%s(%r, %r)" % (self.__class__.__name__, self.label, self.offset)

131	133	def size(self):
132	134	return 1
133	135
134		def serialize(self, addr=None):
135		return [self.label.serialize()[0]]
	136	def serialize(self, addr):
	137	return [self.label.serialize(addr)[0]]
136	138
137	139	def __repr__(self):
138	140	return "%s(%r)" % (self.__class__.__name__, self.label)

146	148	def size(self):
147	149	return 1
148	150
149		def serialize(self, addr=None):
150		return [self.label.serialize()[1]]
	151	def serialize(self, addr):
	152	return [self.label.serialize(addr)[1]]
151	153
152	154	def __repr__(self):
153	155	return "%s(%r)" % (self.__class__.__name__, self.label)

+13

-15

src/sixtypical/gen6502.py less more

7	7	"""Size of the operand for the mode (not including the opcode)"""
8	8	raise NotImplementedError
9	9
10		def serialize(self, addr=None):
	10	def serialize(self, addr):
11	11	raise NotImplementedError
12	12
13	13	def __repr__(self):

18	18	def size(self):
19	19	return 0
20	20
21		def serialize(self, addr=None):
	21	def serialize(self, addr):
22	22	return []
23	23
24	24	def __repr__(self):

33	33	def size(self):
34	34	return 1
35	35
36		def serialize(self, addr=None):
37		return self.value.serialize()
	36	def serialize(self, addr):
	37	return self.value.serialize(addr)
38	38
39	39
40	40	class Absolute(AddressingMode):

45	45	def size(self):
46	46	return 2
47	47
48		def serialize(self, addr=None):
49		return self.value.serialize()
	48	def serialize(self, addr):
	49	return self.value.serialize(addr)
50	50
51	51
52	52	class AbsoluteX(Absolute):

65	65	def size(self):
66	66	return 1
67	67
68		def serialize(self, addr=None):
69		return self.value.serialize_as_zero_page()
	68	def serialize(self, addr):
	69	return self.value.serialize_as_zero_page(addr)
70	70
71	71
72	72	class Indirect(AddressingMode):

77	77	def size(self):
78	78	return 2
79	79
80		def serialize(self, addr=None):
81		return self.value.serialize()
	80	def serialize(self, addr):
	81	return self.value.serialize(addr)
82	82
83	83
84	84	class IndirectY(ZeroPage):

93	93	def size(self):
94	94	return 1
95	95
96		def serialize(self, addr=None):
	96	def serialize(self, addr):
97	97	return self.value.serialize_relative_to(addr)
98	98
99	99

107	107	def size(self):
108	108	return 1 + self.operand.size() if self.operand else 0
109	109
110		def serialize(self, addr=None):
111		serialized_operand = self.operand.serialize(addr)
112		assert isinstance(serialized_operand, list), self.operand.__class__
113		return [self.opcodes[self.operand.__class__]] + serialized_operand
	110	def serialize(self, addr):
	111	return [self.opcodes[self.operand.__class__]] + self.operand.serialize(addr)
114	112
115	113	def __repr__(self):
116	114	return "%s(%r)" % (self.__class__.__name__, self.operand)