Add module objects, method objects and a start at builtins

Author: ncw

builtin/builtin.go

@@ -0,0 +1,73 @@
+// Built-in functions
+package builtin
+
+import (
+	"fmt"
+	"github.com/ncw/gpython/py"
+)
+
+const builtin_doc = `Built-in functions, exceptions, and other objects.
+
+Noteworthy: None is the 'nil' object; Ellipsis represents '...' in slices.`
+
+// Initialise the module
+func init() {
+	methods := []*py.Method{
+		// py.NewMethodWithKeywords("__build_class__", builtin___build_class__, py.METH_VARARGS|py.METH_KEYWORDS, build_class_doc),
+		// py.NewMethodWithKeywords("__import__", builtin___import__, py.METH_VARARGS|py.METH_KEYWORDS, import_doc),
+		// py.NewMethod("abs", builtin_abs, py.METH_O, abs_doc),
+		// py.NewMethod("all", builtin_all, py.METH_O, all_doc),
+		// py.NewMethod("any", builtin_any, py.METH_O, any_doc),
+		// py.NewMethod("ascii", builtin_ascii, py.METH_O, ascii_doc),
+		// py.NewMethod("bin", builtin_bin, py.METH_O, bin_doc),
+		// py.NewMethod("callable", builtin_callable, py.METH_O, callable_doc),
+		// py.NewMethod("chr", builtin_chr, py.METH_VARARGS, chr_doc),
+		// py.NewMethodWithKeywords("compile", builtin_compile, py.METH_VARARGS|py.METH_KEYWORDS, compile_doc),
+		// py.NewMethod("delattr", builtin_delattr, py.METH_VARARGS, delattr_doc),
+		// py.NewMethod("dir", builtin_dir, py.METH_VARARGS, dir_doc),
+		// py.NewMethod("divmod", builtin_divmod, py.METH_VARARGS, divmod_doc),
+		// py.NewMethod("eval", builtin_eval, py.METH_VARARGS, eval_doc),
+		// py.NewMethod("exec", builtin_exec, py.METH_VARARGS, exec_doc),
+		// py.NewMethod("format", builtin_format, py.METH_VARARGS, format_doc),
+		// py.NewMethod("getattr", builtin_getattr, py.METH_VARARGS, getattr_doc),
+		// py.NewMethod("globals", builtin_globals, py.METH_NOARGS, globals_doc),
+		// py.NewMethod("hasattr", builtin_hasattr, py.METH_VARARGS, hasattr_doc),
+		// py.NewMethod("hash", builtin_hash, py.METH_O, hash_doc),
+		// py.NewMethod("hex", builtin_hex, py.METH_O, hex_doc),
+		// py.NewMethod("id", builtin_id, py.METH_O, id_doc),
+		// py.NewMethod("input", builtin_input, py.METH_VARARGS, input_doc),
+		// py.NewMethod("isinstance", builtin_isinstance, py.METH_VARARGS, isinstance_doc),
+		// py.NewMethod("issubclass", builtin_issubclass, py.METH_VARARGS, issubclass_doc),
+		// py.NewMethod("iter", builtin_iter, py.METH_VARARGS, iter_doc),
+		// py.NewMethod("len", builtin_len, py.METH_O, len_doc),
+		// py.NewMethod("locals", builtin_locals, py.METH_NOARGS, locals_doc),
+		// py.NewMethodWithKeywords("max", builtin_max, py.METH_VARARGS|py.METH_KEYWORDS, max_doc),
+		// py.NewMethodWithKeywords("min", builtin_min, py.METH_VARARGS|py.METH_KEYWORDS, min_doc),
+		// py.NewMethod("next", builtin_next, py.METH_VARARGS, next_doc),
+		// py.NewMethod("oct", builtin_oct, py.METH_O, oct_doc),
+		// py.NewMethod("ord", builtin_ord, py.METH_O, ord_doc),
+		// py.NewMethod("pow", builtin_pow, py.METH_VARARGS, pow_doc),
+		py.NewMethodWithKeywords("print", builtin_print, py.METH_VARARGS|py.METH_KEYWORDS, print_doc),
+		// py.NewMethod("repr", builtin_repr, py.METH_O, repr_doc),
+		// py.NewMethodWithKeywords("round", builtin_round, py.METH_VARARGS|py.METH_KEYWORDS, round_doc),
+		// py.NewMethod("setattr", builtin_setattr, py.METH_VARARGS, setattr_doc),
+		// py.NewMethodWithKeywords("sorted", builtin_sorted, py.METH_VARARGS|py.METH_KEYWORDS, sorted_doc),
+		// py.NewMethod("sum", builtin_sum, py.METH_VARARGS, sum_doc),
+		// py.NewMethod("vars", builtin_vars, py.METH_VARARGS, vars_doc),
+	}
+	py.NewModule("builtins", builtin_doc, methods)
+}
+
+const print_doc = `print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)
+
+Prints the values to a stream, or to sys.stdout by default.
+Optional keyword arguments:
+file:  a file-like object (stream); defaults to the current sys.stdout.
+sep:   string inserted between values, default a space.
+end:   string appended after the last value, default a newline.
+flush: whether to forcibly flush the stream.`
+
+func builtin_print(self py.Object, args py.Tuple, kwargs py.Dict) py.Object {
+	fmt.Printf("print %v, %v, %v\n", self, args, kwargs)
+	return py.None
+}

py/method.go

@@ -0,0 +1,119 @@
+// Method objects
+//
+// This is about the type 'builtin_function_or_method', not Python
+// methods in user-defined classes.  See class.go for the latter.
+
+package py
+
+// Types for methods
+type PyCFunction func(Object, Tuple) Object
+type PyCFunctionWithKeywords func(Object, Tuple, Dict) Object
+
+const (
+
+	// This is the typical calling convention, where the methods have the
+	// type PyCFunction. The function expects two PyObject* values. The
+	// first one is the self object for methods; for module functions, it
+	// is the module object. The second parameter (often called args) is a
+	// tuple object representing all arguments. This parameter is
+	// typically processed using PyArg_ParseTuple() or
+	// PyArg_UnpackTuple().
+	METH_VARARGS = 0x0001
+
+	// Methods with these flags must be of type
+	// PyCFunctionWithKeywords. The function expects three parameters:
+	// self, args, and a dictionary of all the keyword arguments. The flag
+	// is typically combined with METH_VARARGS, and the parameters are
+	// typically processed using PyArg_ParseTupleAndKeywords().
+	METH_KEYWORDS = 0x0002
+
+	// Methods without parameters don’t need to check whether arguments
+	// are given if they are listed with the METH_NOARGS flag. They need
+	// to be of type PyCFunction. The first parameter is typically named
+	// self and will hold a reference to the module or object instance. In
+	// all cases the second parameter will be NULL.
+	METH_NOARGS = 0x0004
+
+	// Methods with a single object argument can be listed with the METH_O
+	// flag, instead of invoking PyArg_ParseTuple() with a "O"
+	// argument. They have the type PyCFunction, with the self parameter,
+	// and a PyObject* parameter representing the single argument.
+	METH_O = 0x0008
+
+	// These two constants are not used to indicate the calling convention
+	// but the binding when use with methods of classes. These may not be
+	// used for functions defined for modules. At most one of these flags
+	// may be set for any given method.
+
+	// The method will be passed the type object as the first parameter
+	// rather than an instance of the type. This is used to create class
+	// methods, similar to what is created when using the classmethod()
+	// built-in function.
+	METH_CLASS = 0x0010
+
+	// The method will be passed NULL as the first parameter rather than
+	// an instance of the type. This is used to create static methods,
+	// similar to what is created when using the staticmethod() built-in
+	// function.
+	METH_STATIC = 0x0020
+
+	// One other constant controls whether a method is loaded in
+	// place of another definition with the same method name.
+
+	// The method will be loaded in place of existing definitions. Without
+	// METH_COEXIST, the default is to skip repeated definitions. Since
+	// slot wrappers are loaded before the method table, the existence of
+	// a sq_contains slot, for example, would generate a wrapped method
+	// named __contains__() and preclude the loading of a corresponding
+	// PyCFunction with the same name. With the flag defined, the
+	// PyCFunction will be loaded in place of the wrapper object and will
+	// co-exist with the slot. This is helpful because calls to
+	// PyCFunctions are optimized more than wrapper object calls.
+	METH_COEXIST = 0x0040
+)
+
+// A python Method object
+type Method struct {
+	// Name of this function
+	name string
+	// Doc string
+	doc string
+	// Flags - see METH_* flags
+	flags int
+	// C function implementation (two definitions, only one is used)
+	method             PyCFunction
+	methodWithKeywords PyCFunctionWithKeywords
+}
+
+var MethodType = NewType("method")
+
+// Type of this object
+func (o *Method) Type() *Type {
+	return MethodType
+}
+
+// Define a new method
+func NewMethod(name string, method PyCFunction, flags int, doc string) *Method {
+	if flags&METH_KEYWORDS != 0 {
+		panic("Can't set METH_KEYWORDS")
+	}
+	return &Method{
+		name:   name,
+		doc:    doc,
+		flags:  flags,
+		method: method,
+	}
+}
+
+// Define a new method with keyword arguments
+func NewMethodWithKeywords(name string, method PyCFunctionWithKeywords, flags int, doc string) *Method {
+	if flags&METH_KEYWORDS == 0 {
+		panic("Must set METH_KEYWORDS")
+	}
+	return &Method{
+		name:               name,
+		doc:                doc,
+		flags:              flags,
+		methodWithKeywords: method,
+	}
+}

py/module.go

@@ -0,0 +1,27 @@
+// Module objects
+
+package py
+
+// A python Module object
+type Module struct {
+	name    string
+	doc     string
+	methods []*Method
+	//	dict Dict
+}
+
+var ModuleType = NewType("module")
+
+// Type of this object
+func (o *Module) Type() *Type {
+	return ModuleType
+}
+
+// Define a new module
+func NewModule(name, doc string, methods []*Method) *Module {
+	return &Module{
+		name:    name,
+		doc:     doc,
+		methods: methods,
+	}
+}