package otto
import (
"errors"
"reflect"
"github.com/robertkrimen/otto/ast"
"github.com/robertkrimen/otto/parser"
)
type _global struct {
Object *_object // Object( ... ), new Object( ... ) - 1 (length)
Function *_object // Function( ... ), new Function( ... ) - 1
Array *_object // Array( ... ), new Array( ... ) - 1
String *_object // String( ... ), new String( ... ) - 1
Boolean *_object // Boolean( ... ), new Boolean( ... ) - 1
Number *_object // Number( ... ), new Number( ... ) - 1
Math *_object
Date *_object // Date( ... ), new Date( ... ) - 7
RegExp *_object // RegExp( ... ), new RegExp( ... ) - 2
Error *_object // Error( ... ), new Error( ... ) - 1
EvalError *_object
TypeError *_object
RangeError *_object
ReferenceError *_object
SyntaxError *_object
URIError *_object
JSON *_object
ObjectPrototype *_object // Object.prototype
FunctionPrototype *_object // Function.prototype
ArrayPrototype *_object // Array.prototype
StringPrototype *_object // String.prototype
BooleanPrototype *_object // Boolean.prototype
NumberPrototype *_object // Number.prototype
DatePrototype *_object // Date.prototype
RegExpPrototype *_object // RegExp.prototype
ErrorPrototype *_object // Error.prototype
EvalErrorPrototype *_object
TypeErrorPrototype *_object
RangeErrorPrototype *_object
ReferenceErrorPrototype *_object
SyntaxErrorPrototype *_object
URIErrorPrototype *_object
}
type _runtime struct {
Stack [](*_executionContext)
GlobalObject *_object
GlobalEnvironment *_objectEnvironment
Global _global
eval *_object // The builtin eval, for determine indirect versus direct invocation
Otto *Otto
labels []string // FIXME
}
func (self *_runtime) EnterGlobalExecutionContext() {
self.EnterExecutionContext(newExecutionContext(self.GlobalEnvironment, self.GlobalEnvironment, self.GlobalObject))
}
func (self *_runtime) EnterExecutionContext(scope *_executionContext) {
self.Stack = append(self.Stack, scope)
}
func (self *_runtime) LeaveExecutionContext() {
self.Stack = self.Stack[:len(self.Stack)-1]
}
func (self *_runtime) _executionContext(depth int) *_executionContext {
if depth == 0 {
return self.Stack[len(self.Stack)-1]
}
if len(self.Stack)-1+depth >= 0 {
return self.Stack[len(self.Stack)-1+depth]
}
return nil
}
func (self *_runtime) EnterFunctionExecutionContext(function *_object, this Value) *_functionEnvironment {
scopeEnvironment := function.functionValue().call.ScopeEnvironment()
if scopeEnvironment == nil {
scopeEnvironment = self.GlobalEnvironment
}
environment := self.newFunctionEnvironment(scopeEnvironment)
var thisObject *_object
switch this._valueType {
case valueUndefined, valueNull:
thisObject = self.GlobalObject
default:
thisObject = self.toObject(this)
}
self.EnterExecutionContext(newExecutionContext(environment, environment, thisObject))
return environment
}
func (self *_runtime) EnterEvalExecutionContext(call FunctionCall) {
// Skip the current function lexical/variable environment, which is of the function execution context call
// to eval (the global execution context). Instead, execute in the context of where the eval was called,
// which is essentially dynamic scoping
parent := self._executionContext(-1)
new := newExecutionContext(parent.LexicalEnvironment, parent.VariableEnvironment, parent.this)
// FIXME Make passing through of self.GlobalObject more general? Whenever newExecutionContext is passed a nil object?
new.eval = true
self.EnterExecutionContext(new)
}
func (self *_runtime) GetValue(value Value) Value {
if value.isReference() {
return value.reference().GetValue()
}
return value
}
func (self *_runtime) PutValue(reference _reference, value Value) {
if !reference.PutValue(value) {
// Why? -- If reference.Base == nil
strict := false
self.GlobalObject.defineProperty(reference.GetName(), value, 0111, strict)
}
}
func (self *_runtime) Call(function *_object, this Value, argumentList []Value, evalHint bool) Value {
// Pass eval boolean through to EnterFunctionExecutionContext for further testing
_functionEnvironment := self.EnterFunctionExecutionContext(function, this)
defer func() {
self.LeaveExecutionContext()
}()
if evalHint {
evalHint = function == self.eval // If evalHint is true, then it IS a direct eval
}
callValue := function.functionValue().call.Dispatch(function, _functionEnvironment, self, this, argumentList, evalHint)
if value, valid := callValue.value.(_result); valid {
return value.value
}
return callValue
}
func (self *_runtime) tryCatchEvaluate(inner func() Value) (tryValue Value, exception bool) {
// resultValue = The value of the block (e.g. the last statement)
// throw = Something was thrown
// throwValue = The value of what was thrown
// other = Something that changes flow (return, break, continue) that is not a throw
// Otherwise, some sort of unknown panic happened, we'll just propagate it
defer func() {
if caught := recover(); caught != nil {
if exception, ok := caught.(*_exception); ok {
caught = exception.eject()
}
switch caught := caught.(type) {
case _error:
exception = true
tryValue = toValue_object(self.newError(caught.Name, caught.MessageValue()))
//case *_syntaxError:
// exception = true
// tryValue = toValue_object(self.newError("SyntaxError", toValue_string(caught.Message)))
case Value:
exception = true
tryValue = caught
default:
panic(caught)
}
}
}()
tryValue = inner()
return
}
// _executionContext Proxy
func (self *_runtime) localGet(name string) Value {
return self._executionContext(0).getValue(name)
}
func (self *_runtime) localSet(name string, value Value) {
self._executionContext(0).setValue(name, value, false)
}
func (self *_runtime) VariableEnvironment() _environment {
return self._executionContext(0).VariableEnvironment
}
func (self *_runtime) LexicalEnvironment() _environment {
return self._executionContext(0).LexicalEnvironment
}
// toObject
func (self *_runtime) toObject(value Value) *_object {
switch value._valueType {
case valueEmpty, valueUndefined, valueNull:
panic(newTypeError())
case valueBoolean:
return self.newBoolean(value)
case valueString:
return self.newString(value)
case valueNumber:
return self.newNumber(value)
case valueObject:
return value._object()
}
panic(newTypeError())
}
func (self *_runtime) objectCoerce(value Value) (*_object, error) {
switch value._valueType {
case valueUndefined:
return nil, errors.New("undefined")
case valueNull:
return nil, errors.New("null")
case valueBoolean:
return self.newBoolean(value), nil
case valueString:
return self.newString(value), nil
case valueNumber:
return self.newNumber(value), nil
case valueObject:
return value._object(), nil
}
panic(newTypeError())
}
func checkObjectCoercible(value Value) {
isObject, mustCoerce := testObjectCoercible(value)
if !isObject && !mustCoerce {
panic(newTypeError())
}
}
// testObjectCoercible
func testObjectCoercible(value Value) (isObject bool, mustCoerce bool) {
switch value._valueType {
case valueReference, valueEmpty, valueNull, valueUndefined:
return false, false
case valueNumber, valueString, valueBoolean:
isObject = false
mustCoerce = true
case valueObject:
isObject = true
mustCoerce = false
}
return
}
func (self *_runtime) ToValue(value interface{}) (Value, error) {
result := UndefinedValue()
err := catchPanic(func() {
result = self.toValue(value)
})
return result, err
}
func (self *_runtime) toValue(value interface{}) Value {
switch value := value.(type) {
case Value:
return value
case func(FunctionCall) Value:
return toValue_object(self.newNativeFunction("", value))
case _nativeFunction:
return toValue_object(self.newNativeFunction("", value))
case Object, *Object, _object, *_object:
// Nothing happens.
// FIXME
default:
{
value := reflect.ValueOf(value)
switch value.Kind() {
case reflect.Ptr:
switch reflect.Indirect(value).Kind() {
case reflect.Struct:
return toValue_object(self.newGoStructObject(value))
case reflect.Array:
return toValue_object(self.newGoArray(value))
}
case reflect.Func:
return toValue_object(self.newNativeFunction("", func(call FunctionCall) Value {
args := make([]reflect.Value, len(call.ArgumentList))
for i, a := range call.ArgumentList {
args[i] = reflect.ValueOf(a.export())
}
retvals := value.Call(args)
if len(retvals) > 1 {
panic(newTypeError())
} else if len(retvals) == 1 {
return toValue(retvals[0].Interface())
}
return UndefinedValue()
}))
case reflect.Struct:
return toValue_object(self.newGoStructObject(value))
case reflect.Map:
return toValue_object(self.newGoMapObject(value))
case reflect.Slice:
return toValue_object(self.newGoSlice(value))
case reflect.Array:
return toValue_object(self.newGoArray(value))
}
}
}
return toValue(value)
}
func (runtime *_runtime) newGoSlice(value reflect.Value) *_object {
self := runtime.newGoSliceObject(value)
self.prototype = runtime.Global.ArrayPrototype
return self
}
func (runtime *_runtime) newGoArray(value reflect.Value) *_object {
self := runtime.newGoArrayObject(value)
self.prototype = runtime.Global.ArrayPrototype
return self
}
func (runtime *_runtime) parse(filename string, src interface{}) (*ast.Program, error) {
return parser.ParseFile(nil, filename, src, 0)
}
func (runtime *_runtime) cmpl_parse(filename string, src interface{}) (*_nodeProgram, error) {
program, err := parser.ParseFile(nil, filename, src, 0)
if err != nil {
return nil, err
}
return cmpl_parse(program), nil
}
func (self *_runtime) parseSource(src interface{}) (*_nodeProgram, *ast.Program, error) {
switch src := src.(type) {
case *ast.Program:
return nil, src, nil
case *Script:
return src.program, nil, nil
}
program, err := self.parse("", src)
return nil, program, err
}
func (self *_runtime) cmpl_run(src interface{}) (Value, error) {
result := UndefinedValue()
cmpl_program, program, err := self.parseSource(src)
if err != nil {
return result, err
}
if cmpl_program == nil {
cmpl_program = cmpl_parse(program)
}
err = catchPanic(func() {
result = self.cmpl_evaluate_nodeProgram(cmpl_program)
})
switch result._valueType {
case valueEmpty:
result = UndefinedValue()
case valueReference:
result = self.GetValue(result)
}
return result, err
}
func (self *_runtime) parseThrow(err error) {
if err == nil {
return
}
switch err := err.(type) {
case parser.ErrorList:
{
err := err[0]
if err.Message == "Invalid left-hand side in assignment" {
panic(newReferenceError(err.Message))
}
panic(newSyntaxError(err.Message))
}
}
panic(newSyntaxError(err.Error()))
}
func (self *_runtime) parseOrThrow(source string) *ast.Program {
program, err := self.parse("", source)
self.parseThrow(err) // Will panic/throw appropriately
return program
}
func (self *_runtime) cmpl_parseOrThrow(source string) *_nodeProgram {
program, err := self.cmpl_parse("", source)
self.parseThrow(err) // Will panic/throw appropriately
return program
}
