Byte code loaded and partly executing

Author: ncw

main.go

@@ -5,10 +5,11 @@ package main
 import (
 	"flag"
 	"fmt"
-	"os"
-	//"github.com/ncw/gpython/vm"
 	"github.com/ncw/gpython/marshal"
+	"github.com/ncw/gpython/py"
+	"github.com/ncw/gpython/vm"
 	"log"
+	"os"
 	"strings"
 )
 
@@ -58,7 +59,8 @@ func main() {
 	if err != nil {
 		log.Fatal(err)
 	}
-	_ = obj
-	// fmt.Println(obj)
+	code := obj.(*py.Code)
+	v := vm.NewVm()
+	v.Run(code)
 
 }

py/code.go

@@ -9,25 +9,25 @@ import (
 // Code object
 type Code struct {
 	// Object_HEAD
-	argcount       int32  // #arguments, except *args
-	kwonlyargcount int32  // #keyword only arguments
-	nlocals        int32  // #local variables
-	stacksize      int32  // #entries needed for evaluation stack
-	flags          int32  // CO_..., see below
-	code           Object // instruction opcodes
-	consts         Object // list (constants used)
-	names          Object // list of strings (names used)
-	varnames       Object // tuple of strings (local variable names)
-	freevars       Object // tuple of strings (free variable names)
-	cellvars       Object // tuple of strings (cell variable names)
+	Argcount       int32  // #arguments, except *args
+	Kwonlyargcount int32  // #keyword only arguments
+	Nlocals        int32  // #local variables
+	Stacksize      int32  // #entries needed for evaluation stack
+	Flags          int32  // CO_..., see below
+	Code           String // instruction opcodes
+	Consts         Tuple  // list (constants used)
+	Names          Tuple  // list of strings (names used)
+	Varnames       Tuple  // tuple of strings (local variable names)
+	Freevars       Tuple  // tuple of strings (free variable names)
+	Cellvars       Tuple  // tuple of strings (cell variable names)
 	// The rest doesn't count for hash or comparisons
-	cell2arg    *byte  // Maps cell vars which are arguments.
-	filename    Object // unicode (where it was loaded from)
-	name        Object // unicode (name, for reference)
-	firstlineno int32  // first source line number
-	lnotab      Object // string (encoding addr<->lineno mapping) See Objects/lnotab_notes.txt for details.
+	Cell2arg    *byte  // Maps cell vars which are arguments.
+	Filename    String // unicode (where it was loaded from)
+	Name        String // unicode (name, for reference)
+	Firstlineno int32  // first source line number
+	Lnotab      String // string (encoding addr<->lineno mapping) See Objects/lnotab_notes.txt for details.
 
-	weakreflist Object // to support weakrefs to code objects
+	Weakreflist List // to support weakrefs to code objects
 }
 
 var CodeType = NewType("code")
@@ -95,7 +95,7 @@ func all_name_chars(s String) bool {
 // Make a new code object
 func NewCode(argcount int32, kwonlyargcount int32,
 	nlocals int32, stacksize int32, flags int32,
-	code Object, consts_ Object, names_ Object,
+	code_ Object, consts_ Object, names_ Object,
 	varnames_ Object, freevars_ Object, cellvars_ Object,
 	filename_ Object, name_ Object, firstlineno int32,
 	lnotab_ Object) *Code {
@@ -111,6 +111,7 @@ func NewCode(argcount int32, kwonlyargcount int32,
 	name := name_.(String)
 	filename := filename_.(String)
 	lnotab := lnotab_.(String)
+	code := code_.(String)
 
 	// Check argument types
 	if argcount < 0 || kwonlyargcount < 0 || nlocals < 0 {
@@ -167,22 +168,22 @@ func NewCode(argcount int32, kwonlyargcount int32,
 	}
 
 	return &Code{
-		argcount:       argcount,
-		kwonlyargcount: kwonlyargcount,
-		nlocals:        nlocals,
-		stacksize:      stacksize,
-		flags:          flags,
-		code:           code,
-		consts:         consts,
-		names:          names,
-		varnames:       varnames,
-		freevars:       freevars,
-		cellvars:       cellvars,
-		cell2arg:       cell2arg,
-		filename:       filename,
-		name:           name,
-		firstlineno:    firstlineno,
-		lnotab:         lnotab,
-		weakreflist:    nil,
+		Argcount:       argcount,
+		Kwonlyargcount: kwonlyargcount,
+		Nlocals:        nlocals,
+		Stacksize:      stacksize,
+		Flags:          flags,
+		Code:           code,
+		Consts:         consts,
+		Names:          names,
+		Varnames:       varnames,
+		Freevars:       freevars,
+		Cellvars:       cellvars,
+		Cell2arg:       cell2arg,
+		Filename:       filename,
+		Name:           name,
+		Firstlineno:    firstlineno,
+		Lnotab:         lnotab,
+		Weakreflist:    nil,
 	}
 }

vm/eval.go

@@ -2,6 +2,7 @@
 package vm
 
 import (
+	"fmt"
 	"github.com/ncw/gpython/py"
 )
 
@@ -145,11 +146,20 @@ func init() {
 
 // Virtual machine state
 type Vm struct {
+	// Object stack
 	stack []py.Object
+	// Current code object
+	co *py.Code
+	// Whether ext should be added to the next arg
+	extended bool
+	// 16 bit extension for argument for next opcode
+	ext int32
+	// Whether we should exit
+	exit bool
 }
 
 // Make a new VM
-func NewVM() *Vm {
+func NewVm() *Vm {
 	vm := new(Vm)
 	vm.stack = make([]py.Object, 0, 1024)
 	return vm
@@ -416,6 +426,7 @@ func do_MAP_ADD(vm *Vm, i int32) {
 
 // Returns with TOS to the caller of the function.
 func do_RETURN_VALUE(vm *Vm, arg int32) {
+	vm.exit = true
 }
 
 // Pops TOS and delegates to it as a subiterator from a generator.
@@ -525,10 +536,12 @@ func do_DELETE_GLOBAL(vm *Vm, namei int32) {
 
 // Pushes co_consts[consti] onto the stack.
 func do_LOAD_CONST(vm *Vm, consti int32) {
+	vm.PUSH(vm.co.Consts[consti])
 }
 
 // Pushes the value associated with co_names[namei] onto the stack.
 func do_LOAD_NAME(vm *Vm, namei int32) {
+	vm.PUSH(vm.co.Names[namei])
 }
 
 // Creates a tuple consuming count items from the stack, and pushes
@@ -686,6 +699,18 @@ func do_RAISE_VARARGS(vm *Vm, argc int32) {
 // function arguments, and the function itself off the stack, and
 // pushes the return value.
 func do_CALL_FUNCTION(vm *Vm, argc int32) {
+	nargs := int(argc & 0xFF)
+	nkwargs := int((argc >> 8) & 0xFF)
+	p, q := len(vm.stack)-2*nkwargs, len(vm.stack)
+	kwargs := vm.stack[p:q]
+	p, q = p-nargs, p
+	args := vm.stack[p:q]
+	p, q = p-1, p
+	fn := vm.stack[p]
+	fmt.Printf("Call %v with args = %v, kwargs = %v\n", fn, args, kwargs)
+	// Drop the args off the stack and put return value in
+	vm.stack = vm.stack[:q]
+	vm.stack[p] = py.None
 }
 
 // Pushes a new function object on the stack. TOS is the code
@@ -713,6 +738,8 @@ func do_BUILD_SLICE(vm *Vm, argc int32) {
 // together with the subsequent opcode’s argument, comprise a
 // four-byte argument, ext being the two most-significant bytes.
 func do_EXTENDED_ARG(vm *Vm, ext int32) {
+	vm.ext = ext
+	vm.extended = true
 }
 
 // Calls a function. argc is interpreted as in CALL_FUNCTION. The top
@@ -733,3 +760,31 @@ func do_CALL_FUNCTION_KW(vm *Vm, argc int32) {
 // keyword and positional arguments.
 func do_CALL_FUNCTION_VAR_KW(vm *Vm, argc int32) {
 }
+
+// Run the virtual machine on the code object
+func (vm *Vm) Run(co *py.Code) {
+	vm.co = co
+	ip := 0
+	var opcode byte
+	var arg int32
+	code := co.Code
+	for !vm.exit {
+		opcode = code[ip]
+		ip++
+		if HAS_ARG(opcode) {
+			arg = int32(code[ip])
+			ip++
+			arg += int32(code[ip] << 8)
+			ip++
+			if vm.extended {
+				arg += vm.ext << 16
+			}
+			fmt.Printf("Opcode %d with arg %d\n", opcode, arg)
+		} else {
+			fmt.Printf("Opcode %d\n", opcode)
+		}
+		vm.extended = false
+		jumpTable[opcode](vm, arg)
+	}
+	// Return something?
+}