Make List mutable - type is now *List

Author: ncw

marshal/marshal.go

@@ -208,7 +208,7 @@ func ReadObject(r io.Reader) (obj py.Object, err error) {
 		case TYPE_TUPLE:
 			return py.Tuple(tuple), nil
 		case TYPE_LIST:
-			return py.List(tuple), nil
+			return py.NewListFromItems(tuple), nil
 		}
 
 		set := make(py.Set, len(tuple))

notes.txt

@@ -43,23 +43,14 @@ Polymorphism
 
   ok, res := obj.Type().Call0("__XXX__")
   ok, res := obj.Type().Call1("__XXX__", a)
-  ok, res := obj.Type().Call2("__XXX__", b)
+  ok, res := obj.Type().Call2("__XXX__", a, b)
   ok is method found
   res is valid if found (or maybe NotImplemented)
 
   Call() looks up name in methods and if found calls it either C wise or py-wise
 
   Calling C-wise is easy enough, but how to call py-wise?
 
-  Assuming we are being called from the VM we would like to use the
-  same VM to execute it? Or could make a new one which seems a little
-  expensive and what is going to happen to exceptions and unwinding
-  the stack?
-
-  Looks like python makes a new vm with PyEval_EvalCode so will need
-  to make sure we store the unwinding stack frame in the exception
-  (which is what python does I think)
-
 all together
 
   var ok bool
@@ -77,16 +68,28 @@ ObjectType in *Type is probably redundant
 Todo
 ====
 
-  * Closures
   * With statements
   * Import
+  * Dict
+  * Set
+  * Tracebacks - need to update the traceback object when unwinding the stack - could include go traceback too
 
 Difference between gpython and cpython
 ======================================
 
 Uses native types for some of the objects, eg String, Int, Tuple, StringDict
 
-Does not support threading, so no thread state or thread local variables
+The immutable types String, Int are passed by value. Tuple is an
+[]Object which is a reference type as is StringDict which is a
+map[string]Object. Note that Tuples can't be appended to.
+
+List is a struct with a []Object in it so append can mutate the list.
+
+All other types are pointers to structures.
+
+Does not support threading, so no thread state or thread local
+variables as the intention is to support go routines and channels via
+the threading module.
 
 Attributes of built in types
 ============================

py/code.go

@@ -26,7 +26,7 @@ type Code struct {
 	Firstlineno int32  // first source line number
 	Lnotab      string // string (encoding addr<->lineno mapping) See Objects/lnotab_notes.txt for details.
 
-	Weakreflist List // to support weakrefs to code objects
+	Weakreflist *List // to support weakrefs to code objects
 }
 
 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.")

py/list.go

@@ -5,50 +5,90 @@ package py
 var ListType = NewType("list", "list() -> new empty list\nlist(iterable) -> new list initialized from iterable's items")
 
 // FIXME lists are mutable so this should probably be struct { Tuple } then can use the sub methods on Tuple
-type List []Object
+type List struct {
+	Items []Object
+}
 
 // Type of this List object
-func (o List) Type() *Type {
+func (o *List) Type() *Type {
 	return ListType
 }
 
-// Copy a list object
-func (l List) Copy() List {
-	newL := make(List, len(l))
-	for i := range l {
-		newL[i] = l[i]
+// Make a new empty list
+func NewList() *List {
+	return &List{}
+}
+
+// Make a new empty list with given capacity
+func NewListWithCapacity(n int) *List {
+	l := &List{}
+	if n != 0 {
+		l.Items = make([]Object, 0, n)
 	}
-	return newL
+	return l
+}
+
+// Make a list with n nil elements
+func NewListSized(n int) *List {
+	l := &List{}
+	if n != 0 {
+		l.Items = make([]Object, n)
+	}
+	return l
+}
+
+// Make a new list from an []Object
+//
+// The []Object is copied into the list
+func NewListFromItems(items []Object) *List {
+	l := NewListSized(len(items))
+	copy(l.Items, items)
+	return l
+}
+
+// Copy a list object
+func (l *List) Copy() *List {
+	return NewListFromItems(l.Items)
+}
+
+// Append an item
+func (l *List) Append(item Object) {
+	l.Items = append(l.Items, item)
+}
+
+// Extend the list with items
+func (l *List) Extend(items []Object) {
+	l.Items = append(l.Items, items...)
 }
 
-func (t List) M__len__() Object {
-	return Int(len(t))
+func (l *List) M__len__() Object {
+	return Int(len(l.Items))
 }
 
-func (t List) M__bool__() Object {
-	return NewBool(len(t) > 0)
+func (l *List) M__bool__() Object {
+	return NewBool(len(l.Items) > 0)
 }
 
-func (t List) M__iter__() Object {
-	return NewIterator(t)
+func (l *List) M__iter__() Object {
+	return NewIterator(l.Items)
 }
 
-func (t List) M__getitem__(key Object) Object {
-	i := IndexIntCheck(key, len(t))
-	return t[i]
+func (l *List) M__getitem__(key Object) Object {
+	i := IndexIntCheck(key, len(l.Items))
+	return l.Items[i]
 }
 
-func (t List) M__setitem__(key, value Object) Object {
-	i := IndexIntCheck(key, len(t))
-	t[i] = value
+func (l *List) M__setitem__(key, value Object) Object {
+	i := IndexIntCheck(key, len(l.Items))
+	l.Items[i] = value
 	return None
 }
 
 // Check interface is satisfied
-var _ I__len__ = List(nil)
-var _ I__bool__ = List(nil)
-var _ I__iter__ = List(nil)
-var _ I__getitem__ = List(nil)
-var _ I__setitem__ = List(nil)
+var _ I__len__ = (*List)(nil)
+var _ I__bool__ = (*List)(nil)
+var _ I__iter__ = (*List)(nil)
+var _ I__getitem__ = (*List)(nil)
+var _ I__setitem__ = (*List)(nil)
 
-// var _ richComparison = List(nil)
+// var _ richComparison = (*List)(nil)

py/sequence.go

@@ -8,19 +8,19 @@ func SequenceTuple(v Object) Tuple {
 	switch x := v.(type) {
 	case Tuple:
 		return x
-	case List:
-		return Tuple(x.Copy())
+	case *List:
+		return Tuple(x.Items).Copy()
 	}
 	panic("SequenceTuple not fully implemented")
 }
 
 // Converts a sequence object v into a List
-func SequenceList(v Object) List {
+func SequenceList(v Object) *List {
 	// FIXME need to support iterable objects etc!
 	switch x := v.(type) {
 	case Tuple:
-		return List(x).Copy()
-	case List:
+		return NewListFromItems(x)
+	case *List:
 		return x.Copy()
 	}
 	panic("SequenceList not fully implemented")

py/tuple.go

@@ -14,9 +14,7 @@ func (o Tuple) Type() *Type {
 // Copy a tuple object
 func (t Tuple) Copy() Tuple {
 	newT := make(Tuple, len(t))
-	for i := range t {
-		newT[i] = t[i]
-	}
+	copy(newT, t)
 	return newT
 }
 func (t Tuple) M__len__() Object {

py/type.go

@@ -536,9 +536,9 @@ func lookup_method(self Object, attr string) Object {
 // each class to all its successors in the linearization.  See
 // the paper for definition of EPG.
 
-func tail_contains(list List, whence int, o Object) bool {
-	for j := whence + 1; j < len(list); j++ {
-		if list[j] == o {
+func tail_contains(list *List, whence int, o Object) bool {
+	for j := whence + 1; j < len(list.Items); j++ {
+		if list.Items[j] == o {
 			return true
 		}
 	}
@@ -557,13 +557,13 @@ func class_name(cls Object) string {
 	return string(nameString)
 }
 
-func check_duplicates(list List) {
+func check_duplicates(list *List) {
 	// Let's use a quadratic time algorithm,
 	// assuming that the bases lists is short.
-	for i := range list {
-		o := list[i]
-		for j := i + 1; j < len(list); j++ {
-			if list[j] == o {
+	for i := range list.Items {
+		o := list.Items[i]
+		for j := i + 1; j < len(list.Items); j++ {
+			if list.Items[j] == o {
 				panic(ExceptionNewf(TypeError, "duplicate base class %s", class_name(o)))
 			}
 		}
@@ -577,7 +577,7 @@ func check_duplicates(list List) {
 // to be put next into the MRO.  There is some conflict between the
 // order in which they should be put in the MRO, but it's hard to
 // diagnose what constraint can't be satisfied.
-func set_mro_error(to_merge List, remain []int) {
+func set_mro_error(to_merge *List, remain []int) {
 	panic(ExceptionNewf(TypeError, "mro is wonky"))
 	/* FIXME implement this!
 	       Py_ssize_t i, n, off, to_merge_size;
@@ -623,12 +623,12 @@ func set_mro_error(to_merge List, remain []int) {
 	*/
 }
 
-func pmerge(acc, to_merge List) {
+func pmerge(acc, to_merge *List) {
 	// Py_ssize_t i, j, to_merge_size, empty_cnt;
 	// int *remain;
 	// int ok;
 
-	to_merge_size := len(to_merge)
+	to_merge_size := len(to_merge.Items)
 
 	// remain stores an index into each sublist of to_merge.
 	// remain[i] is the index of the next base in to_merge[i]
@@ -638,9 +638,9 @@ func pmerge(acc, to_merge List) {
 again:
 	empty_cnt := 0
 	for i := 0; i < to_merge_size; i++ {
-		cur_list := to_merge[i].(List)
+		cur_list := to_merge.Items[i].(*List)
 
-		if remain[i] >= len(cur_list) {
+		if remain[i] >= len(cur_list.Items) {
 			empty_cnt++
 			continue
 		}
@@ -651,17 +651,17 @@ again:
 		// If not, choose the class which appears in the MRO
 		// of the earliest direct superclass of the new class.
 
-		candidate := cur_list[remain[i]]
+		candidate := cur_list.Items[remain[i]]
 		for j := 0; j < to_merge_size; j++ {
-			j_lst := to_merge[j].(List)
+			j_lst := to_merge.Items[j].(*List)
 			if tail_contains(j_lst, remain[j], candidate) {
 				goto skip // continue outer loop
 			}
 		}
-		acc = append(acc, candidate)
+		acc.Append(candidate)
 		for j := 0; j < to_merge_size; j++ {
-			j_lst := to_merge[j].(List)
-			if remain[j] < len(j_lst) && j_lst[remain[j]] == candidate {
+			j_lst := to_merge.Items[j].(*List)
+			if remain[j] < len(j_lst.Items) && j_lst.Items[remain[j]] == candidate {
 				remain[j]++
 			}
 		}
@@ -695,22 +695,22 @@ func (t *Type) mro_implementation() Object {
 
 	bases := t.Bases
 	n := len(bases)
-	to_merge := make(List, n+1)
+	to_merge := NewListSized(n + 1)
 
 	for i := range bases {
 		base := bases[i].(*Type)
 		parentMRO := SequenceList(base.Mro)
-		to_merge[i] = parentMRO
+		to_merge.Items[i] = parentMRO
 	}
 
 	bases_aslist := SequenceList(bases)
 
 	// This is just a basic sanity check.
 	check_duplicates(bases_aslist)
 
-	to_merge[n] = bases_aslist
+	to_merge.Items[n] = bases_aslist
 
-	result := List{t}
+	result := NewListFromItems([]Object{t})
 
 	pmerge(result, to_merge)