// Copyright 2018 The go-python Authors. All rights reserved.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

// Evaluate opcodes

package vm

/*

FIXME

cpython keeps a zombie frame on each code object to speed up execution

of a code object so a frame doesn't have to be allocated and

deallocated each time which seems like a good idea. If we want to

work with go routines then it might have to be more sophisticated.

FIXME could make the stack be permanently allocated and just keep a

pointer into it rather than using append etc...

If we are caching the frames need to make sure we clear the stack

objects so they can be GCed

*/

import (

"fmt"

"os"

"runtime/debug"

"strings"

"github.com/go-python/gpython/py"

)

const (

nameErrorMsg = "name '%s' is not defined"

globalNameErrorMsg = "global name '%s' is not defined"

unboundLocalErrorMsg = "local variable '%s' referenced before assignment"

unboundFreeErrorMsg = "free variable '%s' referenced before assignment in enclosing scope"

cannotCatchMsg = "catching '%s' that does not inherit from BaseException is not allowed"

)

const debugging = false

// Debug print

func debugf(format string, a ...interface{}) {

fmt.Printf(format, a...)

}

// Stack operations

func (vm *Vm) STACK_LEVEL() int { return len(vm.frame.Stack) }

func (vm *Vm) TOP() py.Object { return vm.frame.Stack[len(vm.frame.Stack)-1] }

func (vm *Vm) SECOND() py.Object { return vm.frame.Stack[len(vm.frame.Stack)-2] }

func (vm *Vm) THIRD() py.Object { return vm.frame.Stack[len(vm.frame.Stack)-3] }

func (vm *Vm) FOURTH() py.Object { return vm.frame.Stack[len(vm.frame.Stack)-4] }

func (vm *Vm) PEEK(n int) py.Object { return vm.frame.Stack[len(vm.frame.Stack)-n] }

func (vm *Vm) SET_TOP(v py.Object) { vm.frame.Stack[len(vm.frame.Stack)-1] = v }

func (vm *Vm) SET_SECOND(v py.Object) { vm.frame.Stack[len(vm.frame.Stack)-2] = v }

func (vm *Vm) SET_THIRD(v py.Object) { vm.frame.Stack[len(vm.frame.Stack)-3] = v }

func (vm *Vm) SET_FOURTH(v py.Object) { vm.frame.Stack[len(vm.frame.Stack)-4] = v }

func (vm *Vm) SET_VALUE(n int, v py.Object) { vm.frame.Stack[len(vm.frame.Stack)-(n)] = (v) }

func (vm *Vm) DROP() { vm.frame.Stack = vm.frame.Stack[:len(vm.frame.Stack)-1] }

func (vm *Vm) DROPN(n int) { vm.frame.Stack = vm.frame.Stack[:len(vm.frame.Stack)-n] }

// Pop from top of vm stack

func (vm *Vm) POP() py.Object {

// FIXME what if empty?

out := vm.frame.Stack[len(vm.frame.Stack)-1]

vm.frame.Stack = vm.frame.Stack[:len(vm.frame.Stack)-1]

return out

}

// Push to top of vm stack

func (vm *Vm) PUSH(obj py.Object) {

vm.frame.Stack = append(vm.frame.Stack, obj)

}

// Push items to top of vm stack

func (vm *Vm) EXTEND(items py.Tuple) {

vm.frame.Stack = append(vm.frame.Stack, items...)

}

// Push items to top of vm stack in reverse order

func (vm *Vm) EXTEND_REVERSED(items py.Tuple) {

start := len(vm.frame.Stack)

vm.frame.Stack = append(vm.frame.Stack, items...)

py.Tuple(vm.frame.Stack[start:]).Reverse()

}

// Adds a traceback to the exc passed in for the current vm state

func (vm *Vm) AddTraceback(exc *py.ExceptionInfo) {

exc.Traceback = &py.Traceback{

Next: exc.Traceback,

Frame: vm.frame,

Lasti: vm.frame.Lasti,

Lineno: vm.frame.Code.Addr2Line(vm.frame.Lasti),

}

}

// Set an exception in the VM

//

// The exception must be a valid exception instance (eg as returned by

// py.MakeException)

//

// It sets vm.curexc.* and sets vm.why to whyException

func (vm *Vm) SetException(exception py.Object) {

vm.curexc.Value = exception

vm.curexc.Type = exception.Type()

vm.curexc.Traceback = nil

vm.AddTraceback(&vm.curexc)

vm.why = whyException

}

// Check for an exception (panic)

//

// Should be called with the result of recover

func (vm *Vm) CheckExceptionRecover(r interface{}) {

// If what was raised was an ExceptionInfo the stuff this into the current vm

if exc, ok := r.(py.ExceptionInfo); ok {

vm.curexc = exc

vm.AddTraceback(&vm.curexc)

vm.why = whyException

if debugging {

debugf("*** Propagating exception: %s\n", exc.Error())

}

} else {

// Coerce whatever was raised into a *Exception

vm.SetException(py.MakeException(r))

if debugging {

debugf("*** Exception raised %v\n", r)

debug.PrintStack()

}

}

}

// Check for an exception (panic)

//

// Must be called as a defer function

func (vm *Vm) CheckException() {

if r := recover(); r != nil {

if debugging {

debugf("*** Panic recovered %v\n", r)

}

vm.CheckExceptionRecover(r)

}

}

// Illegal instruction

func do_ILLEGAL(vm *Vm, arg int32) error {

return py.ExceptionNewf(py.SystemError, "Illegal opcode")

}

// Do nothing code. Used as a placeholder by the bytecode optimizer.

func do_NOP(vm *Vm, arg int32) error {

return nil

}

// Removes the top-of-stack (TOS) item.

func do_POP_TOP(vm *Vm, arg int32) error {

vm.DROPN(1)

return nil

}

// Swaps the two top-most stack items.

func do_ROT_TWO(vm *Vm, arg int32) error {

top := vm.TOP()

second := vm.SECOND()

vm.SET_TOP(second)

vm.SET_SECOND(top)

return nil

}

// Lifts second and third stack item one position up, moves top down

// to position three.

func do_ROT_THREE(vm *Vm, arg int32) error {

top := vm.TOP()

second := vm.SECOND()

third := vm.THIRD()

vm.SET_TOP(second)

vm.SET_SECOND(third)

vm.SET_THIRD(top)

return nil

}

// Duplicates the reference on top of the stack.

func do_DUP_TOP(vm *Vm, arg int32) error {

vm.PUSH(vm.TOP())

return nil

}

// Duplicates the top two reference on top of the stack.

func do_DUP_TOP_TWO(vm *Vm, arg int32) error {

top := vm.TOP()

second := vm.SECOND()

vm.PUSH(second)

vm.PUSH(top)

return nil

}

// Unary Operations take the top of the stack, apply the operation,

// and push the result back on the stack.

// Set the Top and return the error

func (vm *Vm) setTopAndCheckErr(obj py.Object, err error) error {

if err == nil {

vm.SET_TOP(obj)

}

return err

}

// Implements TOS = +TOS.

func do_UNARY_POSITIVE(vm *Vm, arg int32) error {

return vm.setTopAndCheckErr(py.Pos(vm.TOP()))

}

// Implements TOS = -TOS.

func do_UNARY_NEGATIVE(vm *Vm, arg int32) error {

return vm.setTopAndCheckErr(py.Neg(vm.TOP()))

}

// Implements TOS = not TOS.

func do_UNARY_NOT(vm *Vm, arg int32) error {

return vm.setTopAndCheckErr(py.Not(vm.TOP()))

}

// Implements TOS = ~TOS.

func do_UNARY_INVERT(vm *Vm, arg int32) error {

return vm.setTopAndCheckErr(py.Invert(vm.TOP()))

}

// Implements TOS = iter(TOS).

func do_GET_ITER(vm *Vm, arg int32) error {

return vm.setTopAndCheckErr(py.Iter(vm.TOP()))

}

// Binary operations remove the top of the stack (TOS) and the second

// top-most stack item (TOS1) from the stack. They perform the

// operation, and put the result back on the stack.

// Implements TOS = TOS1 ** TOS.

func do_BINARY_POWER(vm *Vm, arg int32) error {

b := vm.POP()

a := vm.TOP()

return vm.setTopAndCheckErr(py.Pow(a, b, py.None))

}

// Implements TOS = TOS1 * TOS.

func do_BINARY_MULTIPLY(vm *Vm, arg int32) error {

b := vm.POP()

a := vm.TOP()

return vm.setTopAndCheckErr(py.Mul(a, b))

}

// Implements TOS = TOS1 // TOS.

func do_BINARY_FLOOR_DIVIDE(vm *Vm, arg int32) error {

b := vm.POP()

a := vm.TOP()

return vm.setTopAndCheckErr(py.FloorDiv(a, b))

}

// Implements TOS = TOS1 / TOS when from __future__ import division is

// in effect.

func do_BINARY_TRUE_DIVIDE(vm *Vm, arg int32) error {

b := vm.POP()

a := vm.TOP()

return vm.setTopAndCheckErr(py.TrueDiv(a, b))

}

// Implements TOS = TOS1 % TOS.

func do_BINARY_MODULO(vm *Vm, arg int32) error {

b := vm.POP()

a := vm.TOP()

return vm.setTopAndCheckErr(py.Mod(a, b))

}

// Implements TOS = TOS1 + TOS.

func do_BINARY_ADD(vm *Vm, arg int32) error {

b := vm.POP()

a := vm.TOP()

return vm.setTopAndCheckErr(py.Add(a, b))

}

// Implements TOS = TOS1 - TOS.

func do_BINARY_SUBTRACT(vm *Vm, arg int32) error {

b := vm.POP()

a := vm.TOP()

return vm.setTopAndCheckErr(py.Sub(a, b))

}

// Implements TOS = TOS1[TOS].

func do_BINARY_SUBSCR(vm *Vm, arg int32) error {

b := vm.POP()

a := vm.TOP()

return vm.setTopAndCheckErr(py.GetItem(a, b))

}

// Implements TOS = TOS1 << TOS.

func do_BINARY_LSHIFT(vm *Vm, arg int32) error {

b := vm.POP()

a := vm.TOP()

return vm.setTopAndCheckErr(py.Lshift(a, b))

}

// Implements TOS = TOS1 >> TOS.

func do_BINARY_RSHIFT(vm *Vm, arg int32) error {

b := vm.POP()

a := vm.TOP()

return vm.setTopAndCheckErr(py.Rshift(a, b))

}

// Implements TOS = TOS1 & TOS.

func do_BINARY_AND(vm *Vm, arg int32) error {

b := vm.POP()

a := vm.TOP()

return vm.setTopAndCheckErr(py.And(a, b))

}

// Implements TOS = TOS1 ^ TOS.

func do_BINARY_XOR(vm *Vm, arg int32) error {

b := vm.POP()

a := vm.TOP()

return vm.setTopAndCheckErr(py.Xor(a, b))

}

// Implements TOS = TOS1 | TOS.

func do_BINARY_OR(vm *Vm, arg int32) error {

b := vm.POP()

a := vm.TOP()

return vm.setTopAndCheckErr(py.Or(a, b))

}

// In-place operations are like binary operations, in that they remove

// TOS and TOS1, and push the result back on the stack, but the

// operation is done in-place when TOS1 supports it, and the resulting

// TOS may be (but does not have to be) the original TOS1.

// Implements in-place TOS = TOS1 ** TOS.

func do_INPLACE_POWER(vm *Vm, arg int32) error {

b := vm.POP()

a := vm.TOP()

return vm.setTopAndCheckErr(py.IPow(a, b, py.None))

}

// Implements in-place TOS = TOS1 * TOS.

func do_INPLACE_MULTIPLY(vm *Vm, arg int32) error {

b := vm.POP()

a := vm.TOP()

return vm.setTopAndCheckErr(py.IMul(a, b))

}

// Implements in-place TOS = TOS1 // TOS.

func do_INPLACE_FLOOR_DIVIDE(vm *Vm, arg int32) error {

b := vm.POP()

a := vm.TOP()

return vm.setTopAndCheckErr(py.IFloorDiv(a, b))

}

// Implements in-place TOS = TOS1 / TOS when from __future__ import

// division is in effect.

func do_INPLACE_TRUE_DIVIDE(vm *Vm, arg int32) error {

b := vm.POP()

a := vm.TOP()

return vm.setTopAndCheckErr(py.ITrueDiv(a, b))

}

// Implements in-place TOS = TOS1 % TOS.

func do_INPLACE_MODULO(vm *Vm, arg int32) error {

b := vm.POP()

a := vm.TOP()

return vm.setTopAndCheckErr(py.Mod(a, b))

}

// Implements in-place TOS = TOS1 + TOS.

func do_INPLACE_ADD(vm *Vm, arg int32) error {

b := vm.POP()

a := vm.TOP()

return vm.setTopAndCheckErr(py.IAdd(a, b))

}

// Implements in-place TOS = TOS1 - TOS.

func do_INPLACE_SUBTRACT(vm *Vm, arg int32) error {

b := vm.POP()

a := vm.TOP()

return vm.setTopAndCheckErr(py.ISub(a, b))

}

// Implements in-place TOS = TOS1 << TOS.

func do_INPLACE_LSHIFT(vm *Vm, arg int32) error {

b := vm.POP()

a := vm.TOP()

return vm.setTopAndCheckErr(py.ILshift(a, b))

}

// Implements in-place TOS = TOS1 >> TOS.

func do_INPLACE_RSHIFT(vm *Vm, arg int32) error {

b := vm.POP()

a := vm.TOP()

return vm.setTopAndCheckErr(py.IRshift(a, b))

}

// Implements in-place TOS = TOS1 & TOS.

func do_INPLACE_AND(vm *Vm, arg int32) error {

b := vm.POP()

a := vm.TOP()

return vm.setTopAndCheckErr(py.IAnd(a, b))

}

// Implements in-place TOS = TOS1 ^ TOS.

func do_INPLACE_XOR(vm *Vm, arg int32) error {

b := vm.POP()

a := vm.TOP()

return vm.setTopAndCheckErr(py.IXor(a, b))

}

// Implements in-place TOS = TOS1 | TOS.

func do_INPLACE_OR(vm *Vm, arg int32) error {

b := vm.POP()

a := vm.TOP()

return vm.setTopAndCheckErr(py.IOr(a, b))

}

// Implements TOS1[TOS] = TOS2.

func do_STORE_SUBSCR(vm *Vm, arg int32) error {

w := vm.TOP()

v := vm.SECOND()

u := vm.THIRD()

vm.DROPN(3)

// v[w] = u

_, err := py.SetItem(v, w, u)

if err != nil {

return err

}

return nil

}

// Implements del TOS1[TOS].

func do_DELETE_SUBSCR(vm *Vm, arg int32) error {

sub := vm.TOP()

container := vm.SECOND()

vm.DROPN(2)

/* del v[w] */

_, err := py.DelItem(container, sub)

if err != nil {

return err

}

return nil

}

// Miscellaneous opcodes.

// PrintExpr controls where the output of PRINT_EXPR goes which is

// used in the REPL

var PrintExpr = func(out string) {

_, _ = os.Stdout.WriteString(out + "\n")

}

// Implements the expression statement for the interactive mode. TOS

// is removed from the stack and printed. In non-interactive mode, an

// expression statement is terminated with POP_STACK.

func do_PRINT_EXPR(vm *Vm, arg int32) error {

// FIXME this should be calling sys.displayhook

// Print value except if None

// After printing, also assign to '_'

// Before, set '_' to None to avoid recursion

value := vm.POP()

vm.frame.Globals["_"] = py.None

if value != py.None {

repr, err := py.Repr(value)

if err != nil {

return err

}

PrintExpr(fmt.Sprint(repr))

}

vm.frame.Globals["_"] = value

return nil

}

// Terminates a loop due to a break statement.

func do_BREAK_LOOP(vm *Vm, arg int32) error {

vm.why = whyBreak

return nil

}

// Continues a loop due to a continue statement. target is the address

// to jump to (which should be a FOR_ITER instruction).

func do_CONTINUE_LOOP(vm *Vm, target int32) error {

vm.retval = py.Int(target)

vm.why = whyContinue

return nil

}

// Iterate v argcnt times and store the results on the stack (via decreasing

// sp). Return 1 for success, 0 if error.

//

// If argcntafter == -1, do a simple unpack. If it is >= 0, do an unpack

// with a variable target.

func unpack_iterable(vm *Vm, v py.Object, argcnt int, argcntafter int, sp int) error {

it, err := py.Iter(v)

if err != nil {

return err

}

i := 0

for i = 0; i < argcnt; i++ {

w, err := py.Next(it)

if err != nil {

/* Iterator done, via error or exhaustion. */

return py.ExceptionNewf(py.ValueError, "need more than %d value(s) to unpack", i)

}

sp--

vm.frame.Stack[sp] = w

}

if argcntafter == -1 {

/* We better have exhausted the iterator now. */

_, finished := py.Next(it)

if finished != nil {

return nil

}

return py.ExceptionNewf(py.ValueError, "too many values to unpack (expected %d)", argcnt)

}

l, err := py.SequenceList(it)

if err != nil {

return err

}

sp--

vm.frame.Stack[sp] = l

i++

ll := l.Len()

if ll < argcntafter {

return py.ExceptionNewf(py.ValueError, "need more than %d values to unpack", argcnt+ll)

}

/* Pop the "after-variable" args off the list. */

for j := argcntafter; j > 0; j-- {

sp--

vm.frame.Stack[sp], err = l.M__getitem__(py.Int(ll - j))

if err != nil {

return err

}

}

/* Resize the list. */

l.Resize(ll - argcntafter)

return nil

}

// Implements assignment with a starred target: Unpacks an iterable in

// TOS into individual values, where the total number of values can be

// smaller than the number of items in the iterable: one the new

// values will be a list of all leftover items.

//

// The low byte of counts is the number of values before the list

// value, the high byte of counts the number of values after it. The

// resulting values are put onto the stack right-to-left.

func do_UNPACK_EX(vm *Vm, counts int32) error {

before := int(counts & 0xFF)

after := int(counts >> 8)

totalargs := 1 + before + after

seq := vm.POP()

sp := vm.STACK_LEVEL()

vm.EXTEND(make([]py.Object, totalargs))

return unpack_iterable(vm, seq, before, after, sp+totalargs)

}

// Calls set.add(TOS1[-i], TOS). Used to implement set comprehensions.

func do_SET_ADD(vm *Vm, i int32) error {

w := vm.POP()

v := vm.PEEK(int(i))

v.(*py.Set).Add(w)

return nil

}

// Calls list.append(TOS[-i], TOS). Used to implement list

// comprehensions. While the appended value is popped off, the list

// object remains on the stack so that it is available for further

// iterations of the loop.

func do_LIST_APPEND(vm *Vm, i int32) error {

w := vm.POP()

v := vm.PEEK(int(i))

v.(*py.List).Append(w)

return nil

}

// Calls dict.setitem(TOS1[-i], TOS, TOS1). Used to implement dict comprehensions.

func do_MAP_ADD(vm *Vm, i int32) error {

key := vm.TOP()

value := vm.SECOND()

vm.DROPN(2)

dictObj := vm.PEEK(int(i))

dict, err := py.DictCheckExact(dictObj)

if err != nil {

return err

}

_, err = dict.M__setitem__(key, value)

return err

}

// Returns with TOS to the caller of the function.

func do_RETURN_VALUE(vm *Vm, arg int32) error {

vm.retval = vm.POP()

vm.frame.Yielded = false

vm.why = whyReturn

return nil

}

// Pops TOS and delegates to it as a subiterator from a generator.

func do_YIELD_FROM(vm *Vm, arg int32) error {

var retval py.Object

var err error

u := vm.POP()

x := vm.TOP()

// send u to x

if u == py.None {

retval, err = py.Next(x)

} else {

retval, err = py.Send(x, u)

}

if err != nil {

if !py.IsException(py.StopIteration, err) {

return err

}

return nil

}

// x remains on stack, retval is value to be yielded

// FIXME vm.frame.Stacktop = stack_pointer

//why = whyYield

// and repeat...

vm.frame.Lasti--

vm.retval = retval

vm.frame.Yielded = true

vm.why = whyYield

return nil

}

// Pops TOS and yields it from a generator.

func do_YIELD_VALUE(vm *Vm, arg int32) error {

vm.retval = vm.POP()

vm.frame.Yielded = true

vm.why = whyYield

return nil

}

// Loads all symbols not starting with '_' directly from the module

// TOS to the local namespace. The module is popped after loading all

// names. This opcode implements from module import *.

func do_IMPORT_STAR(vm *Vm, arg int32) error {

vm.frame.FastToLocals()

from := vm.POP()

module := from.(*py.Module)

if all, ok := module.Globals["__all__"]; ok {

var loopErr error

iterErr := py.Iterate(all, func(item py.Object) bool {

name, err := py.AttributeName(item)

if err != nil {

loopErr = err

return true

}

vm.frame.Locals[name], err = py.GetAttrString(module, name)

if err != nil {

loopErr = err

return true

}

return false

})

if iterErr != nil {

return iterErr

}

if loopErr != nil {

return loopErr

}

} else {

for name, value := range module.Globals {

if !strings.HasPrefix(name, "_") {

vm.frame.Locals[name] = value

}

}

}

vm.frame.LocalsToFast(false)

return nil

}

// Removes one block from the block stack. Per frame, there is a stack

// of blocks, denoting nested loops, try statements, and such.

func do_POP_BLOCK(vm *Vm, arg int32) error {

vm.frame.PopBlock()

return nil

}

// Removes one block from the block stack. The popped block must be an

// exception handler block, as implicitly created when entering an

// except handler. In addition to popping extraneous values from the

// frame stack, the last three popped values are used to restore the

// exception state.

func do_POP_EXCEPT(vm *Vm, arg int32) error {

frame := vm.frame

b := vm.frame.Block

frame.PopBlock()

if b.Type != py.TryBlockExceptHandler {

return py.ExceptionNewf(py.SystemError, "popped block is not an except handler")

} else {

vm.UnwindExceptHandler(frame, b)

}

return nil

}

// Terminates a finally clause. The interpreter recalls whether the

// exception has to be re-raised, or whether the function returns, and

// continues with the outer-next block.

func do_END_FINALLY(vm *Vm, arg int32) error {

v := vm.POP()

if debugging {

debugf("END_FINALLY v=%#v\n", v)

}

if v == py.None {

// None exception

if debugging {

debugf(" END_FINALLY: None\n")

}

} else if vInt, ok := v.(py.Int); ok {

vm.why = vmStatus(vInt)

if debugging {

debugf(" END_FINALLY: Int %v\n", vm.why)

}

switch vm.why {

case whyYield:

panic("vm: Unexpected whyYield in END_FINALLY")

case whyException:

panic("vm: Unexpected whyException in END_FINALLY")

case whyReturn, whyContinue:

vm.retval = vm.POP()

case whySilenced:

// An exception was silenced by 'with', we must

// manually unwind the EXCEPT_HANDLER block which was

// created when the exception was caught, otherwise

// the stack will be in an inconsistent state.

frame := vm.frame

b := vm.frame.Block

frame.PopBlock()

if b.Type != py.TryBlockExceptHandler {

panic("vm: Expecting EXCEPT_HANDLER in END_FINALLY")

}

vm.UnwindExceptHandler(frame, b)

vm.why = whyNot

}

} else if py.ExceptionClassCheck(v) {

w := vm.POP()

u := vm.POP()

if debugging {

debugf(" END_FINALLY: Exc %v, Type %v, Traceback %v\n", v, w, u)

}

// FIXME PyErr_Restore(v, w, u)

vm.curexc.Type, _ = v.(*py.Type)

vm.curexc.Value = w

vm.curexc.Traceback, _ = u.(*py.Traceback)

vm.why = whyException

} else {

return py.ExceptionNewf(py.SystemError, "'finally' pops bad exception %#v", v)

}

if debugging {

debugf("END_FINALLY: vm.why = %v\n", vm.why)

}

return nil

}

// Loads the __build_class__ helper function to the stack which

// creates a new class object.

func do_LOAD_BUILD_CLASS(vm *Vm, arg int32) error {

vm.PUSH(py.Builtins.Globals["__build_class__"])

return nil

}

// This opcode performs several operations before a with block

// starts. First, it loads __exit__( ) from the context manager and

// pushes it onto the stack for later use by WITH_CLEANUP. Then,

// __enter__( ) is called, and a finally block pointing to delta is

// pushed. Finally, the result of calling the enter method is pushed

// onto the stack. The next opcode will either ignore it (POP_TOP), or

// store it in (a) variable(s) (STORE_FAST, STORE_NAME, or

// UNPACK_SEQUENCE).

func do_SETUP_WITH(vm *Vm, delta int32) error {

mgr := vm.TOP()

// exit := py.ObjectLookupSpecial(mgr, "__exit__")

exit, err := py.GetAttrString(mgr, "__exit__")

if err != nil {

return err

}

vm.SET_TOP(exit)

// enter := py.ObjectLookupSpecial(mgr, "__enter__")

enter, err := py.GetAttrString(mgr, "__enter__")

if err != nil {

return err

}

res, err := py.Call(enter, nil, nil) // FIXME method for this?

if err != nil {

return err

}

// Setup the finally block before pushing the result of __enter__ on the stack.

vm.frame.PushBlock(py.TryBlockSetupFinally, vm.frame.Lasti+delta, vm.STACK_LEVEL())

vm.PUSH(res)

return nil

}

// Cleans up the stack when a with statement block exits. On top of

// the stack are 1–3 values indicating how/why the finally clause was

// entered:

//

// TOP = None

// (TOP, SECOND) = (WHY_{RETURN,CONTINUE}), retval

// TOP = WHY_*; no retval below it

// (TOP, SECOND, THIRD) = exc_info( )

// Under them is EXIT, the context manager’s __exit__( ) bound method.

//

// In the last case, EXIT(TOP, SECOND, THIRD) is called, otherwise

// EXIT(None, None, None).

//

// EXIT is removed from the stack, leaving the values above it in the

// same order. In addition, if the stack represents an exception, and

// the function call returns a ‘true’ value, this information is

// “zapped”, to prevent END_FINALLY from re-raising the

// exception. (But non-local gotos should still be resumed.)

func do_WITH_CLEANUP(vm *Vm, arg int32) error {

var exit_func py.Object

exc := vm.TOP()

var val py.Object = py.None

var tb py.Object = py.None

if exc == py.None {

vm.DROP()

exit_func = vm.TOP()

vm.SET_TOP(exc)

} else if excInt, ok := exc.(py.Int); ok {

vm.DROP()

switch vmStatus(excInt) {

case whyReturn, whyContinue:

/* Retval in TOP. */

exit_func = vm.SECOND()

vm.SET_SECOND(vm.TOP())

vm.SET_TOP(exc)

default:

exit_func = vm.TOP()

vm.SET_TOP(exc)

}

exc = py.None

} else {

val = vm.SECOND()

tb = vm.THIRD()

tp2 := vm.FOURTH()

exc2 := vm.PEEK(5)

tb2 := vm.PEEK(6)

exit_func = vm.PEEK(7)

vm.SET_VALUE(7, tb2)

vm.SET_VALUE(6, exc2)

vm.SET_VALUE(5, tp2)

/* UNWIND_EXCEPT_HANDLER will pop this off. */

vm.SET_FOURTH(nil)

/* We just shifted the stack down, so we have

to tell the except handler block that the

values are lower than it expects. */

block := vm.frame.Block

if block.Type != py.TryBlockExceptHandler {

panic("vm: WITH_CLEANUP expecting TryBlockExceptHandler")

}

block.Level--

}

/* XXX Not the fastest way to call it... */

res, err := py.Call(exit_func, []py.Object{exc, val, tb}, nil)

if err != nil {

return err

}

wasErr := false

if exc != py.None {

wasErr = res == py.True

}

if wasErr {

/* There was an exception and a True return */

vm.PUSH(py.Int(whySilenced))

}

return nil

}

// All of the following opcodes expect arguments. An argument is two bytes, with the more significant byte last.

// Implements name = TOS. namei is the index of name in the attribute

// co_names of the code object. The compiler tries to use STORE_FAST

// or STORE_GLOBAL if possible.

func do_STORE_NAME(vm *Vm, namei int32) error {

if debugging {

debugf("STORE_NAME %v\n", vm.frame.Code.Names[namei])

}

vm.frame.Locals[vm.frame.Code.Names[namei]] = vm.POP()

return nil

}

// Implements del name, where namei is the index into co_names

// attribute of the code object.

func do_DELETE_NAME(vm *Vm, namei int32) error {

name := vm.frame.Code.Names[namei]

if _, ok := vm.frame.Locals[name]; !ok {

return py.ExceptionNewf(py.NameError, nameErrorMsg, name)

} else {

delete(vm.frame.Locals, name)

}

return nil

}

// Unpacks TOS into count individual values, which are put onto the

// stack right-to-left.

func do_UNPACK_SEQUENCE(vm *Vm, count int32) error {

it := vm.POP()

args := int(count)

if tuple, ok := it.(py.Tuple); ok && len(tuple) == args {

vm.EXTEND_REVERSED(tuple)

} else if list, ok := it.(*py.List); ok && list.Len() == args {

vm.EXTEND_REVERSED(list.Items)

} else {

sp := vm.STACK_LEVEL()

vm.EXTEND(make([]py.Object, args))

return unpack_iterable(vm, it, args, -1, sp+args)

}

return nil

}

// Implements TOS.name = TOS1, where namei is the index of name in

// co_names.

func do_STORE_ATTR(vm *Vm, namei int32) error {

w := vm.frame.Code.Names[namei]

v := vm.TOP()

u := vm.SECOND()

vm.DROPN(2)

_, err := py.SetAttrString(v, w, u) /* v.w = u */

if err != nil {

return err

}

return nil

}

// Implements del TOS.name, using namei as index into co_names.

func do_DELETE_ATTR(vm *Vm, namei int32) error {

return py.DeleteAttrString(vm.POP(), vm.frame.Code.Names[namei])

}

// Works as STORE_NAME, but stores the name as a global.

func do_STORE_GLOBAL(vm *Vm, namei int32) error {

vm.frame.Globals[vm.frame.Code.Names[namei]] = vm.POP()

return nil

}

// Works as DELETE_NAME, but deletes a global name.

func do_DELETE_GLOBAL(vm *Vm, namei int32) error {

name := vm.frame.Code.Names[namei]

if _, ok := vm.frame.Globals[name]; !ok {

return py.ExceptionNewf(py.NameError, nameErrorMsg, name)

} else {

delete(vm.frame.Globals, name)

}

return nil

}

// Pushes co_consts[consti] onto the stack.

func do_LOAD_CONST(vm *Vm, consti int32) error {

vm.PUSH(vm.frame.Code.Consts[consti])

// if debugging { debugf("LOAD_CONST %v\n", vm.TOP()) }

return nil

}

// Pushes the value associated with co_names[namei] onto the stack.

func do_LOAD_NAME(vm *Vm, namei int32) error {

name := vm.frame.Code.Names[namei]

if debugging {

debugf("LOAD_NAME %v\n", name)

}

obj, ok := vm.frame.Lookup(name)

if !ok {

return py.ExceptionNewf(py.NameError, nameErrorMsg, name)

} else {

vm.PUSH(obj)

}

return nil

}

// Creates a tuple consuming count items from the stack, and pushes

// the resulting tuple onto the stack.

func do_BUILD_TUPLE(vm *Vm, count int32) error {

tuple := make(py.Tuple, count)

copy(tuple, vm.frame.Stack[len(vm.frame.Stack)-int(count):])

vm.DROPN(int(count))

vm.PUSH(tuple)

return nil

}

// Works as BUILD_TUPLE, but creates a set.

func do_BUILD_SET(vm *Vm, count int32) error {

set := py.NewSetFromItems(vm.frame.Stack[len(vm.frame.Stack)-int(count):])

vm.DROPN(int(count))

vm.PUSH(set)

return nil

}