go-python
diff --git a/‎builtin/builtin.go
Lines changed: 72 additions & 7 deletions b/‎builtin/builtin.go
Lines changed: 72 additions & 7 deletions
diff --git a/‎py/exception.go
Lines changed: 102 additions & 17 deletions b/‎py/exception.go
Lines changed: 102 additions & 17 deletions
diff --git a/‎vm/eval.go
Lines changed: 85 additions & 1 deletion b/‎vm/eval.go
Lines changed: 85 additions & 1 deletion
@@ -57,12 +57,11 @@ func init() {
 		// py.NewMethod("vars", builtin_vars, 0, vars_doc),
 	}
 	globals := py.StringDict{
-		"None":           py.None,
-		"Ellipsis":       py.Ellipsis,
-		"NotImplemented": py.NotImplemented,
-		"False":          py.False,
-		"True":           py.True,
-		"bool":           py.BoolType,
+		"None":     py.None,
+		"Ellipsis": py.Ellipsis,
+		"False":    py.False,
+		"True":     py.True,
+		"bool":     py.BoolType,
 		// "memoryview":     py.MemoryViewType,
 		// "bytearray":      py.ByteArrayType,
 		"bytes": py.BytesType,
@@ -77,7 +76,7 @@ func init() {
 		"int":  py.IntType, // FIXME LongType?
 		"list": py.ListType,
 		// "map":            py.MapType,
-		"object": py.BaseObjectType,
+		"object": py.ObjectType,
 		"range":  py.RangeType,
 		// "reversed":       py.ReversedType,
 		"set": py.SetType,
@@ -88,6 +87,72 @@ func init() {
 		"tuple": py.TupleType,
 		"type":  py.TypeType,
 		// "zip":            py.ZipType,
+
+		// Exceptions
+		"ArithmeticError":           py.ArithmeticError,
+		"AssertionError":            py.AssertionError,
+		"AttributeError":            py.AttributeError,
+		"BaseException":             py.BaseException,
+		"BlockingIOError":           py.BlockingIOError,
+		"BrokenPipeError":           py.BrokenPipeError,
+		"BufferError":               py.BufferError,
+		"BytesWarning":              py.BytesWarning,
+		"ChildProcessError":         py.ChildProcessError,
+		"ConnectionAbortedError":    py.ConnectionAbortedError,
+		"ConnectionError":           py.ConnectionError,
+		"ConnectionRefusedError":    py.ConnectionRefusedError,
+		"ConnectionResetError":      py.ConnectionResetError,
+		"DeprecationWarning":        py.DeprecationWarning,
+		"EOFError":                  py.EOFError,
+		"EnvironmentError":          py.OSError,
+		"Exception":                 py.ExceptionType,
+		"FileExistsError":           py.FileExistsError,
+		"FileNotFoundError":         py.FileNotFoundError,
+		"FloatingPointError":        py.FloatingPointError,
+		"FutureWarning":             py.FutureWarning,
+		"GeneratorExit":             py.GeneratorExit,
+		"IOError":                   py.OSError,
+		"ImportError":               py.ImportError,
+		"ImportWarning":             py.ImportWarning,
+		"IndentationError":          py.IndentationError,
+		"IndexError":                py.IndexError,
+		"InterruptedError":          py.InterruptedError,
+		"IsADirectoryError":         py.IsADirectoryError,
+		"KeyError":                  py.KeyError,
+		"KeyboardInterrupt":         py.KeyboardInterrupt,
+		"LookupError":               py.LookupError,
+		"MemoryError":               py.MemoryError,
+		"NameError":                 py.NameError,
+		"NotADirectoryError":        py.NotADirectoryError,
+		"NotImplemented":            py.NotImplemented,
+		"NotImplementedError":       py.NotImplementedError,
+		"OSError":                   py.OSError,
+		"OverflowError":             py.OverflowError,
+		"PendingDeprecationWarning": py.PendingDeprecationWarning,
+		"PermissionError":           py.PermissionError,
+		"ProcessLookupError":        py.ProcessLookupError,
+		"ReferenceError":            py.ReferenceError,
+		"ResourceWarning":           py.ResourceWarning,
+		"RuntimeError":              py.RuntimeError,
+		"RuntimeWarning":            py.RuntimeWarning,
+		"StopIteration":             py.StopIteration,
+		"SyntaxError":               py.SyntaxError,
+		"SyntaxWarning":             py.SyntaxWarning,
+		"SystemError":               py.SystemError,
+		"SystemExit":                py.SystemExit,
+		"TabError":                  py.TabError,
+		"TimeoutError":              py.TimeoutError,
+		"TypeError":                 py.TypeError,
+		"UnboundLocalError":         py.UnboundLocalError,
+		"UnicodeDecodeError":        py.UnicodeDecodeError,
+		"UnicodeEncodeError":        py.UnicodeEncodeError,
+		"UnicodeError":              py.UnicodeError,
+		"UnicodeTranslateError":     py.UnicodeTranslateError,
+		"UnicodeWarning":            py.UnicodeWarning,
+		"UserWarning":               py.UserWarning,
+		"ValueError":                py.ValueError,
+		"Warning":                   py.Warning,
+		"ZeroDivisionError":         py.ZeroDivisionError,
 	}
 	py.NewModule("builtins", builtin_doc, methods, globals)
 }
 
@@ -2,9 +2,13 @@
 
 package py
 
+import (
+	"fmt"
+)
+
 // A python Exception object
 type Exception struct {
-	Name            string // name of the exception FIXME should be part of class machinery
+	Base            *Type
 	Args            Object
 	Traceback       Object
 	Context         Object
@@ -14,27 +18,108 @@ type Exception struct {
 }
 
 var (
-	// FIXME should be a class probably
-	ExceptionType = NewType("exception", "Common base class for all exceptions")
-
-	// Some well known exceptions - these should be types?
-	// FIXME exceptions should be created in builtins probably
-	// their names should certainly go in there!
-	NotImplemented = NewException("NotImplemented")
-	StopIteration  = NewException("StopIteration")
+	// Exception heirachy
+	BaseException             = ObjectType.NewType("BaseException", "Common base class for all exceptions", ExceptionNew, nil)
+	SystemExit                = BaseException.NewType("SystemExit", "Request to exit from the interpreter.", nil, nil)
+	KeyboardInterrupt         = BaseException.NewType("KeyboardInterrupt", "Program interrupted by user.", nil, nil)
+	GeneratorExit             = BaseException.NewType("GeneratorExit", "Request that a generator exit.", nil, nil)
+	ExceptionType             = BaseException.NewType("Exception", "Common base class for all non-exit exceptions.", nil, nil)
+	StopIteration             = ExceptionType.NewType("StopIteration", "Signal the end from iterator.__next__().", nil, nil)
+	ArithmeticError           = ExceptionType.NewType("ArithmeticError", "Base class for arithmetic errors.", nil, nil)
+	FloatingPointError        = ArithmeticError.NewType("FloatingPointError", "Floating point operation failed.", nil, nil)
+	OverflowError             = ArithmeticError.NewType("OverflowError", "Result too large to be represented.", nil, nil)
+	ZeroDivisionError         = ArithmeticError.NewType("ZeroDivisionError", "Second argument to a division or modulo operation was zero.", nil, nil)
+	AssertionError            = ExceptionType.NewType("AssertionError", "Assertion failed.", nil, nil)
+	AttributeError            = ExceptionType.NewType("AttributeError", "Attribute not found.", nil, nil)
+	BufferError               = ExceptionType.NewType("BufferError", "Buffer error.", nil, nil)
+	EOFError                  = ExceptionType.NewType("EOFError", "Read beyond end of file.", nil, nil)
+	ImportError               = ExceptionType.NewType("ImportError", "Import can't find module, or can't find name in module.", nil, nil)
+	LookupError               = ExceptionType.NewType("LookupError", "Base class for lookup errors.", nil, nil)
+	IndexError                = LookupError.NewType("IndexError", "Sequence index out of range.", nil, nil)
+	KeyError                  = LookupError.NewType("KeyError", "Mapping key not found.", nil, nil)
+	MemoryError               = ExceptionType.NewType("MemoryError", "Out of memory.", nil, nil)
+	NameError                 = ExceptionType.NewType("NameError", "Name not found globally.", nil, nil)
+	UnboundLocalError         = NameError.NewType("UnboundLocalError", "Local name referenced but not bound to a value.", nil, nil)
+	OSError                   = ExceptionType.NewType("OSError", "Base class for I/O related errors.", nil, nil)
+	BlockingIOError           = OSError.NewType("BlockingIOError", "I/O operation would block.", nil, nil)
+	ChildProcessError         = OSError.NewType("ChildProcessError", "Child process error.", nil, nil)
+	ConnectionError           = OSError.NewType("ConnectionError", "Connection error.", nil, nil)
+	BrokenPipeError           = ConnectionError.NewType("BrokenPipeError", "Broken pipe.", nil, nil)
+	ConnectionAbortedError    = ConnectionError.NewType("ConnectionAbortedError", "Connection aborted.", nil, nil)
+	ConnectionRefusedError    = ConnectionError.NewType("ConnectionRefusedError", "Connection refused.", nil, nil)
+	ConnectionResetError      = ConnectionError.NewType("ConnectionResetError", "Connection reset.", nil, nil)
+	FileExistsError           = OSError.NewType("FileExistsError", "File already exists.", nil, nil)
+	FileNotFoundError         = OSError.NewType("FileNotFoundError", "File not found.", nil, nil)
+	InterruptedError          = OSError.NewType("InterruptedError", "Interrupted by signal.", nil, nil)
+	IsADirectoryError         = OSError.NewType("IsADirectoryError", "Operation doesn't work on directories.", nil, nil)
+	NotADirectoryError        = OSError.NewType("NotADirectoryError", "Operation only works on directories.", nil, nil)
+	PermissionError           = OSError.NewType("PermissionError", "Not enough permissions.", nil, nil)
+	ProcessLookupError        = OSError.NewType("ProcessLookupError", "Process not found.", nil, nil)
+	TimeoutError              = OSError.NewType("TimeoutError", "Timeout expired.", nil, nil)
+	ReferenceError            = ExceptionType.NewType("ReferenceError", "Weak ref proxy used after referent went away.", nil, nil)
+	RuntimeError              = ExceptionType.NewType("RuntimeError", "Unspecified run-time error.", nil, nil)
+	NotImplementedError       = RuntimeError.NewType("NotImplementedError", "Method or function hasn't been implemented yet.", nil, nil)
+	SyntaxError               = ExceptionType.NewType("SyntaxError", "Invalid syntax.", nil, nil)
+	IndentationError          = SyntaxError.NewType("IndentationError", "Improper indentation.", nil, nil)
+	TabError                  = IndentationError.NewType("TabError", "Improper mixture of spaces and tabs.", nil, nil)
+	SystemError               = ExceptionType.NewType("SystemError", "Internal error in the Python interpreter.\n\nPlease report this to the Python maintainer, along with the traceback,\nthe Python version, and the hardware/OS platform and version.", nil, nil)
+	TypeError                 = ExceptionType.NewType("TypeError", "Inappropriate argument type.", nil, nil)
+	ValueError                = ExceptionType.NewType("ValueError", "Inappropriate argument value (of correct type).", nil, nil)
+	UnicodeError              = ValueError.NewType("UnicodeError", "Unicode related error.", nil, nil)
+	UnicodeDecodeError        = UnicodeError.NewType("UnicodeDecodeError", "Unicode decoding error.", nil, nil)
+	UnicodeEncodeError        = UnicodeError.NewType("UnicodeEncodeError", "Unicode encoding error.", nil, nil)
+	UnicodeTranslateError     = UnicodeError.NewType("UnicodeTranslateError", "Unicode translation error.", nil, nil)
+	Warning                   = ExceptionType.NewType("Warning", "Base class for warning categories.", nil, nil)
+	DeprecationWarning        = Warning.NewType("DeprecationWarning", "Base class for warnings about deprecated features.", nil, nil)
+	PendingDeprecationWarning = Warning.NewType("PendingDeprecationWarning", "Base class for warnings about features which will be deprecated\nin the future.", nil, nil)
+	RuntimeWarning            = Warning.NewType("RuntimeWarning", "Base class for warnings about dubious runtime behavior.", nil, nil)
+	SyntaxWarning             = Warning.NewType("SyntaxWarning", "Base class for warnings about dubious syntax.", nil, nil)
+	UserWarning               = Warning.NewType("UserWarning", "Base class for warnings generated by user code.", nil, nil)
+	FutureWarning             = Warning.NewType("FutureWarning", "Base class for warnings about constructs that will change semantically\nin the future.", nil, nil)
+	ImportWarning             = Warning.NewType("ImportWarning", "Base class for warnings about probable mistakes in module imports", nil, nil)
+	UnicodeWarning            = Warning.NewType("UnicodeWarning", "Base class for warnings about Unicode related problems, mostly\nrelated to conversion problems.", nil, nil)
+	BytesWarning              = Warning.NewType("BytesWarning", "Base class for warnings about bytes and buffer related problems, mostly\nrelated to conversion from str or comparing to str.", nil, nil)
+	ResourceWarning           = Warning.NewType("ResourceWarning", "Base class for warnings about resource usage.", nil, nil)
+	// Singleton exceptions
+	NotImplemented = NotImplementedError.M__call__(nil, nil)
 )
 
 // Type of this object
 func (o *Exception) Type() *Type {
-	return ExceptionType
+	return o.Base
 }
 
-// Define a new exception
-//
-// FIXME need inheritance machinery to make this work properly
-func NewException(name string) *Exception {
-	m := &Exception{
-		Name: name,
+// RangeNew
+func ExceptionNew(metatype *Type, args Tuple, kwargs StringDict) Object {
+	if len(kwargs) != 0 {
+		// TypeError
+		panic(fmt.Sprintf("TypeError: %s does not take keyword arguments", metatype.Name))
+	}
+	return &Exception{
+		Base: metatype,
+		Args: args.Copy(),
 	}
-	return m
 }
+
+/*
+#define PyType_HasFeature(t,f)  (((t)->tp_flags & (f)) != 0)
+
+#define PyType_FastSubclass(t,f)  PyType_HasFeature(t,f)
+
+#define PyType_Check(op) \
+    PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TYPE_SUBCLASS)
+
+#define PyType_CheckExact(op) (Py_TYPE(op) == &PyType_Type)
+
+#define PyExceptionClass_Check(x)                                       \
+    (PyType_Check((x)) &&                                               \
+     PyType_FastSubclass((PyTypeObject*)(x), Py_TPFLAGS_BASE_EXC_SUBCLASS))
+
+#define PyExceptionInstance_Check(x)                    \
+    PyType_FastSubclass((x)->ob_type, Py_TPFLAGS_BASE_EXC_SUBCLASS)
+
+#define PyExceptionClass_Name(x) \
+     ((char *)(((PyTypeObject*)(x))->tp_name))
+
+#define PyExceptionInstance_Class(x) ((PyObject*)((x)->ob_type))
+*/
@@ -692,7 +692,7 @@ func do_JUMP_ABSOLUTE(vm *Vm, target int32) {
 func do_FOR_ITER(vm *Vm, delta int32) {
 	defer func() {
 		if r := recover(); r != nil {
-			if ex, ok := r.(*py.Exception); ok && ex == py.StopIteration {
+			if ex, ok := r.(*py.Exception); ok && ex.Base == py.StopIteration {
 				// StopIteration raised
 				vm.DROP()
 				vm.frame.Lasti += delta
@@ -788,10 +788,94 @@ func do_DELETE_DEREF(vm *Vm, i int32) {
 	vm.NotImplemented("DELETE_DEREF", i)
 }
 
+// Logic for the raise statement
+func do_raise(exc, cause py.Object) vmExit {
+	/*
+		// FIXME need to keep the current exception somewhere as this needs to change it
+		// in the vm like cpython or maybe return it
+		var t *py.Type
+		var value py.Object
+		if exc == nil {
+			// Reraise
+			panic("FIXME can't re-raise yet")
+			// PyThreadState * tstate = PyThreadState_GET()
+			// PyObject * tb
+			// t = tstate.exc_type
+			// value = tstate.exc_value
+			// tb = tstate.exc_traceback
+			// if t == Py_None {
+			// 	PyErr_SetString(PyExc_RuntimeError, "No active exception to reraise")
+			// 	return exitException
+			// }
+			// PyErr_Restore(t, value, tb)
+			return exitReraise
+		}
+
+		// We support the following forms of raise:
+		// raise
+		// raise <instance>
+		// raise <type>
+		if py.ExceptionClassCheck(exc) {
+			t = exc.(*py.Type)
+			value = py.Call(exc, nil, nil)
+			if value == nil {
+				return exitException
+			}
+			if !py.ExceptionInstanceCheck(value) {
+				PyErr_Format(PyExc_TypeError, "calling %s should have returned an instance of BaseException, not %s", t.Name, value.Type().Name)
+				return exitException
+			}
+		} else if t = py.ExceptionInstanceCheck(exc); t != nil {
+			value = exc
+		} else {
+			// Not something you can raise.  You get an exception
+			// anyway, just not what you specified :-)
+			PyErr_SetString(PyExc_TypeError, "exceptions must derive from BaseException")
+			return exitException
+		}
+
+		if cause != nil {
+			var fixed_cause py.Object
+			if py.ExceptionClassCheck(cause) {
+				fixed_cause = py.Call(cause, nil, nil)
+				if fixed_cause == nil {
+					return exitException
+				}
+			} else if py.ExceptionInstanceCheck(cause) {
+				fixed_cause = cause
+			} else if cause == py.None {
+				fixed_cause = nil
+			} else {
+				PyErr_SetString(PyExc_TypeError, "exception causes must derive from BaseException")
+				return exitException
+			}
+			PyException_SetCause(value, fixed_cause)
+		}
+
+		PyErr_SetObject(t, value)
+		return WHY_EXCEPTION
+	*/
+	return exitException
+}
+
 // Raises an exception. argc indicates the number of parameters to the
 // raise statement, ranging from 0 to 3. The handler will find the
 // traceback as TOS2, the parameter as TOS1, and the exception as TOS.
 func do_RAISE_VARARGS(vm *Vm, argc int32) {
+	// var v, w py.Object
+	// switch argc {
+	// case 2:
+	// 	v = vm.POP() // cause
+	// 	fallthrough
+	// case 1:
+	// 	w = vm.POP() // exc
+	// 	fallthrough
+	// case 0:
+	// 	why = do_raise(w, v)
+	// default:
+	// 	PyErr_SetString(PyExc_SystemError, "bad RAISE_VARARGS oparg")
+	// 	why = WHY_EXCEPTION
+	// }
 	vm.NotImplemented("RAISE_VARARGS", argc)
 }