Make builtin print sort of work

Author: ncw

main.go

@@ -5,6 +5,7 @@ package main
 import (
 	"flag"
 	"fmt"
+	_ "github.com/ncw/gpython/builtin"
 	"github.com/ncw/gpython/marshal"
 	"github.com/ncw/gpython/py"
 	"github.com/ncw/gpython/vm"

py/method.go

@@ -75,11 +75,11 @@ const (
 // A python Method object
 type Method struct {
 	// Name of this function
-	name string
+	Name string
 	// Doc string
-	doc string
+	Doc string
 	// Flags - see METH_* flags
-	flags int
+	Flags int
 	// C function implementation (two definitions, only one is used)
 	method             PyCFunction
 	methodWithKeywords PyCFunctionWithKeywords
@@ -98,9 +98,9 @@ func NewMethod(name string, method PyCFunction, flags int, doc string) *Method {
 		panic("Can't set METH_KEYWORDS")
 	}
 	return &Method{
-		name:   name,
-		doc:    doc,
-		flags:  flags,
+		Name:   name,
+		Doc:    doc,
+		Flags:  flags,
 		method: method,
 	}
 }
@@ -111,9 +111,26 @@ func NewMethodWithKeywords(name string, method PyCFunctionWithKeywords, flags in
 		panic("Must set METH_KEYWORDS")
 	}
 	return &Method{
-		name:               name,
-		doc:                doc,
-		flags:              flags,
+		Name:               name,
+		Doc:                doc,
+		Flags:              flags,
 		methodWithKeywords: method,
 	}
 }
+
+// Call the method with the given arguments
+func (m *Method) Call(self Object, args Tuple) Object {
+	if m.method != nil {
+		return m.method(self, args)
+	}
+	// FIXME or call with empty dict?
+	return m.methodWithKeywords(self, args, NewDict())
+}
+
+// Call the method with the given arguments
+func (m *Method) CallWithKeywords(self Object, args Tuple, kwargs Dict) Object {
+	if m.method != nil {
+		panic("Can't call method with kwargs")
+	}
+	return m.methodWithKeywords(self, args, kwargs)
+}

py/module.go

@@ -2,11 +2,22 @@
 
 package py
 
+import (
+	"fmt"
+)
+
+var (
+	// Registry of installed modules
+	modules = make(map[string]*Module)
+	// Builtin module
+	Builtins *Module
+)
+
 // A python Module object
 type Module struct {
-	name    string
-	doc     string
-	methods []*Method
+	Name    string
+	Doc     string
+	Methods map[string]*Method
 	//	dict Dict
 }
 
@@ -19,9 +30,21 @@ func (o *Module) Type() *Type {
 
 // Define a new module
 func NewModule(name, doc string, methods []*Method) *Module {
-	return &Module{
-		name:    name,
-		doc:     doc,
-		methods: methods,
+	m := &Module{
+		Name:    name,
+		Doc:     doc,
+		Methods: make(map[string]*Method),
+	}
+	// Insert the methods into the module dictionary
+	for _, method := range methods {
+		m.Methods[method.Name] = method
+	}
+	// Register the module
+	modules[name] = m
+	// Make a note of the builtin module
+	if name == "builtins" {
+		Builtins = m
 	}
+	fmt.Printf("Registering module %q\n", name)
+	return m
 }

py/py.go

@@ -81,6 +81,11 @@ func (o Dict) Type() *Type {
 	return DictType
 }
 
+// Make a new dictionary
+func NewDict() Dict {
+	return make(Dict)
+}
+
 var SetType = NewType("set")
 
 type Set map[Object]struct{}

vm/eval.go

@@ -704,10 +704,25 @@ func do_CALL_FUNCTION(vm *Vm, argc int32) {
 	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]
+	args := py.Tuple(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)
+	// FIXME look the function up
+	fn_name := string(fn.(py.String))
+	if method, ok := py.Builtins.Methods[fn_name]; ok {
+		// FIXME need module as self
+		self := py.None
+		if len(kwargs) > 0 {
+			// FIXME need to convert kwargs to dictionary
+			kwargsd := py.NewDict()
+			vm.stack[p] = method.CallWithKeywords(self, args, kwargsd)
+		} else {
+			vm.stack[p] = method.Call(self, args)
+		}
+	} else {
+		panic("Couldn't find method")
+	}
 	// Drop the args off the stack and put return value in
 	vm.stack = vm.stack[:q]
 	vm.stack[p] = py.None