2013-04-25 Filip Pizlo <fpizlo@apple.com>
+ Unreviewed, roll out http://trac.webkit.org/changeset/148999
+ It broke http://kripken.github.io/ammo.js/examples/new/ammo.html
+
+ * JavaScriptCore.order:
+ * bytecompiler/BytecodeGenerator.cpp:
+ (JSC::BytecodeGenerator::emitNewArray):
+ (JSC::BytecodeGenerator::emitThrowReferenceError):
+ (JSC::BytecodeGenerator::emitReadOnlyExceptionIfNeeded):
+ * bytecompiler/BytecodeGenerator.h:
+ (JSC::BytecodeGenerator::shouldEmitProfileHooks):
+ (BytecodeGenerator):
+ * bytecompiler/NodesCodegen.cpp:
+ (JSC):
+ (JSC::NullNode::emitBytecode):
+ (JSC::BooleanNode::emitBytecode):
+ (JSC::NumberNode::emitBytecode):
+ (JSC::StringNode::emitBytecode):
+ (JSC::IfNode::emitBytecode):
+ (JSC::IfElseNode::emitBytecode):
+ * parser/ASTBuilder.h:
+ (JSC::ASTBuilder::createIfStatement):
+ (ASTBuilder):
+ * parser/NodeConstructors.h:
+ (JSC):
+ (JSC::NullNode::NullNode):
+ (JSC::BooleanNode::BooleanNode):
+ (JSC::NumberNode::NumberNode):
+ (JSC::StringNode::StringNode):
+ (JSC::IfNode::IfNode):
+ (JSC::IfElseNode::IfElseNode):
+ * parser/Nodes.h:
+ (JSC::ExpressionNode::isPure):
+ (JSC::ExpressionNode::isSubtract):
+ (StatementNode):
+ (NullNode):
+ (JSC::NullNode::isNull):
+ (BooleanNode):
+ (JSC::BooleanNode::isPure):
+ (NumberNode):
+ (JSC::NumberNode::value):
+ (JSC::NumberNode::isPure):
+ (StringNode):
+ (JSC::StringNode::isPure):
+ (JSC::StringNode::isString):
+ (BinaryOpNode):
+ (IfNode):
+ (JSC):
+ (IfElseNode):
+ (ContinueNode):
+ (BreakNode):
+ * parser/Parser.cpp:
+ (JSC::::parseIfStatement):
+ * parser/ResultType.h:
+ (ResultType):
+ * runtime/JSCJSValueInlines.h:
+ (JSC::JSValue::pureToBoolean):
+ * runtime/JSCell.h:
+ (JSCell):
+ * runtime/JSCellInlines.h:
+ (JSC):
+
+2013-04-25 Filip Pizlo <fpizlo@apple.com>
+
PreciseJumpTargets should treat loop_hint as a jump target
https://bugs.webkit.org/show_bug.cgi?id=115209
__ZNK3JSC14ExpressionNode21isBracketAccessorNodeEv
__ZN3JSC9CodeBlock25createRareDataIfNecessaryEv
__ZN3WTF6VectorIN3JSC8LineInfoELm0EE14expandCapacityEm
+__ZN3JSC6IfNode12emitBytecodeERNS_17BytecodeGeneratorEPNS_10RegisterIDE
__ZN3JSC17BytecodeGenerator8newLabelEv
__ZNK3JSC14ExpressionNode26hasConditionContextCodegenEv
__ZN3WTF6VectorIN3JSC19ExpressionRangeInfoELm0EE14expandCapacityEm
bool hadVariableExpression = false;
if (length) {
for (ElementNode* n = elements; n; n = n->next()) {
- if (!n->value()->isConstant()) {
+ if (!n->value()->isNumber() && !n->value()->isString()) {
hadVariableExpression = true;
break;
}
JSValue* constantBuffer = m_codeBlock->constantBuffer(constantBufferIndex).data();
unsigned index = 0;
for (ElementNode* n = elements; index < length; n = n->next()) {
- ASSERT(n->value()->isConstant());
- constantBuffer[index++] = static_cast<ConstantNode*>(n->value())->jsValue(*this);
+ if (n->value()->isNumber())
+ constantBuffer[index++] = jsNumber(static_cast<NumberNode*>(n->value())->value());
+ else {
+ ASSERT(n->value()->isString());
+ constantBuffer[index++] = addStringConstant(static_cast<StringNode*>(n->value())->value());
+ }
}
emitOpcode(op_new_array_buffer);
instructions().append(dst->index());
void BytecodeGenerator::emitThrowReferenceError(const String& message)
{
emitOpcode(op_throw_static_error);
- instructions().append(addConstantValue(addStringConstant(Identifier(m_vm, message)))->index());
+ instructions().append(addConstantValue(jsString(vm(), message))->index());
instructions().append(true);
}
if (!isStrictMode())
return;
emitOpcode(op_throw_static_error);
- instructions().append(addConstantValue(addStringConstant(Identifier(m_vm, StrictModeReadonlyPropertyWriteError)))->index());
+ instructions().append(addConstantValue(jsString(vm(), StrictModeReadonlyPropertyWriteError))->index());
instructions().append(false);
}
CodeType codeType() const { return m_codeType; }
bool shouldEmitProfileHooks() { return m_shouldEmitProfileHooks; }
- bool shouldEmitDebugHooks() { return m_shouldEmitDebugHooks; }
bool isStrictMode() const { return m_codeBlock->isStrictMode(); }
return UnlinkedFunctionExecutable::create(m_vm, m_scopeNode->source(), body);
}
+ JSString* addStringConstant(const Identifier&);
+
void addLineInfo(unsigned lineNo)
{
m_codeBlock->addLineInfo(instructions().size(), lineNo - m_scopeNode->firstLine());
RegisterID* emitInitLazyRegister(RegisterID*);
public:
- JSString* addStringConstant(const Identifier&);
-
Vector<UnlinkedInstruction, 0, UnsafeVectorOverflow>& instructions() { return m_instructions; }
SharedSymbolTable& symbolTable() { return *m_symbolTable; }
return generator.newTemporary();
}
-// ------------------------------ ConstantNode ----------------------------------
+// ------------------------------ NullNode -------------------------------------
-void ConstantNode::emitBytecodeInConditionContext(BytecodeGenerator& generator, Label* trueTarget, Label* falseTarget, FallThroughMode fallThroughMode)
+RegisterID* NullNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
- TriState value = jsValue(generator).pureToBoolean();
- if (value == MixedTriState)
- ExpressionNode::emitBytecodeInConditionContext(generator, trueTarget, falseTarget, fallThroughMode);
- else if (value == TrueTriState && fallThroughMode == FallThroughMeansFalse)
- generator.emitJump(trueTarget);
- else if (value == FalseTriState && fallThroughMode == FallThroughMeansTrue)
- generator.emitJump(falseTarget);
+ if (dst == generator.ignoredResult())
+ return 0;
+ return generator.emitLoad(dst, jsNull());
+}
- // All other cases are unconditional fall-throughs, like "if (true)".
+// ------------------------------ BooleanNode ----------------------------------
+
+RegisterID* BooleanNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
+{
+ if (dst == generator.ignoredResult())
+ return 0;
+ return generator.emitLoad(dst, m_value);
}
-RegisterID* ConstantNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
+// ------------------------------ NumberNode -----------------------------------
+
+RegisterID* NumberNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
if (dst == generator.ignoredResult())
return 0;
- return generator.emitLoad(dst, jsValue(generator));
+ return generator.emitLoad(dst, m_value);
}
-JSValue StringNode::jsValue(BytecodeGenerator& generator) const
+// ------------------------------ StringNode -----------------------------------
+
+RegisterID* StringNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
- return generator.addStringConstant(m_value);
+ if (dst == generator.ignoredResult())
+ return 0;
+ return generator.emitLoad(dst, m_value);
}
// ------------------------------ RegExpNode -----------------------------------
return generator.emitStrcat(generator.finalDestination(dst, temporaryRegisters[0].get()), temporaryRegisters[0].get(), temporaryRegisters.size());
}
-void BinaryOpNode::emitBytecodeInConditionContext(BytecodeGenerator& generator, Label* trueTarget, Label* falseTarget, FallThroughMode fallThroughMode)
-{
- TriState branchCondition;
- ExpressionNode* branchExpression;
- tryFoldToBranch(generator, branchCondition, branchExpression);
-
- if (branchCondition == MixedTriState)
- ExpressionNode::emitBytecodeInConditionContext(generator, trueTarget, falseTarget, fallThroughMode);
- else if (branchCondition == TrueTriState)
- generator.emitNodeInConditionContext(branchExpression, trueTarget, falseTarget, fallThroughMode);
- else
- generator.emitNodeInConditionContext(branchExpression, falseTarget, trueTarget, invert(fallThroughMode));
-}
-
-static inline bool canFoldToBranch(OpcodeID opcodeID, ExpressionNode* branchExpression, JSValue constant)
-{
- ResultType expressionType = branchExpression->resultDescriptor();
-
- if (expressionType.definitelyIsBoolean() && constant.isBoolean())
- return true;
- else if (expressionType.isInt32() && constant.isInt32() && (constant.asInt32() == 0 || constant.asInt32() == 1))
- return true;
- else if (expressionType.definitelyIsBoolean() && constant.isInt32() && (constant.asInt32() == 0 || constant.asInt32() == 1))
- return opcodeID == op_eq || opcodeID == op_neq; // Strict equality is false in the case of type mismatch, so we can't fold to a branch based on truthiness.
-
- return false;
-}
-
-void BinaryOpNode::tryFoldToBranch(BytecodeGenerator& generator, TriState& branchCondition, ExpressionNode*& branchExpression)
-{
- branchCondition = MixedTriState;
- branchExpression = 0;
-
- ConstantNode* constant = 0;
- if (m_expr1->isConstant()) {
- constant = static_cast<ConstantNode*>(m_expr1);
- branchExpression = m_expr2;
- } else if (m_expr2->isConstant()) {
- constant = static_cast<ConstantNode*>(m_expr2);
- branchExpression = m_expr1;
- }
-
- if (!constant)
- return;
- ASSERT(branchExpression);
-
- OpcodeID opcodeID = this->opcodeID();
- JSValue value = constant->jsValue(generator);
- bool canFoldToBranch = JSC::canFoldToBranch(opcodeID, branchExpression, value);
- if (!canFoldToBranch)
- return;
-
- if (opcodeID == op_eq || opcodeID == op_stricteq)
- branchCondition = triState(value.pureToBoolean());
- else if (opcodeID == op_neq || opcodeID == op_nstricteq)
- branchCondition = triState(!value.pureToBoolean());
-}
-
RegisterID* BinaryOpNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
OpcodeID opcodeID = this->opcodeID();
generator.emitNode(m_expr);
}
-// ------------------------------ IfElseNode ---------------------------------------
+// ------------------------------ IfNode ---------------------------------------
-static inline StatementNode* singleStatement(StatementNode* statementNode)
+void IfNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
- if (statementNode->isBlock())
- return static_cast<BlockNode*>(statementNode)->singleStatement();
- return statementNode;
-}
-
-bool IfElseNode::tryFoldBreakAndContinue(BytecodeGenerator& generator, StatementNode* ifBlock,
- Label*& trueTarget, FallThroughMode& fallThroughMode)
-{
- StatementNode* singleStatement = JSC::singleStatement(ifBlock);
- if (!singleStatement)
- return false;
-
- if (singleStatement->isBreak()) {
- BreakNode* breakNode = static_cast<BreakNode*>(singleStatement);
- Label* target = breakNode->trivialTarget(generator);
- if (!target)
- return false;
- trueTarget = target;
- fallThroughMode = FallThroughMeansFalse;
- return true;
- }
+ generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), charPosition());
+
+ RefPtr<Label> afterThen = generator.newLabel();
- if (singleStatement->isContinue()) {
- ContinueNode* continueNode = static_cast<ContinueNode*>(singleStatement);
- Label* target = continueNode->trivialTarget(generator);
- if (!target)
- return false;
- trueTarget = target;
- fallThroughMode = FallThroughMeansFalse;
- return true;
- }
+ RefPtr<Label> beforeThen = generator.newLabel();
+ generator.emitNodeInConditionContext(m_condition, beforeThen.get(), afterThen.get(), FallThroughMeansTrue);
+ generator.emitLabel(beforeThen.get());
- return false;
+ generator.emitNode(dst, m_ifBlock);
+ generator.emitLabel(afterThen.get());
}
+// ------------------------------ IfElseNode ---------------------------------------
+
void IfElseNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), charPosition());
- RefPtr<Label> beforeThen = generator.newLabel();
RefPtr<Label> beforeElse = generator.newLabel();
RefPtr<Label> afterElse = generator.newLabel();
- Label* trueTarget = beforeThen.get();
- Label* falseTarget = beforeElse.get();
- FallThroughMode fallThroughMode = FallThroughMeansTrue;
- bool didFoldIfBlock = tryFoldBreakAndContinue(generator, m_ifBlock, trueTarget, fallThroughMode);
-
- generator.emitNodeInConditionContext(m_condition, trueTarget, falseTarget, fallThroughMode);
+ RefPtr<Label> beforeThen = generator.newLabel();
+ generator.emitNodeInConditionContext(m_condition, beforeThen.get(), beforeElse.get(), FallThroughMeansTrue);
generator.emitLabel(beforeThen.get());
- if (!didFoldIfBlock) {
- generator.emitNode(dst, m_ifBlock);
- if (m_elseBlock)
- generator.emitJump(afterElse.get());
- }
+ generator.emitNode(dst, m_ifBlock);
+ generator.emitJump(afterElse.get());
generator.emitLabel(beforeElse.get());
- if (m_elseBlock)
- generator.emitNode(dst, m_elseBlock);
+ generator.emitNode(dst, m_elseBlock);
generator.emitLabel(afterElse.get());
}
// ------------------------------ ContinueNode ---------------------------------
-Label* ContinueNode::trivialTarget(BytecodeGenerator& generator)
-{
- if (generator.shouldEmitDebugHooks())
- return 0;
-
- LabelScope* scope = generator.continueTarget(m_ident);
- ASSERT(scope);
-
- if (generator.scopeDepth() != scope->scopeDepth())
- return 0;
-
- return scope->continueTarget();
-}
-
void ContinueNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
{
generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), charPosition());
// ------------------------------ BreakNode ------------------------------------
-Label* BreakNode::trivialTarget(BytecodeGenerator& generator)
-{
- if (generator.shouldEmitDebugHooks())
- return 0;
-
- LabelScope* scope = generator.breakTarget(m_ident);
- ASSERT(scope);
-
- if (generator.scopeDepth() != scope->scopeDepth())
- return 0;
-
- return scope->breakTarget();
-}
-
void BreakNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
{
generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), charPosition());
return result;
}
+ StatementNode* createIfStatement(const JSTokenLocation& location, ExpressionNode* condition, StatementNode* trueBlock, int start, int end)
+ {
+ IfNode* result = new (m_vm) IfNode(location, condition, trueBlock);
+ result->setLoc(start, end, location.charPosition);
+ return result;
+ }
+
StatementNode* createIfStatement(const JSTokenLocation& location, ExpressionNode* condition, StatementNode* trueBlock, StatementNode* falseBlock, int start, int end)
{
- IfElseNode* result = new (m_vm) IfElseNode(location, condition, trueBlock, falseBlock);
+ IfNode* result = new (m_vm) IfElseNode(location, condition, trueBlock, falseBlock);
result->setLoc(start, end, location.charPosition);
return result;
}
{
}
- inline ConstantNode::ConstantNode(const JSTokenLocation& location, ResultType resultType)
- : ExpressionNode(location, resultType)
- {
- }
-
inline NullNode::NullNode(const JSTokenLocation& location)
- : ConstantNode(location, ResultType::nullType())
+ : ExpressionNode(location, ResultType::nullType())
{
}
inline BooleanNode::BooleanNode(const JSTokenLocation& location, bool value)
- : ConstantNode(location, ResultType::booleanType())
+ : ExpressionNode(location, ResultType::booleanType())
, m_value(value)
{
}
inline NumberNode::NumberNode(const JSTokenLocation& location, double value)
- : ConstantNode(location, ResultType::numberType())
+ : ExpressionNode(location, ResultType::numberType())
, m_value(value)
{
}
inline StringNode::StringNode(const JSTokenLocation& location, const Identifier& value)
- : ConstantNode(location, ResultType::stringType())
+ : ExpressionNode(location, ResultType::stringType())
, m_value(value)
{
}
{
}
- inline IfElseNode::IfElseNode(const JSTokenLocation& location, ExpressionNode* condition, StatementNode* ifBlock, StatementNode* elseBlock)
+ inline IfNode::IfNode(const JSTokenLocation& location, ExpressionNode* condition, StatementNode* ifBlock)
: StatementNode(location)
, m_condition(condition)
, m_ifBlock(ifBlock)
+ {
+ }
+
+ inline IfElseNode::IfElseNode(const JSTokenLocation& location, ExpressionNode* condition, StatementNode* ifBlock, StatementNode* elseBlock)
+ : IfNode(location, condition, ifBlock)
, m_elseBlock(elseBlock)
{
}
virtual bool isString() const { return false; }
virtual bool isNull() const { return false; }
virtual bool isPure(BytecodeGenerator&) const { return false; }
- virtual bool isConstant() const { return false; }
virtual bool isLocation() const { return false; }
virtual bool isResolveNode() const { return false; }
virtual bool isBracketAccessorNode() const { return false; }
virtual bool isSimpleArray() const { return false; }
virtual bool isAdd() const { return false; }
virtual bool isSubtract() const { return false; }
- virtual bool isBoolean() const { return false; }
virtual void emitBytecodeInConditionContext(BytecodeGenerator&, Label*, Label*, FallThroughMode);
virtual bool isEmptyStatement() const { return false; }
virtual bool isReturnNode() const { return false; }
virtual bool isExprStatement() const { return false; }
- virtual bool isBreak() const { return false; }
- virtual bool isContinue() const { return false; }
+
virtual bool isBlock() const { return false; }
private:
int m_lastLine;
};
- class ConstantNode : public ExpressionNode {
- public:
- ConstantNode(const JSTokenLocation&, ResultType);
- virtual bool isPure(BytecodeGenerator&) const { return true; }
- virtual bool isConstant() const { return true; }
- virtual JSValue jsValue(BytecodeGenerator&) const = 0;
- private:
- virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
- void emitBytecodeInConditionContext(BytecodeGenerator&, Label* trueTarget, Label* falseTarget, FallThroughMode);
- };
-
- class NullNode : public ConstantNode {
+ class NullNode : public ExpressionNode {
public:
NullNode(const JSTokenLocation&);
private:
+ virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+
virtual bool isNull() const { return true; }
- virtual JSValue jsValue(BytecodeGenerator&) const { return jsNull(); }
};
- class BooleanNode : public ConstantNode {
+ class BooleanNode : public ExpressionNode {
public:
BooleanNode(const JSTokenLocation&, bool value);
- bool value() { return m_value; }
private:
- virtual bool isBoolean() const { return true; }
- virtual JSValue jsValue(BytecodeGenerator&) const { return jsBoolean(m_value); }
+ virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+
+ virtual bool isPure(BytecodeGenerator&) const { return true; }
bool m_value;
};
- class NumberNode : public ConstantNode {
+ class NumberNode : public ExpressionNode {
public:
NumberNode(const JSTokenLocation&, double value);
- double value() { return m_value; }
+
+ double value() const { return m_value; }
void setValue(double value) { m_value = value; }
private:
+ virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+
virtual bool isNumber() const { return true; }
- virtual JSValue jsValue(BytecodeGenerator&) const { return jsNumber(m_value); }
+ virtual bool isPure(BytecodeGenerator&) const { return true; }
double m_value;
};
- class StringNode : public ConstantNode {
+ class StringNode : public ExpressionNode {
public:
StringNode(const JSTokenLocation&, const Identifier&);
+
const Identifier& value() { return m_value; }
private:
+ virtual bool isPure(BytecodeGenerator&) const { return true; }
+
+ virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+
virtual bool isString() const { return true; }
- virtual JSValue jsValue(BytecodeGenerator&) const;
const Identifier& m_value;
};
BinaryOpNode(const JSTokenLocation&, ResultType, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
RegisterID* emitStrcat(BytecodeGenerator& generator, RegisterID* destination, RegisterID* lhs = 0, ReadModifyResolveNode* emitExpressionInfoForMe = 0);
- void emitBytecodeInConditionContext(BytecodeGenerator&, Label* trueTarget, Label* falseTarget, FallThroughMode);
ExpressionNode* lhs() { return m_expr1; };
ExpressionNode* rhs() { return m_expr2; };
private:
- void tryFoldToBranch(BytecodeGenerator&, TriState& branchCondition, ExpressionNode*& branchExpression);
virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
protected:
ExpressionNode* m_expr;
};
- class IfElseNode : public StatementNode {
+ class IfNode : public StatementNode {
public:
- IfElseNode(const JSTokenLocation&, ExpressionNode* condition, StatementNode* ifBlock, StatementNode* elseBlock);
+ IfNode(const JSTokenLocation&, ExpressionNode* condition, StatementNode* ifBlock);
- private:
+ protected:
virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0);
- bool tryFoldBreakAndContinue(BytecodeGenerator&, StatementNode* ifBlock,
- Label*& trueTarget, FallThroughMode&);
ExpressionNode* m_condition;
StatementNode* m_ifBlock;
+ };
+
+ class IfElseNode : public IfNode {
+ public:
+ IfElseNode(const JSTokenLocation&, ExpressionNode* condition, StatementNode* ifBlock, StatementNode* elseBlock);
+
+ private:
+ virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+
StatementNode* m_elseBlock;
};
public:
ContinueNode(VM*, const JSTokenLocation&);
ContinueNode(const JSTokenLocation&, const Identifier&);
- Label* trivialTarget(BytecodeGenerator&);
private:
- virtual bool isContinue() const { return true; }
virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0);
const Identifier& m_ident;
public:
BreakNode(VM*, const JSTokenLocation&);
BreakNode(const JSTokenLocation&, const Identifier&);
- Label* trivialTarget(BytecodeGenerator&);
private:
- virtual bool isBreak() const { return true; }
virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0);
const Identifier& m_ident;
#include "ASTBuilder.h"
#include "CodeBlock.h"
#include "Debugger.h"
-#include "JSCJSValueInlines.h"
+#include "VM.h"
#include "Lexer.h"
#include "NodeInfo.h"
#include "SourceProvider.h"
-#include "VM.h"
#include <utility>
#include <wtf/HashFunctions.h>
#include <wtf/OwnPtr.h>
failIfFalse(trueBlock);
if (!match(ELSE))
- return context.createIfStatement(ifLocation, condition, trueBlock, 0, start, end);
+ return context.createIfStatement(ifLocation, condition, trueBlock, start, end);
Vector<TreeExpression> exprStack;
Vector<pair<int, int> > posStack;
posStack.removeLast();
JSTokenLocation elseLocation = tokenLocationStack.last();
tokenLocationStack.removeLast();
- statementStack.append(context.createIfStatement(elseLocation, condition, trueBlock, 0, pos.first, pos.second));
+ statementStack.append(context.createIfStatement(elseLocation, condition, trueBlock, pos.first, pos.second));
}
while (!exprStack.isEmpty()) {
return (m_type & TypeBits) == TypeMaybeString;
}
- bool definitelyIsBoolean()
- {
- return (m_type & TypeBits) == TypeMaybeBool;
- }
-
bool mightBeNumber()
{
return m_type & TypeMaybeNumber;
if (isDouble())
return (asDouble() > 0.0 || asDouble() < 0.0) ? TrueTriState : FalseTriState; // false for NaN
if (isCell())
- return asCell()->pureToBoolean();
+ return MixedTriState;
return isTrue() ? TrueTriState : FalseTriState;
}
JS_EXPORT_PRIVATE JSValue toPrimitive(ExecState*, PreferredPrimitiveType) const;
bool getPrimitiveNumber(ExecState*, double& number, JSValue&) const;
bool toBoolean(ExecState*) const;
- TriState pureToBoolean() const;
JS_EXPORT_PRIVATE double toNumber(ExecState*) const;
JS_EXPORT_PRIVATE JSObject* toObject(ExecState*, JSGlobalObject*) const;
return !structure()->masqueradesAsUndefined(exec->lexicalGlobalObject());
}
-inline TriState JSCell::pureToBoolean() const
-{
- if (isString())
- return static_cast<const JSString*>(this)->toBoolean() ? TrueTriState : FalseTriState;
- return MixedTriState;
-}
-
} // namespace JSC
#endif // JSCellInlines_h
+2013-04-25 Filip Pizlo <fpizlo@apple.com>
+
+ Unreviewed, roll out http://trac.webkit.org/changeset/148999
+ It broke http://kripken.github.io/ammo.js/examples/new/ammo.html
+
+ * wtf/TriState.h:
+
2013-04-25 Oliver Hunt <oliver@apple.com>
Fix 32bit build
MixedTriState
};
-inline TriState triState(bool boolean)
-{
- return static_cast<TriState>(boolean);
-}
-
}
using WTF::TriState;
git://git.webkit.org / WebKit-https.git / commitdiff