go-python
diff --git a/‎builtin/builtin.go
Lines changed: 4 additions & 4 deletions b/‎builtin/builtin.go
Lines changed: 4 additions & 4 deletions
diff --git a/‎py/args.go
Lines changed: 7 additions & 2 deletions b/‎py/args.go
Lines changed: 7 additions & 2 deletions
diff --git a/‎py/bool.go
Lines changed: 8 additions & 0 deletions b/‎py/bool.go
Lines changed: 8 additions & 0 deletions
diff --git a/‎py/float.go
Lines changed: 1 addition & 1 deletion b/‎py/float.go
Lines changed: 1 addition & 1 deletion
diff --git a/‎py/int.go
Lines changed: 9 additions & 3 deletions b/‎py/int.go
Lines changed: 9 additions & 3 deletions
diff --git a/‎py/internal.go
Lines changed: 20 additions & 2 deletions b/‎py/internal.go
Lines changed: 20 additions & 2 deletions
diff --git a/‎py/py.go
Lines changed: 1 addition & 1 deletion b/‎py/py.go
Lines changed: 1 addition & 1 deletion
diff --git a/‎py/range.go
Lines changed: 83 additions & 0 deletions b/‎py/range.go
Lines changed: 83 additions & 0 deletions
diff --git a/‎vm/eval.go
Lines changed: 2 additions & 1 deletion b/‎vm/eval.go
Lines changed: 2 additions & 1 deletion
@@ -77,8 +77,8 @@ func init() {
 		"int":  py.IntType, // FIXME LongType?
 		"list": py.ListType,
 		// "map":            py.MapType,
-		// "object":         py.BaseObjectType,
-		// "range":          py.RangeType,
+		"object": py.BaseObjectType,
+		"range":  py.RangeType,
 		// "reversed":       py.ReversedType,
 		"set": py.SetType,
 		// "slice":          py.SliceType,
@@ -114,7 +114,7 @@ equivalent to (x**y) % z, but may be more efficient (e.g. for ints).`
 func builtin_pow(self py.Object, args py.Tuple) py.Object {
 	var v, w, z py.Object
 	z = py.None
-	py.UnpackTuple(args, "pow", 2, 3, &v, &w, &z)
+	py.UnpackTuple(args, nil, "pow", 2, 3, &v, &w, &z)
 	return py.Pow(v, w, z)
 }
 
@@ -137,7 +137,7 @@ func builtin_round(self py.Object, args py.Tuple, kwargs py.StringDict) py.Objec
 	ndigits = py.Int(0)
 	// var kwlist = []string{"number", "ndigits"}
 	// FIXME py.ParseTupleAndKeywords(args, kwargs, "O|O:round", kwlist, &number, &ndigits)
-	py.UnpackTuple(args, "round", 1, 2, &number, &ndigits)
+	py.UnpackTuple(args, nil, "round", 1, 2, &number, &ndigits)
 
 	numberRounder, ok := number.(py.I__round__)
 	if !ok {
 
@@ -512,9 +512,14 @@ func checkNumberOfArgs(name string, nargs, nresults, min, max int) {
 // Unpack the args tuple into the results
 //
 // Up to the caller to set default values
-func UnpackTuple(args Tuple, name string, min int, max int, results ...*Object) {
+func UnpackTuple(args Tuple, kwargs StringDict, name string, min int, max int, results ...*Object) {
+	if len(kwargs) != 0 {
+		// FIXME type error
+		panic(fmt.Sprintf("TypeError: %s() does not take keyword arguments", name))
+	}
+
 	// Check number of arguments
-	checkNumberOfArgs(name, len(args), min, max, len(results))
+	checkNumberOfArgs(name, len(args), len(results), min, max)
 
 	// Copy the results in
 	for i := range args {
 
@@ -20,5 +20,13 @@ func (a Bool) M__bool__() Object {
 	return a
 }
 
+func (a Bool) M__index__() Int {
+	if a {
+		return Int(1)
+	}
+	return Int(0)
+}
+
 // Check interface is satisfied
 var _ I__bool__ = Bool(false)
+var _ I__index__ = Bool(false)
@@ -219,7 +219,7 @@ func (a Float) M__complex__() Object {
 func (a Float) M__round__(digitsObj Object) Object {
 	digits := 0
 	if digitsObj != None {
-		digits = Index(digitsObj)
+		digits = IndexInt(digitsObj)
 	}
 	scale := Float(math.Pow(10, float64(digits)))
 	return scale * Float(math.Floor(float64(a)/float64(scale)))
 
@@ -11,6 +11,13 @@ var IntType = NewType("int", "int(x=0) -> integer\nint(x, base=10) -> integer\n\
 
 type Int int64
 
+const (
+	// Maximum possible Int
+	IntMax = 1<<63 - 1
+	// Minimum possible Int
+	IntMin = -IntMax - 1
+)
+
 // Type of this Int object
 func (o Int) Type() *Type {
 	return IntType
@@ -306,9 +313,8 @@ func (a Int) M__bool__() Object {
 	return True
 }
 
-func (a Int) M__index__() int {
-	// FIXME moan if it overflows an int
-	return int(a)
+func (a Int) M__index__() Int {
+	return a
 }
 
 func (a Int) M__int__() Object {
 
@@ -36,10 +36,10 @@ func MakeBool(a Object) Object {
 	return True
 }
 
-// Index the python Object returning an int
+// Index the python Object returning an Int
 //
 // Will raise TypeError if Index can't be run on this object
-func Index(a Object) int {
+func Index(a Object) Int {
 	A, ok := a.(I__index__)
 	if ok {
 		return A.M__index__()
@@ -49,6 +49,24 @@ func Index(a Object) int {
 	panic(fmt.Sprintf("TypeError: unsupported operand type(s) for index: '%s'", a.Type().Name))
 }
 
+// Index the python Object returning an int
+//
+// Will raise TypeError if Index can't be run on this object
+//
+// or IndexError if the Int won't fit!
+func IndexInt(a Object) int {
+	i := Index(a)
+	intI := int(i)
+
+	// Int might not fit in an int
+	if Int(intI) != i {
+		// FIXME IndexError
+		panic(fmt.Sprintf("IndexError: cannot fit %d into an index-sized integer", i))
+	}
+
+	return intI
+}
+
 // Return the result of not a
 func Not(a Object) Object {
 	switch MakeBool(a) {
 
@@ -879,7 +879,7 @@ type I__round__ interface {
 
 // object.__index__(self)
 type I__index__ interface {
-	M__index__() int
+	M__index__() Int
 }
 
 // Int, Float and Complex should satisfy this
 
@@ -0,0 +1,83 @@
+// Range object
+
+package py
+
+// A python Range object
+// FIXME one day support BigInts too!
+type Range struct {
+	Start Int
+	Stop  Int
+	Step  Int
+	//Length Object
+}
+
+// A python Range iterator
+type RangeIterator struct {
+	Range
+	Index Int
+}
+
+var RangeType = NewTypeX("range", `range(stop) -> range object
+range(start, stop[, step]) -> range object
+
+Return a virtual sequence of numbers from start to stop by step.`,
+	RangeNew, nil)
+
+var RangeIteratorType = NewType("range_iterator", `range_iterator object`)
+
+// Type of this object
+func (o *Range) Type() *Type {
+	return RangeType
+}
+
+// Type of this object
+func (o *RangeIterator) Type() *Type {
+	return RangeIteratorType
+}
+
+// RangeNew
+func RangeNew(metatype *Type, args Tuple, kwargs StringDict) Object {
+	var start Object
+	var stop Object
+	var step Object = Int(1)
+	UnpackTuple(args, kwargs, "range", 1, 3, &start, &stop, &step)
+	if len(args) == 1 {
+		return &Range{
+			Start: Int(0),
+			Stop:  Index(start),
+			Step:  Int(1),
+		}
+	}
+	return &Range{
+		Start: Index(start),
+		Stop:  Index(stop),
+		Step:  Index(step),
+	}
+}
+
+// Make a range iterator from a range
+func (r *Range) M__iter__() Object {
+	return &RangeIterator{
+		Range: *r,
+		Index: r.Start,
+	}
+}
+
+// Range iterator
+func (it *RangeIterator) M__iter__() Object {
+	return it
+}
+
+// Range iterator next
+func (it *RangeIterator) M__next__() Object {
+	r := it.Index
+	if r >= it.Stop {
+		panic(StopIteration)
+	}
+	it.Index++
+	return r
+}
+
+// Check interface is satisfied
+var _ I__iter__ = (*Range)(nil)
+var _ I_iterator = (*RangeIterator)(nil)
@@ -666,7 +666,8 @@ func do_FOR_ITER(vm *Vm, delta int32) {
 			}
 		}
 	}()
-	it := vm.TOP().(*py.Iterator)
+	// FIXME should look in instance dictionary
+	it := vm.TOP().(py.I__next__)
 	r := it.M__next__()
 	vm.PUSH(r)
 }
Original file line number	Diff line number	Diff line change
`@@ -219,7 +219,7 @@ func (a Float) M__complex__() Object {`
`219`	`219`	`func (a Float) M__round__(digitsObj Object) Object {`
`220`	`220`	`digits := 0`
`221`	`221`	`if digitsObj != None {`
`222`		`- digits = Index(digitsObj)`
	`222`	`+ digits = IndexInt(digitsObj)`
`223`	`223`	`}`
`224`	`224`	`scale := Float(math.Pow(10, float64(digits)))`
`225`	`225`	`return scale * Float(math.Floor(float64(a)/float64(scale)))`
Original file line number	Diff line number	Diff line change
`@@ -879,7 +879,7 @@ type I__round__ interface {`
`879`	`879`
`880`	`880`	`// object.__index__(self)`
`881`	`881`	`type I__index__ interface {`
`882`		`- M__index__() int`
	`882`	`+ M__index__() Int`
`883`	`883`	`}`
`884`	`884`
`885`	`885`	`// Int, Float and Complex should satisfy this`
Original file line number	Diff line number	Diff line change
`@@ -666,7 +666,8 @@ func do_FOR_ITER(vm *Vm, delta int32) {`
`666`	`666`	`}`
`667`	`667`	`}`
`668`	`668`	`}()`
`669`		`- it := vm.TOP().(*py.Iterator)`
	`669`	`+ // FIXME should look in instance dictionary`
	`670`	`+ it := vm.TOP().(py.I__next__)`
`670`	`671`	`r := it.M__next__()`
`671`	`672`	`vm.PUSH(r)`
`672`	`673`	`}`