vm: more tests for lists and DELETE_SUBSCR, UNPACK_EX, UNPACK_SEQUENCE etc

ncw · ncw · commit acaa5df39295 · 2015-05-22T17:45:18.000+01:00
* Change interface to py.Next
  * Fill out List interface
diff --git a/builtin/builtin.go b/builtin/builtin.go
@@ -324,7 +324,15 @@ func builtin_next(self py.Object, args py.Tuple) (res py.Object) {
 		}()
 	}
 
-	return py.Next(it)
+	res, finished := py.Next(it)
+	if finished != nil {
+		if def != nil {
+			res = def
+		} else {
+			panic(finished)
+		}
+	}
+	return res
 }
 
 const import_doc = `__import__(name, globals=None, locals=None, fromlist=(), level=0) -> module
diff --git a/py/list.go b/py/list.go
@@ -66,11 +66,21 @@ func (l *List) Append(item Object) {
 	l.Items = append(l.Items, item)
 }
 
+// Resize the list
+func (l *List) Resize(newSize int) {
+	l.Items = l.Items[:newSize]
+}
+
 // Extend the list with items
 func (l *List) Extend(items []Object) {
 	l.Items = append(l.Items, items...)
 }
 
+// Len of list
+func (l *List) Len() int {
+	return len(l.Items)
+}
+
 func (l *List) M__len__() Object {
 	return Int(len(l.Items))
 }
@@ -99,25 +109,56 @@ func (l *List) M__getitem__(key Object) Object {
 func (l *List) M__setitem__(key, value Object) Object {
 	if slice, ok := key.(*Slice); ok {
 		start, stop, step, slicelength := slice.GetIndices(len(l.Items))
-		if step != 1 {
-			panic("Setting slices with step != 1 not implemented yet")
-		}
-		if stop == len(l.Items) {
-			// tail of the list only
+		if step == 1 {
+			// Make a copy of the tail
+			tailSlice := l.Items[stop:]
+			tail := make([]Object, len(tailSlice))
+			copy(tail, tailSlice)
 			l.Items = l.Items[:start]
 			Iterate(value, func(item Object) {
 				l.Append(item)
 			})
-			return None
+			l.Items = append(l.Items, tail...)
+		} else {
+			newItems := SequenceTuple(value)
+			if len(newItems) != slicelength {
+				panic(ExceptionNewf(ValueError, "attempt to assign sequence of size %d to extended slice of size %d", len(newItems), slicelength))
+			}
+			j := 0
+			for i := start; i < stop; i += step {
+				l.Items[i] = newItems[j]
+				j++
+			}
 		}
-		_ = slicelength
-		_ = start
-		_ = stop
-		panic("Set slice not implemented fully yet")
-		return None
+	} else {
+		i := IndexIntCheck(key, len(l.Items))
+		l.Items[i] = value
+	}
+	return None
+}
+
+// Removes the item at i
+func (a *List) DelItem(i int) {
+	a.Items = append(a.Items[:i], a.Items[i+1:]...)
+}
+
+// Removes items from a list
+func (a *List) M__delitem__(key Object) Object {
+	if slice, ok := key.(*Slice); ok {
+		start, stop, step, _ := slice.GetIndices(len(a.Items))
+		if step == 1 {
+			a.Items = append(a.Items[:start], a.Items[stop:]...)
+		} else {
+			j := 0
+			for i := start; i < stop; i += step {
+				a.DelItem(i - j)
+				j++
+			}
+		}
+	} else {
+		i := IndexIntCheck(key, len(a.Items))
+		a.DelItem(i)
 	}
-	i := IndexIntCheck(key, len(l.Items))
-	l.Items[i] = value
 	return None
 }
 
@@ -177,3 +218,35 @@ var _ I__getitem__ = (*List)(nil)
 var _ I__setitem__ = (*List)(nil)
 
 // var _ richComparison = (*List)(nil)
+
+func (a *List) M__eq__(other Object) Object {
+	b, ok := other.(*List)
+	if !ok {
+		return NotImplemented
+	}
+	if len(a.Items) != len(b.Items) {
+		return False
+	}
+	for i := range a.Items {
+		if Eq(a.Items[i], b.Items[i]) == False {
+			return False
+		}
+	}
+	return True
+}
+
+func (a *List) M__ne__(other Object) Object {
+	b, ok := other.(*List)
+	if !ok {
+		return NotImplemented
+	}
+	if len(a.Items) != len(b.Items) {
+		return True
+	}
+	for i := range a.Items {
+		if Eq(a.Items[i], b.Items[i]) == False {
+			return True
+		}
+	}
+	return False
+}
diff --git a/py/sequence.go b/py/sequence.go
@@ -35,28 +35,34 @@ func SequenceList(v Object) *List {
 }
 
 // Call __next__ for the python object
-func Next(self Object) Object {
-	if I, ok := self.(I__next__); ok {
-		return I.M__next__()
-	} else if res, ok := TypeCall0(self, "__next__"); ok {
-		return res
-	}
-
-	panic(ExceptionNewf(TypeError, "'%s' object is not iterable", self.Type().Name))
-}
-
-// Create an iterator from obj and iterate the iterator until finished
-// calling the function passed in on each object
-func Iterate(obj Object, fn func(Object)) {
+//
+// Returns the next object
+//
+// finished == StopIteration or subclass when finished
+func Next(self Object) (obj Object, finished Object) {
 	defer func() {
 		if r := recover(); r != nil {
 			if IsException(StopIteration, r) {
 				// StopIteration or subclass raised
+				finished = r.(Object)
 			} else {
 				panic(r)
 			}
 		}
 	}()
+	if I, ok := self.(I__next__); ok {
+		obj = I.M__next__()
+		return
+	} else if obj, ok = TypeCall0(self, "__next__"); ok {
+		return
+	}
+
+	panic(ExceptionNewf(TypeError, "'%s' object is not iterable", self.Type().Name))
+}
+
+// Create an iterator from obj and iterate the iterator until finished
+// calling the function passed in on each object
+func Iterate(obj Object, fn func(Object)) {
 	// Some easy cases
 	switch x := obj.(type) {
 	case Tuple:
@@ -78,7 +84,10 @@ func Iterate(obj Object, fn func(Object)) {
 	default:
 		iterator := Iter(obj)
 		for {
-			item := Next(iterator)
+			item, finished := Next(iterator)
+			if finished != nil {
+				break
+			}
 			fn(item)
 		}
 	}
diff --git a/vm/eval.go b/vm/eval.go
@@ -85,6 +85,13 @@ func (vm *Vm) EXTEND(items py.Tuple) {
 	vm.frame.Stack = append(vm.frame.Stack, items...)
 }
 
+// Push items to top of vm stack in reverse order
+func (vm *Vm) EXTEND_REVERSED(items py.Tuple) {
+	start := len(vm.frame.Stack)
+	vm.frame.Stack = append(vm.frame.Stack, items...)
+	py.Tuple(vm.frame.Stack[start:]).Reverse()
+}
+
 // Adds a traceback to the exc passed in for the current vm state
 func (vm *Vm) AddTraceback(exc *py.ExceptionInfo) {
 	exc.Traceback = &py.Traceback{
@@ -473,7 +480,11 @@ func do_STORE_SUBSCR(vm *Vm, arg int32) {
 // Implements del TOS1[TOS].
 func do_DELETE_SUBSCR(vm *Vm, arg int32) {
 	defer vm.CheckException()
-	vm.NotImplemented("DELETE_SUBSCR", arg)
+	sub := vm.TOP()
+	container := vm.SECOND()
+	vm.DROPN(2)
+	/* del v[w] */
+	py.DelItem(container, sub)
 }
 
 // Miscellaneous opcodes.
@@ -513,6 +524,52 @@ func do_CONTINUE_LOOP(vm *Vm, target int32) {
 	vm.frame.Lasti = vm.frame.Block.Handler
 }
 
+// Iterate v argcnt times and store the results on the stack (via decreasing
+// sp).  Return 1 for success, 0 if error.
+//
+// If argcntafter == -1, do a simple unpack. If it is >= 0, do an unpack
+// with a variable target.
+func unpack_iterable(vm *Vm, v py.Object, argcnt int, argcntafter int, sp int) {
+	it := py.Iter(v)
+	i := 0
+	for i = 0; i < argcnt; i++ {
+		w, finished := py.Next(it)
+		if finished != nil {
+			/* Iterator done, via error or exhaustion. */
+			panic(py.ExceptionNewf(py.ValueError, "need more than %d value(s) to unpack", i))
+		}
+		sp--
+		vm.frame.Stack[sp] = w
+	}
+
+	if argcntafter == -1 {
+		/* We better have exhausted the iterator now. */
+		_, finished := py.Next(it)
+		if finished != nil {
+			return
+		}
+		panic(py.ExceptionNewf(py.ValueError, "too many values to unpack (expected %d)", argcnt))
+	}
+
+	l := py.SequenceList(it)
+	sp--
+	vm.frame.Stack[sp] = l
+	i++
+
+	ll := l.Len()
+	if ll < argcntafter {
+		panic(py.ExceptionNewf(py.ValueError, "need more than %d values to unpack", argcnt+ll))
+	}
+
+	/* Pop the "after-variable" args off the list. */
+	for j := argcntafter; j > 0; j-- {
+		sp--
+		vm.frame.Stack[sp] = l.M__getitem__(py.Int(ll - j))
+	}
+	/* Resize the list. */
+	l.Resize(ll - argcntafter)
+}
+
 // Implements assignment with a starred target: Unpacks an iterable in
 // TOS into individual values, where the total number of values can be
 // smaller than the number of items in the iterable: one the new
@@ -523,7 +580,13 @@ func do_CONTINUE_LOOP(vm *Vm, target int32) {
 // resulting values are put onto the stack right-to-left.
 func do_UNPACK_EX(vm *Vm, counts int32) {
 	defer vm.CheckException()
-	vm.NotImplemented("UNPACK_EX", counts)
+	before := int(counts & 0xFF)
+	after := int(counts >> 8)
+	totalargs := 1 + before + after
+	seq := vm.POP()
+	sp := len(vm.frame.Stack)
+	vm.EXTEND(make([]py.Object, totalargs))
+	unpack_iterable(vm, seq, before, after, sp+totalargs)
 }
 
 // Calls set.add(TOS1[-i], TOS). Used to implement set comprehensions.
@@ -571,23 +634,21 @@ func do_RETURN_VALUE(vm *Vm, arg int32) {
 
 // Pops TOS and delegates to it as a subiterator from a generator.
 func do_YIELD_FROM(vm *Vm, arg int32) {
-	defer func() {
-		if r := recover(); r != nil {
-			if vm.catchStopIteration(r) {
-				// No extra action needed
-			}
-		}
-	}()
+	defer vm.CheckException()
 
 	var retval py.Object
+	var finished py.Object
 	u := vm.POP()
 	x := vm.TOP()
 	// send u to x
 	if u == py.None {
-		retval = py.Next(x)
+		retval, finished = py.Next(x)
 	} else {
 		retval = py.Send(x, u)
 	}
+	if finished != nil {
+		return
+	}
 	// x remains on stack, retval is value to be yielded
 	// FIXME vm.frame.Stacktop = stack_pointer
 	//why = exitYield
@@ -756,19 +817,16 @@ func do_DELETE_NAME(vm *Vm, namei int32) {
 func do_UNPACK_SEQUENCE(vm *Vm, count int32) {
 	defer vm.CheckException()
 	it := vm.POP()
-	i := count
-	items := make(py.Tuple, count)
-	py.Iterate(it, func(item py.Object) {
-		i--
-		if i < 0 {
-			panic(py.ExceptionNewf(py.ValueError, "Too many values to unpack (expected %d)", count))
-		}
-		items[i] = item
-	})
-	if i != 0 {
-		panic(py.ExceptionNewf(py.ValueError, "Need more than %d values to unpack (expected %d)", count-i, count))
+	args := int(count)
+	if tuple, ok := it.(py.Tuple); ok && len(tuple) == args {
+		vm.EXTEND_REVERSED(tuple)
+	} else if list, ok := it.(*py.List); ok && list.Len() == args {
+		vm.EXTEND_REVERSED(list.Items)
+	} else {
+		sp := len(vm.frame.Stack)
+		vm.EXTEND(make([]py.Object, args))
+		unpack_iterable(vm, it, args, -1, sp+args)
 	}
-	vm.EXTEND(items)
 }
 
 // Implements TOS.name = TOS1, where namei is the index of name in
@@ -1018,16 +1076,14 @@ func do_JUMP_ABSOLUTE(vm *Vm, target int32) {
 // iterator indicates it is exhausted TOS is popped, and the bytecode
 // counter is incremented by delta.
 func do_FOR_ITER(vm *Vm, delta int32) {
-	defer func() {
-		if r := recover(); r != nil {
-			if vm.catchStopIteration(r) {
-				vm.DROP()
-				vm.frame.Lasti += delta
-			}
-		}
-	}()
-	r := py.Next(vm.TOP())
-	vm.PUSH(r)
+	defer vm.CheckException()
+	r, finished := py.Next(vm.TOP())
+	if finished != nil {
+		vm.DROP()
+		vm.frame.Lasti += delta
+	} else {
+		vm.PUSH(r)
+	}
 }
 
 // Loads the global named co_names[namei] onto the stack.
diff --git a/vm/tests/exceptions.py b/vm/tests/exceptions.py
@@ -144,5 +144,13 @@
 #     assert False, "Expecting ValueError (outer)"
 # assert ok1 and ok2
 
+# FIXME - exeption not being caught
+# ok = False
+# try:
+#     print(1/0)
+# except ZeroDivisionError:
+#     ok = True
+# assert ok
+
 # End with this
 finished = True
diff --git a/vm/tests/lists.py b/vm/tests/lists.py
