@@ -125,91 +125,93 @@ func do_STORE_LOCALS(vm *Vm, arg int32) {
125
125
// Implements TOS = TOS1 ** TOS.
126
126
func do_BINARY_POWER (vm * Vm , arg int32 ) {
127
127
b := vm .POP ()
128
- a := vm .POP ()
129
- vm .PUSH (py .Pow (a , b , py .None ))
128
+ a := vm .TOP ()
129
+ vm .SET_TOP (py .Pow (a , b , py .None ))
130
130
}
131
131
132
132
// Implements TOS = TOS1 * TOS.
133
133
func do_BINARY_MULTIPLY (vm * Vm , arg int32 ) {
134
134
b := vm .POP ()
135
- a := vm .POP ()
136
- vm .PUSH (py .Mul (a , b ))
135
+ a := vm .TOP ()
136
+ vm .SET_TOP (py .Mul (a , b ))
137
137
}
138
138
139
139
// Implements TOS = TOS1 // TOS.
140
140
func do_BINARY_FLOOR_DIVIDE (vm * Vm , arg int32 ) {
141
141
b := vm .POP ()
142
- a := vm .POP ()
143
- vm .PUSH (py .FloorDiv (a , b ))
142
+ a := vm .TOP ()
143
+ vm .SET_TOP (py .FloorDiv (a , b ))
144
144
}
145
145
146
146
// Implements TOS = TOS1 / TOS when from __future__ import division is
147
147
// in effect.
148
148
func do_BINARY_TRUE_DIVIDE (vm * Vm , arg int32 ) {
149
149
b := vm .POP ()
150
- a := vm .POP ()
151
- vm .PUSH (py .TrueDiv (a , b ))
150
+ a := vm .TOP ()
151
+ vm .SET_TOP (py .TrueDiv (a , b ))
152
152
}
153
153
154
154
// Implements TOS = TOS1 % TOS.
155
155
func do_BINARY_MODULO (vm * Vm , arg int32 ) {
156
156
b := vm .POP ()
157
- a := vm .POP ()
158
- vm .PUSH (py .Mod (a , b ))
157
+ a := vm .TOP ()
158
+ vm .SET_TOP (py .Mod (a , b ))
159
159
}
160
160
161
161
// Implements TOS = TOS1 + TOS.
162
162
func do_BINARY_ADD (vm * Vm , arg int32 ) {
163
163
b := vm .POP ()
164
- a := vm .POP ()
165
- vm .PUSH (py .Add (a , b ))
164
+ a := vm .TOP ()
165
+ vm .SET_TOP (py .Add (a , b ))
166
166
}
167
167
168
168
// Implements TOS = TOS1 - TOS.
169
169
func do_BINARY_SUBTRACT (vm * Vm , arg int32 ) {
170
170
b := vm .POP ()
171
- a := vm .POP ()
172
- vm .PUSH (py .Sub (a , b ))
171
+ a := vm .TOP ()
172
+ vm .SET_TOP (py .Sub (a , b ))
173
173
}
174
174
175
175
// Implements TOS = TOS1[TOS].
176
176
func do_BINARY_SUBSCR (vm * Vm , arg int32 ) {
177
- vm .NotImplemented ("BINARY_SUBSCR" , arg )
177
+ b := vm .POP ()
178
+ a := vm .TOP ()
179
+ vm .SET_TOP (py .GetItem (a , b ))
178
180
}
179
181
180
182
// Implements TOS = TOS1 << TOS.
181
183
func do_BINARY_LSHIFT (vm * Vm , arg int32 ) {
182
184
b := vm .POP ()
183
- a := vm .POP ()
184
- vm .PUSH (py .Lshift (a , b ))
185
+ a := vm .TOP ()
186
+ vm .SET_TOP (py .Lshift (a , b ))
185
187
}
186
188
187
189
// Implements TOS = TOS1 >> TOS.
188
190
func do_BINARY_RSHIFT (vm * Vm , arg int32 ) {
189
191
b := vm .POP ()
190
- a := vm .POP ()
191
- vm .PUSH (py .Rshift (a , b ))
192
+ a := vm .TOP ()
193
+ vm .SET_TOP (py .Rshift (a , b ))
192
194
}
193
195
194
196
// Implements TOS = TOS1 & TOS.
195
197
func do_BINARY_AND (vm * Vm , arg int32 ) {
196
198
b := vm .POP ()
197
- a := vm .POP ()
198
- vm .PUSH (py .And (a , b ))
199
+ a := vm .TOP ()
200
+ vm .SET_TOP (py .And (a , b ))
199
201
}
200
202
201
203
// Implements TOS = TOS1 ^ TOS.
202
204
func do_BINARY_XOR (vm * Vm , arg int32 ) {
203
205
b := vm .POP ()
204
- a := vm .POP ()
205
- vm .PUSH (py .Xor (a , b ))
206
+ a := vm .TOP ()
207
+ vm .SET_TOP (py .Xor (a , b ))
206
208
}
207
209
208
210
// Implements TOS = TOS1 | TOS.
209
211
func do_BINARY_OR (vm * Vm , arg int32 ) {
210
212
b := vm .POP ()
211
- a := vm .POP ()
212
- vm .PUSH (py .Or (a , b ))
213
+ a := vm .TOP ()
214
+ vm .SET_TOP (py .Or (a , b ))
213
215
}
214
216
215
217
// In-place operations are like binary operations, in that they remove
@@ -220,86 +222,86 @@ func do_BINARY_OR(vm *Vm, arg int32) {
220
222
// Implements in-place TOS = TOS1 ** TOS.
221
223
func do_INPLACE_POWER (vm * Vm , arg int32 ) {
222
224
b := vm .POP ()
223
- a := vm .POP ()
224
- vm .PUSH (py .IPow (a , b , py .None ))
225
+ a := vm .TOP ()
226
+ vm .SET_TOP (py .IPow (a , b , py .None ))
225
227
}
226
228
227
229
// Implements in-place TOS = TOS1 * TOS.
228
230
func do_INPLACE_MULTIPLY (vm * Vm , arg int32 ) {
229
231
b := vm .POP ()
230
- a := vm .POP ()
231
- vm .PUSH (py .IMul (a , b ))
232
+ a := vm .TOP ()
233
+ vm .SET_TOP (py .IMul (a , b ))
232
234
}
233
235
234
236
// Implements in-place TOS = TOS1 // TOS.
235
237
func do_INPLACE_FLOOR_DIVIDE (vm * Vm , arg int32 ) {
236
238
b := vm .POP ()
237
- a := vm .POP ()
238
- vm .PUSH (py .IFloorDiv (a , b ))
239
+ a := vm .TOP ()
240
+ vm .SET_TOP (py .IFloorDiv (a , b ))
239
241
}
240
242
241
243
// Implements in-place TOS = TOS1 / TOS when from __future__ import
242
244
// division is in effect.
243
245
func do_INPLACE_TRUE_DIVIDE (vm * Vm , arg int32 ) {
244
246
b := vm .POP ()
245
- a := vm .POP ()
246
- vm .PUSH (py .ITrueDiv (a , b ))
247
+ a := vm .TOP ()
248
+ vm .SET_TOP (py .ITrueDiv (a , b ))
247
249
}
248
250
249
251
// Implements in-place TOS = TOS1 % TOS.
250
252
func do_INPLACE_MODULO (vm * Vm , arg int32 ) {
251
253
b := vm .POP ()
252
- a := vm .POP ()
253
- vm .PUSH (py .Mod (a , b ))
254
+ a := vm .TOP ()
255
+ vm .SET_TOP (py .Mod (a , b ))
254
256
}
255
257
256
258
// Implements in-place TOS = TOS1 + TOS.
257
259
func do_INPLACE_ADD (vm * Vm , arg int32 ) {
258
260
b := vm .POP ()
259
- a := vm .POP ()
260
- vm .PUSH (py .IAdd (a , b ))
261
+ a := vm .TOP ()
262
+ vm .SET_TOP (py .IAdd (a , b ))
261
263
}
262
264
263
265
// Implements in-place TOS = TOS1 - TOS.
264
266
func do_INPLACE_SUBTRACT (vm * Vm , arg int32 ) {
265
267
b := vm .POP ()
266
- a := vm .POP ()
267
- vm .PUSH (py .ISub (a , b ))
268
+ a := vm .TOP ()
269
+ vm .SET_TOP (py .ISub (a , b ))
268
270
}
269
271
270
272
// Implements in-place TOS = TOS1 << TOS.
271
273
func do_INPLACE_LSHIFT (vm * Vm , arg int32 ) {
272
274
b := vm .POP ()
273
- a := vm .POP ()
274
- vm .PUSH (py .ILshift (a , b ))
275
+ a := vm .TOP ()
276
+ vm .SET_TOP (py .ILshift (a , b ))
275
277
}
276
278
277
279
// Implements in-place TOS = TOS1 >> TOS.
278
280
func do_INPLACE_RSHIFT (vm * Vm , arg int32 ) {
279
281
b := vm .POP ()
280
- a := vm .POP ()
281
- vm .PUSH (py .IRshift (a , b ))
282
+ a := vm .TOP ()
283
+ vm .SET_TOP (py .IRshift (a , b ))
282
284
}
283
285
284
286
// Implements in-place TOS = TOS1 & TOS.
285
287
func do_INPLACE_AND (vm * Vm , arg int32 ) {
286
288
b := vm .POP ()
287
- a := vm .POP ()
288
- vm .PUSH (py .IAnd (a , b ))
289
+ a := vm .TOP ()
290
+ vm .SET_TOP (py .IAnd (a , b ))
289
291
}
290
292
291
293
// Implements in-place TOS = TOS1 ^ TOS.
292
294
func do_INPLACE_XOR (vm * Vm , arg int32 ) {
293
295
b := vm .POP ()
294
- a := vm .POP ()
295
- vm .PUSH (py .IXor (a , b ))
296
+ a := vm .TOP ()
297
+ vm .SET_TOP (py .IXor (a , b ))
296
298
}
297
299
298
300
// Implements in-place TOS = TOS1 | TOS.
299
301
func do_INPLACE_OR (vm * Vm , arg int32 ) {
300
302
b := vm .POP ()
301
- a := vm .POP ()
302
- vm .PUSH (py .IOr (a , b ))
303
+ a := vm .TOP ()
304
+ vm .SET_TOP (py .IOr (a , b ))
303
305
}
304
306
305
307
// Implements TOS1[TOS] = TOS2.
@@ -562,7 +564,7 @@ func do_LOAD_ATTR(vm *Vm, namei int32) {
562
564
// cmp_op[opname].
563
565
func do_COMPARE_OP (vm * Vm , opname int32 ) {
564
566
b := vm .POP ()
565
- a := vm .POP ()
567
+ a := vm .TOP ()
566
568
var r py.Object
567
569
switch opname {
568
570
case PyCmp_LT :
@@ -580,7 +582,7 @@ func do_COMPARE_OP(vm *Vm, opname int32) {
580
582
default :
581
583
vm .NotImplemented ("COMPARE_OP" , opname )
582
584
}
583
- vm .PUSH (r )
585
+ vm .SET_TOP (r )
584
586
}
585
587
586
588
// Imports the module co_names[namei]. TOS and TOS1 are popped and
0 commit comments