1 files changed, 152 insertions, 0 deletions
diff --git a/Godeps/_workspace/src/github.com/obscuren/otto/error.go b/Godeps/_workspace/src/github.com/obscuren/otto/error.go
new file mode 100644
index 000000000..887b954bd
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/obscuren/otto/error.go
@@ -0,0 +1,152 @@
+package otto
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/robertkrimen/otto/ast"
+)
+
+type _exception struct {
+	value interface{}
+}
+
+func newException(value interface{}) *_exception {
+	return &_exception{
+		value: value,
+	}
+}
+
+func (self *_exception) eject() interface{} {
+	value := self.value
+	self.value = nil // Prevent Go from holding on to the value, whatever it is
+	return value
+}
+
+type _error struct {
+	Name    string
+	Message string
+
+	Line int // Hackish -- line where the error/exception occurred
+}
+
+var messageDetail map[string]string = map[string]string{
+	"notDefined": "%v is not defined",
+}
+
+func messageFromDescription(description string, argumentList ...interface{}) string {
+	message := messageDetail[description]
+	if message == "" {
+		message = description
+	}
+	message = fmt.Sprintf(message, argumentList...)
+	return message
+}
+
+func (self _error) MessageValue() Value {
+	if self.Message == "" {
+		return UndefinedValue()
+	}
+	return toValue_string(self.Message)
+}
+
+func (self _error) String() string {
+	if len(self.Name) == 0 {
+		return self.Message
+	}
+	if len(self.Message) == 0 {
+		return self.Name
+	}
+	return fmt.Sprintf("%s: %s", self.Name, self.Message)
+}
+
+func newError(name string, argumentList ...interface{}) _error {
+	description := ""
+	var node ast.Node = nil
+	length := len(argumentList)
+	if length > 0 {
+		if node, _ = argumentList[length-1].(ast.Node); node != nil || argumentList[length-1] == nil {
+			argumentList = argumentList[0 : length-1]
+			length -= 1
+		}
+		if length > 0 {
+			description, argumentList = argumentList[0].(string), argumentList[1:]
+		}
+	}
+	return _error{
+		Name:    name,
+		Message: messageFromDescription(description, argumentList...),
+		Line:    -1,
+	}
+	//error := _error{
+	//    Name:    name,
+	//    Message: messageFromDescription(description, argumentList...),
+	//    Line:    -1,
+	//}
+	//if node != nil {
+	//    error.Line = ast.position()
+	//}
+	//return error
+}
+
+func newReferenceError(argumentList ...interface{}) _error {
+	return newError("ReferenceError", argumentList...)
+}
+
+func newTypeError(argumentList ...interface{}) _error {
+	return newError("TypeError", argumentList...)
+}
+
+func newRangeError(argumentList ...interface{}) _error {
+	return newError("RangeError", argumentList...)
+}
+
+func newSyntaxError(argumentList ...interface{}) _error {
+	return newError("SyntaxError", argumentList...)
+}
+
+func newURIError(argumentList ...interface{}) _error {
+	return newError("URIError", argumentList...)
+}
+
+func typeErrorResult(throw bool) bool {
+	if throw {
+		panic(newTypeError())
+	}
+	return false
+}
+
+func catchPanic(function func()) (err error) {
+	// FIXME
+	defer func() {
+		if caught := recover(); caught != nil {
+			if exception, ok := caught.(*_exception); ok {
+				caught = exception.eject()
+			}
+			switch caught := caught.(type) {
+			//case *_syntaxError:
+			//    err = errors.New(fmt.Sprintf("%s (line %d)", caught.String(), caught.Line+0))
+			//    return
+			case _error:
+				if caught.Line == -1 {
+					err = errors.New(caught.String())
+				} else {
+					// We're 0-based (for now), hence the + 1
+					err = errors.New(fmt.Sprintf("%s (line %d)", caught.String(), caught.Line+1))
+				}
+				return
+			case Value:
+				err = errors.New(toString(caught))
+				return
+				//case string:
+				//    if strings.HasPrefix(caught, "SyntaxError:") {
+				//        err = errors.New(caught)
+				//        return
+				//    }
+			}
+			panic(caught)
+		}
+	}()
+	function()
+	return nil
+}