Working towards making classes work

  * Implement Cell and None types
  * Implement __build_class__ builtin (not fully working yet)
  * Implement globals for modules and __builtin__ globals
  * Correct spelling of Ellipsis
  * __doc__ for modules
  * Add __call__ interface
  * Rework Call yet again to suport __call__
  * Copy a dictionary
  * Add iterator type
  * Fill out more Module internals
  * Opcodes STORE_LOCALS, LOAD_BUILD_CLASS

Author: ncw

builtin/builtin.go

@@ -4,6 +4,7 @@ package builtin
 import (
 	"fmt"
 	"github.com/ncw/gpython/py"
+	"github.com/ncw/gpython/vm"
 )
 
 const builtin_doc = `Built-in functions, exceptions, and other objects.
@@ -13,7 +14,7 @@ Noteworthy: None is the 'nil' object; Ellipsis represents '...' in slices.`
 // Initialise the module
 func init() {
 	methods := []*py.Method{
-		// py.NewMethod("__build_class__", builtin___build_class__, 0, build_class_doc),
+		py.NewMethod("__build_class__", builtin___build_class__, 0, build_class_doc),
 		// py.NewMethod("__import__", builtin___import__, 0, import_doc),
 		py.NewMethod("abs", builtin_abs, 0, abs_doc),
 		// py.NewMethod("all", builtin_all, 0, all_doc),
@@ -55,7 +56,40 @@ func init() {
 		// py.NewMethod("sum", builtin_sum, 0, sum_doc),
 		// py.NewMethod("vars", builtin_vars, 0, vars_doc),
 	}
-	py.NewModule("builtins", builtin_doc, methods)
+	globals := py.StringDict{
+		"None":           py.None,
+		"Ellipsis":       py.Ellipsis,
+		"NotImplemented": py.NotImplemented,
+		"False":          py.False,
+		"True":           py.True,
+		"bool":           py.BoolType,
+		// "memoryview":     py.MemoryViewType,
+		// "bytearray":      py.ByteArrayType,
+		"bytes": py.BytesType,
+		// "classmethod":    py.ClassMethodType,
+		"complex": py.ComplexType,
+		"dict":    py.StringDictType, // FIXME
+		// "enumerate":      py.EnumType,
+		// "filter":         py.FilterType,
+		"float":     py.FloatType,
+		"frozenset": py.FrozenSetType,
+		// "property":       py.PropertyType,
+		"int":  py.IntType, // FIXME LongType?
+		"list": py.ListType,
+		// "map":            py.MapType,
+		// "object":         py.BaseObjectType,
+		// "range":          py.RangeType,
+		// "reversed":       py.ReversedType,
+		"set": py.SetType,
+		// "slice":          py.SliceType,
+		// "staticmethod":   py.StaticMethodType,
+		"str": py.StringType,
+		// "super":          py.SuperType,
+		"tuple": py.TupleType,
+		"type":  py.TypeType,
+		// "zip":            py.ZipType,
+	}
+	py.NewModule("builtins", builtin_doc, methods, globals)
 }
 
 const print_doc = `print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)
@@ -113,3 +147,85 @@ func builtin_round(self py.Object, args py.Tuple, kwargs py.StringDict) py.Objec
 
 	return numberRounder.M__round__(ndigits)
 }
+
+const build_class_doc = `__build_class__(func, name, *bases, metaclass=None, **kwds) -> class
+
+Internal helper function used by the class statement.`
+
+func builtin___build_class__(self py.Object, args py.Tuple, kwargs py.StringDict) py.Object {
+	var prep, cell, cls py.Object
+	var mkw, ns py.StringDict
+	var meta, winner *py.Type
+	var isclass bool
+
+	if len(args) < 2 {
+		// FIXME TypeError
+		panic(fmt.Sprintf("TypeError: __build_class__: not enough arguments"))
+	}
+
+	// Better be callable
+	fn, ok := args[0].(*py.Function)
+	if !ok {
+		// FIXME TypeError
+		panic(fmt.Sprintf("TypeError: __build__class__: func must be a function"))
+	}
+
+	name := args[1].(py.String)
+	if !ok {
+		// FIXME TypeError
+		panic(fmt.Sprintf("TypeError: __build_class__: name is not a string"))
+	}
+	bases := args[2:]
+
+	if kwargs != nil {
+		mkw = kwargs.Copy()      // Don't modify kwds passed in!
+		meta := mkw["metaclass"] // _PyDict_GetItemId(mkw, &PyId_metaclass)
+		if meta != nil {
+			delete(mkw, "metaclass")
+			// metaclass is explicitly given, check if it's indeed a class
+			_, isclass = meta.(*py.Type)
+		}
+	}
+	if meta == nil {
+		// if there are no bases, use type:
+		if len(bases) == 0 {
+			meta = py.TypeType
+		} else {
+			// else get the type of the first base
+			meta = bases[0].Type()
+		}
+		isclass = true // meta is really a class
+	}
+
+	if isclass {
+		// meta is really a class, so check for a more derived
+		// metaclass, or possible metaclass conflicts:
+		winner = meta.CalculateMetaclass(bases)
+		if winner != meta {
+			meta = winner
+		}
+	}
+	// else: meta is not a class, so we cannot do the metaclass
+	// calculation, so we will use the explicitly given object as it is
+	prep = meta.Type().Methods["___prepare__"]
+	if prep == nil {
+		ns = py.NewStringDict()
+	} else {
+		ns = py.Call(prep, py.Tuple{name, bases}, mkw).(py.StringDict)
+	}
+	fmt.Printf("Calling %v with %#v and %#v\n", fn.Name, fn.Globals, ns)
+	cell, err := vm.Run(fn.Globals, ns, fn.Code) // FIXME PyFunction_GET_CLOSURE(fn))
+	fmt.Printf("result %v %s\n", cell, err)
+	if err != nil {
+		// FIXME
+		panic(err)
+	}
+	if cell != nil {
+		fmt.Printf("Calling %v\n", meta)
+		cls = py.Call(meta, py.Tuple{name, bases, ns}, mkw)
+		if c, ok := cell.(*py.Cell); ok {
+			c.Set(cls)
+		}
+	}
+	return cls
+}

main.go

@@ -61,7 +61,7 @@ func main() {
 		log.Fatal(err)
 	}
 	code := obj.(*py.Code)
-	module := py.NewModule("__main__", "", nil)
+	module := py.NewModule("__main__", "", nil, nil)
 	res, err := vm.Run(module.Globals, module.Globals, code)
 	if err != nil {
 		log.Fatal(err)

marshal/marshal.go

@@ -77,7 +77,7 @@ func ReadObject(r io.Reader) (obj py.Object, err error) {
 		return py.StopIteration, nil
 	case TYPE_ELLIPSIS:
 		// The python elipsis object
-		return py.Elipsis, nil
+		return py.Ellipsis, nil
 	case TYPE_INT:
 		// 4 bytes of signed integer
 		var n int32

notes.txt

@@ -1,3 +1,5 @@
+Note byte code is from python 3.3!
+
 Put C modules in sub directory
 Make an all submodule so can insert all of them easily with 
 

py/bool.go

@@ -5,7 +5,7 @@ package py
 type Bool bool
 
 var (
-	BoolType = NewType("bool")
+	BoolType = NewType("bool", "bool(x) -> bool\n\nReturns True when the argument x is true, False otherwise.\nThe builtins True and False are the only two instances of the class bool.\nThe class bool is a subclass of the class int, and cannot be subclassed.")
 	// Some well known bools
 	False = Bool(false)
 	True  = Bool(true)

py/bytes.go

@@ -2,7 +2,7 @@
 
 package py
 
-var BytesType = NewType("bytes")
+var BytesType = NewType("bytes", "bytes(iterable_of_ints) -> bytes\nbytes(string, encoding[, errors]) -> bytes\nbytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer\nbytes(int) -> bytes object of size given by the parameter initialized with null bytes\nbytes() -> empty bytes object\n\nConstruct an immutable array of bytes from:\n  - an iterable yielding integers in range(256)\n  - a text string encoded using the specified encoding\n  - any object implementing the buffer API.\n  - an integer")
 
 type Bytes []byte
 

py/cell.go

@@ -0,0 +1,36 @@
+// Cell object
+//
+// In the Go implementation this is just a pointer to an Object which
+// can be nil
+
+package py
+
+// A python Cell object
+type Cell struct {
+	obj *Object
+}
+
+var CellType = NewType("cell", "cell object")
+
+// Type of this object
+func (o *Cell) Type() *Type {
+	return CellType
+}
+
+// Define a new cell
+func NewCell(obj Object) *Cell {
+	return &Cell{&obj}
+}
+
+// Fetch the contents of the Cell or nil if not set
+func (c *Cell) Get() Object {
+	if c.obj == nil {
+		return nil
+	}
+	return *c.obj
+}
+
+// Set the contents of the Cell
+func (c *Cell) Set(obj Object) {
+	c.obj = &obj
+}

py/code.go

@@ -29,7 +29,7 @@ type Code struct {
 	Weakreflist List // to support weakrefs to code objects
 }
 
-var CodeType = NewType("code")
+var CodeType = NewType("code", "code(argcount, kwonlyargcount, nlocals, stacksize, flags, codestring,\n      constants, names, varnames, filename, name, firstlineno,\n      lnotab[, freevars[, cellvars]])\n\nCreate a code object.  Not for the faint of heart.")
 
 // Type of this object
 func (o *Code) Type() *Type {

py/complex.go

@@ -8,7 +8,7 @@ import (
 	"math/cmplx"
 )
 
-var ComplexType = NewType("complex64")
+var ComplexType = NewType("complex64", "complex(real[, imag]) -> complex number\n\nCreate a complex number from a real part and an optional imaginary part.\nThis is equivalent to (real + imag*1j) where imag defaults to 0.")
 
 type Complex complex128
 

py/dict.go

@@ -5,7 +5,7 @@
 
 package py
 
-var StringDictType = NewType("dict")
+var StringDictType = NewType("dict", "dict() -> new empty dictionary\ndict(mapping) -> new dictionary initialized from a mapping object's\n    (key, value) pairs\ndict(iterable) -> new dictionary initialized as if via:\n    d = {}\n    for k, v in iterable:\n        d[k] = v\ndict(**kwargs) -> new dictionary initialized with the name=value pairs\n    in the keyword argument list.  For example:  dict(one=1, two=2)")
 
 // String to object dictionary
 //
@@ -21,3 +21,12 @@ func (o StringDict) Type() *Type {
 func NewStringDict() StringDict {
 	return make(StringDict)
 }
+
+// Copy a dictionary
+func (d StringDict) Copy() StringDict {
+	e := make(StringDict, len(d))
+	for k, v := range d {
+		e[k] = v
+	}
+	return e
+}

py/exception.go

@@ -14,7 +14,8 @@ type Exception struct {
 }
 
 var (
-	ExceptionType = NewType("exception")
+	// FIXME should be a class probably
+	ExceptionType = NewType("exception", "Common base class for all exceptions")
 
 	// Some well known exceptions - these should be types?
 	// FIXME exceptions should be created in builtins probably

py/float.go

@@ -6,7 +6,7 @@ import (
 	"math"
 )
 
-var FloatType = NewType("float")
+var FloatType = NewType("float", "float(x) -> floating point number\n\nConvert a string or number to a floating point number, if possible.")
 
 type Float float64
 

py/frame.go

@@ -55,7 +55,7 @@ type Frame struct {
 	Localsplus []Object   // locals+stack, dynamically sized
 }
 
-var FrameType = NewType("frame")
+var FrameType = NewType("frame", "Represents a stack frame")
 
 // Type of this object
 func (o *Frame) Type() *Type {

py/function.go

@@ -31,7 +31,7 @@ type Function struct {
 	Qualname    string     // The qualified name
 }
 
-var FunctionType = NewType("function")
+var FunctionType = NewType("function", "A python function")
 
 // Type of this object
 func (o *Function) Type() *Type {
@@ -106,3 +106,23 @@ func (f *Function) LocalsForCallWithKeywords(args Tuple, kwargs StringDict) Stri
 	fmt.Printf("FIXME LocalsForCallWithKeywords NOT IMPLEMENTED\n")
 	return locals
 }
+
+// Call a function
+func (f *Function) M__call__(args Tuple, kwargs StringDict) Object {
+	var locals StringDict
+	if kwargs != nil {
+		locals = f.LocalsForCallWithKeywords(args, kwargs)
+	} else {
+		locals = f.LocalsForCall(args)
+	}
+	result, err := Run(f.Globals, locals, f.Code)
+	if err != nil {
+		// FIXME - do what exactly!
+		panic(err)
+	}
+	return result
+}
+
+// Make sure it satisfies the interface
+var _ Object = (*Function)(nil)
+var _ I__call__ = (*Function)(nil)

py/int.go

@@ -7,7 +7,7 @@ import (
 	"math/big"
 )
 
-var IntType = NewType("int")
+var IntType = NewType("int", "int(x=0) -> integer\nint(x, base=10) -> integer\n\nConvert a number or string to an integer, or return 0 if no arguments\nare given.  If x is a number, return x.__int__().  For floating point\nnumbers, this truncates towards zero.\n\nIf x is not a number or if base is given, then x must be a string,\nbytes, or bytearray instance representing an integer literal in the\ngiven base.  The literal can be preceded by '+' or '-' and be surrounded\nby whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.\nBase 0 means to interpret the base from the string as an integer literal.\n>>> int('0b100', base=0)\n4")
 
 type Int int64
 
@@ -18,7 +18,7 @@ func (o Int) Type() *Type {
 
 type BigInt big.Int
 
-var BigIntType = NewType("bigint")
+var BigIntType = NewType("bigint", "Holds large integers")
 
 // Type of this BigInt object
 func (o *BigInt) Type() *Type {

py/internal.go

@@ -59,3 +59,19 @@ func Not(a Object) Object {
 	}
 	panic("bool() didn't return True or False")
 }
+
+// Calls function fnObj with args and kwargs in a new vm (or directly
+// if Go code)
+//
+// kwargs should be nil if not required
+//
+// fnObj must be a callable type such as *py.Method or *py.Function
+//
+// The result is returned
+func Call(fn Object, args Tuple, kwargs StringDict) Object {
+	if I, ok := fn.(I__call__); ok {
+		return I.M__call__(args, kwargs)
+	}
+	// FIXME should be TypeError
+	panic(fmt.Sprintf("TypeError: '%s' object is not callable", fn.Type().Name))
+}