gruesome 0.0.3 → 0.0.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (22) hide show
  1. data/README.md +1 -2
  2. data/lib/gruesome/cli.rb +62 -62
  3. data/lib/gruesome/logo.rb +8 -8
  4. data/lib/gruesome/machine.rb +11 -11
  5. data/lib/gruesome/version.rb +1 -1
  6. data/lib/gruesome/z/abbreviation_table.rb +17 -17
  7. data/lib/gruesome/z/decoder.rb +273 -273
  8. data/lib/gruesome/z/dictionary.rb +144 -144
  9. data/lib/gruesome/z/header.rb +40 -40
  10. data/lib/gruesome/z/instruction.rb +42 -42
  11. data/lib/gruesome/z/machine.rb +51 -50
  12. data/lib/gruesome/z/memory.rb +301 -232
  13. data/lib/gruesome/z/object_table.rb +424 -424
  14. data/lib/gruesome/z/opcode.rb +489 -491
  15. data/lib/gruesome/z/opcode_class.rb +9 -9
  16. data/lib/gruesome/z/operand_type.rb +10 -10
  17. data/lib/gruesome/z/processor.rb +378 -361
  18. data/lib/gruesome/z/zscii.rb +307 -307
  19. data/lib/gruesome.rb +3 -3
  20. data/spec/z/memory_spec.rb +72 -72
  21. data/spec/z/processor_spec.rb +1883 -1883
  22. metadata +3 -3
data/spec/z/processor_spec.rb CHANGED
@@ -10,1947 +10,1947 @@ require_relative '../../lib/gruesome/z/object_table'
10
10
  # already moves the PC to the next instruction
11
11
 
12
12
  describe Gruesome::Z::Processor do
13
- describe "#execute" do
14
- before(:each) do
15
- zork = File.open('test/zork1.z3', 'r')
16
- @zork_memory = Gruesome::Z::Memory.new(zork.read(zork.size))
17
- @processor = Gruesome::Z::Processor.new(@zork_memory)
18
- @zork_memory.program_counter = 12345
19
- end
20
-
21
- # Note: The decoder already gets the exact branch address
22
- # which is why we don't specify an offset here
23
- describe "Branch Instruction" do
24
- after(:each) do
25
- end
26
-
27
- # not necessarily a branch
28
- describe "call" do
29
- it "should branch to the routine with two local variables given as first operand and store result in destination variable" do
30
- # set up a routine at address $2000
31
- @zork_memory.force_writeb(0x2000, 2)
32
- @zork_memory.force_writew(0x2001, 0)
33
- @zork_memory.force_writew(0x2003, 0)
34
-
35
- # The packed address is 0x2000 / 2
36
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
37
- [Gruesome::Z::OperandType::LARGE],
38
- [0x1000], 128, nil, nil, 0)
39
- @processor.execute(i)
40
- @zork_memory.program_counter.should eql(0x2005)
41
- end
42
-
43
- it "should simply set the destination variable to false when routine address is 0" do
44
- @zork_memory.writev(128, 12345)
45
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
46
- [Gruesome::Z::OperandType::LARGE],
47
- [0], 128, nil, nil, 0)
48
- @processor.execute(i)
49
- @zork_memory.readv(128).should eql(0)
50
- @zork_memory.program_counter.should eql(12345)
51
- end
52
-
53
- it "should create a stack with only the return address when no arguments or local variables are used" do
54
- # set up a routine at address $2000 with no locals
55
- @zork_memory.force_writeb(0x2000, 0)
56
-
57
- # The packed address is 0x2000 / 2
58
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
59
- [Gruesome::Z::OperandType::LARGE],
60
- [0x1000], 128, nil, nil, 0)
61
- @processor.execute(i)
62
- @zork_memory.program_counter.should eql(0x2001)
63
- @zork_memory.readv(0).should eql(12345)
64
- end
65
-
66
- it "should create a stack with only the return address and all arguments copied to locals" do
67
- # set up a routine at address $2000 with two locals
68
- @zork_memory.force_writeb(0x2000, 2)
69
- @zork_memory.force_writew(0x2001, 345)
70
- @zork_memory.force_writew(0x2003, 456)
71
-
72
- # The packed address is 0x2000 / 2
73
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
74
- [Gruesome::Z::OperandType::LARGE],
75
- [0x1000], 128, nil, nil, 0)
76
-
77
- @processor.execute(i)
78
- @zork_memory.program_counter.should eql(0x2005)
79
- @zork_memory.readv(0).should eql(456)
80
- @zork_memory.readv(0).should eql(345)
81
- @zork_memory.readv(0).should eql(12345)
82
- end
83
- end
84
-
85
- # not necessarily a branch
86
- describe "call_1n" do
87
- it "should branch to the routine with two local variables given as first operand" do
88
- # set up a routine at address $2000
89
- @zork_memory.force_writeb(0x2000, 2)
90
- @zork_memory.force_writew(0x2001, 0)
91
- @zork_memory.force_writew(0x2003, 0)
92
-
93
- # The packed address is 0x2000 / 2
94
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL_1N,
95
- [Gruesome::Z::OperandType::LARGE],
96
- [0x1000], nil, nil, nil, 0)
97
- @processor.execute(i)
98
- @zork_memory.program_counter.should eql(0x2005)
99
- end
100
-
101
- it "should simply do nothing when routine address is 0" do
102
- @zork_memory.writev(128, 12345)
103
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL_1N,
104
- [Gruesome::Z::OperandType::LARGE],
105
- [0], nil, nil, nil, 0)
106
- @processor.execute(i)
107
- @zork_memory.program_counter.should eql(12345)
108
- end
109
-
110
- it "should create a stack with only the return address when no arguments or local variables are used" do
111
- # set up a routine at address $2000 with no locals
112
- @zork_memory.force_writeb(0x2000, 0)
113
-
114
- # The packed address is 0x2000 / 2
115
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL_1N,
116
- [Gruesome::Z::OperandType::LARGE],
117
- [0x1000], nil, nil, nil, 0)
118
- @processor.execute(i)
119
- @zork_memory.program_counter.should eql(0x2001)
120
- @zork_memory.readv(0).should eql(12345)
121
- end
122
- end
123
-
124
- describe "dec_chk" do
125
- it "should decrement the value in the variable given as the operand" do
126
- @zork_memory.writev(128, 12345)
127
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::DEC_CHK,
128
- [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
129
- [128, 12345], nil, nil, nil, 0)
130
- @processor.execute(i)
131
- @zork_memory.readv(128).should eql(12344)
132
- end
133
-
134
- it "should consider the value signed and decrement 0 to -1" do
135
- @zork_memory.writev(128, 0)
136
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::DEC_CHK,
137
- [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
138
- [128, 12345], nil, nil, nil, 0)
139
- @processor.execute(i)
140
- @zork_memory.readv(128).should eql(-1+65536)
141
- end
142
-
143
- it "should edit the value on the stack in place" do
144
- @zork_memory.writev(0, 11111)
145
- @zork_memory.writev(0, 12345)
146
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::DEC_CHK,
147
- [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
148
- [0, 12345], nil, nil, nil, 0)
149
- @processor.execute(i)
150
- @zork_memory.readv(0).should eql(12344)
151
- @zork_memory.readv(0).should eql(11111)
152
- end
153
-
154
- it "should branch if the value after decrementing is less than the value given by the operand" do
155
- @zork_memory.writev(128, 12345)
156
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::DEC_CHK,
157
- [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
158
- [128, 12345], nil, 2000, true, 0)
159
- @processor.execute(i)
160
- @zork_memory.program_counter = 2000
161
- end
162
-
163
- it "should not branch if the value after decrementing is not less than the value given by the operand" do
164
- @zork_memory.writev(128, 12345)
165
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::DEC_CHK,
166
- [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
167
- [128, 12345], nil, 2000, true, 0)
168
- @processor.execute(i)
169
- @zork_memory.program_counter = 12345
170
- end
171
-
172
- it "should not branch if the value after decrementing is less than the value given by the operand and condition is negated" do
173
- @zork_memory.writev(128, 12345)
174
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::DEC_CHK,
175
- [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
176
- [128, 12345], nil, 2000, false, 0)
177
- @processor.execute(i)
178
- @zork_memory.program_counter = 12345
179
- end
180
-
181
- it "should branch if the value after decrementing is not less than the value given by the operand and condition is negated" do
182
- @zork_memory.writev(128, 12347)
183
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::DEC_CHK,
184
- [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
185
- [128, 12346], nil, 2000, false, 0)
186
- @processor.execute(i)
187
- @zork_memory.program_counter = 2000
188
- end
189
-
190
- end
191
-
192
- describe "inc_chk" do
193
- it "should increment the value in the variable given as the operand" do
194
- @zork_memory.writev(128, 12345)
195
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::INC_CHK,
196
- [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
197
- [128, 12345], nil, nil, nil, 0)
198
- @processor.execute(i)
199
- @zork_memory.readv(128).should eql(12346)
200
- end
201
-
202
- it "should consider the value signed and increment -1 to 0" do
203
- @zork_memory.writev(128, -1+65536)
204
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::INC_CHK,
205
- [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
206
- [128, 12345], nil, nil, nil, 0)
207
- @processor.execute(i)
208
- @zork_memory.readv(128).should eql(0)
209
- end
210
-
211
- it "should edit the value on the stack in place" do
212
- @zork_memory.writev(0, 11111)
213
- @zork_memory.writev(0, 12345)
214
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::INC_CHK,
215
- [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
216
- [0, 12345], nil, nil, nil, 0)
217
- @processor.execute(i)
218
- @zork_memory.readv(0).should eql(12346)
219
- @zork_memory.readv(0).should eql(11111)
220
- end
221
-
222
- it "should branch if the value after incrementing is greater than the value given by the operand" do
223
- @zork_memory.writev(128, 12345)
224
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::INC_CHK,
225
- [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
226
- [128, 12345], nil, 2000, true, 0)
227
- @processor.execute(i)
228
- @zork_memory.program_counter = 2000
229
- end
230
-
231
- it "should not branch if the value after incrementing is not greater than the value given by the operand" do
232
- @zork_memory.writev(128, 12345)
233
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::INC_CHK,
234
- [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
235
- [128, 12346], nil, 2000, true, 0)
236
- @processor.execute(i)
237
- @zork_memory.program_counter = 12345
238
- end
239
-
240
- it "should not branch if the value after incrementing is greater than the value given by the operand and condition is negated" do
241
- @zork_memory.writev(128, 12345)
242
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::INC_CHK,
243
- [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
244
- [128, 12345], nil, 2000, false, 0)
245
- @processor.execute(i)
246
- @zork_memory.program_counter = 12345
247
- end
248
-
249
- it "should branch if the value after incrementing is not greater than the value given by the operand and condition is negated" do
250
- @zork_memory.writev(128, 12345)
251
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::INC_CHK,
252
- [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
253
- [128, 12346], nil, 2000, false, 0)
254
- @processor.execute(i)
255
- @zork_memory.program_counter = 2000
256
- end
257
- end
258
-
259
- # not necessarily a branch
260
- describe "ret" do
261
- it "should return to the routine that called it" do
262
- # set up a routine at address $2000
263
- @zork_memory.force_writeb(0x2000, 2)
264
- @zork_memory.force_writew(0x2001, 0)
265
- @zork_memory.force_writew(0x2003, 0)
266
-
267
- # The packed address is 0x2000 / 2
268
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
269
- [Gruesome::Z::OperandType::LARGE],
270
- [0x1000], 128, nil, nil, 0)
271
-
272
- @processor.execute(i)
273
-
274
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::RET,
275
- [Gruesome::Z::OperandType::LARGE],
276
- [123], nil, nil, nil, 0)
277
-
278
- @processor.execute(i)
279
-
280
- @zork_memory.program_counter.should eql(12345)
281
- end
282
-
283
- it "should set the variable indicated by the call with the return value as an immediate" do
284
- # set up a routine at address $2000
285
- @zork_memory.force_writeb(0x2000, 2)
286
- @zork_memory.force_writew(0x2001, 0)
287
- @zork_memory.force_writew(0x2003, 0)
288
-
289
- # The packed address is 0x2000 / 2
290
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
291
- [Gruesome::Z::OperandType::LARGE],
292
- [0x1000], 128, nil, nil, 0)
293
-
294
- @processor.execute(i)
295
-
296
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::RET,
297
- [Gruesome::Z::OperandType::LARGE],
298
- [123], nil, nil, nil, 0)
299
-
300
- @processor.execute(i)
301
-
302
- @zork_memory.readv(128).should eql(123)
303
- end
304
-
305
- it "should be able to push the result (given as an immediate) to the stack if the call requests variable 0" do
306
- # set up a routine at address $2000
307
- @zork_memory.force_writeb(0x2000, 2)
308
- @zork_memory.force_writew(0x2001, 0)
309
- @zork_memory.force_writew(0x2003, 0)
310
-
311
- # The packed address is 0x2000 / 2
312
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
313
- [Gruesome::Z::OperandType::LARGE],
314
- [0x1000], 0, nil, nil, 0)
315
-
316
- @processor.execute(i)
317
-
318
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::RET,
319
- [Gruesome::Z::OperandType::LARGE],
320
- [123], nil, nil, nil, 0)
321
-
322
- @processor.execute(i)
323
-
324
- @zork_memory.readv(0).should eql(123)
325
- end
326
- end
327
-
328
- # not necessarily a branch
329
- describe "ret_popped" do
330
- it "should return to the routine that called it" do
331
- # set up a routine at address $2000
332
- @zork_memory.force_writeb(0x2000, 2)
333
- @zork_memory.force_writew(0x2001, 0)
334
- @zork_memory.force_writew(0x2003, 0)
335
-
336
- # The packed address is 0x2000 / 2
337
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
338
- [Gruesome::Z::OperandType::LARGE],
339
- [0x1000], 128, nil, nil, 0)
340
-
341
- @processor.execute(i)
342
-
343
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::RET_POPPED,
344
- [Gruesome::Z::OperandType::LARGE],
345
- [123], nil, nil, nil, 0)
346
-
347
- @processor.execute(i)
348
-
349
- @zork_memory.program_counter.should eql(12345)
350
- end
351
-
352
- it "should be able to push top of callee stack to the stack of the caller" do
353
- # set up a routine at address $2000
354
- @zork_memory.force_writeb(0x2000, 2)
355
- @zork_memory.force_writew(0x2001, 0)
356
- @zork_memory.force_writew(0x2003, 0)
357
- @zork_memory.writev(0, 11111)
13
+ describe "#execute" do
14
+ before(:each) do
15
+ zork = File.open('test/zork1.z3', 'r')
16
+ @zork_memory = Gruesome::Z::Memory.new(zork.read(zork.size))
17
+ @processor = Gruesome::Z::Processor.new(@zork_memory)
18
+ @zork_memory.program_counter = 12345
19
+ end
20
+
21
+ # Note: The decoder already gets the exact branch address
22
+ # which is why we don't specify an offset here
23
+ describe "Branch Instruction" do
24
+ after(:each) do
25
+ end
26
+
27
+ # not necessarily a branch
28
+ describe "call" do
29
+ it "should branch to the routine with two local variables given as first operand and store result in destination variable" do
30
+ # set up a routine at address $2000
31
+ @zork_memory.force_writeb(0x2000, 2)
32
+ @zork_memory.force_writew(0x2001, 0)
33
+ @zork_memory.force_writew(0x2003, 0)
34
+
35
+ # The packed address is 0x2000 / 2
36
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
37
+ [Gruesome::Z::OperandType::LARGE],
38
+ [0x1000], 128, nil, nil, 0)
39
+ @processor.execute(i)
40
+ @zork_memory.program_counter.should eql(0x2005)
41
+ end
42
+
43
+ it "should simply set the destination variable to false when routine address is 0" do
44
+ @zork_memory.writev(128, 12345)
45
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
46
+ [Gruesome::Z::OperandType::LARGE],
47
+ [0], 128, nil, nil, 0)
48
+ @processor.execute(i)
49
+ @zork_memory.readv(128).should eql(0)
50
+ @zork_memory.program_counter.should eql(12345)
51
+ end
52
+
53
+ it "should create a stack with only the return address when no arguments or local variables are used" do
54
+ # set up a routine at address $2000 with no locals
55
+ @zork_memory.force_writeb(0x2000, 0)
56
+
57
+ # The packed address is 0x2000 / 2
58
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
59
+ [Gruesome::Z::OperandType::LARGE],
60
+ [0x1000], 128, nil, nil, 0)
61
+ @processor.execute(i)
62
+ @zork_memory.program_counter.should eql(0x2001)
63
+ @zork_memory.readv(0).should eql(12345)
64
+ end
65
+
66
+ it "should create a stack with only the return address and all arguments copied to locals" do
67
+ # set up a routine at address $2000 with two locals
68
+ @zork_memory.force_writeb(0x2000, 2)
69
+ @zork_memory.force_writew(0x2001, 345)
70
+ @zork_memory.force_writew(0x2003, 456)
71
+
72
+ # The packed address is 0x2000 / 2
73
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
74
+ [Gruesome::Z::OperandType::LARGE],
75
+ [0x1000], 128, nil, nil, 0)
76
+
77
+ @processor.execute(i)
78
+ @zork_memory.program_counter.should eql(0x2005)
79
+ @zork_memory.readv(0).should eql(456)
80
+ @zork_memory.readv(0).should eql(345)
81
+ @zork_memory.readv(0).should eql(12345)
82
+ end
83
+ end
84
+
85
+ # not necessarily a branch
86
+ describe "call_1n" do
87
+ it "should branch to the routine with two local variables given as first operand" do
88
+ # set up a routine at address $2000
89
+ @zork_memory.force_writeb(0x2000, 2)
90
+ @zork_memory.force_writew(0x2001, 0)
91
+ @zork_memory.force_writew(0x2003, 0)
92
+
93
+ # The packed address is 0x2000 / 2
94
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL_1N,
95
+ [Gruesome::Z::OperandType::LARGE],
96
+ [0x1000], nil, nil, nil, 0)
97
+ @processor.execute(i)
98
+ @zork_memory.program_counter.should eql(0x2005)
99
+ end
100
+
101
+ it "should simply do nothing when routine address is 0" do
102
+ @zork_memory.writev(128, 12345)
103
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL_1N,
104
+ [Gruesome::Z::OperandType::LARGE],
105
+ [0], nil, nil, nil, 0)
106
+ @processor.execute(i)
107
+ @zork_memory.program_counter.should eql(12345)
108
+ end
109
+
110
+ it "should create a stack with only the return address when no arguments or local variables are used" do
111
+ # set up a routine at address $2000 with no locals
112
+ @zork_memory.force_writeb(0x2000, 0)
113
+
114
+ # The packed address is 0x2000 / 2
115
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL_1N,
116
+ [Gruesome::Z::OperandType::LARGE],
117
+ [0x1000], nil, nil, nil, 0)
118
+ @processor.execute(i)
119
+ @zork_memory.program_counter.should eql(0x2001)
120
+ @zork_memory.readv(0).should eql(12345)
121
+ end
122
+ end
123
+
124
+ describe "dec_chk" do
125
+ it "should decrement the value in the variable given as the operand" do
126
+ @zork_memory.writev(128, 12345)
127
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::DEC_CHK,
128
+ [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
129
+ [128, 12345], nil, nil, nil, 0)
130
+ @processor.execute(i)
131
+ @zork_memory.readv(128).should eql(12344)
132
+ end
133
+
134
+ it "should consider the value signed and decrement 0 to -1" do
135
+ @zork_memory.writev(128, 0)
136
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::DEC_CHK,
137
+ [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
138
+ [128, 12345], nil, nil, nil, 0)
139
+ @processor.execute(i)
140
+ @zork_memory.readv(128).should eql(-1+65536)
141
+ end
142
+
143
+ it "should edit the value on the stack in place" do
144
+ @zork_memory.writev(0, 11111)
145
+ @zork_memory.writev(0, 12345)
146
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::DEC_CHK,
147
+ [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
148
+ [0, 12345], nil, nil, nil, 0)
149
+ @processor.execute(i)
150
+ @zork_memory.readv(0).should eql(12344)
151
+ @zork_memory.readv(0).should eql(11111)
152
+ end
153
+
154
+ it "should branch if the value after decrementing is less than the value given by the operand" do
155
+ @zork_memory.writev(128, 12345)
156
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::DEC_CHK,
157
+ [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
158
+ [128, 12345], nil, 2000, true, 0)
159
+ @processor.execute(i)
160
+ @zork_memory.program_counter = 2000
161
+ end
162
+
163
+ it "should not branch if the value after decrementing is not less than the value given by the operand" do
164
+ @zork_memory.writev(128, 12345)
165
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::DEC_CHK,
166
+ [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
167
+ [128, 12345], nil, 2000, true, 0)
168
+ @processor.execute(i)
169
+ @zork_memory.program_counter = 12345
170
+ end
171
+
172
+ it "should not branch if the value after decrementing is less than the value given by the operand and condition is negated" do
173
+ @zork_memory.writev(128, 12345)
174
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::DEC_CHK,
175
+ [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
176
+ [128, 12345], nil, 2000, false, 0)
177
+ @processor.execute(i)
178
+ @zork_memory.program_counter = 12345
179
+ end
180
+
181
+ it "should branch if the value after decrementing is not less than the value given by the operand and condition is negated" do
182
+ @zork_memory.writev(128, 12347)
183
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::DEC_CHK,
184
+ [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
185
+ [128, 12346], nil, 2000, false, 0)
186
+ @processor.execute(i)
187
+ @zork_memory.program_counter = 2000
188
+ end
189
+
190
+ end
191
+
192
+ describe "inc_chk" do
193
+ it "should increment the value in the variable given as the operand" do
194
+ @zork_memory.writev(128, 12345)
195
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::INC_CHK,
196
+ [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
197
+ [128, 12345], nil, nil, nil, 0)
198
+ @processor.execute(i)
199
+ @zork_memory.readv(128).should eql(12346)
200
+ end
201
+
202
+ it "should consider the value signed and increment -1 to 0" do
203
+ @zork_memory.writev(128, -1+65536)
204
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::INC_CHK,
205
+ [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
206
+ [128, 12345], nil, nil, nil, 0)
207
+ @processor.execute(i)
208
+ @zork_memory.readv(128).should eql(0)
209
+ end
210
+
211
+ it "should edit the value on the stack in place" do
212
+ @zork_memory.writev(0, 11111)
213
+ @zork_memory.writev(0, 12345)
214
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::INC_CHK,
215
+ [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
216
+ [0, 12345], nil, nil, nil, 0)
217
+ @processor.execute(i)
218
+ @zork_memory.readv(0).should eql(12346)
219
+ @zork_memory.readv(0).should eql(11111)
220
+ end
221
+
222
+ it "should branch if the value after incrementing is greater than the value given by the operand" do
223
+ @zork_memory.writev(128, 12345)
224
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::INC_CHK,
225
+ [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
226
+ [128, 12345], nil, 2000, true, 0)
227
+ @processor.execute(i)
228
+ @zork_memory.program_counter = 2000
229
+ end
230
+
231
+ it "should not branch if the value after incrementing is not greater than the value given by the operand" do
232
+ @zork_memory.writev(128, 12345)
233
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::INC_CHK,
234
+ [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
235
+ [128, 12346], nil, 2000, true, 0)
236
+ @processor.execute(i)
237
+ @zork_memory.program_counter = 12345
238
+ end
239
+
240
+ it "should not branch if the value after incrementing is greater than the value given by the operand and condition is negated" do
241
+ @zork_memory.writev(128, 12345)
242
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::INC_CHK,
243
+ [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
244
+ [128, 12345], nil, 2000, false, 0)
245
+ @processor.execute(i)
246
+ @zork_memory.program_counter = 12345
247
+ end
248
+
249
+ it "should branch if the value after incrementing is not greater than the value given by the operand and condition is negated" do
250
+ @zork_memory.writev(128, 12345)
251
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::INC_CHK,
252
+ [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
253
+ [128, 12346], nil, 2000, false, 0)
254
+ @processor.execute(i)
255
+ @zork_memory.program_counter = 2000
256
+ end
257
+ end
258
+
259
+ # not necessarily a branch
260
+ describe "ret" do
261
+ it "should return to the routine that called it" do
262
+ # set up a routine at address $2000
263
+ @zork_memory.force_writeb(0x2000, 2)
264
+ @zork_memory.force_writew(0x2001, 0)
265
+ @zork_memory.force_writew(0x2003, 0)
266
+
267
+ # The packed address is 0x2000 / 2
268
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
269
+ [Gruesome::Z::OperandType::LARGE],
270
+ [0x1000], 128, nil, nil, 0)
271
+
272
+ @processor.execute(i)
273
+
274
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::RET,
275
+ [Gruesome::Z::OperandType::LARGE],
276
+ [123], nil, nil, nil, 0)
277
+
278
+ @processor.execute(i)
279
+
280
+ @zork_memory.program_counter.should eql(12345)
281
+ end
282
+
283
+ it "should set the variable indicated by the call with the return value as an immediate" do
284
+ # set up a routine at address $2000
285
+ @zork_memory.force_writeb(0x2000, 2)
286
+ @zork_memory.force_writew(0x2001, 0)
287
+ @zork_memory.force_writew(0x2003, 0)
288
+
289
+ # The packed address is 0x2000 / 2
290
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
291
+ [Gruesome::Z::OperandType::LARGE],
292
+ [0x1000], 128, nil, nil, 0)
293
+
294
+ @processor.execute(i)
295
+
296
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::RET,
297
+ [Gruesome::Z::OperandType::LARGE],
298
+ [123], nil, nil, nil, 0)
299
+
300
+ @processor.execute(i)
301
+
302
+ @zork_memory.readv(128).should eql(123)
303
+ end
304
+
305
+ it "should be able to push the result (given as an immediate) to the stack if the call requests variable 0" do
306
+ # set up a routine at address $2000
307
+ @zork_memory.force_writeb(0x2000, 2)
308
+ @zork_memory.force_writew(0x2001, 0)
309
+ @zork_memory.force_writew(0x2003, 0)
310
+
311
+ # The packed address is 0x2000 / 2
312
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
313
+ [Gruesome::Z::OperandType::LARGE],
314
+ [0x1000], 0, nil, nil, 0)
315
+
316
+ @processor.execute(i)
317
+
318
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::RET,
319
+ [Gruesome::Z::OperandType::LARGE],
320
+ [123], nil, nil, nil, 0)
321
+
322
+ @processor.execute(i)
323
+
324
+ @zork_memory.readv(0).should eql(123)
325
+ end
326
+ end
327
+
328
+ # not necessarily a branch
329
+ describe "ret_popped" do
330
+ it "should return to the routine that called it" do
331
+ # set up a routine at address $2000
332
+ @zork_memory.force_writeb(0x2000, 2)
333
+ @zork_memory.force_writew(0x2001, 0)
334
+ @zork_memory.force_writew(0x2003, 0)
335
+
336
+ # The packed address is 0x2000 / 2
337
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
338
+ [Gruesome::Z::OperandType::LARGE],
339
+ [0x1000], 128, nil, nil, 0)
340
+
341
+ @processor.execute(i)
342
+
343
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::RET_POPPED,
344
+ [Gruesome::Z::OperandType::LARGE],
345
+ [123], nil, nil, nil, 0)
346
+
347
+ @processor.execute(i)
348
+
349
+ @zork_memory.program_counter.should eql(12345)
350
+ end
351
+
352
+ it "should be able to push top of callee stack to the stack of the caller" do
353
+ # set up a routine at address $2000
354
+ @zork_memory.force_writeb(0x2000, 2)
355
+ @zork_memory.force_writew(0x2001, 0)
356
+ @zork_memory.force_writew(0x2003, 0)
357
+ @zork_memory.writev(0, 11111)
358
358
 
359
- # The packed address is 0x2000 / 2
360
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
361
- [Gruesome::Z::OperandType::LARGE],
362
- [0x1000], 0, nil, nil, 0)
359
+ # The packed address is 0x2000 / 2
360
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
361
+ [Gruesome::Z::OperandType::LARGE],
362
+ [0x1000], 0, nil, nil, 0)
363
363
 
364
- @processor.execute(i)
365
- @zork_memory.writev(0, 22222)
366
- @zork_memory.writev(0, 23456)
364
+ @processor.execute(i)
365
+ @zork_memory.writev(0, 22222)
366
+ @zork_memory.writev(0, 23456)
367
367
 
368
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::RET_POPPED,
369
- [Gruesome::Z::OperandType::LARGE],
370
- [123], nil, nil, nil, 0)
368
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::RET_POPPED,
369
+ [Gruesome::Z::OperandType::LARGE],
370
+ [123], nil, nil, nil, 0)
371
371
 
372
- @processor.execute(i)
372
+ @processor.execute(i)
373
373
 
374
- @zork_memory.readv(0).should eql(23456)
375
- @zork_memory.readv(0).should eql(11111)
376
- end
377
- end
374
+ @zork_memory.readv(0).should eql(23456)
375
+ @zork_memory.readv(0).should eql(11111)
376
+ end
377
+ end
378
378
 
379
- # not necessarily a branch
380
- describe "rfalse" do
381
- it "should set the variable indicated by the call with 0" do
382
- # set up a routine at address $2000
383
- @zork_memory.force_writeb(0x2000, 2)
384
- @zork_memory.force_writew(0x2001, 0)
385
- @zork_memory.force_writew(0x2003, 0)
379
+ # not necessarily a branch
380
+ describe "rfalse" do
381
+ it "should set the variable indicated by the call with 0" do
382
+ # set up a routine at address $2000
383
+ @zork_memory.force_writeb(0x2000, 2)
384
+ @zork_memory.force_writew(0x2001, 0)
385
+ @zork_memory.force_writew(0x2003, 0)
386
386
 
387
- # The packed address is 0x2000 / 2
388
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
389
- [Gruesome::Z::OperandType::LARGE],
390
- [0x1000], 128, nil, nil, 0)
387
+ # The packed address is 0x2000 / 2
388
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
389
+ [Gruesome::Z::OperandType::LARGE],
390
+ [0x1000], 128, nil, nil, 0)
391
391
 
392
- @processor.execute(i)
392
+ @processor.execute(i)
393
393
 
394
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::RFALSE,
395
- [], [], nil, nil, nil, 0)
394
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::RFALSE,
395
+ [], [], nil, nil, nil, 0)
396
396
 
397
- @processor.execute(i)
397
+ @processor.execute(i)
398
398
 
399
- @zork_memory.readv(128).should eql(0)
400
- end
399
+ @zork_memory.readv(128).should eql(0)
400
+ end
401
401
 
402
- it "should push 0 to the caller's stack when indicated" do
403
- # set up a routine at address $2000
404
- @zork_memory.force_writeb(0x2000, 2)
405
- @zork_memory.force_writew(0x2001, 0)
406
- @zork_memory.force_writew(0x2003, 0)
407
-
408
- # The packed address is 0x2000 / 2
409
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
410
- [Gruesome::Z::OperandType::LARGE],
411
- [0x1000], 0, nil, nil, 0)
412
-
413
- @processor.execute(i)
414
-
415
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::RFALSE,
416
- [], [], nil, nil, nil, 0)
417
-
418
- @processor.execute(i)
419
-
420
- @zork_memory.readv(0).should eql(0)
421
- end
422
- end
423
-
424
- # not necessarily a branch
425
- describe "rtrue" do
426
- it "should set the variable indicated by the call with 1" do
427
- # set up a routine at address $2000
428
- @zork_memory.force_writeb(0x2000, 2)
429
- @zork_memory.force_writew(0x2001, 0)
430
- @zork_memory.force_writew(0x2003, 0)
431
-
432
- # The packed address is 0x2000 / 2
433
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
434
- [Gruesome::Z::OperandType::LARGE],
435
- [0x1000], 128, nil, nil, 0)
436
-
437
- @processor.execute(i)
438
-
439
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::RTRUE,
440
- [], [], nil, nil, nil, 0)
441
-
442
- @processor.execute(i)
443
-
444
- @zork_memory.readv(128).should eql(1)
445
- end
446
-
447
- it "should push 1 to the caller's stack when indicated" do
448
- # set up a routine at address $2000
449
- @zork_memory.force_writeb(0x2000, 2)
450
- @zork_memory.force_writew(0x2001, 0)
451
- @zork_memory.force_writew(0x2003, 0)
452
-
453
- # The packed address is 0x2000 / 2
454
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
455
- [Gruesome::Z::OperandType::LARGE],
456
- [0x1000], 0, nil, nil, 0)
457
-
458
- @processor.execute(i)
459
-
460
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::RTRUE,
461
- [], [], nil, nil, nil, 0)
462
-
463
- @processor.execute(i)
464
-
465
- @zork_memory.readv(0).should eql(1)
466
- end
467
- end
468
-
469
- describe "jg" do
470
- it "should branch if the first operand is greater than the second" do
471
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JG,
472
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
473
- [(-12345+65536), (-23456+65536)], nil, 2000, true, 0)
474
-
475
- @processor.execute(i)
476
- @zork_memory.program_counter.should eql(2000)
477
- end
478
-
479
- it "should not branch if the first operand is not greater than the second" do
480
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JG,
481
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
482
- [12345, 12345], nil, 2000, true, 0)
483
-
484
- @processor.execute(i)
485
- @zork_memory.program_counter.should eql(12345)
486
- end
487
-
488
- it "should not branch if the first operand is greater than the second and condition is negated" do
489
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JG,
490
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
491
- [(-12345+65536), (-23456+65536)], nil, 2000, false, 0)
492
-
493
- @processor.execute(i)
494
- @zork_memory.program_counter.should eql(12345)
495
- end
496
-
497
- it "should branch if the first operand is not greater than the second and condition is negated" do
498
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JG,
499
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
500
- [(-12345+65536), 12345], nil, 2000, false, 0)
501
-
502
- @processor.execute(i)
503
- @zork_memory.program_counter.should eql(2000)
504
- end
505
- end
506
-
507
- describe "je" do
508
- it "should branch if the first operand is equal to one of four operands" do
509
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JE,
510
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE,
511
- Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
512
- [(-12345+65536), 123, 1234, (-12345+65536)], nil, 2000, true, 0)
513
-
514
- @processor.execute(i)
515
- @zork_memory.program_counter.should eql(2000)
516
- end
517
-
518
- it "should not branch if the first operand is not equal to one of four operands" do
519
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JE,
520
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE,
521
- Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
522
- [(-123+65536), 123, 1234, (12345+65536)], nil, 2000, true, 0)
523
-
524
- @processor.execute(i)
525
- @zork_memory.program_counter.should eql(12345)
526
- end
527
-
528
- it "should not branch if the first operand is equal to one of four operands and condition is negated" do
529
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JE,
530
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE,
531
- Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
532
- [(-12345+65536), 1234, 123, (-12345+65536)], nil, 2000, false, 0)
533
-
534
- @processor.execute(i)
535
- @zork_memory.program_counter.should eql(12345)
536
- end
537
-
538
- it "should branch if the first operand is not equal to one of four operands and condition is negated" do
539
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JE,
540
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE,
541
- Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
542
- [(-123+65536), 123, 12345, 12344], nil, 2000, false, 0)
543
-
544
- @processor.execute(i)
545
- @zork_memory.program_counter.should eql(2000)
546
- end
547
-
548
- it "should branch if the first operand is equal to one of three operands" do
549
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JE,
550
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
551
- [(-12345+65536), 123, (-12345+65536)], nil, 2000, true, 0)
552
-
553
- @processor.execute(i)
554
- @zork_memory.program_counter.should eql(2000)
555
- end
556
-
557
- it "should not branch if the first operand is not equal to one of three operands" do
558
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JE,
559
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
560
- [(-123+65536), 123, (12345+65536)], nil, 2000, true, 0)
561
-
562
- @processor.execute(i)
563
- @zork_memory.program_counter.should eql(12345)
564
- end
565
-
566
- it "should not branch if the first operand is equal to one of three operands and condition is negated" do
567
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JE,
568
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
569
- [(-12345+65536), 123, (-12345+65536)], nil, 2000, false, 0)
570
-
571
- @processor.execute(i)
572
- @zork_memory.program_counter.should eql(12345)
573
- end
574
-
575
- it "should branch if the first operand is not equal to one of three operands and condition is negated" do
576
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JE,
577
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
578
- [(-123+65536), 12345, 12344], nil, 2000, false, 0)
579
-
580
- @processor.execute(i)
581
- @zork_memory.program_counter.should eql(2000)
582
- end
583
-
584
- it "should branch if the first operand is equal to the second of two operands" do
585
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JE,
586
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
587
- [(-12345+65536), (-12345+65536)], nil, 2000, true, 0)
588
-
589
- @processor.execute(i)
590
- @zork_memory.program_counter.should eql(2000)
591
- end
592
-
593
- it "should not branch if the first operand is not equal to the second of two operands" do
594
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JE,
595
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
596
- [(-123+65536), (12345+65536)], nil, 2000, true, 0)
597
-
598
- @processor.execute(i)
599
- @zork_memory.program_counter.should eql(12345)
600
- end
601
-
602
- it "should not branch if the first operand is equal to the second of two operands and condition is negated" do
603
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JE,
604
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
605
- [(-12345+65536), (-12345+65536)], nil, 2000, false, 0)
606
-
607
- @processor.execute(i)
608
- @zork_memory.program_counter.should eql(12345)
609
- end
610
-
611
- it "should branch if the first operand is not equal to the second of two operands and condition is negated" do
612
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JE,
613
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
614
- [(-123+65536), (12345+65536)], nil, 2000, false, 0)
615
-
616
- @processor.execute(i)
617
- @zork_memory.program_counter.should eql(2000)
618
- end
619
- end
620
-
621
- describe "jl" do
622
- it "should branch if the first operand is less than the second" do
623
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JL,
624
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
625
- [(-23456+65536), (-12345+65536)], nil, 2000, true, 0)
626
-
627
- @processor.execute(i)
628
- @zork_memory.program_counter.should eql(2000)
629
- end
630
-
631
- it "should not branch if the first operand is not less than the second" do
632
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JL,
633
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
634
- [12345, 12345], nil, 2000, true, 0)
635
-
636
- @processor.execute(i)
637
- @zork_memory.program_counter.should eql(12345)
638
- end
639
-
640
- it "should not branch if the first operand is less than the second and condition is negated" do
641
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JL,
642
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
643
- [(-23456+65536), (-12345+65536)], nil, 2000, false, 0)
644
-
645
- @processor.execute(i)
646
- @zork_memory.program_counter.should eql(12345)
647
- end
648
-
649
- it "should branch if the first operand is not less than the second and condition is negated" do
650
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JL,
651
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
652
- [12345, (-12345+65536)], nil, 2000, false, 0)
653
-
654
- @processor.execute(i)
655
- @zork_memory.program_counter.should eql(2000)
656
- end
657
- end
658
-
659
- describe "jz" do
660
- it "should branch if the first operand is zero" do
661
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JZ,
662
- [Gruesome::Z::OperandType::LARGE],
663
- [0], nil, 2000, true, 0)
664
-
665
- @processor.execute(i)
666
- @zork_memory.program_counter.should eql(2000)
667
- end
668
-
669
- it "should not branch if the first operand is not zero" do
670
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JZ,
671
- [Gruesome::Z::OperandType::LARGE],
672
- [12345], nil, 2000, true, 0)
673
-
674
- @processor.execute(i)
675
- @zork_memory.program_counter.should eql(12345)
676
- end
677
-
678
- it "should not branch if the first operand is zero and condition is negated" do
679
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JZ,
680
- [Gruesome::Z::OperandType::LARGE],
681
- [0], nil, 2000, false, 0)
682
-
683
- @processor.execute(i)
684
- @zork_memory.program_counter.should eql(12345)
685
- end
686
-
687
- it "should branch if the first operand is not zero and condition is negated" do
688
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JZ,
689
- [Gruesome::Z::OperandType::LARGE],
690
- [12345], nil, 2000, false, 0)
691
-
692
- @processor.execute(i)
693
- @zork_memory.program_counter.should eql(2000)
694
- end
695
- end
696
-
697
- describe "jump" do
698
- it "should update the program counter via a signed offset" do
699
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JUMP,
700
- [Gruesome::Z::OperandType::LARGE],
701
- [(-12343+65536)], nil, nil, nil, 0)
702
-
703
- @processor.execute(i)
704
- @zork_memory.program_counter.should eql(0)
705
- end
706
- end
707
-
708
- describe "piracy" do
709
- it "should simply act as a jump and update the program counter via a signed offset" do
710
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PIRACY,
711
- [Gruesome::Z::OperandType::LARGE],
712
- [(-12343+65536)], nil, nil, nil, 0)
713
-
714
- @processor.execute(i)
715
- @zork_memory.program_counter.should eql(0)
716
- end
717
- end
718
-
719
- describe "test" do
720
- it "should branch if the first operand has all bits set that the second has set" do
721
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::TEST,
722
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
723
- [0b1000110110111101, 0b1000100010001000], nil, 2000, true, 0)
724
-
725
- @processor.execute(i)
726
- @zork_memory.program_counter.should eql(2000)
727
- end
728
-
729
- it "should not branch if the first operand does not have all bits set that the second has set" do
730
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::TEST,
731
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
732
- [0b1000110110111101, 0b1111100010001000], nil, 2000, true, 0)
733
-
734
- @processor.execute(i)
735
- @zork_memory.program_counter.should eql(12345)
736
- end
737
-
738
- it "should not branch if the first operand has all bits set that the second has set and condition is negated" do
739
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::TEST,
740
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
741
- [0b1000110110111101, 0b1000100010001000], nil, 2000, false, 0)
742
-
743
- @processor.execute(i)
744
- @zork_memory.program_counter.should eql(12345)
745
- end
746
-
747
- it "should branch if the first operand does not have all bits set that the second has set and condition is negated" do
748
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::TEST,
749
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
750
- [0b1000110110111101, 0b1111100010001000], nil, 2000, false, 0)
751
-
752
- @processor.execute(i)
753
- @zork_memory.program_counter.should eql(2000)
754
- end
755
- end
756
- end
757
-
758
- describe "Store Instruction" do
759
- before(:each) do
760
- @zork_memory.writev(128, 0)
761
- end
762
-
763
- after(:each) do
764
- # instructions should not affect PC
765
- @zork_memory.program_counter.should eql(12345)
766
- end
767
-
768
- describe "art_shift" do
769
- it "should shift left when places is positive" do
770
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::ART_SHIFT,
771
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
772
- [1234, 2], 128, nil, nil, 0)
773
-
774
- @processor.execute(i)
775
-
776
- @zork_memory.readv(128).should eql(((1234 << 2) & 65535))
777
- end
778
-
779
- it "should shift right when places is positive and sign extend" do
780
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::ART_SHIFT,
781
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
782
- [-123+65536, -2+65536], 128, nil, nil, 0)
783
-
784
- @processor.execute(i)
785
-
786
- @zork_memory.readv(128).should eql((-123 >> 2) & 65535)
787
- end
788
- end
789
-
790
- describe "load" do
791
- it "should store the value of the variable into the result" do
792
- @zork_memory.writev(128, 30)
793
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::LOAD,
794
- [Gruesome::Z::OperandType::VARIABLE],
795
- [128], 130, nil, nil, 0)
796
- @processor.execute(i)
797
- @zork_memory.readv(130).should eql(30)
798
- end
799
-
800
- it "should not pop the value off of the stack if variable %00 is used" do
801
- @zork_memory.writev(0, 11111)
802
- @zork_memory.writev(0, 12345)
803
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::LOAD,
804
- [Gruesome::Z::OperandType::VARIABLE],
805
- [0], 130, nil, nil, 0)
806
- @processor.execute(i)
807
- @zork_memory.readv(130).should eql(12345)
808
- @zork_memory.readv(0).should eql(12345)
809
- @zork_memory.readv(0).should eql(11111)
810
- end
811
- end
812
-
813
- describe "loadb" do
814
- it "should store the value of the byte at the location given by the base and offset into the result" do
815
- @zork_memory.writeb(2589+200, 127)
816
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::LOADB,
817
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
818
- [2589, 200], 130, nil, nil, 0)
819
- @processor.execute(i)
820
- @zork_memory.readv(130).should eql(127)
821
- end
822
- end
823
-
824
- describe "loadw" do
825
- it "should store the value of the word at the location given by the base and offset into the result" do
826
- @zork_memory.writew(2480+200, 12345)
827
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::LOADW,
828
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
829
- [2480, 100], 130, nil, nil, 0)
830
- @processor.execute(i)
831
- @zork_memory.readv(130).should eql(12345)
832
- end
833
- end
834
-
835
- describe "random" do
836
- it "should return 0 when a negative value is used to seed the generator" do
837
- @zork_memory.writev(130, 11111)
838
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::RANDOM,
839
- [Gruesome::Z::OperandType::LARGE],
840
- [-1+65536], 130, nil, nil, 0)
841
- @processor.execute(i)
842
- @zork_memory.readv(130).should eql(0)
843
- end
844
-
845
- it "should return 0 when 0 is used to seed the generator" do
846
- @zork_memory.writev(130, 11111)
847
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::RANDOM,
848
- [Gruesome::Z::OperandType::LARGE],
849
- [-1+65536], 130, nil, nil, 0)
850
- @processor.execute(i)
851
- @zork_memory.readv(130).should eql(0)
852
- end
853
-
854
- it "should be able to be seeded with a negative value such that the behavior is predicable" do
855
- srand = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::RANDOM,
856
- [Gruesome::Z::OperandType::LARGE],
857
- [-1+65536], 130, nil, nil, 0)
858
- @processor.execute(srand)
859
-
860
- rnd = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::RANDOM,
861
- [Gruesome::Z::OperandType::LARGE],
862
- [1234], 130, nil, nil, 0)
863
- @processor.execute(rnd)
864
- store1 = @zork_memory.readv(130)
865
- @processor.execute(rnd)
866
- store2 = @zork_memory.readv(130)
867
-
868
- @processor.execute(srand)
869
-
870
- @processor.execute(rnd)
871
- @zork_memory.readv(130).should eql(store1)
872
- @processor.execute(rnd)
873
- @zork_memory.readv(130).should eql(store2)
874
- end
875
- end
876
- end
877
-
878
- describe "Input Instruction" do
879
- before(:each) do
880
- # We take over stdin so that we can simulate the keyboard input
881
- @stdin = $stdin
882
-
883
- # sread text-buffer parse-buffer (v 1-3)
884
-
885
- # text-buffer byte 0 indicates maximum length
886
- # parse-buffer byte 0 indicates maximum words
887
-
888
- @zork_memory.force_writeb(0x1000, 50)
889
- end
890
-
891
- after(:each) do
892
- $stdin = @stdin
893
-
894
- # The program counter should not be changed
895
- @zork_memory.program_counter.should eql(12345)
896
- end
897
-
898
- describe "sread" do
899
- it "should read in a line of text" do
900
- $stdin = StringIO.new("foo bar johnson\n")
901
-
902
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::SREAD,
903
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
904
- [0x1000, 0x1200], nil, nil, nil, 0)
905
- @processor.execute(i)
906
- end
907
- end
908
- end
909
-
910
- describe "Output and Branching Instruction" do
911
- before(:each) do
912
- # We take over stdout so that we can see what it prints
913
- @stdout = $stdout
914
- $stdout = StringIO.new
915
- end
916
-
917
- after(:each) do
918
- $stdout = @stdout
919
- end
920
-
921
- describe "print_ret" do
922
- it "should return to the routine that called it" do
923
- # set up a routine at address $2000
924
- @zork_memory.force_writeb(0x2000, 2)
925
- @zork_memory.force_writew(0x2001, 0)
926
- @zork_memory.force_writew(0x2003, 0)
927
-
928
- # The packed address is 0x2000 / 2
929
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
930
- [Gruesome::Z::OperandType::LARGE],
931
- [0x1000], 128, nil, nil, 0)
932
-
933
- @processor.execute(i)
934
-
935
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PRINT_RET,
936
- [Gruesome::Z::OperandType::STRING],
937
- ["Hello World"], nil, nil, nil, 0)
938
-
939
- @processor.execute(i)
940
-
941
- @zork_memory.program_counter.should eql(12345)
942
- end
943
-
944
- it "should print out the string given as an operand followed by a newline to stdout" do
945
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PRINT_RET,
946
- [Gruesome::Z::OperandType::STRING],
947
- ["Hello World"], nil, nil, nil, 0)
948
-
949
- @processor.execute(i)
950
- $stdout.string.should eql("Hello World\n")
951
- end
952
-
953
- it "should as a return value set the variable indicated by the call with 1" do
954
- # set up a routine at address $2000
955
- @zork_memory.force_writeb(0x2000, 2)
956
- @zork_memory.force_writew(0x2001, 0)
957
- @zork_memory.force_writew(0x2003, 0)
958
-
959
- # The packed address is 0x2000 / 2
960
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
961
- [Gruesome::Z::OperandType::LARGE],
962
- [0x1000], 128, nil, nil, 0)
963
-
964
- @processor.execute(i)
965
-
966
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PRINT_RET,
967
- [Gruesome::Z::OperandType::STRING],
968
- ["Hello World"], nil, nil, nil, 0)
969
-
970
- @processor.execute(i)
971
-
972
- @zork_memory.readv(128).should eql(1)
973
- end
974
-
975
- it "should as a return value push 1 to the caller's stack when indicated" do
976
- # set up a routine at address $2000
977
- @zork_memory.force_writeb(0x2000, 2)
978
- @zork_memory.force_writew(0x2001, 0)
979
- @zork_memory.force_writew(0x2003, 0)
980
- @zork_memory.writev(0, 11111)
981
-
982
- # The packed address is 0x2000 / 2
983
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
984
- [Gruesome::Z::OperandType::LARGE],
985
- [0x1000], 0, nil, nil, 0)
986
-
987
- @processor.execute(i)
988
-
989
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PRINT_RET,
990
- [Gruesome::Z::OperandType::STRING],
991
- ["Hello World"], nil, nil, nil, 0)
992
-
993
- @processor.execute(i)
994
-
995
- @zork_memory.readv(0).should eql(1)
996
- @zork_memory.readv(0).should eql(11111)
997
- end
998
- end
999
- end
1000
-
1001
- describe "Output Instruction" do
1002
- before(:each) do
1003
- # We take over stdout so that we can see what it prints
1004
- @stdout = $stdout
1005
- $stdout = StringIO.new
1006
- end
1007
-
1008
- after(:each) do
1009
- $stdout = @stdout
1010
-
1011
- # The program counter should not be changed
1012
- @zork_memory.program_counter.should eql(12345)
1013
- end
1014
-
1015
- describe "new_line" do
1016
- it "should print a carriage return" do
1017
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::NEW_LINE,
1018
- [], [], nil, nil, nil, 0)
1019
- @processor.execute(i)
1020
- $stdout.string.should eql("\n")
1021
- end
1022
- end
1023
-
1024
- describe "print_char" do
1025
- it "should print out the zchar given as an operand to stdout" do
1026
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PRINT_CHAR,
1027
- [Gruesome::Z::OperandType::LARGE],
1028
- [215], nil, nil, nil, 0)
1029
-
1030
- @processor.execute(i)
1031
- $stdout.string.should eql("\u00fe")
1032
- end
1033
- end
1034
-
1035
- describe "print_num" do
1036
- it "should print out a number given as an operand in decimal to stdout" do
1037
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PRINT_NUM,
1038
- [Gruesome::Z::OperandType::LARGE],
1039
- [12345], nil, nil, nil, 0)
1040
-
1041
- @processor.execute(i)
1042
- $stdout.string.should eql("12345")
1043
- end
1044
-
1045
- it "should print out a signed number given as an operand in decimal to stdout" do
1046
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PRINT_NUM,
1047
- [Gruesome::Z::OperandType::LARGE],
1048
- [-12345+65536], nil, nil, nil, 0)
1049
-
1050
- @processor.execute(i)
1051
- $stdout.string.should eql("-12345")
1052
- end
1053
- end
1054
-
1055
- describe "print" do
1056
- it "should print out the string given as an operand to stdout" do
1057
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PRINT,
1058
- [Gruesome::Z::OperandType::STRING],
1059
- ["Hello World"], nil, nil, nil, 0)
1060
-
1061
- @processor.execute(i)
1062
- $stdout.string.should eql("Hello World")
1063
- end
1064
- end
1065
-
1066
- describe "print_addr" do
1067
- it "should print out the string located at the byte address given by the operand" do
1068
- # 'grue' is written at 0x4291
1069
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PRINT_ADDR,
1070
- [Gruesome::Z::OperandType::LARGE],
1071
- [0x4291], nil, nil, nil, 0)
1072
-
1073
- @processor.execute(i)
1074
- $stdout.string.should eql("grue")
1075
- end
1076
- end
1077
-
1078
- describe "print_paddr" do
1079
- it "should print out the string located at the packed address given by the operand" do
1080
- # 'ZORK I: The Great Underground Empire' is written at 0x6ee4 (packed: 0x3772)
1081
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PRINT_PADDR,
1082
- [Gruesome::Z::OperandType::LARGE],
1083
- [0x3772], nil, nil, nil, 0)
1084
-
1085
- @processor.execute(i)
1086
- $stdout.string[/(.*)\n/,1].should eql("ZORK I: The Great Underground Empire")
1087
- end
1088
- end
1089
-
1090
- describe "log_shift" do
1091
- it "should shift left when places is positive" do
1092
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::LOG_SHIFT,
1093
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1094
- [-12345+65536, 2], 128, nil, nil, 0)
1095
-
1096
- @processor.execute(i)
1097
-
1098
- @zork_memory.readv(128).should eql((((-12345+65536) << 2) & 65535))
1099
- end
1100
-
1101
- it "should shift right when places is positive and not sign extend" do
1102
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::LOG_SHIFT,
1103
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1104
- [-123+65536, -2+65536], 128, nil, nil, 0)
1105
-
1106
- @processor.execute(i)
1107
-
1108
- @zork_memory.readv(128).should eql(((-123+65536) >> 2))
1109
- end
1110
- end
1111
-
1112
- describe "not" do
1113
- it "should perform a logical negation on the operand and assign to the appropriate variable" do
1114
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::NOT,
1115
- [Gruesome::Z::OperandType::LARGE],
1116
- [12345], 128, nil, nil, 0)
1117
-
1118
- @processor.execute(i)
1119
-
1120
- @zork_memory.readv(128).should eql((~12345)+65536)
1121
- end
1122
- end
1123
-
1124
- describe "and" do
1125
- it "should bitwise and two signed shorts together and assign to the appropriate variable" do
1126
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::AND,
1127
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1128
- [-12345+65536, 12344], 128, nil, nil, 0)
1129
-
1130
- @processor.execute(i)
1131
-
1132
- @zork_memory.readv(128).should eql((-12345 & 12344) & 65535)
1133
- end
1134
- end
1135
-
1136
- describe "or" do
1137
- it "should bitwise or two signed shorts together and assign to the appropriate variable" do
1138
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::OR,
1139
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1140
- [-12345+65536, 12344], 128, nil, nil, 0)
1141
-
1142
- @processor.execute(i)
402
+ it "should push 0 to the caller's stack when indicated" do
403
+ # set up a routine at address $2000
404
+ @zork_memory.force_writeb(0x2000, 2)
405
+ @zork_memory.force_writew(0x2001, 0)
406
+ @zork_memory.force_writew(0x2003, 0)
407
+
408
+ # The packed address is 0x2000 / 2
409
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
410
+ [Gruesome::Z::OperandType::LARGE],
411
+ [0x1000], 0, nil, nil, 0)
412
+
413
+ @processor.execute(i)
414
+
415
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::RFALSE,
416
+ [], [], nil, nil, nil, 0)
417
+
418
+ @processor.execute(i)
419
+
420
+ @zork_memory.readv(0).should eql(0)
421
+ end
422
+ end
423
+
424
+ # not necessarily a branch
425
+ describe "rtrue" do
426
+ it "should set the variable indicated by the call with 1" do
427
+ # set up a routine at address $2000
428
+ @zork_memory.force_writeb(0x2000, 2)
429
+ @zork_memory.force_writew(0x2001, 0)
430
+ @zork_memory.force_writew(0x2003, 0)
431
+
432
+ # The packed address is 0x2000 / 2
433
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
434
+ [Gruesome::Z::OperandType::LARGE],
435
+ [0x1000], 128, nil, nil, 0)
436
+
437
+ @processor.execute(i)
438
+
439
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::RTRUE,
440
+ [], [], nil, nil, nil, 0)
441
+
442
+ @processor.execute(i)
443
+
444
+ @zork_memory.readv(128).should eql(1)
445
+ end
446
+
447
+ it "should push 1 to the caller's stack when indicated" do
448
+ # set up a routine at address $2000
449
+ @zork_memory.force_writeb(0x2000, 2)
450
+ @zork_memory.force_writew(0x2001, 0)
451
+ @zork_memory.force_writew(0x2003, 0)
452
+
453
+ # The packed address is 0x2000 / 2
454
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
455
+ [Gruesome::Z::OperandType::LARGE],
456
+ [0x1000], 0, nil, nil, 0)
457
+
458
+ @processor.execute(i)
459
+
460
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::RTRUE,
461
+ [], [], nil, nil, nil, 0)
462
+
463
+ @processor.execute(i)
464
+
465
+ @zork_memory.readv(0).should eql(1)
466
+ end
467
+ end
468
+
469
+ describe "jg" do
470
+ it "should branch if the first operand is greater than the second" do
471
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JG,
472
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
473
+ [(-12345+65536), (-23456+65536)], nil, 2000, true, 0)
474
+
475
+ @processor.execute(i)
476
+ @zork_memory.program_counter.should eql(2000)
477
+ end
478
+
479
+ it "should not branch if the first operand is not greater than the second" do
480
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JG,
481
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
482
+ [12345, 12345], nil, 2000, true, 0)
483
+
484
+ @processor.execute(i)
485
+ @zork_memory.program_counter.should eql(12345)
486
+ end
487
+
488
+ it "should not branch if the first operand is greater than the second and condition is negated" do
489
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JG,
490
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
491
+ [(-12345+65536), (-23456+65536)], nil, 2000, false, 0)
492
+
493
+ @processor.execute(i)
494
+ @zork_memory.program_counter.should eql(12345)
495
+ end
496
+
497
+ it "should branch if the first operand is not greater than the second and condition is negated" do
498
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JG,
499
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
500
+ [(-12345+65536), 12345], nil, 2000, false, 0)
501
+
502
+ @processor.execute(i)
503
+ @zork_memory.program_counter.should eql(2000)
504
+ end
505
+ end
506
+
507
+ describe "je" do
508
+ it "should branch if the first operand is equal to one of four operands" do
509
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JE,
510
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE,
511
+ Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
512
+ [(-12345+65536), 123, 1234, (-12345+65536)], nil, 2000, true, 0)
513
+
514
+ @processor.execute(i)
515
+ @zork_memory.program_counter.should eql(2000)
516
+ end
517
+
518
+ it "should not branch if the first operand is not equal to one of four operands" do
519
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JE,
520
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE,
521
+ Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
522
+ [(-123+65536), 123, 1234, (12345+65536)], nil, 2000, true, 0)
523
+
524
+ @processor.execute(i)
525
+ @zork_memory.program_counter.should eql(12345)
526
+ end
527
+
528
+ it "should not branch if the first operand is equal to one of four operands and condition is negated" do
529
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JE,
530
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE,
531
+ Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
532
+ [(-12345+65536), 1234, 123, (-12345+65536)], nil, 2000, false, 0)
533
+
534
+ @processor.execute(i)
535
+ @zork_memory.program_counter.should eql(12345)
536
+ end
537
+
538
+ it "should branch if the first operand is not equal to one of four operands and condition is negated" do
539
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JE,
540
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE,
541
+ Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
542
+ [(-123+65536), 123, 12345, 12344], nil, 2000, false, 0)
543
+
544
+ @processor.execute(i)
545
+ @zork_memory.program_counter.should eql(2000)
546
+ end
547
+
548
+ it "should branch if the first operand is equal to one of three operands" do
549
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JE,
550
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
551
+ [(-12345+65536), 123, (-12345+65536)], nil, 2000, true, 0)
552
+
553
+ @processor.execute(i)
554
+ @zork_memory.program_counter.should eql(2000)
555
+ end
556
+
557
+ it "should not branch if the first operand is not equal to one of three operands" do
558
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JE,
559
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
560
+ [(-123+65536), 123, (12345+65536)], nil, 2000, true, 0)
561
+
562
+ @processor.execute(i)
563
+ @zork_memory.program_counter.should eql(12345)
564
+ end
565
+
566
+ it "should not branch if the first operand is equal to one of three operands and condition is negated" do
567
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JE,
568
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
569
+ [(-12345+65536), 123, (-12345+65536)], nil, 2000, false, 0)
570
+
571
+ @processor.execute(i)
572
+ @zork_memory.program_counter.should eql(12345)
573
+ end
574
+
575
+ it "should branch if the first operand is not equal to one of three operands and condition is negated" do
576
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JE,
577
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
578
+ [(-123+65536), 12345, 12344], nil, 2000, false, 0)
579
+
580
+ @processor.execute(i)
581
+ @zork_memory.program_counter.should eql(2000)
582
+ end
583
+
584
+ it "should branch if the first operand is equal to the second of two operands" do
585
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JE,
586
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
587
+ [(-12345+65536), (-12345+65536)], nil, 2000, true, 0)
588
+
589
+ @processor.execute(i)
590
+ @zork_memory.program_counter.should eql(2000)
591
+ end
592
+
593
+ it "should not branch if the first operand is not equal to the second of two operands" do
594
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JE,
595
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
596
+ [(-123+65536), (12345+65536)], nil, 2000, true, 0)
597
+
598
+ @processor.execute(i)
599
+ @zork_memory.program_counter.should eql(12345)
600
+ end
601
+
602
+ it "should not branch if the first operand is equal to the second of two operands and condition is negated" do
603
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JE,
604
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
605
+ [(-12345+65536), (-12345+65536)], nil, 2000, false, 0)
606
+
607
+ @processor.execute(i)
608
+ @zork_memory.program_counter.should eql(12345)
609
+ end
610
+
611
+ it "should branch if the first operand is not equal to the second of two operands and condition is negated" do
612
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JE,
613
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
614
+ [(-123+65536), (12345+65536)], nil, 2000, false, 0)
615
+
616
+ @processor.execute(i)
617
+ @zork_memory.program_counter.should eql(2000)
618
+ end
619
+ end
620
+
621
+ describe "jl" do
622
+ it "should branch if the first operand is less than the second" do
623
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JL,
624
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
625
+ [(-23456+65536), (-12345+65536)], nil, 2000, true, 0)
626
+
627
+ @processor.execute(i)
628
+ @zork_memory.program_counter.should eql(2000)
629
+ end
630
+
631
+ it "should not branch if the first operand is not less than the second" do
632
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JL,
633
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
634
+ [12345, 12345], nil, 2000, true, 0)
635
+
636
+ @processor.execute(i)
637
+ @zork_memory.program_counter.should eql(12345)
638
+ end
639
+
640
+ it "should not branch if the first operand is less than the second and condition is negated" do
641
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JL,
642
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
643
+ [(-23456+65536), (-12345+65536)], nil, 2000, false, 0)
644
+
645
+ @processor.execute(i)
646
+ @zork_memory.program_counter.should eql(12345)
647
+ end
648
+
649
+ it "should branch if the first operand is not less than the second and condition is negated" do
650
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JL,
651
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
652
+ [12345, (-12345+65536)], nil, 2000, false, 0)
653
+
654
+ @processor.execute(i)
655
+ @zork_memory.program_counter.should eql(2000)
656
+ end
657
+ end
658
+
659
+ describe "jz" do
660
+ it "should branch if the first operand is zero" do
661
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JZ,
662
+ [Gruesome::Z::OperandType::LARGE],
663
+ [0], nil, 2000, true, 0)
664
+
665
+ @processor.execute(i)
666
+ @zork_memory.program_counter.should eql(2000)
667
+ end
668
+
669
+ it "should not branch if the first operand is not zero" do
670
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JZ,
671
+ [Gruesome::Z::OperandType::LARGE],
672
+ [12345], nil, 2000, true, 0)
673
+
674
+ @processor.execute(i)
675
+ @zork_memory.program_counter.should eql(12345)
676
+ end
677
+
678
+ it "should not branch if the first operand is zero and condition is negated" do
679
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JZ,
680
+ [Gruesome::Z::OperandType::LARGE],
681
+ [0], nil, 2000, false, 0)
682
+
683
+ @processor.execute(i)
684
+ @zork_memory.program_counter.should eql(12345)
685
+ end
686
+
687
+ it "should branch if the first operand is not zero and condition is negated" do
688
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JZ,
689
+ [Gruesome::Z::OperandType::LARGE],
690
+ [12345], nil, 2000, false, 0)
691
+
692
+ @processor.execute(i)
693
+ @zork_memory.program_counter.should eql(2000)
694
+ end
695
+ end
696
+
697
+ describe "jump" do
698
+ it "should update the program counter via a signed offset" do
699
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JUMP,
700
+ [Gruesome::Z::OperandType::LARGE],
701
+ [(-12343+65536)], nil, nil, nil, 0)
702
+
703
+ @processor.execute(i)
704
+ @zork_memory.program_counter.should eql(0)
705
+ end
706
+ end
707
+
708
+ describe "piracy" do
709
+ it "should simply act as a jump and update the program counter via a signed offset" do
710
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PIRACY,
711
+ [Gruesome::Z::OperandType::LARGE],
712
+ [(-12343+65536)], nil, nil, nil, 0)
713
+
714
+ @processor.execute(i)
715
+ @zork_memory.program_counter.should eql(0)
716
+ end
717
+ end
718
+
719
+ describe "test" do
720
+ it "should branch if the first operand has all bits set that the second has set" do
721
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::TEST,
722
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
723
+ [0b1000110110111101, 0b1000100010001000], nil, 2000, true, 0)
724
+
725
+ @processor.execute(i)
726
+ @zork_memory.program_counter.should eql(2000)
727
+ end
728
+
729
+ it "should not branch if the first operand does not have all bits set that the second has set" do
730
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::TEST,
731
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
732
+ [0b1000110110111101, 0b1111100010001000], nil, 2000, true, 0)
733
+
734
+ @processor.execute(i)
735
+ @zork_memory.program_counter.should eql(12345)
736
+ end
737
+
738
+ it "should not branch if the first operand has all bits set that the second has set and condition is negated" do
739
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::TEST,
740
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
741
+ [0b1000110110111101, 0b1000100010001000], nil, 2000, false, 0)
742
+
743
+ @processor.execute(i)
744
+ @zork_memory.program_counter.should eql(12345)
745
+ end
746
+
747
+ it "should branch if the first operand does not have all bits set that the second has set and condition is negated" do
748
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::TEST,
749
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
750
+ [0b1000110110111101, 0b1111100010001000], nil, 2000, false, 0)
751
+
752
+ @processor.execute(i)
753
+ @zork_memory.program_counter.should eql(2000)
754
+ end
755
+ end
756
+ end
757
+
758
+ describe "Store Instruction" do
759
+ before(:each) do
760
+ @zork_memory.writev(128, 0)
761
+ end
762
+
763
+ after(:each) do
764
+ # instructions should not affect PC
765
+ @zork_memory.program_counter.should eql(12345)
766
+ end
767
+
768
+ describe "art_shift" do
769
+ it "should shift left when places is positive" do
770
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::ART_SHIFT,
771
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
772
+ [1234, 2], 128, nil, nil, 0)
773
+
774
+ @processor.execute(i)
775
+
776
+ @zork_memory.readv(128).should eql(((1234 << 2) & 65535))
777
+ end
778
+
779
+ it "should shift right when places is positive and sign extend" do
780
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::ART_SHIFT,
781
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
782
+ [-123+65536, -2+65536], 128, nil, nil, 0)
783
+
784
+ @processor.execute(i)
785
+
786
+ @zork_memory.readv(128).should eql((-123 >> 2) & 65535)
787
+ end
788
+ end
789
+
790
+ describe "load" do
791
+ it "should store the value of the variable into the result" do
792
+ @zork_memory.writev(128, 30)
793
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::LOAD,
794
+ [Gruesome::Z::OperandType::VARIABLE],
795
+ [128], 130, nil, nil, 0)
796
+ @processor.execute(i)
797
+ @zork_memory.readv(130).should eql(30)
798
+ end
799
+
800
+ it "should not pop the value off of the stack if variable %00 is used" do
801
+ @zork_memory.writev(0, 11111)
802
+ @zork_memory.writev(0, 12345)
803
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::LOAD,
804
+ [Gruesome::Z::OperandType::VARIABLE],
805
+ [0], 130, nil, nil, 0)
806
+ @processor.execute(i)
807
+ @zork_memory.readv(130).should eql(12345)
808
+ @zork_memory.readv(0).should eql(12345)
809
+ @zork_memory.readv(0).should eql(11111)
810
+ end
811
+ end
812
+
813
+ describe "loadb" do
814
+ it "should store the value of the byte at the location given by the base and offset into the result" do
815
+ @zork_memory.writeb(2589+200, 127)
816
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::LOADB,
817
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
818
+ [2589, 200], 130, nil, nil, 0)
819
+ @processor.execute(i)
820
+ @zork_memory.readv(130).should eql(127)
821
+ end
822
+ end
823
+
824
+ describe "loadw" do
825
+ it "should store the value of the word at the location given by the base and offset into the result" do
826
+ @zork_memory.writew(2480+200, 12345)
827
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::LOADW,
828
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
829
+ [2480, 100], 130, nil, nil, 0)
830
+ @processor.execute(i)
831
+ @zork_memory.readv(130).should eql(12345)
832
+ end
833
+ end
834
+
835
+ describe "random" do
836
+ it "should return 0 when a negative value is used to seed the generator" do
837
+ @zork_memory.writev(130, 11111)
838
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::RANDOM,
839
+ [Gruesome::Z::OperandType::LARGE],
840
+ [-1+65536], 130, nil, nil, 0)
841
+ @processor.execute(i)
842
+ @zork_memory.readv(130).should eql(0)
843
+ end
844
+
845
+ it "should return 0 when 0 is used to seed the generator" do
846
+ @zork_memory.writev(130, 11111)
847
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::RANDOM,
848
+ [Gruesome::Z::OperandType::LARGE],
849
+ [-1+65536], 130, nil, nil, 0)
850
+ @processor.execute(i)
851
+ @zork_memory.readv(130).should eql(0)
852
+ end
853
+
854
+ it "should be able to be seeded with a negative value such that the behavior is predicable" do
855
+ srand = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::RANDOM,
856
+ [Gruesome::Z::OperandType::LARGE],
857
+ [-1+65536], 130, nil, nil, 0)
858
+ @processor.execute(srand)
859
+
860
+ rnd = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::RANDOM,
861
+ [Gruesome::Z::OperandType::LARGE],
862
+ [1234], 130, nil, nil, 0)
863
+ @processor.execute(rnd)
864
+ store1 = @zork_memory.readv(130)
865
+ @processor.execute(rnd)
866
+ store2 = @zork_memory.readv(130)
867
+
868
+ @processor.execute(srand)
869
+
870
+ @processor.execute(rnd)
871
+ @zork_memory.readv(130).should eql(store1)
872
+ @processor.execute(rnd)
873
+ @zork_memory.readv(130).should eql(store2)
874
+ end
875
+ end
876
+ end
877
+
878
+ describe "Input Instruction" do
879
+ before(:each) do
880
+ # We take over stdin so that we can simulate the keyboard input
881
+ @stdin = $stdin
882
+
883
+ # sread text-buffer parse-buffer (v 1-3)
884
+
885
+ # text-buffer byte 0 indicates maximum length
886
+ # parse-buffer byte 0 indicates maximum words
887
+
888
+ @zork_memory.force_writeb(0x1000, 50)
889
+ end
890
+
891
+ after(:each) do
892
+ $stdin = @stdin
893
+
894
+ # The program counter should not be changed
895
+ @zork_memory.program_counter.should eql(12345)
896
+ end
897
+
898
+ describe "sread" do
899
+ it "should read in a line of text" do
900
+ $stdin = StringIO.new("foo bar johnson\n")
901
+
902
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::SREAD,
903
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
904
+ [0x1000, 0x1200], nil, nil, nil, 0)
905
+ @processor.execute(i)
906
+ end
907
+ end
908
+ end
909
+
910
+ describe "Output and Branching Instruction" do
911
+ before(:each) do
912
+ # We take over stdout so that we can see what it prints
913
+ @stdout = $stdout
914
+ $stdout = StringIO.new
915
+ end
916
+
917
+ after(:each) do
918
+ $stdout = @stdout
919
+ end
920
+
921
+ describe "print_ret" do
922
+ it "should return to the routine that called it" do
923
+ # set up a routine at address $2000
924
+ @zork_memory.force_writeb(0x2000, 2)
925
+ @zork_memory.force_writew(0x2001, 0)
926
+ @zork_memory.force_writew(0x2003, 0)
927
+
928
+ # The packed address is 0x2000 / 2
929
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
930
+ [Gruesome::Z::OperandType::LARGE],
931
+ [0x1000], 128, nil, nil, 0)
932
+
933
+ @processor.execute(i)
934
+
935
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PRINT_RET,
936
+ [Gruesome::Z::OperandType::STRING],
937
+ ["Hello World"], nil, nil, nil, 0)
938
+
939
+ @processor.execute(i)
940
+
941
+ @zork_memory.program_counter.should eql(12345)
942
+ end
943
+
944
+ it "should print out the string given as an operand followed by a newline to stdout" do
945
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PRINT_RET,
946
+ [Gruesome::Z::OperandType::STRING],
947
+ ["Hello World"], nil, nil, nil, 0)
948
+
949
+ @processor.execute(i)
950
+ $stdout.string.should eql("Hello World\n")
951
+ end
952
+
953
+ it "should as a return value set the variable indicated by the call with 1" do
954
+ # set up a routine at address $2000
955
+ @zork_memory.force_writeb(0x2000, 2)
956
+ @zork_memory.force_writew(0x2001, 0)
957
+ @zork_memory.force_writew(0x2003, 0)
958
+
959
+ # The packed address is 0x2000 / 2
960
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
961
+ [Gruesome::Z::OperandType::LARGE],
962
+ [0x1000], 128, nil, nil, 0)
963
+
964
+ @processor.execute(i)
965
+
966
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PRINT_RET,
967
+ [Gruesome::Z::OperandType::STRING],
968
+ ["Hello World"], nil, nil, nil, 0)
969
+
970
+ @processor.execute(i)
971
+
972
+ @zork_memory.readv(128).should eql(1)
973
+ end
974
+
975
+ it "should as a return value push 1 to the caller's stack when indicated" do
976
+ # set up a routine at address $2000
977
+ @zork_memory.force_writeb(0x2000, 2)
978
+ @zork_memory.force_writew(0x2001, 0)
979
+ @zork_memory.force_writew(0x2003, 0)
980
+ @zork_memory.writev(0, 11111)
981
+
982
+ # The packed address is 0x2000 / 2
983
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CALL,
984
+ [Gruesome::Z::OperandType::LARGE],
985
+ [0x1000], 0, nil, nil, 0)
986
+
987
+ @processor.execute(i)
988
+
989
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PRINT_RET,
990
+ [Gruesome::Z::OperandType::STRING],
991
+ ["Hello World"], nil, nil, nil, 0)
992
+
993
+ @processor.execute(i)
994
+
995
+ @zork_memory.readv(0).should eql(1)
996
+ @zork_memory.readv(0).should eql(11111)
997
+ end
998
+ end
999
+ end
1000
+
1001
+ describe "Output Instruction" do
1002
+ before(:each) do
1003
+ # We take over stdout so that we can see what it prints
1004
+ @stdout = $stdout
1005
+ $stdout = StringIO.new
1006
+ end
1007
+
1008
+ after(:each) do
1009
+ $stdout = @stdout
1010
+
1011
+ # The program counter should not be changed
1012
+ @zork_memory.program_counter.should eql(12345)
1013
+ end
1014
+
1015
+ describe "new_line" do
1016
+ it "should print a carriage return" do
1017
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::NEW_LINE,
1018
+ [], [], nil, nil, nil, 0)
1019
+ @processor.execute(i)
1020
+ $stdout.string.should eql("\n")
1021
+ end
1022
+ end
1023
+
1024
+ describe "print_char" do
1025
+ it "should print out the zchar given as an operand to stdout" do
1026
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PRINT_CHAR,
1027
+ [Gruesome::Z::OperandType::LARGE],
1028
+ [215], nil, nil, nil, 0)
1029
+
1030
+ @processor.execute(i)
1031
+ $stdout.string.should eql("\u00fe")
1032
+ end
1033
+ end
1034
+
1035
+ describe "print_num" do
1036
+ it "should print out a number given as an operand in decimal to stdout" do
1037
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PRINT_NUM,
1038
+ [Gruesome::Z::OperandType::LARGE],
1039
+ [12345], nil, nil, nil, 0)
1040
+
1041
+ @processor.execute(i)
1042
+ $stdout.string.should eql("12345")
1043
+ end
1044
+
1045
+ it "should print out a signed number given as an operand in decimal to stdout" do
1046
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PRINT_NUM,
1047
+ [Gruesome::Z::OperandType::LARGE],
1048
+ [-12345+65536], nil, nil, nil, 0)
1049
+
1050
+ @processor.execute(i)
1051
+ $stdout.string.should eql("-12345")
1052
+ end
1053
+ end
1054
+
1055
+ describe "print" do
1056
+ it "should print out the string given as an operand to stdout" do
1057
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PRINT,
1058
+ [Gruesome::Z::OperandType::STRING],
1059
+ ["Hello World"], nil, nil, nil, 0)
1060
+
1061
+ @processor.execute(i)
1062
+ $stdout.string.should eql("Hello World")
1063
+ end
1064
+ end
1065
+
1066
+ describe "print_addr" do
1067
+ it "should print out the string located at the byte address given by the operand" do
1068
+ # 'grue' is written at 0x4291
1069
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PRINT_ADDR,
1070
+ [Gruesome::Z::OperandType::LARGE],
1071
+ [0x4291], nil, nil, nil, 0)
1072
+
1073
+ @processor.execute(i)
1074
+ $stdout.string.should eql("grue")
1075
+ end
1076
+ end
1077
+
1078
+ describe "print_paddr" do
1079
+ it "should print out the string located at the packed address given by the operand" do
1080
+ # 'ZORK I: The Great Underground Empire' is written at 0x6ee4 (packed: 0x3772)
1081
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PRINT_PADDR,
1082
+ [Gruesome::Z::OperandType::LARGE],
1083
+ [0x3772], nil, nil, nil, 0)
1084
+
1085
+ @processor.execute(i)
1086
+ $stdout.string[/(.*)\n/,1].should eql("ZORK I: The Great Underground Empire")
1087
+ end
1088
+ end
1089
+
1090
+ describe "log_shift" do
1091
+ it "should shift left when places is positive" do
1092
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::LOG_SHIFT,
1093
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1094
+ [-12345+65536, 2], 128, nil, nil, 0)
1095
+
1096
+ @processor.execute(i)
1097
+
1098
+ @zork_memory.readv(128).should eql((((-12345+65536) << 2) & 65535))
1099
+ end
1100
+
1101
+ it "should shift right when places is positive and not sign extend" do
1102
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::LOG_SHIFT,
1103
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1104
+ [-123+65536, -2+65536], 128, nil, nil, 0)
1105
+
1106
+ @processor.execute(i)
1107
+
1108
+ @zork_memory.readv(128).should eql(((-123+65536) >> 2))
1109
+ end
1110
+ end
1111
+
1112
+ describe "not" do
1113
+ it "should perform a logical negation on the operand and assign to the appropriate variable" do
1114
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::NOT,
1115
+ [Gruesome::Z::OperandType::LARGE],
1116
+ [12345], 128, nil, nil, 0)
1117
+
1118
+ @processor.execute(i)
1119
+
1120
+ @zork_memory.readv(128).should eql((~12345)+65536)
1121
+ end
1122
+ end
1123
+
1124
+ describe "and" do
1125
+ it "should bitwise and two signed shorts together and assign to the appropriate variable" do
1126
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::AND,
1127
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1128
+ [-12345+65536, 12344], 128, nil, nil, 0)
1129
+
1130
+ @processor.execute(i)
1131
+
1132
+ @zork_memory.readv(128).should eql((-12345 & 12344) & 65535)
1133
+ end
1134
+ end
1135
+
1136
+ describe "or" do
1137
+ it "should bitwise or two signed shorts together and assign to the appropriate variable" do
1138
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::OR,
1139
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1140
+ [-12345+65536, 12344], 128, nil, nil, 0)
1141
+
1142
+ @processor.execute(i)
1143
1143
 
1144
- @zork_memory.readv(128).should eql((-12345 | 12344) & 65535)
1145
- end
1146
- end
1144
+ @zork_memory.readv(128).should eql((-12345 | 12344) & 65535)
1145
+ end
1146
+ end
1147
1147
 
1148
- describe "add" do
1149
- it "should add two signed shorts together and assign to the appropriate variable" do
1150
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::ADD,
1151
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1152
- [-12345+65536, 12344], 128, nil, nil, 0)
1148
+ describe "add" do
1149
+ it "should add two signed shorts together and assign to the appropriate variable" do
1150
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::ADD,
1151
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1152
+ [-12345+65536, 12344], 128, nil, nil, 0)
1153
1153
 
1154
- @processor.execute(i)
1154
+ @processor.execute(i)
1155
1155
 
1156
- @zork_memory.readv(128).should eql(-1+65536)
1157
- end
1158
- end
1156
+ @zork_memory.readv(128).should eql(-1+65536)
1157
+ end
1158
+ end
1159
1159
 
1160
- describe "sub" do
1161
- it "should subtract two signed shorts together and assign to the appropriate variable" do
1162
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::SUB,
1163
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1164
- [-12345+65536, 12344], 128, nil, nil, 0)
1160
+ describe "sub" do
1161
+ it "should subtract two signed shorts together and assign to the appropriate variable" do
1162
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::SUB,
1163
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1164
+ [-12345+65536, 12344], 128, nil, nil, 0)
1165
1165
 
1166
- @processor.execute(i)
1166
+ @processor.execute(i)
1167
1167
 
1168
- @zork_memory.readv(128).should eql(-24689+65536)
1169
- end
1170
- end
1168
+ @zork_memory.readv(128).should eql(-24689+65536)
1169
+ end
1170
+ end
1171
1171
 
1172
- describe "mul" do
1173
- it "should multiply two signed shorts together and assign to the appropriate variable" do
1174
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::MUL,
1175
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1176
- [-12345+65536, 12344], 128, nil, nil, 0)
1172
+ describe "mul" do
1173
+ it "should multiply two signed shorts together and assign to the appropriate variable" do
1174
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::MUL,
1175
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1176
+ [-12345+65536, 12344], 128, nil, nil, 0)
1177
1177
 
1178
- @processor.execute(i)
1178
+ @processor.execute(i)
1179
1179
 
1180
- @zork_memory.readv(128).should eql(50056)
1181
- end
1182
- end
1180
+ @zork_memory.readv(128).should eql(50056)
1181
+ end
1182
+ end
1183
1183
 
1184
- describe "div" do
1185
- it "should divide one negative and one positive short together and assign to the appropriate variable" do
1186
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::DIV,
1187
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1188
- [-11+65536, 2], 128, nil, nil, 0)
1184
+ describe "div" do
1185
+ it "should divide one negative and one positive short together and assign to the appropriate variable" do
1186
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::DIV,
1187
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1188
+ [-11+65536, 2], 128, nil, nil, 0)
1189
1189
 
1190
- @processor.execute(i)
1190
+ @processor.execute(i)
1191
1191
 
1192
- @zork_memory.readv(128).should eql(-5+65536)
1193
- end
1192
+ @zork_memory.readv(128).should eql(-5+65536)
1193
+ end
1194
1194
 
1195
- it "should divide one positive and one negative short together and assign to the appropriate variable" do
1196
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::DIV,
1197
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1198
- [11, -2+65536], 128, nil, nil, 0)
1195
+ it "should divide one positive and one negative short together and assign to the appropriate variable" do
1196
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::DIV,
1197
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1198
+ [11, -2+65536], 128, nil, nil, 0)
1199
1199
 
1200
- @processor.execute(i)
1200
+ @processor.execute(i)
1201
1201
 
1202
- @zork_memory.readv(128).should eql(-5+65536)
1203
- end
1202
+ @zork_memory.readv(128).should eql(-5+65536)
1203
+ end
1204
1204
 
1205
- it "should divide two positive shorts together and assign to the appropriate variable" do
1206
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::DIV,
1207
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1208
- [11, 2], 128, nil, nil, 0)
1205
+ it "should divide two positive shorts together and assign to the appropriate variable" do
1206
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::DIV,
1207
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1208
+ [11, 2], 128, nil, nil, 0)
1209
1209
 
1210
- @processor.execute(i)
1210
+ @processor.execute(i)
1211
1211
 
1212
- @zork_memory.readv(128).should eql(5)
1213
- end
1212
+ @zork_memory.readv(128).should eql(5)
1213
+ end
1214
1214
 
1215
- it "should divide two negative shorts together and assign to the appropriate variable" do
1216
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::DIV,
1217
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1218
- [-11+65536, -2+65536], 128, nil, nil, 0)
1215
+ it "should divide two negative shorts together and assign to the appropriate variable" do
1216
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::DIV,
1217
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1218
+ [-11+65536, -2+65536], 128, nil, nil, 0)
1219
1219
 
1220
- @processor.execute(i)
1220
+ @processor.execute(i)
1221
1221
 
1222
- @zork_memory.readv(128).should eql(5)
1223
- end
1224
- end
1222
+ @zork_memory.readv(128).should eql(5)
1223
+ end
1224
+ end
1225
1225
 
1226
- describe "mul" do
1227
- it "should modulo one negative and one positive short together and assign to the appropriate variable" do
1228
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::MOD,
1229
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1230
- [-13+65536, 5], 128, nil, nil, 0)
1226
+ describe "mul" do
1227
+ it "should modulo one negative and one positive short together and assign to the appropriate variable" do
1228
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::MOD,
1229
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1230
+ [-13+65536, 5], 128, nil, nil, 0)
1231
1231
 
1232
- @processor.execute(i)
1232
+ @processor.execute(i)
1233
1233
 
1234
- @zork_memory.readv(128).should eql(-3+65536)
1235
- end
1234
+ @zork_memory.readv(128).should eql(-3+65536)
1235
+ end
1236
1236
 
1237
- it "should modulo one positive and one negative short together and assign to the appropriate variable" do
1238
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::MOD,
1239
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1240
- [13, -5+65536], 128, nil, nil, 0)
1237
+ it "should modulo one positive and one negative short together and assign to the appropriate variable" do
1238
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::MOD,
1239
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1240
+ [13, -5+65536], 128, nil, nil, 0)
1241
1241
 
1242
- @processor.execute(i)
1242
+ @processor.execute(i)
1243
1243
 
1244
- @zork_memory.readv(128).should eql(3)
1245
- end
1244
+ @zork_memory.readv(128).should eql(3)
1245
+ end
1246
1246
 
1247
- it "should modulo two positive shorts together and assign to the appropriate variable" do
1248
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::MOD,
1249
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1250
- [13, 5], 128, nil, nil, 0)
1247
+ it "should modulo two positive shorts together and assign to the appropriate variable" do
1248
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::MOD,
1249
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1250
+ [13, 5], 128, nil, nil, 0)
1251
1251
 
1252
- @processor.execute(i)
1252
+ @processor.execute(i)
1253
1253
 
1254
- @zork_memory.readv(128).should eql(3)
1255
- end
1254
+ @zork_memory.readv(128).should eql(3)
1255
+ end
1256
1256
 
1257
- it "should modulo two negative shorts together and assign to the appropriate variable" do
1258
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::MOD,
1259
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1260
- [-13+65536, -5+65536], 128, nil, nil, 0)
1257
+ it "should modulo two negative shorts together and assign to the appropriate variable" do
1258
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::MOD,
1259
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1260
+ [-13+65536, -5+65536], 128, nil, nil, 0)
1261
1261
 
1262
- @processor.execute(i)
1262
+ @processor.execute(i)
1263
1263
 
1264
- @zork_memory.readv(128).should eql(-3+65536)
1265
- end
1266
- end
1267
- end
1264
+ @zork_memory.readv(128).should eql(-3+65536)
1265
+ end
1266
+ end
1267
+ end
1268
1268
 
1269
- describe "Object" do
1270
- before(:each) do
1271
- # Build object table
1272
- @zork_memory.force_writew(0x0a, 0x200)
1269
+ describe "Object" do
1270
+ before(:each) do
1271
+ # Build object table
1272
+ @zork_memory.force_writew(0x0a, 0x200)
1273
1273
 
1274
- # Build property defaults (for versions 1-3)
1275
- # Each property will have the default value as
1276
- # equally the property number (remember properties
1277
- # start counting at 1)
1278
- 31.times do |i|
1279
- @zork_memory.force_writew(0x200 + (i*2), i+1)
1280
- end
1281
- addr = 0x200 + (31 * 2)
1274
+ # Build property defaults (for versions 1-3)
1275
+ # Each property will have the default value as
1276
+ # equally the property number (remember properties
1277
+ # start counting at 1)
1278
+ 31.times do |i|
1279
+ @zork_memory.force_writew(0x200 + (i*2), i+1)
1280
+ end
1281
+ addr = 0x200 + (31 * 2)
1282
1282
 
1283
- # Build a couple of objects
1283
+ # Build a couple of objects
1284
1284
 
1285
- # Object #1
1285
+ # Object #1
1286
1286
 
1287
- # Attributes: 2, 3, 10, 31
1288
- # Parent: nil
1289
- # Sibling: nil
1290
- # Child: #2
1287
+ # Attributes: 2, 3, 10, 31
1288
+ # Parent: nil
1289
+ # Sibling: nil
1290
+ # Child: #2
1291
1291
 
1292
- @zork_memory.force_writeb(addr+0, 0b00110000)
1293
- @zork_memory.force_writeb(addr+1, 0b00100000)
1294
- @zork_memory.force_writeb(addr+2, 0b00000000)
1295
- @zork_memory.force_writeb(addr+3, 0b00000001)
1292
+ @zork_memory.force_writeb(addr+0, 0b00110000)
1293
+ @zork_memory.force_writeb(addr+1, 0b00100000)
1294
+ @zork_memory.force_writeb(addr+2, 0b00000000)
1295
+ @zork_memory.force_writeb(addr+3, 0b00000001)
1296
1296
 
1297
- @zork_memory.force_writeb(addr+4, 0)
1298
- @zork_memory.force_writeb(addr+5, 0)
1299
- @zork_memory.force_writeb(addr+6, 2)
1297
+ @zork_memory.force_writeb(addr+4, 0)
1298
+ @zork_memory.force_writeb(addr+5, 0)
1299
+ @zork_memory.force_writeb(addr+6, 2)
1300
1300
 
1301
- @zork_memory.force_writew(addr+7, 0x300)
1301
+ @zork_memory.force_writew(addr+7, 0x300)
1302
1302
 
1303
- addr += 9
1303
+ addr += 9
1304
1304
 
1305
- # Object #2
1305
+ # Object #2
1306
1306
 
1307
- # Attributes: 5, 7, 11, 18, 25
1308
- # Parent: #1
1309
- # Sibling: #3
1310
- # Child: nil
1307
+ # Attributes: 5, 7, 11, 18, 25
1308
+ # Parent: #1
1309
+ # Sibling: #3
1310
+ # Child: nil
1311
1311
 
1312
- @zork_memory.force_writeb(addr+0, 0b00000101)
1313
- @zork_memory.force_writeb(addr+1, 0b00010000)
1314
- @zork_memory.force_writeb(addr+2, 0b00100000)
1315
- @zork_memory.force_writeb(addr+3, 0b01000001)
1312
+ @zork_memory.force_writeb(addr+0, 0b00000101)
1313
+ @zork_memory.force_writeb(addr+1, 0b00010000)
1314
+ @zork_memory.force_writeb(addr+2, 0b00100000)
1315
+ @zork_memory.force_writeb(addr+3, 0b01000001)
1316
1316
 
1317
- @zork_memory.force_writeb(addr+4, 1)
1318
- @zork_memory.force_writeb(addr+5, 3)
1319
- @zork_memory.force_writeb(addr+6, 0)
1320
-
1321
- @zork_memory.force_writew(addr+7, 0x300)
1322
-
1323
- addr += 9
1324
-
1325
- # Object #3
1326
-
1327
- # Attributes: 0
1328
- # Parent: #1
1329
- # Sibling: #2
1330
- # Child: nil
1317
+ @zork_memory.force_writeb(addr+4, 1)
1318
+ @zork_memory.force_writeb(addr+5, 3)
1319
+ @zork_memory.force_writeb(addr+6, 0)
1320
+
1321
+ @zork_memory.force_writew(addr+7, 0x300)
1322
+
1323
+ addr += 9
1324
+
1325
+ # Object #3
1326
+
1327
+ # Attributes: 0
1328
+ # Parent: #1
1329
+ # Sibling: #2
1330
+ # Child: nil
1331
1331
 
1332
- @zork_memory.force_writeb(addr+0, 0b10000000)
1333
- @zork_memory.force_writeb(addr+1, 0b00000000)
1334
- @zork_memory.force_writeb(addr+2, 0b00000000)
1335
- @zork_memory.force_writeb(addr+3, 0b00000000)
1336
-
1337
- @zork_memory.force_writeb(addr+4, 1)
1338
- @zork_memory.force_writeb(addr+5, 2)
1339
- @zork_memory.force_writeb(addr+6, 0)
1340
-
1341
- @zork_memory.force_writew(addr+7, 0x4290)
1342
-
1343
- addr += 9
1344
-
1345
- # Properties Table
1346
- #
1347
- # 'grue' is written at 0x4291
1348
- # So, lets abuse that
1349
- #
1350
- # Give the short-name a length of 4
1351
- @zork_memory.force_writeb(0x4290, 2)
1352
-
1353
- # Now the property list
1354
- written_size = (2 - 1) << 5
1355
- property_number = 15
1356
- @zork_memory.force_writeb(0x4295, written_size + property_number)
1357
- @zork_memory.force_writew(0x4296, 34567)
1358
-
1359
- written_size = (1 - 1) << 5
1360
- property_number = 20
1361
- @zork_memory.force_writeb(0x4298, written_size + property_number)
1362
- @zork_memory.force_writeb(0x4299, 123)
1363
-
1364
- # End list
1365
- @zork_memory.force_writeb(0x429a, 0)
1366
-
1367
- @object_table = Gruesome::Z::ObjectTable.new(@zork_memory)
1368
-
1369
- # need to reinstantiate the processor
1370
- @processor = Gruesome::Z::Processor.new(@zork_memory)
1371
- end
1372
-
1373
- describe "Output Instruction" do
1374
- before(:each) do
1375
- # We take over stdout so that we can see what it prints
1376
- @stdout = $stdout
1377
- $stdout = StringIO.new
1378
- end
1379
-
1380
- after(:each) do
1381
- $stdout = @stdout
1382
-
1383
- # The program counter should not be changed
1384
- @zork_memory.program_counter.should eql(12345)
1385
- end
1386
-
1387
- describe "print_obj" do
1388
- it "should print to stdout out the short name of the object whose index is given as an operand" do
1389
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PRINT_OBJ,
1390
- [Gruesome::Z::OperandType::LARGE],
1391
- [3], nil, nil, nil, 0)
1392
-
1393
- @processor.execute(i)
1394
- $stdout.string.should eql("grue")
1395
- end
1396
- end
1397
- end
1398
-
1399
- describe "Branch Instruction" do
1400
- describe "get_child" do
1401
- # Note:
1402
- # - Object 1 has one child: Object 2
1403
- # - Object 2 has no children
1404
-
1405
- it "should not branch if the child object index of the requested object is 0" do
1406
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_CHILD,
1407
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1408
- [2], 128, 2000, true, 0)
1409
-
1410
- @processor.execute(i)
1411
- @zork_memory.program_counter.should eql(12345)
1412
- end
1413
-
1414
- it "should branch if the child object index exists for the requested object" do
1415
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_CHILD,
1416
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1417
- [1], 128, 2000, true, 0)
1418
- @processor.execute(i)
1419
- @zork_memory.program_counter.should eql(2000)
1420
- end
1421
-
1422
- it "should branch if the child object index of the requested object is 0 and condition is negated" do
1423
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_CHILD,
1424
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1425
- [2], 128, 2000, false, 0)
1426
-
1427
- @processor.execute(i)
1428
- @zork_memory.program_counter.should eql(2000)
1429
- end
1430
-
1431
- it "should not branch if the child object index exists for the requested object and condition is negated" do
1432
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_CHILD,
1433
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1434
- [1], 128, 2000, false, 0)
1435
- @processor.execute(i)
1436
- @zork_memory.program_counter.should eql(12345)
1437
- end
1438
-
1439
-
1440
- it "should store the child object index to the destination variable" do
1441
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_CHILD,
1442
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1443
- [1], 128, 2000, true, 0)
1444
- @processor.execute(i)
1445
- @zork_memory.readv(128).should eql(2)
1446
- end
1447
- end
1448
-
1449
- describe "get_sibling" do
1450
- # Note:
1451
- # - Object 1 has no siblings
1452
- # - Object 2 has one sibling: Object 3
1453
-
1454
- it "should not branch if the sibling object index of the requested object is 0" do
1455
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_SIBLING,
1456
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1457
- [1], 128, 2000, true, 0)
1458
-
1459
- @processor.execute(i)
1460
- @zork_memory.program_counter.should eql(12345)
1461
- end
1462
-
1463
- it "should branch if the sibling object index exists for the requested object" do
1464
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_SIBLING,
1465
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1466
- [2], 128, 2000, true, 0)
1467
- @processor.execute(i)
1468
- @zork_memory.program_counter.should eql(2000)
1469
- end
1470
-
1471
- it "should branch if the sibling object index of the requested object is 0 and condition is negated" do
1472
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_SIBLING,
1473
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1474
- [1], 128, 2000, false, 0)
1475
-
1476
- @processor.execute(i)
1477
- @zork_memory.program_counter.should eql(2000)
1478
- end
1479
-
1480
- it "should not branch if the sibling object index exists for the requested object and condition is negated" do
1481
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_SIBLING,
1482
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1483
- [2], 128, 2000, false, 0)
1484
- @processor.execute(i)
1485
- @zork_memory.program_counter.should eql(12345)
1486
- end
1487
-
1488
-
1489
- it "should store the sibling object index to the destination variable" do
1490
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_SIBLING,
1491
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1492
- [2], 128, 2000, true, 0)
1493
- @processor.execute(i)
1494
- @zork_memory.readv(128).should eql(3)
1495
- end
1496
- end
1497
-
1498
- describe "get_parent" do
1499
- # Note:
1500
- # - Object 1 has no parents
1501
- # - Object 2 has a parent: Object 1
1502
-
1503
- it "should store the parent object index to the destination variable" do
1504
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_PARENT,
1505
- [Gruesome::Z::OperandType::LARGE],
1506
- [2], 128, 2000, true, 0)
1507
- @processor.execute(i)
1508
- @zork_memory.readv(128).should eql(1)
1509
- end
1510
- end
1511
-
1512
- describe "jin" do
1513
- # Note:
1514
- # - Object 1 has no parents
1515
- # - Object 2 has a parent: Object 1
1516
-
1517
- it "should not branch if the given object is not a child of the other" do
1518
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JIN,
1519
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1520
- [1, 2], 128, 2000, true, 0)
1521
-
1522
- @processor.execute(i)
1523
- @zork_memory.program_counter.should eql(12345)
1524
- end
1525
-
1526
- it "should branch if the given object is a child of the other" do
1527
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JIN,
1528
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1529
- [2,1], 128, 2000, true, 0)
1530
- @processor.execute(i)
1531
- @zork_memory.program_counter.should eql(2000)
1532
- end
1533
-
1534
- it "should branch if the given object is not a child of the other and condition is negated" do
1535
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JIN,
1536
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1537
- [1, 2], 128, 2000, false, 0)
1538
-
1539
- @processor.execute(i)
1540
- @zork_memory.program_counter.should eql(2000)
1541
- end
1542
-
1543
- it "should not branch if the given object is a child of the other and condition is negated" do
1544
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JIN,
1545
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1546
- [2,1], 128, 2000, false, 0)
1547
- @processor.execute(i)
1548
- @zork_memory.program_counter.should eql(12345)
1549
- end
1550
- end
1551
-
1552
- describe "test_attr" do
1553
- it "should branch if the object has the attribute set" do
1554
- @object_table.object_has_attribute?(1, 10).should eql(true)
1555
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::TEST_ATTR,
1556
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1557
- [1, 10], nil, 2000, true, 0)
1558
-
1559
- @processor.execute(i)
1560
- @zork_memory.program_counter.should eql(2000)
1561
- end
1562
-
1563
- it "should not branch if the object does not have the attribute set" do
1564
- @object_table.object_has_attribute?(1, 11).should eql(false)
1565
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::TEST_ATTR,
1566
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1567
- [1, 11], nil, 2000, true, 0)
1568
-
1569
- @processor.execute(i)
1570
- @zork_memory.program_counter.should eql(12345)
1571
- end
1572
-
1573
- it "should not branch if the first operand has all bits set that the second has set and condition is negated" do
1574
- @object_table.object_has_attribute?(1, 10).should eql(true)
1575
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::TEST_ATTR,
1576
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1577
- [1, 10], nil, 2000, false, 0)
1578
-
1579
- @processor.execute(i)
1580
- @zork_memory.program_counter.should eql(12345)
1581
- end
1582
-
1583
- it "should branch if the first operand does not have all bits set that the second has set and condition is negated" do
1584
- @object_table.object_has_attribute?(1, 11).should eql(false)
1585
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::TEST_ATTR,
1586
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1587
- [1, 11], nil, 2000, false, 0)
1588
-
1589
- @processor.execute(i)
1590
- @zork_memory.program_counter.should eql(2000)
1591
- end
1592
-
1593
- end
1594
- end
1595
-
1596
- describe "Instruction" do
1597
- after(:each) do
1598
- # The program counter should not be changed
1599
- @zork_memory.program_counter.should eql(12345)
1600
- end
1601
-
1602
- describe "put_prop" do
1603
- it "should set the property in the object's list when it is a byte" do
1604
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PUT_PROP,
1605
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1606
- [3, 20, 234], nil, nil, nil, 0)
1607
- @processor.execute(i)
1608
- @object_table.object_get_property_word(3, 20).should eql(234)
1609
- end
1610
-
1611
- it "should store the least significant part of the value to the property in the object's list when the property is a byte" do
1612
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PUT_PROP,
1613
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1614
- [3, 20, 0x5432], nil, nil, nil, 0)
1615
- @processor.execute(i)
1616
- @object_table.object_get_property_word(3, 20).should eql(0x32)
1617
- end
1618
-
1619
- it "should set the property in the object's list when it is a word" do
1620
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PUT_PROP,
1621
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1622
- [3, 15, 54321], nil, nil, nil, 0)
1623
- @processor.execute(i)
1624
- @object_table.object_get_property_word(3, 15).should eql(54321)
1625
- end
1626
-
1627
- # XXX: Check for halt when property does not exist
1628
- end
1629
-
1630
- describe "get_prop" do
1631
- it "should retrieve the property in the object's list when it is a byte" do
1632
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_PROP,
1633
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1634
- [3, 20], 128, nil, nil, 0)
1635
- @processor.execute(i)
1636
- @zork_memory.readv(128).should eql(123)
1637
- end
1638
-
1639
- it "should retrieve the property in the object's list when it is a word" do
1640
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_PROP,
1641
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1642
- [3, 15], 128, nil, nil, 0)
1643
- @processor.execute(i)
1644
- @zork_memory.readv(128).should eql(34567)
1645
- end
1646
-
1647
- it "should retrieve the default property when the object list does not have the property listed" do
1648
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_PROP,
1649
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1650
- [3, 28], 128, nil, nil, 0)
1651
- @processor.execute(i)
1652
- @zork_memory.readv(128).should eql(28)
1653
- end
1654
- end
1655
-
1656
- describe "get_prop_addr" do
1657
- it "should retrieve the address of the property in the object's list" do
1658
- @zork_memory.writev(128, 11111)
1659
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_PROP_ADDR,
1660
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1661
- [3, 20], 128, nil, nil, 0)
1662
- @processor.execute(i)
1663
- @zork_memory.readv(128).should eql(0x4299)
1664
- end
1665
-
1666
- it "should set the variable given to 0 when the property is not in the object's list" do
1667
- @zork_memory.writev(128, 11111)
1668
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_PROP_ADDR,
1669
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1670
- [3, 28], 128, nil, nil, 0)
1671
- @processor.execute(i)
1672
- @zork_memory.readv(128).should eql(0)
1673
- end
1674
- end
1675
-
1676
- describe "get_prop_len" do
1677
- it "should retrieve the property data size for the byte property in the object's list" do
1678
- @zork_memory.writev(128, 11111)
1679
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_PROP_LEN,
1680
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1681
- [0x4299], 128, nil, nil, 0)
1682
- @processor.execute(i)
1683
- @zork_memory.readv(128).should eql(1)
1684
- end
1685
-
1686
- it "should retrieve the property data size for the word property in the object's list" do
1687
- @zork_memory.writev(128, 11111)
1688
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_PROP_LEN,
1689
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1690
- [0x4296], 128, nil, nil, 0)
1691
- @processor.execute(i)
1692
- @zork_memory.readv(128).should eql(2)
1693
- end
1694
-
1695
- it "should return 0 when the property address given is 0" do
1696
- @zork_memory.writev(128, 11111)
1697
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_PROP_LEN,
1698
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1699
- [0], 128, nil, nil, 0)
1700
- @processor.execute(i)
1701
- @zork_memory.readv(128).should eql(0)
1702
- end
1703
- end
1704
-
1705
- describe "insert_obj" do
1706
- it "should insert the object given as the child of the other object given" do
1707
- @object_table.object_get_child(2).should eql(0)
1708
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::INSERT_OBJ,
1709
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1710
- [3, 2], nil, nil, nil, 0)
1711
- @processor.execute(i)
1712
-
1713
- @object_table.object_get_child(2).should eql(3)
1714
- end
1715
-
1716
- it "should set the sibling of the given object as the previous child of the other object given" do
1717
- @object_table.object_get_sibling(3).should eql(2)
1718
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::INSERT_OBJ,
1719
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1720
- [3, 2], nil, nil, nil, 0)
1721
- @processor.execute(i)
1722
-
1723
- @object_table.object_get_sibling(3).should eql(0)
1724
- end
1725
- end
1726
-
1727
- describe "remove_obj" do
1728
- it "should clear the parent of the given object" do
1729
- @object_table.object_get_parent(2).should eql(1)
1730
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::REMOVE_OBJ,
1731
- [Gruesome::Z::OperandType::LARGE],
1732
- [2], nil, nil, nil, 0)
1733
- @processor.execute(i)
1734
-
1735
- @object_table.object_get_parent(2).should eql(0)
1736
- end
1737
- end
1738
-
1739
-
1740
- describe "clear_attr" do
1741
- it "should clear the attribute when it exists in the object attribute list without altering other attributes" do
1742
- @object_table.object_has_attribute?(2, 25).should eql(true)
1743
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CLEAR_ATTR,
1744
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1745
- [2, 25], nil, nil, nil, 0)
1746
- @processor.execute(i)
1747
-
1748
- @object_table.object_has_attribute?(2, 25).should eql(false)
1749
- @object_table.object_has_attribute?(2, 31).should eql(true)
1750
- end
1751
-
1752
- it "should do nothing when the attribute is already cleared" do
1753
- @object_table.object_has_attribute?(2, 26).should eql(false)
1754
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CLEAR_ATTR,
1755
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1756
- [2, 26], nil, nil, nil, 0)
1757
- @processor.execute(i)
1758
-
1759
- @object_table.object_has_attribute?(2, 26).should eql(false)
1760
- @object_table.object_has_attribute?(2, 31).should eql(true)
1761
- end
1762
- end
1763
-
1764
- describe "set_attr" do
1765
- it "should set the attribute when it exists in the object attribute list without altering other attributes" do
1766
- @object_table.object_has_attribute?(2, 26).should eql(false)
1767
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::SET_ATTR,
1768
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1769
- [2, 26], nil, nil, nil, 0)
1770
- @processor.execute(i)
1771
-
1772
- @object_table.object_has_attribute?(2, 26).should eql(true)
1773
- @object_table.object_has_attribute?(2, 31).should eql(true)
1774
- end
1775
-
1776
- it "should do nothing when the attribute is already set" do
1777
- @object_table.object_has_attribute?(2, 25).should eql(true)
1778
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::SET_ATTR,
1779
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1780
- [2, 25], nil, nil, nil, 0)
1781
- @processor.execute(i)
1782
-
1783
- @object_table.object_has_attribute?(2, 25).should eql(true)
1784
- @object_table.object_has_attribute?(2, 31).should eql(true)
1785
- end
1786
- end
1787
- end
1788
- end
1789
-
1790
- describe "Instruction" do
1791
- after(:each) do
1792
- # The program counter should not be changed
1793
- @zork_memory.program_counter.should eql(12345)
1794
- end
1795
-
1796
- describe "store" do
1797
- it "should store the value into the variable referenced by the operand" do
1798
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::STORE,
1799
- [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
1800
- [128, -13+65536], nil, nil, nil, 0)
1801
-
1802
- @processor.execute(i)
1803
-
1804
- @zork_memory.readv(128).should eql(-13+65536)
1805
- end
1806
-
1807
- it "should write to the stack in-place when variable %00 is used" do
1808
- @zork_memory.writev(0, 11111)
1809
- @zork_memory.writev(0, 12345)
1810
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::STORE,
1811
- [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
1812
- [0, -13+65536], nil, nil, nil, 0)
1813
-
1814
- @processor.execute(i)
1815
-
1816
- @zork_memory.readv(0).should eql(-13+65536)
1817
- @zork_memory.readv(0).should eql(11111)
1818
- end
1819
- end
1820
-
1821
- describe "storeb" do
1822
- it "should store the byte given into the byte address given by the operands providing base and offset" do
1823
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::STOREB,
1824
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1825
- [2000, 100, 123], nil, nil, nil, 0)
1826
-
1827
- @processor.execute(i)
1828
-
1829
- @zork_memory.force_readb(2000+100).should eql(123)
1830
- end
1831
- end
1832
-
1833
- describe "storew" do
1834
- it "should store the word given into the byte address given by the operands providing base and offset" do
1835
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::STOREW,
1836
- [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1837
- [2000, 100, 12345], nil, nil, nil, 0)
1838
-
1839
- @processor.execute(i)
1840
-
1841
- @zork_memory.force_readw(2000+200).should eql(12345)
1842
- end
1843
- end
1844
-
1845
- describe "pull" do
1846
- it "should pop the value from the stack that was most recently pushed" do
1847
- @zork_memory.writev(0, 23456)
1848
- @zork_memory.writev(0, 34567)
1849
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PULL,
1850
- [Gruesome::Z::OperandType::VARIABLE], [128], nil, nil, nil, 0)
1851
-
1852
- @processor.execute(i)
1853
- @zork_memory.readv(128).should eql(34567)
1854
- @zork_memory.readv(0).should eql(23456)
1855
- end
1856
-
1857
- it "should not change the stack if the given variable is %00" do
1858
- @zork_memory.writev(0, 23456)
1859
- @zork_memory.writev(0, 34567)
1860
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PULL,
1861
- [Gruesome::Z::OperandType::VARIABLE], [0], nil, nil, nil, 0)
1862
-
1863
- @processor.execute(i)
1864
- @zork_memory.readv(0).should eql(34567)
1865
- @zork_memory.readv(0).should eql(23456)
1866
- end
1867
- end
1868
-
1869
- describe "push" do
1870
- it "should push the value on the stack such that a read of variable %00 will yield that value" do
1871
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PUSH,
1872
- [Gruesome::Z::OperandType::LARGE],
1873
- [23456], nil, nil, nil, 0)
1874
-
1875
- @processor.execute(i)
1876
-
1877
- @zork_memory.readv(0).should eql(23456)
1878
- end
1879
- end
1880
-
1881
- describe "pop" do
1882
- it "should throw away the most recently pushed item on the stack" do
1883
- @zork_memory.writev(0, 23456)
1884
- @zork_memory.writev(0, 34567)
1885
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::POP,
1886
- [], [], nil, nil, nil, 0)
1887
-
1888
- @processor.execute(i)
1889
- @zork_memory.readv(0).should eql(23456)
1890
- end
1891
- end
1892
-
1893
- describe "dec" do
1894
- it "should decrement the value in the variable given as the operand" do
1895
- @zork_memory.writev(128, 12345)
1896
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::DEC,
1897
- [Gruesome::Z::OperandType::VARIABLE],
1898
- [128], nil, nil, nil, 0)
1899
- @processor.execute(i)
1900
- @zork_memory.readv(128).should eql(12344)
1901
- end
1902
-
1903
- it "should consider the value signed and decrement 0 to -1" do
1904
- @zork_memory.writev(128, 0)
1905
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::DEC,
1906
- [Gruesome::Z::OperandType::VARIABLE],
1907
- [128], nil, nil, nil, 0)
1908
- @processor.execute(i)
1909
- @zork_memory.readv(128).should eql(-1+65536)
1910
- end
1911
-
1912
- it "should edit the value on the stack in place" do
1913
- @zork_memory.writev(0, 11111)
1914
- @zork_memory.writev(0, 12345)
1915
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::DEC,
1916
- [Gruesome::Z::OperandType::VARIABLE],
1917
- [0], nil, nil, nil, 0)
1918
- @processor.execute(i)
1919
- @zork_memory.readv(0).should eql(12344)
1920
- @zork_memory.readv(0).should eql(11111)
1921
- end
1922
- end
1923
-
1924
- describe "inc" do
1925
- it "should increment the value in the variable given as the operand" do
1926
- @zork_memory.writev(128, 12345)
1927
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::INC,
1928
- [Gruesome::Z::OperandType::VARIABLE],
1929
- [128], nil, nil, nil, 0)
1930
- @processor.execute(i)
1931
- @zork_memory.readv(128).should eql(12346)
1932
- end
1933
-
1934
- it "should consider the value signed and increment -1 to 0" do
1935
- @zork_memory.writev(128, -1+65536)
1936
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::INC,
1937
- [Gruesome::Z::OperandType::VARIABLE],
1938
- [128], nil, nil, nil, 0)
1939
- @processor.execute(i)
1940
- @zork_memory.readv(128).should eql(0)
1941
- end
1942
-
1943
- it "should edit the value on the stack in place" do
1944
- @zork_memory.writev(0, 11111)
1945
- @zork_memory.writev(0, 12345)
1946
- i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::INC,
1947
- [Gruesome::Z::OperandType::VARIABLE],
1948
- [0], nil, nil, nil, 0)
1949
- @processor.execute(i)
1950
- @zork_memory.readv(0).should eql(12346)
1951
- @zork_memory.readv(0).should eql(11111)
1952
- end
1953
- end
1954
- end
1955
- end
1332
+ @zork_memory.force_writeb(addr+0, 0b10000000)
1333
+ @zork_memory.force_writeb(addr+1, 0b00000000)
1334
+ @zork_memory.force_writeb(addr+2, 0b00000000)
1335
+ @zork_memory.force_writeb(addr+3, 0b00000000)
1336
+
1337
+ @zork_memory.force_writeb(addr+4, 1)
1338
+ @zork_memory.force_writeb(addr+5, 2)
1339
+ @zork_memory.force_writeb(addr+6, 0)
1340
+
1341
+ @zork_memory.force_writew(addr+7, 0x4290)
1342
+
1343
+ addr += 9
1344
+
1345
+ # Properties Table
1346
+ #
1347
+ # 'grue' is written at 0x4291
1348
+ # So, lets abuse that
1349
+ #
1350
+ # Give the short-name a length of 4
1351
+ @zork_memory.force_writeb(0x4290, 2)
1352
+
1353
+ # Now the property list
1354
+ written_size = (2 - 1) << 5
1355
+ property_number = 15
1356
+ @zork_memory.force_writeb(0x4295, written_size + property_number)
1357
+ @zork_memory.force_writew(0x4296, 34567)
1358
+
1359
+ written_size = (1 - 1) << 5
1360
+ property_number = 20
1361
+ @zork_memory.force_writeb(0x4298, written_size + property_number)
1362
+ @zork_memory.force_writeb(0x4299, 123)
1363
+
1364
+ # End list
1365
+ @zork_memory.force_writeb(0x429a, 0)
1366
+
1367
+ @object_table = Gruesome::Z::ObjectTable.new(@zork_memory)
1368
+
1369
+ # need to reinstantiate the processor
1370
+ @processor = Gruesome::Z::Processor.new(@zork_memory)
1371
+ end
1372
+
1373
+ describe "Output Instruction" do
1374
+ before(:each) do
1375
+ # We take over stdout so that we can see what it prints
1376
+ @stdout = $stdout
1377
+ $stdout = StringIO.new
1378
+ end
1379
+
1380
+ after(:each) do
1381
+ $stdout = @stdout
1382
+
1383
+ # The program counter should not be changed
1384
+ @zork_memory.program_counter.should eql(12345)
1385
+ end
1386
+
1387
+ describe "print_obj" do
1388
+ it "should print to stdout out the short name of the object whose index is given as an operand" do
1389
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PRINT_OBJ,
1390
+ [Gruesome::Z::OperandType::LARGE],
1391
+ [3], nil, nil, nil, 0)
1392
+
1393
+ @processor.execute(i)
1394
+ $stdout.string.should eql("grue")
1395
+ end
1396
+ end
1397
+ end
1398
+
1399
+ describe "Branch Instruction" do
1400
+ describe "get_child" do
1401
+ # Note:
1402
+ # - Object 1 has one child: Object 2
1403
+ # - Object 2 has no children
1404
+
1405
+ it "should not branch if the child object index of the requested object is 0" do
1406
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_CHILD,
1407
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1408
+ [2], 128, 2000, true, 0)
1409
+
1410
+ @processor.execute(i)
1411
+ @zork_memory.program_counter.should eql(12345)
1412
+ end
1413
+
1414
+ it "should branch if the child object index exists for the requested object" do
1415
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_CHILD,
1416
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1417
+ [1], 128, 2000, true, 0)
1418
+ @processor.execute(i)
1419
+ @zork_memory.program_counter.should eql(2000)
1420
+ end
1421
+
1422
+ it "should branch if the child object index of the requested object is 0 and condition is negated" do
1423
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_CHILD,
1424
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1425
+ [2], 128, 2000, false, 0)
1426
+
1427
+ @processor.execute(i)
1428
+ @zork_memory.program_counter.should eql(2000)
1429
+ end
1430
+
1431
+ it "should not branch if the child object index exists for the requested object and condition is negated" do
1432
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_CHILD,
1433
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1434
+ [1], 128, 2000, false, 0)
1435
+ @processor.execute(i)
1436
+ @zork_memory.program_counter.should eql(12345)
1437
+ end
1438
+
1439
+
1440
+ it "should store the child object index to the destination variable" do
1441
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_CHILD,
1442
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1443
+ [1], 128, 2000, true, 0)
1444
+ @processor.execute(i)
1445
+ @zork_memory.readv(128).should eql(2)
1446
+ end
1447
+ end
1448
+
1449
+ describe "get_sibling" do
1450
+ # Note:
1451
+ # - Object 1 has no siblings
1452
+ # - Object 2 has one sibling: Object 3
1453
+
1454
+ it "should not branch if the sibling object index of the requested object is 0" do
1455
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_SIBLING,
1456
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1457
+ [1], 128, 2000, true, 0)
1458
+
1459
+ @processor.execute(i)
1460
+ @zork_memory.program_counter.should eql(12345)
1461
+ end
1462
+
1463
+ it "should branch if the sibling object index exists for the requested object" do
1464
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_SIBLING,
1465
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1466
+ [2], 128, 2000, true, 0)
1467
+ @processor.execute(i)
1468
+ @zork_memory.program_counter.should eql(2000)
1469
+ end
1470
+
1471
+ it "should branch if the sibling object index of the requested object is 0 and condition is negated" do
1472
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_SIBLING,
1473
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1474
+ [1], 128, 2000, false, 0)
1475
+
1476
+ @processor.execute(i)
1477
+ @zork_memory.program_counter.should eql(2000)
1478
+ end
1479
+
1480
+ it "should not branch if the sibling object index exists for the requested object and condition is negated" do
1481
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_SIBLING,
1482
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1483
+ [2], 128, 2000, false, 0)
1484
+ @processor.execute(i)
1485
+ @zork_memory.program_counter.should eql(12345)
1486
+ end
1487
+
1488
+
1489
+ it "should store the sibling object index to the destination variable" do
1490
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_SIBLING,
1491
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1492
+ [2], 128, 2000, true, 0)
1493
+ @processor.execute(i)
1494
+ @zork_memory.readv(128).should eql(3)
1495
+ end
1496
+ end
1497
+
1498
+ describe "get_parent" do
1499
+ # Note:
1500
+ # - Object 1 has no parents
1501
+ # - Object 2 has a parent: Object 1
1502
+
1503
+ it "should store the parent object index to the destination variable" do
1504
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_PARENT,
1505
+ [Gruesome::Z::OperandType::LARGE],
1506
+ [2], 128, 2000, true, 0)
1507
+ @processor.execute(i)
1508
+ @zork_memory.readv(128).should eql(1)
1509
+ end
1510
+ end
1511
+
1512
+ describe "jin" do
1513
+ # Note:
1514
+ # - Object 1 has no parents
1515
+ # - Object 2 has a parent: Object 1
1516
+
1517
+ it "should not branch if the given object is not a child of the other" do
1518
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JIN,
1519
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1520
+ [1, 2], 128, 2000, true, 0)
1521
+
1522
+ @processor.execute(i)
1523
+ @zork_memory.program_counter.should eql(12345)
1524
+ end
1525
+
1526
+ it "should branch if the given object is a child of the other" do
1527
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JIN,
1528
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1529
+ [2,1], 128, 2000, true, 0)
1530
+ @processor.execute(i)
1531
+ @zork_memory.program_counter.should eql(2000)
1532
+ end
1533
+
1534
+ it "should branch if the given object is not a child of the other and condition is negated" do
1535
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JIN,
1536
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1537
+ [1, 2], 128, 2000, false, 0)
1538
+
1539
+ @processor.execute(i)
1540
+ @zork_memory.program_counter.should eql(2000)
1541
+ end
1542
+
1543
+ it "should not branch if the given object is a child of the other and condition is negated" do
1544
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::JIN,
1545
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1546
+ [2,1], 128, 2000, false, 0)
1547
+ @processor.execute(i)
1548
+ @zork_memory.program_counter.should eql(12345)
1549
+ end
1550
+ end
1551
+
1552
+ describe "test_attr" do
1553
+ it "should branch if the object has the attribute set" do
1554
+ @object_table.object_has_attribute?(1, 10).should eql(true)
1555
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::TEST_ATTR,
1556
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1557
+ [1, 10], nil, 2000, true, 0)
1558
+
1559
+ @processor.execute(i)
1560
+ @zork_memory.program_counter.should eql(2000)
1561
+ end
1562
+
1563
+ it "should not branch if the object does not have the attribute set" do
1564
+ @object_table.object_has_attribute?(1, 11).should eql(false)
1565
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::TEST_ATTR,
1566
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1567
+ [1, 11], nil, 2000, true, 0)
1568
+
1569
+ @processor.execute(i)
1570
+ @zork_memory.program_counter.should eql(12345)
1571
+ end
1572
+
1573
+ it "should not branch if the first operand has all bits set that the second has set and condition is negated" do
1574
+ @object_table.object_has_attribute?(1, 10).should eql(true)
1575
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::TEST_ATTR,
1576
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1577
+ [1, 10], nil, 2000, false, 0)
1578
+
1579
+ @processor.execute(i)
1580
+ @zork_memory.program_counter.should eql(12345)
1581
+ end
1582
+
1583
+ it "should branch if the first operand does not have all bits set that the second has set and condition is negated" do
1584
+ @object_table.object_has_attribute?(1, 11).should eql(false)
1585
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::TEST_ATTR,
1586
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1587
+ [1, 11], nil, 2000, false, 0)
1588
+
1589
+ @processor.execute(i)
1590
+ @zork_memory.program_counter.should eql(2000)
1591
+ end
1592
+
1593
+ end
1594
+ end
1595
+
1596
+ describe "Instruction" do
1597
+ after(:each) do
1598
+ # The program counter should not be changed
1599
+ @zork_memory.program_counter.should eql(12345)
1600
+ end
1601
+
1602
+ describe "put_prop" do
1603
+ it "should set the property in the object's list when it is a byte" do
1604
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PUT_PROP,
1605
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1606
+ [3, 20, 234], nil, nil, nil, 0)
1607
+ @processor.execute(i)
1608
+ @object_table.object_get_property_word(3, 20).should eql(234)
1609
+ end
1610
+
1611
+ it "should store the least significant part of the value to the property in the object's list when the property is a byte" do
1612
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PUT_PROP,
1613
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1614
+ [3, 20, 0x5432], nil, nil, nil, 0)
1615
+ @processor.execute(i)
1616
+ @object_table.object_get_property_word(3, 20).should eql(0x32)
1617
+ end
1618
+
1619
+ it "should set the property in the object's list when it is a word" do
1620
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PUT_PROP,
1621
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1622
+ [3, 15, 54321], nil, nil, nil, 0)
1623
+ @processor.execute(i)
1624
+ @object_table.object_get_property_word(3, 15).should eql(54321)
1625
+ end
1626
+
1627
+ # XXX: Check for halt when property does not exist
1628
+ end
1629
+
1630
+ describe "get_prop" do
1631
+ it "should retrieve the property in the object's list when it is a byte" do
1632
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_PROP,
1633
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1634
+ [3, 20], 128, nil, nil, 0)
1635
+ @processor.execute(i)
1636
+ @zork_memory.readv(128).should eql(123)
1637
+ end
1638
+
1639
+ it "should retrieve the property in the object's list when it is a word" do
1640
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_PROP,
1641
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1642
+ [3, 15], 128, nil, nil, 0)
1643
+ @processor.execute(i)
1644
+ @zork_memory.readv(128).should eql(34567)
1645
+ end
1646
+
1647
+ it "should retrieve the default property when the object list does not have the property listed" do
1648
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_PROP,
1649
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1650
+ [3, 28], 128, nil, nil, 0)
1651
+ @processor.execute(i)
1652
+ @zork_memory.readv(128).should eql(28)
1653
+ end
1654
+ end
1655
+
1656
+ describe "get_prop_addr" do
1657
+ it "should retrieve the address of the property in the object's list" do
1658
+ @zork_memory.writev(128, 11111)
1659
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_PROP_ADDR,
1660
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1661
+ [3, 20], 128, nil, nil, 0)
1662
+ @processor.execute(i)
1663
+ @zork_memory.readv(128).should eql(0x4299)
1664
+ end
1665
+
1666
+ it "should set the variable given to 0 when the property is not in the object's list" do
1667
+ @zork_memory.writev(128, 11111)
1668
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_PROP_ADDR,
1669
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1670
+ [3, 28], 128, nil, nil, 0)
1671
+ @processor.execute(i)
1672
+ @zork_memory.readv(128).should eql(0)
1673
+ end
1674
+ end
1675
+
1676
+ describe "get_prop_len" do
1677
+ it "should retrieve the property data size for the byte property in the object's list" do
1678
+ @zork_memory.writev(128, 11111)
1679
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_PROP_LEN,
1680
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1681
+ [0x4299], 128, nil, nil, 0)
1682
+ @processor.execute(i)
1683
+ @zork_memory.readv(128).should eql(1)
1684
+ end
1685
+
1686
+ it "should retrieve the property data size for the word property in the object's list" do
1687
+ @zork_memory.writev(128, 11111)
1688
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_PROP_LEN,
1689
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1690
+ [0x4296], 128, nil, nil, 0)
1691
+ @processor.execute(i)
1692
+ @zork_memory.readv(128).should eql(2)
1693
+ end
1694
+
1695
+ it "should return 0 when the property address given is 0" do
1696
+ @zork_memory.writev(128, 11111)
1697
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::GET_PROP_LEN,
1698
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1699
+ [0], 128, nil, nil, 0)
1700
+ @processor.execute(i)
1701
+ @zork_memory.readv(128).should eql(0)
1702
+ end
1703
+ end
1704
+
1705
+ describe "insert_obj" do
1706
+ it "should insert the object given as the child of the other object given" do
1707
+ @object_table.object_get_child(2).should eql(0)
1708
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::INSERT_OBJ,
1709
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1710
+ [3, 2], nil, nil, nil, 0)
1711
+ @processor.execute(i)
1712
+
1713
+ @object_table.object_get_child(2).should eql(3)
1714
+ end
1715
+
1716
+ it "should set the sibling of the given object as the previous child of the other object given" do
1717
+ @object_table.object_get_sibling(3).should eql(2)
1718
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::INSERT_OBJ,
1719
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1720
+ [3, 2], nil, nil, nil, 0)
1721
+ @processor.execute(i)
1722
+
1723
+ @object_table.object_get_sibling(3).should eql(0)
1724
+ end
1725
+ end
1726
+
1727
+ describe "remove_obj" do
1728
+ it "should clear the parent of the given object" do
1729
+ @object_table.object_get_parent(2).should eql(1)
1730
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::REMOVE_OBJ,
1731
+ [Gruesome::Z::OperandType::LARGE],
1732
+ [2], nil, nil, nil, 0)
1733
+ @processor.execute(i)
1734
+
1735
+ @object_table.object_get_parent(2).should eql(0)
1736
+ end
1737
+ end
1738
+
1739
+
1740
+ describe "clear_attr" do
1741
+ it "should clear the attribute when it exists in the object attribute list without altering other attributes" do
1742
+ @object_table.object_has_attribute?(2, 25).should eql(true)
1743
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CLEAR_ATTR,
1744
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1745
+ [2, 25], nil, nil, nil, 0)
1746
+ @processor.execute(i)
1747
+
1748
+ @object_table.object_has_attribute?(2, 25).should eql(false)
1749
+ @object_table.object_has_attribute?(2, 31).should eql(true)
1750
+ end
1751
+
1752
+ it "should do nothing when the attribute is already cleared" do
1753
+ @object_table.object_has_attribute?(2, 26).should eql(false)
1754
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::CLEAR_ATTR,
1755
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1756
+ [2, 26], nil, nil, nil, 0)
1757
+ @processor.execute(i)
1758
+
1759
+ @object_table.object_has_attribute?(2, 26).should eql(false)
1760
+ @object_table.object_has_attribute?(2, 31).should eql(true)
1761
+ end
1762
+ end
1763
+
1764
+ describe "set_attr" do
1765
+ it "should set the attribute when it exists in the object attribute list without altering other attributes" do
1766
+ @object_table.object_has_attribute?(2, 26).should eql(false)
1767
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::SET_ATTR,
1768
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1769
+ [2, 26], nil, nil, nil, 0)
1770
+ @processor.execute(i)
1771
+
1772
+ @object_table.object_has_attribute?(2, 26).should eql(true)
1773
+ @object_table.object_has_attribute?(2, 31).should eql(true)
1774
+ end
1775
+
1776
+ it "should do nothing when the attribute is already set" do
1777
+ @object_table.object_has_attribute?(2, 25).should eql(true)
1778
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::SET_ATTR,
1779
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1780
+ [2, 25], nil, nil, nil, 0)
1781
+ @processor.execute(i)
1782
+
1783
+ @object_table.object_has_attribute?(2, 25).should eql(true)
1784
+ @object_table.object_has_attribute?(2, 31).should eql(true)
1785
+ end
1786
+ end
1787
+ end
1788
+ end
1789
+
1790
+ describe "Instruction" do
1791
+ after(:each) do
1792
+ # The program counter should not be changed
1793
+ @zork_memory.program_counter.should eql(12345)
1794
+ end
1795
+
1796
+ describe "store" do
1797
+ it "should store the value into the variable referenced by the operand" do
1798
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::STORE,
1799
+ [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
1800
+ [128, -13+65536], nil, nil, nil, 0)
1801
+
1802
+ @processor.execute(i)
1803
+
1804
+ @zork_memory.readv(128).should eql(-13+65536)
1805
+ end
1806
+
1807
+ it "should write to the stack in-place when variable %00 is used" do
1808
+ @zork_memory.writev(0, 11111)
1809
+ @zork_memory.writev(0, 12345)
1810
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::STORE,
1811
+ [Gruesome::Z::OperandType::VARIABLE, Gruesome::Z::OperandType::LARGE],
1812
+ [0, -13+65536], nil, nil, nil, 0)
1813
+
1814
+ @processor.execute(i)
1815
+
1816
+ @zork_memory.readv(0).should eql(-13+65536)
1817
+ @zork_memory.readv(0).should eql(11111)
1818
+ end
1819
+ end
1820
+
1821
+ describe "storeb" do
1822
+ it "should store the byte given into the byte address given by the operands providing base and offset" do
1823
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::STOREB,
1824
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1825
+ [2000, 100, 123], nil, nil, nil, 0)
1826
+
1827
+ @processor.execute(i)
1828
+
1829
+ @zork_memory.force_readb(2000+100).should eql(123)
1830
+ end
1831
+ end
1832
+
1833
+ describe "storew" do
1834
+ it "should store the word given into the byte address given by the operands providing base and offset" do
1835
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::STOREW,
1836
+ [Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE, Gruesome::Z::OperandType::LARGE],
1837
+ [2000, 100, 12345], nil, nil, nil, 0)
1838
+
1839
+ @processor.execute(i)
1840
+
1841
+ @zork_memory.force_readw(2000+200).should eql(12345)
1842
+ end
1843
+ end
1844
+
1845
+ describe "pull" do
1846
+ it "should pop the value from the stack that was most recently pushed" do
1847
+ @zork_memory.writev(0, 23456)
1848
+ @zork_memory.writev(0, 34567)
1849
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PULL,
1850
+ [Gruesome::Z::OperandType::VARIABLE], [128], nil, nil, nil, 0)
1851
+
1852
+ @processor.execute(i)
1853
+ @zork_memory.readv(128).should eql(34567)
1854
+ @zork_memory.readv(0).should eql(23456)
1855
+ end
1856
+
1857
+ it "should not change the stack if the given variable is %00" do
1858
+ @zork_memory.writev(0, 23456)
1859
+ @zork_memory.writev(0, 34567)
1860
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PULL,
1861
+ [Gruesome::Z::OperandType::VARIABLE], [0], nil, nil, nil, 0)
1862
+
1863
+ @processor.execute(i)
1864
+ @zork_memory.readv(0).should eql(34567)
1865
+ @zork_memory.readv(0).should eql(23456)
1866
+ end
1867
+ end
1868
+
1869
+ describe "push" do
1870
+ it "should push the value on the stack such that a read of variable %00 will yield that value" do
1871
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::PUSH,
1872
+ [Gruesome::Z::OperandType::LARGE],
1873
+ [23456], nil, nil, nil, 0)
1874
+
1875
+ @processor.execute(i)
1876
+
1877
+ @zork_memory.readv(0).should eql(23456)
1878
+ end
1879
+ end
1880
+
1881
+ describe "pop" do
1882
+ it "should throw away the most recently pushed item on the stack" do
1883
+ @zork_memory.writev(0, 23456)
1884
+ @zork_memory.writev(0, 34567)
1885
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::POP,
1886
+ [], [], nil, nil, nil, 0)
1887
+
1888
+ @processor.execute(i)
1889
+ @zork_memory.readv(0).should eql(23456)
1890
+ end
1891
+ end
1892
+
1893
+ describe "dec" do
1894
+ it "should decrement the value in the variable given as the operand" do
1895
+ @zork_memory.writev(128, 12345)
1896
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::DEC,
1897
+ [Gruesome::Z::OperandType::VARIABLE],
1898
+ [128], nil, nil, nil, 0)
1899
+ @processor.execute(i)
1900
+ @zork_memory.readv(128).should eql(12344)
1901
+ end
1902
+
1903
+ it "should consider the value signed and decrement 0 to -1" do
1904
+ @zork_memory.writev(128, 0)
1905
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::DEC,
1906
+ [Gruesome::Z::OperandType::VARIABLE],
1907
+ [128], nil, nil, nil, 0)
1908
+ @processor.execute(i)
1909
+ @zork_memory.readv(128).should eql(-1+65536)
1910
+ end
1911
+
1912
+ it "should edit the value on the stack in place" do
1913
+ @zork_memory.writev(0, 11111)
1914
+ @zork_memory.writev(0, 12345)
1915
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::DEC,
1916
+ [Gruesome::Z::OperandType::VARIABLE],
1917
+ [0], nil, nil, nil, 0)
1918
+ @processor.execute(i)
1919
+ @zork_memory.readv(0).should eql(12344)
1920
+ @zork_memory.readv(0).should eql(11111)
1921
+ end
1922
+ end
1923
+
1924
+ describe "inc" do
1925
+ it "should increment the value in the variable given as the operand" do
1926
+ @zork_memory.writev(128, 12345)
1927
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::INC,
1928
+ [Gruesome::Z::OperandType::VARIABLE],
1929
+ [128], nil, nil, nil, 0)
1930
+ @processor.execute(i)
1931
+ @zork_memory.readv(128).should eql(12346)
1932
+ end
1933
+
1934
+ it "should consider the value signed and increment -1 to 0" do
1935
+ @zork_memory.writev(128, -1+65536)
1936
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::INC,
1937
+ [Gruesome::Z::OperandType::VARIABLE],
1938
+ [128], nil, nil, nil, 0)
1939
+ @processor.execute(i)
1940
+ @zork_memory.readv(128).should eql(0)
1941
+ end
1942
+
1943
+ it "should edit the value on the stack in place" do
1944
+ @zork_memory.writev(0, 11111)
1945
+ @zork_memory.writev(0, 12345)
1946
+ i = Gruesome::Z::Instruction.new(Gruesome::Z::Opcode::INC,
1947
+ [Gruesome::Z::OperandType::VARIABLE],
1948
+ [0], nil, nil, nil, 0)
1949
+ @processor.execute(i)
1950
+ @zork_memory.readv(0).should eql(12346)
1951
+ @zork_memory.readv(0).should eql(11111)
1952
+ end
1953
+ end
1954
+ end
1955
+ end
1956
1956
  end