Use more native types

Author: ncw

py/code.go

@@ -8,23 +8,23 @@ import (
 
 // Code object
 type Code struct {
-	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)
+	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          []string // list of strings (names used)
+	Varnames       []string // tuple of strings (local variable names)
+	Freevars       []string // tuple of strings (free variable names)
+	Cellvars       []string // tuple of strings (cell variable names)
 	// The rest doesn't count for hash or comparisons
 	Cell2arg    *byte  // Maps cell vars which are arguments.
-	Filename    String // unicode (where it was loaded from)
-	Name        String // unicode (name, for reference)
+	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.
+	Lnotab      string // string (encoding addr<->lineno mapping) See Objects/lnotab_notes.txt for details.
 
 	Weakreflist List // to support weakrefs to code objects
 }
@@ -103,14 +103,32 @@ func NewCode(argcount int32, kwonlyargcount int32,
 
 	// Type assert the objects
 	consts := consts_.(Tuple)
-	names := names_.(Tuple)
-	varnames := varnames_.(Tuple)
-	freevars := freevars_.(Tuple)
-	cellvars := cellvars_.(Tuple)
-	name := name_.(String)
-	filename := filename_.(String)
-	lnotab := lnotab_.(String)
-	code := code_.(String)
+	namesTuple := names_.(Tuple)
+	varnamesTuple := varnames_.(Tuple)
+	freevarsTuple := freevars_.(Tuple)
+	cellvarsTuple := cellvars_.(Tuple)
+	name := string(name_.(String))
+	filename := string(filename_.(String))
+	lnotab := string(lnotab_.(String))
+	code := string(code_.(String))
+
+	// Convert Tuples to native []string for speed
+	names := make([]string, len(namesTuple))
+	for i := range namesTuple {
+		names[i] = string(namesTuple[i].(String))
+	}
+	varnames := make([]string, len(varnamesTuple))
+	for i := range varnamesTuple {
+		varnames[i] = string(varnamesTuple[i].(String))
+	}
+	freevars := make([]string, len(freevarsTuple))
+	for i := range freevarsTuple {
+		freevars[i] = string(freevarsTuple[i].(String))
+	}
+	cellvars := make([]string, len(cellvarsTuple))
+	for i := range cellvarsTuple {
+		cellvars[i] = string(cellvarsTuple[i].(String))
+	}
 
 	// Check argument types
 	if argcount < 0 || kwonlyargcount < 0 || nlocals < 0 {
@@ -124,10 +142,10 @@ func NewCode(argcount int32, kwonlyargcount int32,
 	// }
 
 	n_cellvars := len(cellvars)
-	intern_strings(names)
-	intern_strings(varnames)
-	intern_strings(freevars)
-	intern_strings(cellvars)
+	intern_strings(namesTuple)
+	intern_strings(varnamesTuple)
+	intern_strings(freevarsTuple)
+	intern_strings(cellvarsTuple)
 	/* Intern selected string constants */
 	for i := len(consts) - 1; i >= 0; i-- {
 		if v, ok := consts[i].(String); ok {

py/function.go

@@ -28,12 +28,12 @@ type Function struct {
 	KwDefaults  StringDict // NULL or a dict
 	Closure     Tuple      // NULL or a tuple of cell objects
 	Doc         Object     // The __doc__ attribute, can be anything
-	Name        String     // The __name__ attribute, a string object
+	Name        string     // The __name__ attribute, a string object
 	Dict        StringDict // The __dict__ attribute, a dict or NULL
 	Weakreflist List       // List of weak references
 	Module      *Module    // The __module__ attribute, can be anything
 	Annotations StringDict // Annotations, a dict or NULL
-	Qualname    String     // The qualified name
+	Qualname    string     // The qualified name
 }
 
 var FunctionType = NewType("function")
@@ -56,7 +56,7 @@ func (o *Function) Type() *Type {
 // attribute. qualname should be a unicode object or ""; if "", the
 // __qualname__ attribute is set to the same value as its __name__
 // attribute.
-func NewFunction(code *Code, globals StringDict, qualname String) *Function {
+func NewFunction(code *Code, globals StringDict, qualname string) *Function {
 	var doc Object
 	var module *Module
 	if len(code.Consts) >= 1 {
@@ -99,7 +99,7 @@ func (f *Function) Call(self Object, args Tuple) Object {
 	// Copy the args into the local variables
 	locals := NewStringDict()
 	for i := range args {
-		locals[string(f.Code.Varnames[i].(String))] = args[i]
+		locals[f.Code.Varnames[i]] = args[i]
 	}
 	fmt.Printf("locals = %v\n", locals)
 	// FIXME return?

vm/eval.go

@@ -395,7 +395,7 @@ func do_WITH_CLEANUP(vm *Vm, arg int32) {
 // 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) {
-	vm.locals[string(vm.co.Names[namei].(py.String))] = vm.POP()
+	vm.locals[vm.co.Names[namei]] = vm.POP()
 }
 
 // Implements del name, where namei is the index into co_names
@@ -439,7 +439,7 @@ func do_LOAD_CONST(vm *Vm, consti int32) {
 
 // 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])
+	vm.PUSH(py.String(vm.co.Names[namei]))
 }
 
 // Creates a tuple consuming count items from the stack, and pushes
@@ -562,7 +562,7 @@ func do_STORE_MAP(vm *Vm, arg int32) {
 
 // Pushes a reference to the local co_varnames[var_num] onto the stack.
 func do_LOAD_FAST(vm *Vm, var_num int32) {
-	vm.PUSH(vm.locals[string(vm.co.Varnames[var_num].(py.String))])
+	vm.PUSH(vm.locals[vm.co.Varnames[var_num]])
 }
 
 // Stores TOS into the local co_varnames[var_num].
@@ -650,7 +650,7 @@ func do_MAKE_FUNCTION(vm *Vm, argc int32) {
 	num_annotations := (argc >> 16) & 0x7fff
 	qualname := vm.POP()
 	code := vm.POP()
-	function := py.NewFunction(code.(*py.Code), vm.globals, qualname.(py.String))
+	function := py.NewFunction(code.(*py.Code), vm.globals, string(qualname.(py.String)))
 
 	// FIXME share code with MAKE_CLOSURE
 	// if opcode == MAKE_CLOSURE {