diff options
Diffstat (limited to 'Godeps/_workspace/src/github.com/obscuren/otto/cmpl_evaluate_expression.go')
-rw-r--r-- | Godeps/_workspace/src/github.com/obscuren/otto/cmpl_evaluate_expression.go | 391 |
1 files changed, 0 insertions, 391 deletions
diff --git a/Godeps/_workspace/src/github.com/obscuren/otto/cmpl_evaluate_expression.go b/Godeps/_workspace/src/github.com/obscuren/otto/cmpl_evaluate_expression.go deleted file mode 100644 index 657667b36..000000000 --- a/Godeps/_workspace/src/github.com/obscuren/otto/cmpl_evaluate_expression.go +++ /dev/null @@ -1,391 +0,0 @@ -package otto - -import ( - "fmt" - "math" - "runtime" - - "github.com/robertkrimen/otto/token" -) - -func (self *_runtime) cmpl_evaluate_nodeExpression(node _nodeExpression) Value { - // Allow interpreter interruption - // If the Interrupt channel is nil, then - // we avoid runtime.Gosched() overhead (if any) - // FIXME: Test this - if self.Otto.Interrupt != nil { - runtime.Gosched() - select { - case value := <-self.Otto.Interrupt: - value() - default: - } - } - - switch node := node.(type) { - - case *_nodeArrayLiteral: - return self.cmpl_evaluate_nodeArrayLiteral(node) - - case *_nodeAssignExpression: - return self.cmpl_evaluate_nodeAssignExpression(node) - - case *_nodeBinaryExpression: - if node.comparison { - return self.cmpl_evaluate_nodeBinaryExpression_comparison(node) - } else { - return self.cmpl_evaluate_nodeBinaryExpression(node) - } - - case *_nodeBracketExpression: - return self.cmpl_evaluate_nodeBracketExpression(node) - - case *_nodeCallExpression: - return self.cmpl_evaluate_nodeCallExpression(node, nil) - - case *_nodeConditionalExpression: - return self.cmpl_evaluate_nodeConditionalExpression(node) - - case *_nodeDotExpression: - return self.cmpl_evaluate_nodeDotExpression(node) - - case *_nodeFunctionLiteral: - var local = self.LexicalEnvironment() - if node.name != "" { - local = self.newDeclarativeEnvironment(local) - } - - value := toValue_object(self.newNodeFunction(node, local)) - if node.name != "" { - local.CreateMutableBinding(node.name, false) - local.SetMutableBinding(node.name, value, false) - } - return value - - case *_nodeIdentifier: - name := node.name - // TODO Should be true or false (strictness) depending on context - // getIdentifierReference should not return nil, but we check anyway and panic - // so as not to propagate the nil into something else - reference := getIdentifierReference(self.LexicalEnvironment(), name, false) - if reference == nil { - // Should never get here! - panic(hereBeDragons("referenceError == nil: " + name)) - } - return toValue(reference) - - case *_nodeLiteral: - return node.value - - case *_nodeNewExpression: - return self.cmpl_evaluate_nodeNewExpression(node) - - case *_nodeObjectLiteral: - return self.cmpl_evaluate_nodeObjectLiteral(node) - - case *_nodeRegExpLiteral: - return toValue_object(self._newRegExp(node.pattern, node.flags)) - - case *_nodeSequenceExpression: - return self.cmpl_evaluate_nodeSequenceExpression(node) - - case *_nodeThisExpression: - return toValue_object(self._executionContext(0).this) - - case *_nodeUnaryExpression: - return self.cmpl_evaluate_nodeUnaryExpression(node) - - case *_nodeVariableExpression: - return self.cmpl_evaluate_nodeVariableExpression(node) - } - - panic(fmt.Errorf("Here be dragons: evaluate_nodeExpression(%T)", node)) -} - -func (self *_runtime) cmpl_evaluate_nodeArrayLiteral(node *_nodeArrayLiteral) Value { - - valueArray := []Value{} - - for _, node := range node.value { - if node == nil { - valueArray = append(valueArray, Value{}) - } else { - valueArray = append(valueArray, self.GetValue(self.cmpl_evaluate_nodeExpression(node))) - } - } - - result := self.newArrayOf(valueArray) - - return toValue_object(result) -} - -func (self *_runtime) cmpl_evaluate_nodeAssignExpression(node *_nodeAssignExpression) Value { - - left := self.cmpl_evaluate_nodeExpression(node.left) - right := self.cmpl_evaluate_nodeExpression(node.right) - rightValue := self.GetValue(right) - - result := rightValue - if node.operator != token.ASSIGN { - result = self.calculateBinaryExpression(node.operator, left, rightValue) - } - - self.PutValue(left.reference(), result) - - return result -} - -func (self *_runtime) cmpl_evaluate_nodeBinaryExpression(node *_nodeBinaryExpression) Value { - - left := self.cmpl_evaluate_nodeExpression(node.left) - leftValue := self.GetValue(left) - - switch node.operator { - // Logical - case token.LOGICAL_AND: - if !toBoolean(leftValue) { - return leftValue - } - right := self.cmpl_evaluate_nodeExpression(node.right) - return self.GetValue(right) - case token.LOGICAL_OR: - if toBoolean(leftValue) { - return leftValue - } - right := self.cmpl_evaluate_nodeExpression(node.right) - return self.GetValue(right) - } - - return self.calculateBinaryExpression(node.operator, leftValue, self.cmpl_evaluate_nodeExpression(node.right)) -} - -func (self *_runtime) cmpl_evaluate_nodeBinaryExpression_comparison(node *_nodeBinaryExpression) Value { - - left := self.GetValue(self.cmpl_evaluate_nodeExpression(node.left)) - right := self.GetValue(self.cmpl_evaluate_nodeExpression(node.right)) - - return toValue_bool(self.calculateComparison(node.operator, left, right)) -} - -func (self *_runtime) cmpl_evaluate_nodeBracketExpression(node *_nodeBracketExpression) Value { - target := self.cmpl_evaluate_nodeExpression(node.left) - targetValue := self.GetValue(target) - member := self.cmpl_evaluate_nodeExpression(node.member) - memberValue := self.GetValue(member) - - // TODO Pass in base value as-is, and defer toObject till later? - return toValue(newPropertyReference(self.toObject(targetValue), toString(memberValue), false)) -} - -func (self *_runtime) cmpl_evaluate_nodeCallExpression(node *_nodeCallExpression, withArgumentList []interface{}) Value { - callee := self.cmpl_evaluate_nodeExpression(node.callee) - calleeValue := self.GetValue(callee) - argumentList := []Value{} - if withArgumentList != nil { - argumentList = self.toValueArray(withArgumentList...) - } else { - for _, argumentNode := range node.argumentList { - argumentList = append(argumentList, self.GetValue(self.cmpl_evaluate_nodeExpression(argumentNode))) - } - } - this := UndefinedValue() - calleeReference := callee.reference() - evalHint := false - if calleeReference != nil { - if calleeReference.IsPropertyReference() { - calleeObject := calleeReference.GetBase().(*_object) - this = toValue_object(calleeObject) - } else { - // TODO ImplictThisValue - } - if calleeReference.GetName() == "eval" { - evalHint = true // Possible direct eval - } - } - if !calleeValue.IsFunction() { - panic(newTypeError("%v is not a function", calleeValue)) - } - return self.Call(calleeValue._object(), this, argumentList, evalHint) -} - -func (self *_runtime) cmpl_evaluate_nodeConditionalExpression(node *_nodeConditionalExpression) Value { - test := self.cmpl_evaluate_nodeExpression(node.test) - testValue := self.GetValue(test) - if toBoolean(testValue) { - return self.cmpl_evaluate_nodeExpression(node.consequent) - } - return self.cmpl_evaluate_nodeExpression(node.alternate) -} - -func (self *_runtime) cmpl_evaluate_nodeDotExpression(node *_nodeDotExpression) Value { - target := self.cmpl_evaluate_nodeExpression(node.left) - targetValue := self.GetValue(target) - // TODO Pass in base value as-is, and defer toObject till later? - object, err := self.objectCoerce(targetValue) - if err != nil { - panic(newTypeError(fmt.Sprintf("Cannot access member '%s' of %s", node.identifier, err.Error()))) - } - return toValue(newPropertyReference(object, node.identifier, false)) -} - -func (self *_runtime) cmpl_evaluate_nodeNewExpression(node *_nodeNewExpression) Value { - callee := self.cmpl_evaluate_nodeExpression(node.callee) - calleeValue := self.GetValue(callee) - argumentList := []Value{} - for _, argumentNode := range node.argumentList { - argumentList = append(argumentList, self.GetValue(self.cmpl_evaluate_nodeExpression(argumentNode))) - } - this := UndefinedValue() - if !calleeValue.IsFunction() { - panic(newTypeError("%v is not a function", calleeValue)) - } - return calleeValue._object().Construct(this, argumentList) -} - -func (self *_runtime) cmpl_evaluate_nodeObjectLiteral(node *_nodeObjectLiteral) Value { - - result := self.newObject() - - for _, property := range node.value { - switch property.kind { - case "value": - result.defineProperty(property.key, self.GetValue(self.cmpl_evaluate_nodeExpression(property.value)), 0111, false) - case "get": - getter := self.newNodeFunction(property.value.(*_nodeFunctionLiteral), self.LexicalEnvironment()) - descriptor := _property{} - descriptor.mode = 0211 - descriptor.value = _propertyGetSet{getter, nil} - result.defineOwnProperty(property.key, descriptor, false) - case "set": - setter := self.newNodeFunction(property.value.(*_nodeFunctionLiteral), self.LexicalEnvironment()) - descriptor := _property{} - descriptor.mode = 0211 - descriptor.value = _propertyGetSet{nil, setter} - result.defineOwnProperty(property.key, descriptor, false) - default: - panic(fmt.Errorf("Here be dragons: evaluate_nodeObjectLiteral: invalid property.Kind: %v", property.kind)) - } - } - - return toValue_object(result) -} - -func (self *_runtime) cmpl_evaluate_nodeSequenceExpression(node *_nodeSequenceExpression) Value { - var result Value - for _, node := range node.sequence { - result = self.cmpl_evaluate_nodeExpression(node) - result = self.GetValue(result) - } - return result -} - -func (self *_runtime) cmpl_evaluate_nodeUnaryExpression(node *_nodeUnaryExpression) Value { - - target := self.cmpl_evaluate_nodeExpression(node.operand) - switch node.operator { - case token.TYPEOF, token.DELETE: - if target._valueType == valueReference && target.reference().IsUnresolvable() { - if node.operator == token.TYPEOF { - return toValue_string("undefined") - } - return TrueValue() - } - } - - switch node.operator { - case token.NOT: - targetValue := self.GetValue(target) - if targetValue.toBoolean() { - return FalseValue() - } - return TrueValue() - case token.BITWISE_NOT: - targetValue := self.GetValue(target) - integerValue := toInt32(targetValue) - return toValue_int32(^integerValue) - case token.PLUS: - targetValue := self.GetValue(target) - return toValue_float64(targetValue.toFloat()) - case token.MINUS: - targetValue := self.GetValue(target) - value := targetValue.toFloat() - // TODO Test this - sign := float64(-1) - if math.Signbit(value) { - sign = 1 - } - return toValue_float64(math.Copysign(value, sign)) - case token.INCREMENT: - targetValue := self.GetValue(target) - if node.postfix { - // Postfix++ - oldValue := targetValue.toFloat() - newValue := toValue_float64(+1 + oldValue) - self.PutValue(target.reference(), newValue) - return toValue_float64(oldValue) - } else { - // ++Prefix - newValue := toValue_float64(+1 + targetValue.toFloat()) - self.PutValue(target.reference(), newValue) - return newValue - } - case token.DECREMENT: - targetValue := self.GetValue(target) - if node.postfix { - // Postfix-- - oldValue := targetValue.toFloat() - newValue := toValue_float64(-1 + oldValue) - self.PutValue(target.reference(), newValue) - return toValue_float64(oldValue) - } else { - // --Prefix - newValue := toValue_float64(-1 + targetValue.toFloat()) - self.PutValue(target.reference(), newValue) - return newValue - } - case token.VOID: - self.GetValue(target) // FIXME Side effect? - return UndefinedValue() - case token.DELETE: - reference := target.reference() - if reference == nil { - return TrueValue() - } - return toValue_bool(target.reference().Delete()) - case token.TYPEOF: - targetValue := self.GetValue(target) - switch targetValue._valueType { - case valueUndefined: - return toValue_string("undefined") - case valueNull: - return toValue_string("object") - case valueBoolean: - return toValue_string("boolean") - case valueNumber: - return toValue_string("number") - case valueString: - return toValue_string("string") - case valueObject: - if targetValue._object().functionValue().call != nil { - return toValue_string("function") - } - return toValue_string("object") - default: - // FIXME ? - } - } - - panic(hereBeDragons()) -} - -func (self *_runtime) cmpl_evaluate_nodeVariableExpression(node *_nodeVariableExpression) Value { - if node.initializer != nil { - // FIXME If reference is nil - left := getIdentifierReference(self.LexicalEnvironment(), node.name, false) - right := self.cmpl_evaluate_nodeExpression(node.initializer) - rightValue := self.GetValue(right) - - self.PutValue(left, rightValue) - } - return toValue_string(node.name) -} |