Changeset 35245 in webkit


Ignore:
Timestamp:
Jul 18, 2008, 6:44:24 PM (17 years ago)
Author:
oliver@apple.com
Message:

Bug 18774: SQUIRRELFISH: print meaningful error messages <​https://bugs.webkit.org/show_bug.cgi?id=18774>
<rdar://problem/5769353> SQUIRRELFISH: JavaScript error messages are missing informative text

Reviewed by Cameron Zwarich

Add support for decent error messages in JavaScript. This patch achieves this by providing
ensuring the common errors and exceptions have messages that provide the text of expression
that trigger the exception. In addition it attaches a number of properties to the exception
object detailing where in the source the expression came from.

Location:
trunk
Files:
2 added
37 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/ChangeLog

    r35242 r35245  
     12008-07-18  Oliver Hunt  <oliver@apple.com>
     2
     3        Reviewed by Cameron Zwarich.
     4
     5        Bug 18774: SQUIRRELFISH: print meaningful error messages <https://bugs.webkit.org/show_bug.cgi?id=18774>
     6        <rdar://problem/5769353> SQUIRRELFISH: JavaScript error messages are missing informative text
     7
     8        Add support for decent error messages in JavaScript.  This patch achieves this by providing
     9        ensuring the common errors and exceptions have messages that provide the text of expression
     10        that trigger the exception.  In addition it attaches a number of properties to the exception
     11        object detailing where in the source the expression came from.
     12
     13        * JavaScriptCore.exp:
     14        * VM/CodeBlock.cpp:
     15        (KJS::CodeBlock::lineNumberForVPC):
     16        (KJS::CodeBlock::expressionRangeForVPC):
     17            Function to recover the expression range for an instruction
     18            that triggered an exception.
     19        * VM/CodeBlock.h:
     20        (KJS::ExpressionRangeInfo::):
     21        (KJS::CodeBlock::CodeBlock):
     22        * VM/CodeGenerator.cpp:
     23        (KJS::CodeGenerator::emitCall):
     24        (KJS::CodeGenerator::emitCallEval):
     25            Emit call needed to be modified so to place the expression range info internally,
     26            as the CodeGenerator emits the arguments nodes itself, rather than the various call
     27            nodes.
     28        * VM/CodeGenerator.h:
     29        (KJS::CodeGenerator::emitExpressionInfo):
     30            Record the expression range info.
     31        * VM/ExceptionHelpers.cpp:
     32        (KJS::createErrorMessage):
     33        (KJS::createInvalidParamError):
     34        (KJS::createUndefinedVariableError):
     35        (KJS::createNotAConstructorError):
     36        (KJS::createNotAFunctionError):
     37        (KJS::createNotAnObjectErrorStub):
     38        (KJS::createNotAnObjectError):
     39            Rewrite all the code for the error messages so that they make use of the newly available
     40            information.
     41        * VM/ExceptionHelpers.h:
     42        * VM/Machine.cpp:
     43        (KJS::isNotObject):  Now needs vPC and codeBlock
     44        (KJS::Machine::throwException):
     45            New logic to handle the NotAnObjectErrorStub and to handle the absurd "no default value" edge case
     46        (KJS::Machine::privateExecute):
     47        * VM/Machine.h:
     48        * kjs/DebuggerCallFrame.cpp:
     49        (KJS::DebuggerCallFrame::evaluate):
     50        * kjs/Error.cpp:
     51        (KJS::Error::create):
     52        * kjs/Error.h:
     53        * kjs/JSGlobalObjectFunctions.cpp:
     54        * kjs/JSImmediate.cpp:
     55        (KJS::JSImmediate::toObject):
     56        (KJS::JSImmediate::prototype):
     57            My changes to the JSNotAnObject constructor needed to be handled here.
     58        * kjs/JSNotAnObject.h:
     59        (KJS::JSNotAnObjectErrorStub::JSNotAnObjectErrorStub):
     60        (KJS::JSNotAnObjectErrorStub::isNull):
     61        (KJS::JSNotAnObjectErrorStub::isNotAnObjectErrorStub):
     62            Added a JSNotAnObjectErrorStub class to ease the handling of toObject failure exceptions,
     63            and potentially allow even more detailed error messages in future.
     64        * kjs/JSObject.h:
     65        * kjs/Parser.h:
     66        (KJS::Parser::parse):
     67        * kjs/SourceRange.h:
     68        * kjs/grammar.y:
     69            Large amounts of position propagation.
     70        * kjs/lexer.cpp:
     71        (KJS::Lexer::Lexer):
     72        (KJS::Lexer::shift):
     73        (KJS::Lexer::lex):
     74            The lexer needed a few changes to be able to correctly track token character positions.
     75        * kjs/lexer.h:
     76        * kjs/nodes.cpp:
     77        (KJS::ThrowableExpressionData::emitThrowError):
     78        (KJS::StatementNode::StatementNode):
     79        (KJS::ResolveNode::emitCode):
     80        (KJS::BracketAccessorNode::emitCode):
     81        (KJS::DotAccessorNode::emitCode):
     82        (KJS::NewExprNode::emitCode):
     83        (KJS::EvalFunctionCallNode::emitCode):
     84        (KJS::FunctionCallValueNode::emitCode):
     85        (KJS::FunctionCallResolveNode::emitCode):
     86        (KJS::FunctionCallBracketNode::emitCode):
     87        (KJS::FunctionCallDotNode::emitCode):
     88        (KJS::PostfixResolveNode::emitCode):
     89        (KJS::PostfixBracketNode::emitCode):
     90        (KJS::PostfixDotNode::emitCode):
     91        (KJS::DeleteResolveNode::emitCode):
     92        (KJS::DeleteBracketNode::emitCode):
     93        (KJS::DeleteDotNode::emitCode):
     94        (KJS::PrefixResolveNode::emitCode):
     95        (KJS::PrefixBracketNode::emitCode):
     96        (KJS::PrefixDotNode::emitCode):
     97        (KJS::ThrowableBinaryOpNode::emitCode):
     98        (KJS::ReadModifyResolveNode::emitCode):
     99        (KJS::AssignResolveNode::emitCode):
     100        (KJS::AssignDotNode::emitCode):
     101        (KJS::ReadModifyDotNode::emitCode):
     102        (KJS::AssignBracketNode::emitCode):
     103        (KJS::ReadModifyBracketNode::emitCode):
     104        (KJS::ForInNode::ForInNode):
     105        (KJS::ForInNode::emitCode):
     106        (KJS::WithNode::emitCode):
     107        (KJS::LabelNode::emitCode):
     108        (KJS::ThrowNode::emitCode):
     109        (KJS::ProgramNode::ProgramNode):
     110        (KJS::ProgramNode::create):
     111        (KJS::EvalNode::generateCode):
     112        (KJS::FunctionBodyNode::create):
     113        (KJS::FunctionBodyNode::generateCode):
     114        (KJS::ProgramNode::generateCode):
     115            All of these methods were handling the position information. 
     116            Constructors and create methods were modified to store the information.
     117            All the emitCall implementations listed needed to be updated to actually
     118            record the position information we have so carefully collected.
     119        * kjs/nodes.h:
     120        (KJS::ThrowableExpressionData::ThrowableExpressionData):
     121        (KJS::ThrowableExpressionData::setExceptionSourceRange):
     122        (KJS::ThrowableExpressionData::divot):
     123        (KJS::ThrowableExpressionData::startOffset):
     124        (KJS::ThrowableExpressionData::endOffset):
     125        (KJS::ThrowableSubExpressionData::ThrowableSubExpressionData):
     126        (KJS::ThrowableSubExpressionData::setSubexpressionInfo):
     127        (KJS::ThrowablePrefixedSubExpressionData::ThrowablePrefixedSubExpressionData):
     128        (KJS::ThrowablePrefixedSubExpressionData::setSubexpressionInfo):
     129            ThrowableExpressionData is just a uniform mechanism for storing the position
     130            information.
     131        (KJS::ResolveNode::):
     132        (KJS::PrePostResolveNode::):
     133        (KJS::ThrowableBinaryOpNode::):
     134        (KJS::WithNode::):
     135
    11362008-07-18  Geoffrey Garen  <ggaren@apple.com>
    2137

  • trunk/JavaScriptCore/JavaScriptCore.exp

    r35228 r35245  
    9393__ZN3KJS11JSImmediate9prototypeEPKNS_7JSValueEPNS_9ExecStateE
    9494__ZN3KJS11ProfileNode4sortEPFbRKN3WTF6RefPtrIS0_EES5_E
    95 __ZN3KJS11ProgramNode6createEPNS_12JSGlobalDataEPNS_14SourceElementsEPN3WTF6VectorISt4pairINS_10IdentifierEjELm16EEEPNS6_INS5_6RefPtrINS_12FuncDeclNodeEEELm16EEEbb
     95__ZN3KJS11ProgramNode6createEPNS_12JSGlobalDataEPNS_14SourceElementsEPN3WTF6VectorISt4pairINS_10IdentifierEjELm16EEEPNS6_INS5_6RefPtrINS_12FuncDeclNodeEEELm16EEEPNS_14SourceProviderEbb
    9696__ZN3KJS11PropertyMap11getLocationERKNS_10IdentifierE
    9797__ZN3KJS11PropertyMap11getLocationERKNS_10IdentifierERb

  • trunk/JavaScriptCore/VM/CodeBlock.cpp

    r35231 r35245  
    655655int CodeBlock::lineNumberForVPC(const Instruction* vPC)
    656656{
     657    ASSERT(lineInfo.size());   
    657658    unsigned instructionOffset = vPC - instructions.begin();
    658659    ASSERT(instructionOffset < instructions.size());
    … …  
    670671            high = mid;
    671672    }
    672 
    673673    return lineInfo[low - 1].lineNumber;
    674674}
    675675
     676int CodeBlock::expressionRangeForVPC(const Instruction* vPC, int& divot, int& startOffset, int& endOffset)
     677{
     678    unsigned instructionOffset = vPC - instructions.begin();
     679    ASSERT(instructionOffset < instructions.size());
     680
     681    if (!expressionInfo.size()) {
     682        // We didn't think anything could throw.  Apparently we were wrong.
     683        startOffset = 0;
     684        endOffset = 0;
     685        divot = 0;
     686        return lineNumberForVPC(vPC);
     687    }
     688
     689    int low = 0;
     690    int high = expressionInfo.size();
     691    while (low < high) {
     692        int mid = low + (high - low) / 2;
     693        if (expressionInfo[mid].instructionOffset <= instructionOffset)
     694            low = mid + 1;
     695        else
     696            high = mid;
     697    }
     698   
     699    ASSERT(low);
     700    if (!low) {
     701        startOffset = 0;
     702        endOffset = 0;
     703        divot = 0;
     704        return lineNumberForVPC(vPC);
     705    }
     706
     707    startOffset = expressionInfo[low - 1].startOffset;
     708    endOffset = expressionInfo[low - 1].endOffset;
     709    divot = expressionInfo[low - 1].divotPoint + sourceOffset;
     710    return lineNumberForVPC(vPC);
     711}
     712
    676713} // namespace KJS

  • trunk/JavaScriptCore/VM/CodeBlock.h

    r35231 r35245  
    3434#include "JSGlobalObject.h"
    3535#include "nodes.h"
     36#include "SourceRange.h"
    3637#include "ustring.h"
    3738#include <wtf/RefPtr.h>
    … …  
    4546
    4647    struct HandlerInfo {
    47         unsigned start;
    48         unsigned end;
    49         unsigned target;
    50         unsigned scopeDepth;
     48        uint32_t start;
     49        uint32_t end;
     50        uint32_t target;
     51        uint32_t scopeDepth;
     52    };
     53
     54    struct ExpressionRangeInfo {
     55        enum { MaxOffset = (1 << 7) - 1,
     56               MaxDivot = (1 << 25) - 1
     57        };
     58        uint32_t instructionOffset : 25;
     59        uint32_t divotPoint : 25;
     60        uint32_t startOffset : 7;
     61        uint32_t endOffset : 7;
    5162    };
    5263
    5364    struct LineInfo {
    54         unsigned instructionOffset;
    55         int lineNumber;
     65        uint32_t instructionOffset;
     66        int32_t lineNumber;
    5667    };
    5768
    5869    struct CodeBlock {
    59         CodeBlock(ScopeNode* ownerNode_, CodeType codeType_)
     70        CodeBlock(ScopeNode* ownerNode_, CodeType codeType_, PassRefPtr<SourceProvider> source_, unsigned sourceOffset_)
    6071            : ownerNode(ownerNode_)
    6172            , numTemporaries(0)
    … …  
    6677            , usesEval(ownerNode_->usesEval())
    6778            , codeType(codeType_)
     79            , source(source_)
     80            , sourceOffset(sourceOffset_)
    6881        {
    6982        }
    7083
    7184        void dump(ExecState*) const;
    72         int lineNumberForVPC(const Instruction*);
     85        int expressionRangeForVPC(const Instruction*, int& divot, int& startOffset, int& endOffset);
     86        int lineNumberForVPC(const Instruction* vPC);
    7387        bool getHandlerForVPC(const Instruction* vPC, Instruction*& target, int& scopeDepth);
    7488        void mark();
    … …  
    8498        bool usesEval;
    8599        CodeType codeType;
     100        RefPtr<SourceProvider> source;
     101        unsigned sourceOffset;
    86102
    87103        Vector<Instruction> instructions;
    … …  
    94110        Vector<RefPtr<RegExp> > regexps;
    95111        Vector<HandlerInfo> exceptionHandlers;
     112        Vector<ExpressionRangeInfo> expressionInfo;
    96113        Vector<LineInfo> lineInfo;
    97114
    … …  
    104121
    105122    struct ProgramCodeBlock : public CodeBlock {
    106         ProgramCodeBlock(ScopeNode* ownerNode_, CodeType codeType_, JSGlobalObject* globalObject_)
    107             : CodeBlock(ownerNode_, codeType_)
     123        ProgramCodeBlock(ScopeNode* ownerNode_, CodeType codeType_, JSGlobalObject* globalObject_, PassRefPtr<SourceProvider> source_)
     124            : CodeBlock(ownerNode_, codeType_, source_, 0)
    108125            , globalObject(globalObject_)
    109126        {
    … …  
    121138
    122139    struct EvalCodeBlock : public ProgramCodeBlock {
    123         EvalCodeBlock(ScopeNode* ownerNode_, JSGlobalObject* globalObject_)
    124             : ProgramCodeBlock(ownerNode_, EvalCode, globalObject_)
     140        EvalCodeBlock(ScopeNode* ownerNode_, JSGlobalObject* globalObject_, PassRefPtr<SourceProvider> source_)
     141            : ProgramCodeBlock(ownerNode_, EvalCode, globalObject_, source_)
    125142        {
    126143        }

  • trunk/JavaScriptCore/VM/CodeGenerator.cpp

    r35231 r35245  
    850850}
    851851
    852 RegisterID* CodeGenerator::emitCall(RegisterID* dst, RegisterID* func, RegisterID* base, ArgumentsNode* argumentsNode)
    853 {
    854     return emitCall(op_call, dst, func, base, argumentsNode);
    855 }
    856 
    857 RegisterID* CodeGenerator::emitCallEval(RegisterID* dst, RegisterID* func, RegisterID* base, ArgumentsNode* argumentsNode)
    858 {
    859     return emitCall(op_call_eval, dst, func, base, argumentsNode);
    860 }
    861 
    862 RegisterID* CodeGenerator::emitCall(OpcodeID opcodeID, RegisterID* dst, RegisterID* func, RegisterID* base, ArgumentsNode* argumentsNode)
     852RegisterID* CodeGenerator::emitCall(RegisterID* dst, RegisterID* func, RegisterID* base, ArgumentsNode* argumentsNode, unsigned divot, unsigned startOffset, unsigned endOffset)
     853{
     854    return emitCall(op_call, dst, func, base, argumentsNode, divot, startOffset, endOffset);
     855}
     856
     857RegisterID* CodeGenerator::emitCallEval(RegisterID* dst, RegisterID* func, RegisterID* base, ArgumentsNode* argumentsNode, unsigned divot, unsigned startOffset, unsigned endOffset)
     858{
     859    return emitCall(op_call_eval, dst, func, base, argumentsNode, divot, startOffset, endOffset);
     860}
     861
     862RegisterID* CodeGenerator::emitCall(OpcodeID opcodeID, RegisterID* dst, RegisterID* func, RegisterID* base, ArgumentsNode* argumentsNode, unsigned divot, unsigned startOffset, unsigned endOffset)
    863863{
    864864    ASSERT(opcodeID == op_call || opcodeID == op_call_eval);
    … …  
    883883    }
    884884
     885    emitExpressionInfo(divot, startOffset, endOffset);
    885886    emitOpcode(opcodeID);
    886887    instructions().append(dst->index());

  • trunk/JavaScriptCore/VM/CodeGenerator.h

    r35037 r35245  
    183183        }
    184184
     185        void emitExpressionInfo(unsigned divot, unsigned startOffset, unsigned endOffset)
     186        {
     187            divot -= m_codeBlock->sourceOffset;
     188            if (divot > ExpressionRangeInfo::MaxDivot) {
     189                // Overflow has occurred, we can only give line number info for errors for this region
     190                divot = 0;
     191                startOffset = 0;
     192                endOffset = 0;
     193            } else if (startOffset > ExpressionRangeInfo::MaxOffset) {
     194                // If the start offset is out of bounds we clear both offsets
     195                // so we only get the divot marker.  Error message will have to be reduced
     196                // to line and column number.
     197                startOffset = 0;
     198                endOffset = 0;
     199            } else if (endOffset > ExpressionRangeInfo::MaxOffset) {
     200                // The end offset is only used for additional context, and is much more likely
     201                // to overflow (eg. function call arguments) so we are willing to drop it without
     202                // dropping the rest of the range.
     203                endOffset = 0;
     204            }
     205           
     206            ExpressionRangeInfo info;
     207            info.instructionOffset = instructions().size();
     208            info.divotPoint = divot;
     209            info.startOffset = startOffset;
     210            info.endOffset = endOffset;
     211            m_codeBlock->expressionInfo.append(info);
     212        }
     213       
    185214        ALWAYS_INLINE bool leftHandSideNeedsCopy(bool rightHasAssignments, bool rightIsPure)
    186215        {
    … …  
    245274        RegisterID* emitPutSetter(RegisterID* base, const Identifier& property, RegisterID* value);
    246275
    247         RegisterID* emitCall(RegisterID* dst, RegisterID* func, RegisterID* base, ArgumentsNode*);
    248         RegisterID* emitCallEval(RegisterID* dst, RegisterID* func, RegisterID* base, ArgumentsNode*);
     276        RegisterID* emitCall(RegisterID* dst, RegisterID* func, RegisterID* base, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
     277        RegisterID* emitCallEval(RegisterID* dst, RegisterID* func, RegisterID* base, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
    249278
    250279        RegisterID* emitReturn(RegisterID* src) { return emitUnaryNoDstOp(op_ret, src); }
    … …  
    313342        typedef HashMap<RefPtr<UString::Rep>, int, IdentifierRepHash, HashTraits<RefPtr<UString::Rep> >, IdentifierMapIndexHashTraits> IdentifierMap;
    314343
    315         RegisterID* emitCall(OpcodeID, RegisterID*, RegisterID*, RegisterID*, ArgumentsNode*);
     344        RegisterID* emitCall(OpcodeID, RegisterID*, RegisterID*, RegisterID*, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
    316345
    317346        // Maps a register index in the symbol table to a RegisterID index in m_locals.

  • trunk/JavaScriptCore/VM/ExceptionHelpers.cpp

    r34842 r35245  
    3030#include "ExceptionHelpers.h"
    3131
     32#include "CodeBlock.h"
    3233#include "ExecState.h"
    3334#include "nodes.h"
    3435#include "JSObject.h"
     36#include "JSNotAnObject.h"
    3537
    3638namespace KJS {
    … …  
    6870}
    6971
    70 JSValue* createError(ExecState* exec, ErrorType e, const char* msg, JSValue* v, Node* expr)
    71 {
    72     UString message = msg;
    73     substitute(message, v->toString(exec));
    74     if (expr)
    75         substitute(message, expr->toString());
    76     return Error::create(exec, e, message, -1, -1, 0);
    77 }
    78 
    7972JSValue* createError(ExecState* exec, ErrorType e, const char* msg, JSValue* v)
    8073{
    … …  
    8982}
    9083
    91 JSValue* createUndefinedVariableError(ExecState* exec, const Identifier& ident)
    92 {
    93     return createError(exec, ReferenceError, "Can't find variable: %s", ident);
    94 }
    95 
    96 JSValue* createInvalidParamError(ExecState* exec, const char* op, JSValue* v)
    97 {
    98     UString message = "'%s' is not a valid argument for '%s'";
    99     substitute(message,  v->toString(exec));
    100     substitute(message, op);
    101     return Error::create(exec, TypeError, message, -1, -1, 0);
    102 }
    103 
    104 JSValue* createNotAConstructorError(ExecState* exec, JSValue* value, Node* expr)
    105 {
    106     if (expr)
    107         return createError(exec, TypeError, "Value %s (result of expression %s) is not a constructor. Cannot be used with new.", value, expr);
    108     return createError(exec, TypeError, "Value %s is not a constructor. Cannot be used with new.", value);
    109 }
    110 
    111 JSValue* createNotAFunctionError(ExecState* exec, JSValue* value, Node* expr)
    112 {
    113     if (expr)
    114         return createError(exec, TypeError, "Value %s (result of expression %s) does not allow function calls.", value, expr);
    115     return createError(exec, TypeError, "Value %s does not allow function calls.", value);
     84JSValue* createUndefinedVariableError(ExecState* exec, const Identifier& ident, const Instruction* vPC, CodeBlock* codeBlock)
     85{
     86    int startOffset = 0;
     87    int endOffset = 0;
     88    int divotPoint = 0;
     89    int line = codeBlock->expressionRangeForVPC(vPC, divotPoint, startOffset, endOffset);
     90    UString message = "Can't find variable: ";
     91    message.append(ident.ustring());
     92    JSObject* exception = Error::create(exec, ReferenceError, message, line, codeBlock->ownerNode->sourceId(), codeBlock->ownerNode->sourceURL());
     93    exception->putWithAttributes(exec, Identifier(exec, expressionBeginOffsetPropertyName), jsNumber(exec, divotPoint - startOffset), ReadOnly | DontDelete);
     94    exception->putWithAttributes(exec, Identifier(exec, expressionCaretOffsetPropertyName), jsNumber(exec, divotPoint), ReadOnly | DontDelete);
     95    exception->putWithAttributes(exec, Identifier(exec, expressionEndOffsetPropertyName), jsNumber(exec, divotPoint + endOffset), ReadOnly | DontDelete);
     96    return exception;
     97}
     98   
     99bool isStrWhiteSpace(UChar c);
     100
     101static UString createErrorMessage(ExecState* exec, CodeBlock* codeBlock, int, int expressionStart, int expressionStop, JSValue* value, UString error)
     102{
     103    if (!expressionStop || expressionStart > codeBlock->source->length()) {
     104        UString errorText = value->toString(exec);
     105        errorText.append(" is ");
     106        errorText.append(error);
     107        return errorText;
     108    }
     109
     110    UString errorText = "Result of expression ";
     111   
     112    if (expressionStart < expressionStop) {
     113        errorText.append('\'');
     114        errorText.append(codeBlock->source->getRange(expressionStart, expressionStop));
     115        errorText.append("' [");
     116        errorText.append(value->toString(exec));
     117        errorText.append("] is ");
     118    } else {
     119        // No range information, so give a few characters of context
     120        const UChar* data = codeBlock->source->data();
     121        int dataLength = codeBlock->source->length();
     122        int start = expressionStart;
     123        int stop = expressionStart;
     124        // Get up to 20 characters of context to the left and right of the divot, clamping to the line.
     125        // then strip whitespace.
     126        while (start > 0 && (expressionStart - start < 20) && data[start - 1] != '\n')
     127            start--;
     128        while (start < (expressionStart - 1) && isStrWhiteSpace(data[start]))
     129            start++;
     130        while (stop < dataLength && (stop - expressionStart < 20) && data[stop] != '\n')
     131            stop++;
     132        while (stop > expressionStart && isStrWhiteSpace(data[stop]))
     133            stop--;
     134        errorText.append("near '...");
     135        errorText.append(codeBlock->source->getRange(start, stop));
     136        errorText.append("...' [");
     137        errorText.append(value->toString(exec));
     138        errorText.append("] is ");
     139    }
     140    errorText.append(error);
     141    errorText.append(".");
     142    return errorText;
     143}
     144
     145JSValue* createInvalidParamError(ExecState* exec, const char* op, JSValue* value, const Instruction* vPC, CodeBlock* codeBlock)
     146{
     147    UString message = "not a valid argument for '";
     148    message.append(op);
     149    message.append("'");
     150   
     151    int startOffset = 0;
     152    int endOffset = 0;
     153    int divotPoint = 0;
     154    int line = codeBlock->expressionRangeForVPC(vPC, divotPoint, startOffset, endOffset);
     155    UString errorMessage = createErrorMessage(exec, codeBlock, line, divotPoint, divotPoint + endOffset, value, message);
     156    JSObject* exception = Error::create(exec, TypeError, errorMessage, line, codeBlock->ownerNode->sourceId(), codeBlock->ownerNode->sourceURL());
     157    exception->putWithAttributes(exec, Identifier(exec, expressionBeginOffsetPropertyName), jsNumber(exec, divotPoint - startOffset), ReadOnly | DontDelete);
     158    exception->putWithAttributes(exec, Identifier(exec, expressionCaretOffsetPropertyName), jsNumber(exec, divotPoint), ReadOnly | DontDelete);
     159    exception->putWithAttributes(exec, Identifier(exec, expressionEndOffsetPropertyName), jsNumber(exec, divotPoint + endOffset), ReadOnly | DontDelete);
     160    return exception;
     161}
     162
     163JSValue* createNotAConstructorError(ExecState* exec, JSValue* value, const Instruction* vPC, CodeBlock* codeBlock)
     164{
     165    int startOffset = 0;
     166    int endOffset = 0;
     167    int divotPoint = 0;
     168    int line = codeBlock->expressionRangeForVPC(vPC, divotPoint, startOffset, endOffset);
     169
     170    // We're in a "new" expression, so we need to skip over the "new.." part
     171    int startPoint = divotPoint - (startOffset ? startOffset - 4 : 0); // -4 for "new "
     172    const UChar* data = codeBlock->source->data();
     173    while (startPoint < divotPoint && isStrWhiteSpace(data[startPoint]))
     174        startPoint++;
     175   
     176    UString errorMessage = createErrorMessage(exec, codeBlock, line, startPoint, divotPoint, value, "not a constructor");
     177    JSObject* exception = Error::create(exec, TypeError, errorMessage, line, codeBlock->ownerNode->sourceId(), codeBlock->ownerNode->sourceURL());
     178    exception->putWithAttributes(exec, Identifier(exec, expressionBeginOffsetPropertyName), jsNumber(exec, divotPoint - startOffset), ReadOnly | DontDelete);
     179    exception->putWithAttributes(exec, Identifier(exec, expressionCaretOffsetPropertyName), jsNumber(exec, divotPoint), ReadOnly | DontDelete);
     180    exception->putWithAttributes(exec, Identifier(exec, expressionEndOffsetPropertyName), jsNumber(exec, divotPoint + endOffset), ReadOnly | DontDelete);
     181    return exception;
     182}
     183
     184JSValue* createNotAFunctionError(ExecState* exec, JSValue* value, const Instruction* vPC, CodeBlock* codeBlock)
     185{
     186    int startOffset = 0;
     187    int endOffset = 0;
     188    int divotPoint = 0;
     189    int line = codeBlock->expressionRangeForVPC(vPC, divotPoint, startOffset, endOffset);
     190    UString errorMessage = createErrorMessage(exec, codeBlock, line, divotPoint - startOffset, divotPoint, value, "not a function");
     191    JSObject* exception = Error::create(exec, TypeError, errorMessage, line, codeBlock->ownerNode->sourceId(), codeBlock->ownerNode->sourceURL());   
     192    exception->putWithAttributes(exec, Identifier(exec, expressionBeginOffsetPropertyName), jsNumber(exec, divotPoint - startOffset), ReadOnly | DontDelete);
     193    exception->putWithAttributes(exec, Identifier(exec, expressionCaretOffsetPropertyName), jsNumber(exec, divotPoint), ReadOnly | DontDelete);
     194    exception->putWithAttributes(exec, Identifier(exec, expressionEndOffsetPropertyName), jsNumber(exec, divotPoint + endOffset), ReadOnly | DontDelete);
     195    return exception;
     196}
     197
     198JSNotAnObjectErrorStub* createNotAnObjectErrorStub(ExecState* exec, bool isNull)
     199{
     200    return new (exec) JSNotAnObjectErrorStub(isNull);
     201}
     202
     203JSObject* createNotAnObjectError(ExecState* exec, JSNotAnObjectErrorStub* error, const Instruction* vPC, CodeBlock* codeBlock)
     204{
     205    int startOffset = 0;
     206    int endOffset = 0;
     207    int divotPoint = 0;
     208    int line = codeBlock->expressionRangeForVPC(vPC, divotPoint, startOffset, endOffset);
     209    UString errorMessage = createErrorMessage(exec, codeBlock, line, divotPoint - startOffset, divotPoint, error->isNull() ? jsNull() : jsUndefined(), "not an object");
     210    JSObject* exception = Error::create(exec, TypeError, errorMessage, line, codeBlock->ownerNode->sourceId(), codeBlock->ownerNode->sourceURL());
     211    exception->putWithAttributes(exec, Identifier(exec, expressionBeginOffsetPropertyName), jsNumber(exec, divotPoint - startOffset), ReadOnly | DontDelete);
     212    exception->putWithAttributes(exec, Identifier(exec, expressionCaretOffsetPropertyName), jsNumber(exec, divotPoint), ReadOnly | DontDelete);
     213    exception->putWithAttributes(exec, Identifier(exec, expressionEndOffsetPropertyName), jsNumber(exec, divotPoint + endOffset), ReadOnly | DontDelete);
     214    return exception;
    116215}
    117216

  • trunk/JavaScriptCore/VM/ExceptionHelpers.h

    r34842 r35245  
    3535
    3636    class Node;
     37    class CodeBlock;
     38    class Instruction;
     39    class JSNotAnObjectErrorStub;
    3740
    3841    JSValue* createInterruptedExecutionException(ExecState* exec);
    3942    JSValue* createStackOverflowError(ExecState*);
    40     JSValue* createUndefinedVariableError(ExecState*, const Identifier&);
    41     JSValue* createInvalidParamError(ExecState*, const char* op, JSValue*);
    42     JSValue* createNotAConstructorError(ExecState*, JSValue*, Node* expr);
    43     JSValue* createNotAFunctionError(ExecState*, JSValue*, Node* expr);
     43    JSValue* createUndefinedVariableError(ExecState*, const Identifier&, const Instruction*, CodeBlock*);
     44    JSNotAnObjectErrorStub* createNotAnObjectErrorStub(ExecState*, bool isNull);
     45    JSValue* createInvalidParamError(ExecState*, const char* op, JSValue*, const Instruction*, CodeBlock*);
     46    JSValue* createNotAConstructorError(ExecState*, JSValue*, const Instruction*, CodeBlock*);
     47    JSValue* createNotAFunctionError(ExecState*, JSValue*, const Instruction*, CodeBlock*);
     48    JSObject* createNotAnObjectError(ExecState*, JSNotAnObjectErrorStub*, const Instruction*, CodeBlock*);
    4449
    4550} // namespace KJS

  • trunk/JavaScriptCore/VM/Machine.cpp

    r35242 r35245  
    3939#include "JSArray.h"
    4040#include "JSFunction.h"
     41#include "JSNotAnObject.h"
    4142#include "JSPropertyNameIterator.h"
    4243#include "JSString.h"
    … …  
    222223        }
    223224    } while (++iter != end);
    224     exceptionValue = createUndefinedVariableError(exec, ident);
     225    exceptionValue = createUndefinedVariableError(exec, ident, vPC, codeBlock);
    225226    return false;
    226227}
    … …  
    252253        }
    253254    } while (++iter != end);
    254     exceptionValue = createUndefinedVariableError(exec, ident);
     255    exceptionValue = createUndefinedVariableError(exec, ident, vPC, codeBlock);
    255256    return false;
    256257}
    … …  
    311312    } while (iter != end);
    312313
    313     exceptionValue = createUndefinedVariableError(exec, ident);
     314    exceptionValue = createUndefinedVariableError(exec, ident, vPC, codeBlock);
    314315    return false;
    315316}
    … …  
    354355    } while (iter != end);
    355356
    356     exceptionValue = createUndefinedVariableError(exec, ident);
     357    exceptionValue = createUndefinedVariableError(exec, ident, vPC, codeBlock);
    357358    return false;
    358359}
    … …  
    430431}
    431432
    432 static NEVER_INLINE bool isNotObject(ExecState* exec, bool forInstanceOf, CodeBlock*, JSValue* value, JSValue*& exceptionData)
     433static NEVER_INLINE bool isNotObject(ExecState* exec, bool forInstanceOf, CodeBlock* codeBlock, const Instruction* vPC, JSValue* value, JSValue*& exceptionData)
    433434{
    434435    if (value->isObject())
    435436        return false;
    436     exceptionData = createInvalidParamError(exec, forInstanceOf ? "instanceof" : "in" , value);
     437    exceptionData = createInvalidParamError(exec, forInstanceOf ? "instanceof" : "in" , value, vPC, codeBlock);
    437438    return true;
    438439}
    … …  
    620621}
    621622
    622 NEVER_INLINE Instruction* Machine::throwException(ExecState* exec, JSValue* exceptionValue, const Instruction* vPC, CodeBlock*& codeBlock, Register*& k, ScopeChainNode*& scopeChain, Register*& r)
     623NEVER_INLINE Instruction* Machine::throwException(ExecState* exec, JSValue*& exceptionValue, const Instruction* vPC, CodeBlock*& codeBlock, Register*& k, ScopeChainNode*& scopeChain, Register*& r, bool explicitThrow)
    623624{
    624625    // Set up the exception object
    … …  
    626627    if (exceptionValue->isObject()) {
    627628        JSObject* exception = static_cast<JSObject*>(exceptionValue);
    628         if (!exception->hasProperty(exec, Identifier(exec, "line")) && !exception->hasProperty(exec, Identifier(exec, "sourceURL"))) {
    629             exception->put(exec, Identifier(exec, "line"), jsNumber(exec, codeBlock->lineNumberForVPC(vPC)));
    630             exception->put(exec, Identifier(exec, "sourceURL"), jsOwnedString(exec, codeBlock->ownerNode->sourceURL()));
    631         }
    632 
    633         if (exception->isWatchdogException()) {
    634             while (unwindCallFrame(exec, exceptionValue, vPC, codeBlock, k, scopeChain, r)) {
    635                  // Don't need handler checks or anything, we just want to unroll all the JS callframes possible.
     629        if (exception->isNotAnObjectErrorStub()) {
     630            exception = createNotAnObjectError(exec, static_cast<JSNotAnObjectErrorStub*>(exception), vPC, codeBlock);
     631            exceptionValue = exception;
     632        } else {
     633            if (!exception->hasProperty(exec, Identifier(exec, "line")) &&
     634                !exception->hasProperty(exec, Identifier(exec, "sourceId")) &&
     635                !exception->hasProperty(exec, Identifier(exec, "sourceURL")) &&
     636                !exception->hasProperty(exec, Identifier(exec, expressionBeginOffsetPropertyName)) &&
     637                !exception->hasProperty(exec, Identifier(exec, expressionCaretOffsetPropertyName)) &&
     638                !exception->hasProperty(exec, Identifier(exec, expressionEndOffsetPropertyName))) {
     639                if (explicitThrow) {
     640                    int startOffset = 0;
     641                    int endOffset = 0;
     642                    int divotPoint = 0;
     643                    int line = codeBlock->expressionRangeForVPC(vPC, divotPoint, startOffset, endOffset);
     644                    exception->putWithAttributes(exec, Identifier(exec, "line"), jsNumber(exec, line), ReadOnly | DontDelete);
     645                   
     646                    // We only hit this path for error messages and throw statements, which don't have a specific failure position
     647                    // So we just give the full range of the error/throw statement.
     648                    exception->putWithAttributes(exec, Identifier(exec, expressionBeginOffsetPropertyName), jsNumber(exec, divotPoint - startOffset), ReadOnly | DontDelete);
     649                    exception->putWithAttributes(exec, Identifier(exec, expressionEndOffsetPropertyName), jsNumber(exec, divotPoint + endOffset), ReadOnly | DontDelete);
     650                } else
     651                    exception->putWithAttributes(exec, Identifier(exec, "line"), jsNumber(exec, codeBlock->lineNumberForVPC(vPC)), ReadOnly | DontDelete);
     652                exception->putWithAttributes(exec, Identifier(exec, "sourceId"), jsNumber(exec, codeBlock->ownerNode->sourceId()), ReadOnly | DontDelete);
     653                exception->putWithAttributes(exec, Identifier(exec, "sourceURL"), jsOwnedString(exec, codeBlock->ownerNode->sourceURL()), ReadOnly | DontDelete);
    636654            }
    637             return 0;
     655           
     656            if (exception->isWatchdogException()) {
     657                while (unwindCallFrame(exec, exceptionValue, vPC, codeBlock, k, scopeChain, r)) {
     658                    // Don't need handler checks or anything, we just want to unroll all the JS callframes possible.
     659                }
     660                return 0;
     661            }
    638662        }
    639663    }
    … …  
    15771601        JSValue* baseVal = r[base].jsValue();
    15781602
    1579         if (isNotObject(exec, vPC, codeBlock, baseVal, exceptionValue))
     1603        if (isNotObject(exec, true, codeBlock, vPC, baseVal, exceptionValue))
    15801604            goto vm_throw;
    15811605
    … …  
    16131637
    16141638        JSValue* baseVal = r[base].jsValue();
    1615         if (isNotObject(exec, vPC, codeBlock, baseVal, exceptionValue))
     1639        if (isNotObject(exec, false, codeBlock, vPC, baseVal, exceptionValue))
    16161640            goto vm_throw;
    16171641
    … …  
    22822306        ASSERT(callType == CallTypeNone);
    22832307
    2284         exceptionValue = createNotAFunctionError(exec, v, 0);
     2308        exceptionValue = createNotAFunctionError(exec, v, vPC, codeBlock);
    22852309        goto vm_throw;
    22862310    }
    … …  
    24072431        ASSERT(constructType == ConstructTypeNone);
    24082432
    2409         exceptionValue = createNotAConstructorError(exec, constrVal, 0);
     2433        exceptionValue = createNotAConstructorError(exec, constrVal, vPC, codeBlock);
    24102434        goto vm_throw;
    24112435    }
    … …  
    25232547        int ex = (++vPC)->u.operand;
    25242548        exceptionValue = r[ex].jsValue();
    2525         handlerVPC = throwException(exec, exceptionValue, vPC, codeBlock, k, scopeChain, r);
     2549
     2550        handlerVPC = throwException(exec, exceptionValue, vPC, codeBlock, k, scopeChain, r, true);
    25262551        if (!handlerVPC) {
    25272552            *exception = exceptionValue;
    … …  
    26632688            exceptionValue = createInterruptedExecutionException(exec);
    26642689        }
    2665         handlerVPC = throwException(exec, exceptionValue, vPC, codeBlock, k, scopeChain, r);
     2690        handlerVPC = throwException(exec, exceptionValue, vPC, codeBlock, k, scopeChain, r, false);
    26662691        if (!handlerVPC) {
    26672692            *exception = exceptionValue;

  • trunk/JavaScriptCore/VM/Machine.h

    r35231 r35245  
    133133
    134134        NEVER_INLINE bool unwindCallFrame(ExecState*, JSValue*, const Instruction*&, CodeBlock*&, Register*&, ScopeChainNode*&, Register*&);
    135         NEVER_INLINE Instruction* throwException(ExecState*, JSValue*, const Instruction*, CodeBlock*&, Register*&, ScopeChainNode*&, Register*&);
     135        NEVER_INLINE Instruction* throwException(ExecState*, JSValue*&, const Instruction*, CodeBlock*&, Register*&, ScopeChainNode*&, Register*&, bool);
    136136
    137137        Register* callFrame(ExecState*, JSFunction*) const;

  • trunk/JavaScriptCore/kjs/DebuggerCallFrame.cpp

    r35203 r35245  
    8181    int errLine;
    8282    UString errMsg;
    83 
    84     RefPtr<EvalNode> evalNode = newExec.parser()->parse<EvalNode>(&newExec, UString(), 1, UStringSourceProvider::create(script), &sourceId, &errLine, &errMsg);
    85 
     83    RefPtr<SourceProvider> sourceProvider = UStringSourceProvider::create(script);
     84    RefPtr<EvalNode> evalNode = newExec.parser()->parse<EvalNode>(&newExec, UString(), 1, sourceProvider, &sourceId, &errLine, &errMsg);
    8685    if (!evalNode)
    8786        return Error::create(&newExec, SyntaxError, errMsg, errLine, sourceId, 0);

  • trunk/JavaScriptCore/kjs/Error.cpp

    r35022 r35245  
    3333
    3434namespace KJS {
     35
     36const char* expressionBeginOffsetPropertyName = "expressionBeginOffset";
     37const char* expressionCaretOffsetPropertyName = "expressionCaretOffset";
     38const char* expressionEndOffsetPropertyName = "expressionEndOffset";
    3539
    3640JSObject* Error::create(ExecState* exec, ErrorType type, const UString& message, int lineNumber, int sourceId, const UString& sourceURL)
    … …  
    7983
    8084    if (lineNumber != -1)
    81         error->put(exec, Identifier(exec, "line"), jsNumber(exec, lineNumber));
     85        error->putWithAttributes(exec, Identifier(exec, "line"), jsNumber(exec, lineNumber), ReadOnly | DontDelete);
    8286    if (sourceId != -1)
    83         error->put(exec, Identifier(exec, "sourceId"), jsNumber(exec, sourceId));
     87        error->putWithAttributes(exec, Identifier(exec, "sourceId"), jsNumber(exec, sourceId), ReadOnly | DontDelete);
    8488    if (!sourceURL.isNull())
    85         error->put(exec, Identifier(exec, "sourceURL"), jsString(exec, sourceURL));
     89        error->putWithAttributes(exec, Identifier(exec, "sourceURL"), jsString(exec, sourceURL), ReadOnly | DontDelete);
    8690
    8791    return error;

  • trunk/JavaScriptCore/kjs/Error.h

    r35022 r35245  
    4343        URIError       = 6
    4444    };
    45 
     45   
     46    extern const char* expressionBeginOffsetPropertyName;
     47    extern const char* expressionCaretOffsetPropertyName;
     48    extern const char* expressionEndOffsetPropertyName;
     49   
    4650    class Error {
    4751    public:

  • trunk/JavaScriptCore/kjs/JSGlobalObjectFunctions.cpp

    r35027 r35245  
    137137}
    138138
    139 static bool isStrWhiteSpace(unsigned short c)
     139bool isStrWhiteSpace(unsigned short c)
    140140{
    141141    switch (c) {

  • trunk/JavaScriptCore/kjs/JSImmediate.cpp

    r35008 r35245  
    2525#include "BooleanPrototype.h"
    2626#include "Error.h"
     27#include "ExceptionHelpers.h"
    2728#include "JSGlobalObject.h"
    2829#include "JSNotAnObject.h"
    … …  
    3940    if (isBoolean(v))
    4041        return constructBooleanFromImmediateBoolean(exec, const_cast<JSValue*>(v));
    41     if (v == jsNull())
    42         return new (exec) JSNotAnObject(throwError(exec, TypeError, "Null value"));
    43     ASSERT(v == jsUndefined());
    44     return new (exec) JSNotAnObject(throwError(exec, TypeError, "Undefined value"));
     42   
     43    JSNotAnObjectErrorStub* exception = createNotAnObjectErrorStub(exec, v == jsNull());
     44    exec->setException(exception);
     45    return new (exec) JSNotAnObject(exception);
    4546}
    4647
    … …  
    5253    if (isBoolean(v))
    5354        return exec->lexicalGlobalObject()->booleanPrototype();
    54     if (v == jsNull())
    55         return new (exec) JSNotAnObject(throwError(exec, TypeError, "Null value"));
    56     ASSERT(v == jsUndefined());
    57     return new (exec) JSNotAnObject(throwError(exec, TypeError, "Undefined value"));
     55
     56    JSNotAnObjectErrorStub* exception = createNotAnObjectErrorStub(exec, v == jsNull());
     57    exec->setException(exception);
     58    return new (exec) JSNotAnObject(exception);
    5859}
    5960

  • trunk/JavaScriptCore/kjs/JSNotAnObject.h

    r35027 r35245  
    3434namespace KJS {
    3535
     36    class JSNotAnObjectErrorStub : public JSObject {
     37    public:
     38        JSNotAnObjectErrorStub(bool isNull)
     39            : m_isNull(isNull)
     40        {
     41        }
     42        bool isNull() const { return m_isNull; }
     43        bool isNotAnObjectErrorStub() const { return true; }
     44    private:
     45        bool m_isNull;
     46    };
     47   
    3648    // This unholy class is used to allow us to avoid multiple exception checks
    3749    // in certain SquirrelFish opcodes -- effectively it just silently consumes
    … …  
    3951    class JSNotAnObject : public JSObject {
    4052    public:
    41         JSNotAnObject(JSObject* exception)
     53        JSNotAnObject(JSNotAnObjectErrorStub* exception)
    4254            : m_exception(exception)
    4355        {
    … …  
    6880        virtual void getPropertyNames(ExecState*, PropertyNameArray&);
    6981
    70         JSObject* m_exception;
     82        JSNotAnObjectErrorStub* m_exception;
    7183    };
    7284

  • trunk/JavaScriptCore/kjs/JSObject.h

    r35068 r35245  
    324324
    325325        virtual bool isWatchdogException() const { return false; }
     326       
     327        virtual bool isNotAnObjectErrorStub() const { return false; }
    326328
    327329    protected:

  • trunk/JavaScriptCore/kjs/Parser.h

    r35037 r35245  
    8181    {
    8282        m_sourceURL = sourceURL;
    83         parse(exec, sourceURL, startingLineNumber, source, sourceId, errLine, errMsg);
     83        RefPtr<SourceProvider> sourceProvider = source;
     84        parse(exec, sourceURL, startingLineNumber, sourceProvider.get(), sourceId, errLine, errMsg);
    8485        if (!m_sourceElements) {
    8586            m_sourceURL = UString();
    … …  
    9091                                                     m_varDeclarations ? &m_varDeclarations->data : 0,
    9192                                                     m_funcDeclarations ? &m_funcDeclarations->data : 0,
     93                                                     sourceProvider.get(),
    9294                                                     m_usesEval,
    9395                                                     m_needsClosure);

  • trunk/JavaScriptCore/kjs/SourceRange.h

    r34372 r35245  
    5454            return m_sourceProvider->getRange(m_startChar, m_endChar);
    5555        }
    56 
     56       
     57        SourceProvider* sourceProvider() const { return m_sourceProvider.get(); }
     58        int startOffset() const { return m_startChar; }
    5759    private:
    5860        RefPtr<SourceProvider> m_sourceProvider;

  • trunk/JavaScriptCore/kjs/grammar.y

    r35224 r35245  
    5858
    5959#define AUTO_SEMICOLON do { if (!allowAutomaticSemicolon(*LEXER, yychar)) YYABORT; } while (0)
     60#define SET_EXCEPTION_LOCATION(node, start, divot, end) node->setExceptionSourceRange((divot), (divot) - (start), (end) - (divot))
    6061#define DBG(l, s, e) (l)->setLoc((s).first_line, (e).last_line)
    6162
    … …  
    6364using namespace std;
    6465
    65 static ExpressionNode* makeAssignNode(void*, ExpressionNode* loc, Operator, ExpressionNode* expr, bool locHasAssignments, bool exprHasAssignments);
    66 static ExpressionNode* makePrefixNode(void*, ExpressionNode* expr, Operator);
    67 static ExpressionNode* makePostfixNode(void*, ExpressionNode* expr, Operator);
     66static ExpressionNode* makeAssignNode(void*, ExpressionNode* loc, Operator, ExpressionNode* expr, bool locHasAssignments, bool exprHasAssignments, int start, int divot, int end);
     67static ExpressionNode* makePrefixNode(void*, ExpressionNode* expr, Operator, int start, int divot, int end);
     68static ExpressionNode* makePostfixNode(void*, ExpressionNode* expr, Operator, int start, int divot, int end);
    6869static PropertyNode* makeGetterOrSetterPropertyNode(void*, const Identifier &getOrSet, const Identifier& name, ParameterNode*, FunctionBodyNode*, const SourceRange&);
    69 static ExpressionNodeInfo makeFunctionCallNode(void*, ExpressionNodeInfo func, ArgumentsNodeInfo);
     70static ExpressionNodeInfo makeFunctionCallNode(void*, ExpressionNodeInfo func, ArgumentsNodeInfo, int start, int divot, int end);
    7071static ExpressionNode* makeTypeOfNode(void*, ExpressionNode*);
    71 static ExpressionNode* makeDeleteNode(void*, ExpressionNode*);
     72static ExpressionNode* makeDeleteNode(void*, ExpressionNode*, int start, int divot, int end);
    7273static ExpressionNode* makeNegateNode(void*, ExpressionNode*);
    7374static NumberNode* makeNumberNode(void*, double);
    … …  
    288289                                            if (!l.scanRegExp())
    289290                                                YYABORT;
    290                                             $$ = createNodeFeatureInfo<ExpressionNode*>(new RegExpNode(GLOBAL_DATA, l.pattern(), l.flags()), 0);
     291                                            RegExpNode* node = new RegExpNode(GLOBAL_DATA, l.pattern(), l.flags());
     292                                            int size = l.pattern().size() + 2; // + 2 for the two /'s
     293                                            SET_EXCEPTION_LOCATION(node, @1.first_column, @1.first_column + size, @1.first_column + size);
     294                                            $$ = createNodeFeatureInfo<ExpressionNode*>(node, 0);
    291295                                        }
    292296  | DIVEQUAL /* regexp with /= */       {
    … …  
    294298                                            if (!l.scanRegExp())
    295299                                                YYABORT;
    296                                             $$ = createNodeFeatureInfo<ExpressionNode*>(new RegExpNode(GLOBAL_DATA, "=" + l.pattern(), l.flags()), 0);
     300                                            RegExpNode* node = new RegExpNode(GLOBAL_DATA, l.pattern(), l.flags());
     301                                            int size = l.pattern().size() + 2; // + 2 for the two /'s
     302                                            SET_EXCEPTION_LOCATION(node, @1.first_column, @1.first_column + size, @1.first_column + size);
     303                                            $$ = createNodeFeatureInfo<ExpressionNode*>(node, 0);
    297304                                        }
    298305;
    … …  
    328335  | Literal
    329336  | ArrayLiteral
    330   | IDENT                               { $$ = createNodeFeatureInfo<ExpressionNode*>(new ResolveNode(GLOBAL_DATA, *$1), 0); }
     337  | IDENT                               { $$ = createNodeFeatureInfo<ExpressionNode*>(new ResolveNode(GLOBAL_DATA, *$1, @1.first_column), 0); }
    331338  | '(' Expr ')'                        { $$ = $2; }
    332339;
    … …  
    361368    PrimaryExpr
    362369  | FunctionExpr                        { $$ = createNodeFeatureInfo<ExpressionNode*>($1.m_node, $1.m_featureInfo); }
    363   | MemberExpr '[' Expr ']'             { $$ = createNodeFeatureInfo<ExpressionNode*>(new BracketAccessorNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    364   | MemberExpr '.' IDENT                { $$ = createNodeFeatureInfo<ExpressionNode*>(new DotAccessorNode(GLOBAL_DATA, $1.m_node, *$3), $1.m_featureInfo); }
    365   | NEW MemberExpr Arguments            { $$ = createNodeFeatureInfo<ExpressionNode*>(new NewExprNode(GLOBAL_DATA, $2.m_node, $3.m_node), $2.m_featureInfo | $3.m_featureInfo); }
     370  | MemberExpr '[' Expr ']'             { BracketAccessorNode* node = new BracketAccessorNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature);
     371                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @1.last_column, @4.last_column);
     372                                          $$ = createNodeFeatureInfo<ExpressionNode*>(node, $1.m_featureInfo | $3.m_featureInfo);
     373                                        }
     374  | MemberExpr '.' IDENT                { DotAccessorNode* node = new DotAccessorNode(GLOBAL_DATA, $1.m_node, *$3);
     375                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @1.last_column, @3.last_column);
     376                                          $$ = createNodeFeatureInfo<ExpressionNode*>(node, $1.m_featureInfo);
     377                                        }
     378  | NEW MemberExpr Arguments            { NewExprNode* node = new NewExprNode(GLOBAL_DATA, $2.m_node, $3.m_node);
     379                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @2.last_column, @3.last_column);
     380                                          $$ = createNodeFeatureInfo<ExpressionNode*>(node, $2.m_featureInfo | $3.m_featureInfo);
     381                                        }
    366382;
    367383
    368384MemberExprNoBF:
    369385    PrimaryExprNoBrace
    370   | MemberExprNoBF '[' Expr ']'         { $$ = createNodeFeatureInfo<ExpressionNode*>(new BracketAccessorNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    371   | MemberExprNoBF '.' IDENT            { $$ = createNodeFeatureInfo<ExpressionNode*>(new DotAccessorNode(GLOBAL_DATA, $1.m_node, *$3), $1.m_featureInfo); }
    372   | NEW MemberExpr Arguments            { $$ = createNodeFeatureInfo<ExpressionNode*>(new NewExprNode(GLOBAL_DATA, $2.m_node, $3.m_node), $2.m_featureInfo | $3.m_featureInfo); }
     386  | MemberExprNoBF '[' Expr ']'         { BracketAccessorNode* node = new BracketAccessorNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature);
     387                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @1.last_column, @4.last_column);
     388                                          $$ = createNodeFeatureInfo<ExpressionNode*>(node, $1.m_featureInfo | $3.m_featureInfo);
     389                                        }
     390  | MemberExprNoBF '.' IDENT            { DotAccessorNode* node = new DotAccessorNode(GLOBAL_DATA, $1.m_node, *$3);
     391                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @1.last_column, @3.last_column);
     392                                          $$ = createNodeFeatureInfo<ExpressionNode*>(node, $1.m_featureInfo);
     393                                        }
     394  | NEW MemberExpr Arguments            { NewExprNode* node = new NewExprNode(GLOBAL_DATA, $2.m_node, $3.m_node);
     395                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @2.last_column, @3.last_column);
     396                                          $$ = createNodeFeatureInfo<ExpressionNode*>(node, $2.m_featureInfo | $3.m_featureInfo);
     397                                        }
    373398;
    374399
    375400NewExpr:
    376401    MemberExpr
    377   | NEW NewExpr                         { $$ = createNodeFeatureInfo<ExpressionNode*>(new NewExprNode(GLOBAL_DATA, $2.m_node), $2.m_featureInfo); }
     402  | NEW NewExpr                         { NewExprNode* node = new NewExprNode(GLOBAL_DATA, $2.m_node);
     403                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @2.last_column, @2.last_column);
     404                                          $$ = createNodeFeatureInfo<ExpressionNode*>(node, $2.m_featureInfo);
     405                                        }
    378406;
    379407
    380408NewExprNoBF:
    381409    MemberExprNoBF
    382   | NEW NewExpr                         { $$ = createNodeFeatureInfo<ExpressionNode*>(new NewExprNode(GLOBAL_DATA, $2.m_node), $2.m_featureInfo); }
     410  | NEW NewExpr                         { NewExprNode* node = new NewExprNode(GLOBAL_DATA, $2.m_node);
     411                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @2.last_column, @2.last_column);
     412                                          $$ = createNodeFeatureInfo<ExpressionNode*>(node, $2.m_featureInfo);
     413                                        }
    383414;
    384415
    385416CallExpr:
    386     MemberExpr Arguments                { $$ = makeFunctionCallNode(globalPtr, $1, $2); }
    387   | CallExpr Arguments                  { $$ = makeFunctionCallNode(globalPtr, $1, $2); }
    388   | CallExpr '[' Expr ']'               { $$ = createNodeFeatureInfo<ExpressionNode*>(new BracketAccessorNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    389   | CallExpr '.' IDENT                  { $$ = createNodeFeatureInfo<ExpressionNode*>(new DotAccessorNode(GLOBAL_DATA, $1.m_node, *$3), $1.m_featureInfo); }
     417    MemberExpr Arguments                { $$ = makeFunctionCallNode(globalPtr, $1, $2, @1.first_column, @1.last_column, @2.last_column); }
     418  | CallExpr Arguments                  { $$ = makeFunctionCallNode(globalPtr, $1, $2, @1.first_column, @1.last_column, @2.last_column); }
     419  | CallExpr '[' Expr ']'               { BracketAccessorNode* node = new BracketAccessorNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature);
     420                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @1.last_column, @4.last_column);
     421                                          $$ = createNodeFeatureInfo<ExpressionNode*>(node, $1.m_featureInfo | $3.m_featureInfo);
     422                                        }
     423  | CallExpr '.' IDENT                  { DotAccessorNode* node = new DotAccessorNode(GLOBAL_DATA, $1.m_node, *$3);
     424                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @1.last_column, @3.last_column);
     425                                          $$ = createNodeFeatureInfo<ExpressionNode*>(node, $1.m_featureInfo); }
    390426;
    391427
    392428CallExprNoBF:
    393     MemberExprNoBF Arguments            { $$ = makeFunctionCallNode(globalPtr, $1, $2); }
    394   | CallExprNoBF Arguments              { $$ = makeFunctionCallNode(globalPtr, $1, $2); }
    395   | CallExprNoBF '[' Expr ']'           { $$ = createNodeFeatureInfo<ExpressionNode*>(new BracketAccessorNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    396   | CallExprNoBF '.' IDENT              { $$ = createNodeFeatureInfo<ExpressionNode*>(new DotAccessorNode(GLOBAL_DATA, $1.m_node, *$3), $1.m_featureInfo); }
     429    MemberExprNoBF Arguments            { $$ = makeFunctionCallNode(globalPtr, $1, $2, @1.first_column, @1.last_column, @2.last_column); }
     430  | CallExprNoBF Arguments              { $$ = makeFunctionCallNode(globalPtr, $1, $2, @1.first_column, @1.last_column, @2.last_column); }
     431  | CallExprNoBF '[' Expr ']'           { BracketAccessorNode* node = new BracketAccessorNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature);
     432                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @1.last_column, @4.last_column);
     433                                          $$ = createNodeFeatureInfo<ExpressionNode*>(node, $1.m_featureInfo | $3.m_featureInfo);
     434                                        }
     435  | CallExprNoBF '.' IDENT              { DotAccessorNode* node = new DotAccessorNode(GLOBAL_DATA, $1.m_node, *$3);
     436                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @1.last_column, @3.last_column);
     437                                          $$ = createNodeFeatureInfo<ExpressionNode*>(node, $1.m_featureInfo);
     438                                        }
    397439;
    398440
    … …  
    423465PostfixExpr:
    424466    LeftHandSideExpr
    425   | LeftHandSideExpr PLUSPLUS           { $$ = createNodeFeatureInfo<ExpressionNode*>(makePostfixNode(GLOBAL_DATA, $1.m_node, OpPlusPlus), $1.m_featureInfo | AssignFeature); }
    426   | LeftHandSideExpr MINUSMINUS         { $$ = createNodeFeatureInfo<ExpressionNode*>(makePostfixNode(GLOBAL_DATA, $1.m_node, OpMinusMinus), $1.m_featureInfo | AssignFeature); }
     467  | LeftHandSideExpr PLUSPLUS           { $$ = createNodeFeatureInfo<ExpressionNode*>(makePostfixNode(GLOBAL_DATA, $1.m_node, OpPlusPlus, @1.first_column, @1.last_column, @2.last_column), $1.m_featureInfo | AssignFeature); }
     468  | LeftHandSideExpr MINUSMINUS         { $$ = createNodeFeatureInfo<ExpressionNode*>(makePostfixNode(GLOBAL_DATA, $1.m_node, OpMinusMinus, @1.first_column, @1.last_column, @2.last_column), $1.m_featureInfo | AssignFeature); }
    427469;
    428470
    429471PostfixExprNoBF:
    430472    LeftHandSideExprNoBF
    431   | LeftHandSideExprNoBF PLUSPLUS       { $$ = createNodeFeatureInfo<ExpressionNode*>(makePostfixNode(GLOBAL_DATA, $1.m_node, OpPlusPlus), $1.m_featureInfo | AssignFeature); }
    432   | LeftHandSideExprNoBF MINUSMINUS     { $$ = createNodeFeatureInfo<ExpressionNode*>(makePostfixNode(GLOBAL_DATA, $1.m_node, OpMinusMinus), $1.m_featureInfo | AssignFeature); }
     473  | LeftHandSideExprNoBF PLUSPLUS       { $$ = createNodeFeatureInfo<ExpressionNode*>(makePostfixNode(GLOBAL_DATA, $1.m_node, OpPlusPlus, @1.first_column, @1.last_column, @2.last_column), $1.m_featureInfo | AssignFeature); }
     474  | LeftHandSideExprNoBF MINUSMINUS     { $$ = createNodeFeatureInfo<ExpressionNode*>(makePostfixNode(GLOBAL_DATA, $1.m_node, OpMinusMinus, @1.first_column, @1.last_column, @2.last_column), $1.m_featureInfo | AssignFeature); }
    433475;
    434476
    435477UnaryExprCommon:
    436     DELETETOKEN UnaryExpr               { $$ = createNodeFeatureInfo<ExpressionNode*>(makeDeleteNode(GLOBAL_DATA, $2.m_node), $2.m_featureInfo); }
     478    DELETETOKEN UnaryExpr               { $$ = createNodeFeatureInfo<ExpressionNode*>(makeDeleteNode(GLOBAL_DATA, $2.m_node, @1.first_column, @2.last_column, @2.last_column), $2.m_featureInfo); }
    437479  | VOIDTOKEN UnaryExpr                 { $$ = createNodeFeatureInfo<ExpressionNode*>(new VoidNode(GLOBAL_DATA, $2.m_node), $2.m_featureInfo); }
    438480  | TYPEOF UnaryExpr                    { $$ = createNodeFeatureInfo<ExpressionNode*>(makeTypeOfNode(GLOBAL_DATA, $2.m_node), $2.m_featureInfo); }
    439   | PLUSPLUS UnaryExpr                  { $$ = createNodeFeatureInfo<ExpressionNode*>(makePrefixNode(GLOBAL_DATA, $2.m_node, OpPlusPlus), $2.m_featureInfo | AssignFeature); }
    440   | AUTOPLUSPLUS UnaryExpr              { $$ = createNodeFeatureInfo<ExpressionNode*>(makePrefixNode(GLOBAL_DATA, $2.m_node, OpPlusPlus), $2.m_featureInfo | AssignFeature); }
    441   | MINUSMINUS UnaryExpr                { $$ = createNodeFeatureInfo<ExpressionNode*>(makePrefixNode(GLOBAL_DATA, $2.m_node, OpMinusMinus), $2.m_featureInfo | AssignFeature); }
    442   | AUTOMINUSMINUS UnaryExpr            { $$ = createNodeFeatureInfo<ExpressionNode*>(makePrefixNode(GLOBAL_DATA, $2.m_node, OpMinusMinus), $2.m_featureInfo | AssignFeature); }
     481  | PLUSPLUS UnaryExpr                  { $$ = createNodeFeatureInfo<ExpressionNode*>(makePrefixNode(GLOBAL_DATA, $2.m_node, OpPlusPlus, @1.first_column, @2.first_column + 1, @2.last_column), $2.m_featureInfo | AssignFeature); }
     482  | AUTOPLUSPLUS UnaryExpr              { $$ = createNodeFeatureInfo<ExpressionNode*>(makePrefixNode(GLOBAL_DATA, $2.m_node, OpPlusPlus, @1.first_column, @2.first_column + 1, @2.last_column), $2.m_featureInfo | AssignFeature); }
     483  | MINUSMINUS UnaryExpr                { $$ = createNodeFeatureInfo<ExpressionNode*>(makePrefixNode(GLOBAL_DATA, $2.m_node, OpMinusMinus, @1.first_column, @2.first_column + 1, @2.last_column), $2.m_featureInfo | AssignFeature); }
     484  | AUTOMINUSMINUS UnaryExpr            { $$ = createNodeFeatureInfo<ExpressionNode*>(makePrefixNode(GLOBAL_DATA, $2.m_node, OpMinusMinus, @1.first_column, @2.first_column + 1, @2.last_column), $2.m_featureInfo | AssignFeature); }
    443485  | '+' UnaryExpr                       { $$ = createNodeFeatureInfo<ExpressionNode*>(new UnaryPlusNode(GLOBAL_DATA, $2.m_node), $2.m_featureInfo); }
    444486  | '-' UnaryExpr                       { $$ = createNodeFeatureInfo<ExpressionNode*>(makeNegateNode(GLOBAL_DATA, $2.m_node), $2.m_featureInfo); }
    … …  
    507549  | RelationalExpr LE ShiftExpr         { $$ = createNodeFeatureInfo<ExpressionNode*>(new LessEqNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    508550  | RelationalExpr GE ShiftExpr         { $$ = createNodeFeatureInfo<ExpressionNode*>(new GreaterEqNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    509   | RelationalExpr INSTANCEOF ShiftExpr { $$ = createNodeFeatureInfo<ExpressionNode*>(new InstanceOfNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    510   | RelationalExpr INTOKEN ShiftExpr    { $$ = createNodeFeatureInfo<ExpressionNode*>(new InNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
     551  | RelationalExpr INSTANCEOF ShiftExpr { InstanceOfNode* node = new InstanceOfNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature);
     552                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @3.first_column, @3.last_column); 
     553                                          $$ = createNodeFeatureInfo<ExpressionNode*>(node, $1.m_featureInfo | $3.m_featureInfo); }
     554  | RelationalExpr INTOKEN ShiftExpr    { InNode* node = new InNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature);
     555                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @3.first_column, @3.last_column); 
     556                                          $$ = createNodeFeatureInfo<ExpressionNode*>(node, $1.m_featureInfo | $3.m_featureInfo); }
    511557;
    512558
    … …  
    518564  | RelationalExprNoIn GE ShiftExpr     { $$ = createNodeFeatureInfo<ExpressionNode*>(new GreaterEqNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    519565  | RelationalExprNoIn INSTANCEOF ShiftExpr
    520                                         { $$ = createNodeFeatureInfo<ExpressionNode*>(new InstanceOfNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
     566                                        { InstanceOfNode* node = new InstanceOfNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature);
     567                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @3.first_column, @3.last_column); 
     568                                          $$ = createNodeFeatureInfo<ExpressionNode*>(node, $1.m_featureInfo | $3.m_featureInfo); }
    521569;
    522570
    … …  
    528576  | RelationalExprNoBF GE ShiftExpr     { $$ = createNodeFeatureInfo<ExpressionNode*>(new GreaterEqNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    529577  | RelationalExprNoBF INSTANCEOF ShiftExpr
    530                                         { $$ = createNodeFeatureInfo<ExpressionNode*>(new InstanceOfNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    531   | RelationalExprNoBF INTOKEN ShiftExpr     { $$ = createNodeFeatureInfo<ExpressionNode*>(new InNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
     578                                        { InstanceOfNode* node = new InstanceOfNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature);
     579                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @3.first_column, @3.last_column); 
     580                                          $$ = createNodeFeatureInfo<ExpressionNode*>(node, $1.m_featureInfo | $3.m_featureInfo); }
     581  | RelationalExprNoBF INTOKEN ShiftExpr
     582                                        { InNode* node = new InNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature);
     583                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @3.first_column, @3.last_column); 
     584                                          $$ = createNodeFeatureInfo<ExpressionNode*>(node, $1.m_featureInfo | $3.m_featureInfo); }
    532585;
    533586
    … …  
    667720    ConditionalExpr
    668721  | LeftHandSideExpr AssignmentOperator AssignmentExpr
    669                                         { $$ = createNodeFeatureInfo<ExpressionNode*>(makeAssignNode(GLOBAL_DATA, $1.m_node, $2, $3.m_node, $1.m_featureInfo & AssignFeature, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo | AssignFeature); }
     722                                        { $$ = createNodeFeatureInfo<ExpressionNode*>(makeAssignNode(GLOBAL_DATA, $1.m_node, $2, $3.m_node, $1.m_featureInfo & AssignFeature, $3.m_featureInfo & AssignFeature,
     723                                                                                                     @1.first_column, @2.first_column + 1, @3.last_column), $1.m_featureInfo | $3.m_featureInfo | AssignFeature);
     724                                        }
    670725;
    671726
    … …  
    673728    ConditionalExprNoIn
    674729  | LeftHandSideExpr AssignmentOperator AssignmentExprNoIn
    675                                         { $$ = createNodeFeatureInfo<ExpressionNode*>(makeAssignNode(GLOBAL_DATA, $1.m_node, $2, $3.m_node, $1.m_featureInfo & AssignFeature, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo | AssignFeature); }
     730                                        { $$ = createNodeFeatureInfo<ExpressionNode*>(makeAssignNode(GLOBAL_DATA, $1.m_node, $2, $3.m_node, $1.m_featureInfo & AssignFeature, $3.m_featureInfo & AssignFeature,
     731                                                                                                     @1.first_column, @2.first_column + 1, @3.last_column), $1.m_featureInfo | $3.m_featureInfo | AssignFeature);
     732                                        }
    676733;
    677734
    … …  
    679736    ConditionalExprNoBF
    680737  | LeftHandSideExprNoBF AssignmentOperator AssignmentExpr
    681                                         { $$ = createNodeFeatureInfo<ExpressionNode*>(makeAssignNode(GLOBAL_DATA, $1.m_node, $2, $3.m_node, $1.m_featureInfo & AssignFeature, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo | AssignFeature); }
     738                                        { $$ = createNodeFeatureInfo<ExpressionNode*>(makeAssignNode(GLOBAL_DATA, $1.m_node, $2, $3.m_node, $1.m_featureInfo & AssignFeature, $3.m_featureInfo & AssignFeature,
     739                                                                                                     @1.first_column, @2.first_column + 1, @3.last_column), $1.m_featureInfo | $3.m_featureInfo | AssignFeature);
     740                                        }
    682741;
    683742
    … …  
    753812                                          $$.m_featureInfo = 0;
    754813                                        }
    755   | IDENT Initializer                   { $$.m_node = new AssignResolveNode(GLOBAL_DATA, *$1, $2.m_node, $2.m_featureInfo & AssignFeature);
     814  | IDENT Initializer                   { AssignResolveNode* node = new AssignResolveNode(GLOBAL_DATA, *$1, $2.m_node, $2.m_featureInfo & AssignFeature);
     815                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @2.first_column + 1, @2.last_column);
     816                                          $$.m_node = node;
    756817                                          $$.m_varDeclarations = new ParserRefCountedData<DeclarationStacks::VarStack>(GLOBAL_DATA);
    757818                                          appendToVarDeclarationList(GLOBAL_DATA, $$.m_varDeclarations, *$1, DeclarationStacks::HasInitializer);
    … …  
    767828                                        }
    768829  | VariableDeclarationList ',' IDENT Initializer
    769                                         { $$.m_node = combineVarInitializers(GLOBAL_DATA, $1.m_node, new AssignResolveNode(GLOBAL_DATA, *$3, $4.m_node, $4.m_featureInfo & AssignFeature));
     830                                        { AssignResolveNode* node = new AssignResolveNode(GLOBAL_DATA, *$3, $4.m_node, $4.m_featureInfo & AssignFeature);
     831                                          SET_EXCEPTION_LOCATION(node, @3.first_column, @4.first_column + 1, @4.last_column);
     832                                          $$.m_node = combineVarInitializers(GLOBAL_DATA, $1.m_node, node);
    770833                                          $$.m_varDeclarations = $1.m_varDeclarations;
    771834                                          appendToVarDeclarationList(GLOBAL_DATA, $$.m_varDeclarations, *$3, DeclarationStacks::HasInitializer);
    … …  
    782845                                          $$.m_featureInfo = 0;
    783846                                        }
    784   | IDENT InitializerNoIn               { $$.m_node = new AssignResolveNode(GLOBAL_DATA, *$1, $2.m_node, $2.m_featureInfo & AssignFeature);
     847  | IDENT InitializerNoIn               { AssignResolveNode* node = new AssignResolveNode(GLOBAL_DATA, *$1, $2.m_node, $2.m_featureInfo & AssignFeature);
     848                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @2.first_column + 1, @2.last_column);
     849                                          $$.m_node = node;
    785850                                          $$.m_varDeclarations = new ParserRefCountedData<DeclarationStacks::VarStack>(GLOBAL_DATA);
    786851                                          appendToVarDeclarationList(GLOBAL_DATA, $$.m_varDeclarations, *$1, DeclarationStacks::HasInitializer);
    … …  
    796861                                        }
    797862  | VariableDeclarationListNoIn ',' IDENT InitializerNoIn
    798                                         { $$.m_node = combineVarInitializers(GLOBAL_DATA, $1.m_node, new AssignResolveNode(GLOBAL_DATA, *$3, $4.m_node, $4.m_featureInfo & AssignFeature));
     863                                        { AssignResolveNode* node = new AssignResolveNode(GLOBAL_DATA, *$3, $4.m_node, $4.m_featureInfo & AssignFeature);
     864                                          SET_EXCEPTION_LOCATION(node, @3.first_column, @4.first_column + 1, @4.last_column);
     865                                          $$.m_node = combineVarInitializers(GLOBAL_DATA, $1.m_node, node);
    799866                                          $$.m_varDeclarations = $1.m_varDeclarations;
    800867                                          appendToVarDeclarationList(GLOBAL_DATA, $$.m_varDeclarations, *$3, DeclarationStacks::HasInitializer);
    … …  
    888955                                            if (!n->isLocation())
    889956                                                YYABORT;
    890                                             $$ = createNodeDeclarationInfo<StatementNode*>(new ForInNode(GLOBAL_DATA, $3.m_node, $5.m_node, $7.m_node), $7.m_varDeclarations, $7.m_funcDeclarations,
     957                                            ForInNode* node = new ForInNode(GLOBAL_DATA, $3.m_node, $5.m_node, $7.m_node);
     958                                            SET_EXCEPTION_LOCATION(node, @3.first_column, @3.last_column, @5.last_column);
     959                                            $$ = createNodeDeclarationInfo<StatementNode*>(node, $7.m_varDeclarations, $7.m_funcDeclarations,
    891960                                                                                           $3.m_featureInfo | $5.m_featureInfo | $7.m_featureInfo);
    892961                                            DBG($$.m_node, @1, @6);
    893962                                        }
    894963  | FOR '(' VAR IDENT INTOKEN Expr ')' Statement
    895                                         { ForInNode *forIn = new ForInNode(GLOBAL_DATA, *$4, 0, $6.m_node, $8.m_node);
     964                                        { ForInNode *forIn = new ForInNode(GLOBAL_DATA, *$4, 0, $6.m_node, $8.m_node, @5.first_column, @5.first_column - @4.first_column, @6.last_column - @5.first_column);
     965                                          SET_EXCEPTION_LOCATION(forIn, @4.first_column, @5.first_column + 1, @6.last_column);
    896966                                          appendToVarDeclarationList(GLOBAL_DATA, $8.m_varDeclarations, *$4, DeclarationStacks::HasInitializer);
    897967                                          $$ = createNodeDeclarationInfo<StatementNode*>(forIn, $8.m_varDeclarations, $8.m_funcDeclarations, $6.m_featureInfo | $8.m_featureInfo);
    898968                                          DBG($$.m_node, @1, @7); }
    899969  | FOR '(' VAR IDENT InitializerNoIn INTOKEN Expr ')' Statement
    900                                         { ForInNode *forIn = new ForInNode(GLOBAL_DATA, *$4, $5.m_node, $7.m_node, $9.m_node);
     970                                        { ForInNode *forIn = new ForInNode(GLOBAL_DATA, *$4, $5.m_node, $7.m_node, $9.m_node, @5.first_column, @5.first_column - @4.first_column, @5.last_column - @5.first_column);
     971                                          SET_EXCEPTION_LOCATION(forIn, @4.first_column, @6.first_column + 1, @7.last_column);
    901972                                          appendToVarDeclarationList(GLOBAL_DATA, $9.m_varDeclarations, *$4, DeclarationStacks::HasInitializer);
    902973                                          $$ = createNodeDeclarationInfo<StatementNode*>(forIn, $9.m_varDeclarations, $9.m_funcDeclarations,
    … …  
    916987
    917988ContinueStatement:
    918     CONTINUE ';'                        { $$ = createNodeDeclarationInfo<StatementNode*>(new ContinueNode(GLOBAL_DATA), 0, 0, 0);
     989    CONTINUE ';'                        { ContinueNode* node = new ContinueNode(GLOBAL_DATA);
     990                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @1.last_column, @1.last_column);
     991                                          $$ = createNodeDeclarationInfo<StatementNode*>(node, 0, 0, 0);
    919992                                          DBG($$.m_node, @1, @2); }
    920   | CONTINUE error                      { $$ = createNodeDeclarationInfo<StatementNode*>(new ContinueNode(GLOBAL_DATA), 0, 0, 0);
     993  | CONTINUE error                      { ContinueNode* node = new ContinueNode(GLOBAL_DATA);
     994                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @1.last_column, @1.last_column);
     995                                          $$ = createNodeDeclarationInfo<StatementNode*>(node, 0, 0, 0);
    921996                                          DBG($$.m_node, @1, @1); AUTO_SEMICOLON; }
    922   | CONTINUE IDENT ';'                  { $$ = createNodeDeclarationInfo<StatementNode*>(new ContinueNode(GLOBAL_DATA, *$2), 0, 0, 0);
     997  | CONTINUE IDENT ';'                  { ContinueNode* node = new ContinueNode(GLOBAL_DATA, *$2);
     998                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @2.last_column, @2.last_column);
     999                                          $$ = createNodeDeclarationInfo<StatementNode*>(node, 0, 0, 0);
    9231000                                          DBG($$.m_node, @1, @3); }
    924   | CONTINUE IDENT error                { $$ = createNodeDeclarationInfo<StatementNode*>(new ContinueNode(GLOBAL_DATA, *$2), 0, 0, 0);
     1001  | CONTINUE IDENT error                { ContinueNode* node = new ContinueNode(GLOBAL_DATA, *$2);
     1002                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @2.last_column, @2.last_column);
     1003                                          $$ = createNodeDeclarationInfo<StatementNode*>(node, 0, 0, 0);
    9251004                                          DBG($$.m_node, @1, @2); AUTO_SEMICOLON; }
    9261005;
    9271006
    9281007BreakStatement:
    929     BREAK ';'                           { $$ = createNodeDeclarationInfo<StatementNode*>(new BreakNode(GLOBAL_DATA), 0, 0, 0); DBG($$.m_node, @1, @2); }
    930   | BREAK error                         { $$ = createNodeDeclarationInfo<StatementNode*>(new BreakNode(GLOBAL_DATA), 0, 0, 0); DBG($$.m_node, @1, @1); AUTO_SEMICOLON; }
    931   | BREAK IDENT ';'                     { $$ = createNodeDeclarationInfo<StatementNode*>(new BreakNode(GLOBAL_DATA, *$2), 0, 0, 0); DBG($$.m_node, @1, @3); }
    932   | BREAK IDENT error                   { $$ = createNodeDeclarationInfo<StatementNode*>(new BreakNode(GLOBAL_DATA, *$2), 0, 0, 0); DBG($$.m_node, @1, @2); AUTO_SEMICOLON; }
     1008    BREAK ';'                           { BreakNode* node = new BreakNode(GLOBAL_DATA);
     1009                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @1.last_column, @1.last_column);
     1010                                          $$ = createNodeDeclarationInfo<StatementNode*>(node, 0, 0, 0); DBG($$.m_node, @1, @2); }
     1011  | BREAK error                         { BreakNode* node = new BreakNode(GLOBAL_DATA);
     1012                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @1.last_column, @1.last_column);
     1013                                          $$ = createNodeDeclarationInfo<StatementNode*>(new BreakNode(GLOBAL_DATA), 0, 0, 0); DBG($$.m_node, @1, @1); AUTO_SEMICOLON; }
     1014  | BREAK IDENT ';'                     { BreakNode* node = new BreakNode(GLOBAL_DATA, *$2);
     1015                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @2.last_column, @2.last_column);
     1016                                          $$ = createNodeDeclarationInfo<StatementNode*>(node, 0, 0, 0); DBG($$.m_node, @1, @3); }
     1017  | BREAK IDENT error                   { BreakNode* node = new BreakNode(GLOBAL_DATA, *$2);
     1018                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @2.last_column, @2.last_column);
     1019                                          $$ = createNodeDeclarationInfo<StatementNode*>(new BreakNode(GLOBAL_DATA, *$2), 0, 0, 0); DBG($$.m_node, @1, @2); AUTO_SEMICOLON; }
    9331020;
    9341021
    9351022ReturnStatement:
    936     RETURN ';'                          { $$ = createNodeDeclarationInfo<StatementNode*>(new ReturnNode(GLOBAL_DATA, 0), 0, 0, 0); DBG($$.m_node, @1, @2); }
    937   | RETURN error                        { $$ = createNodeDeclarationInfo<StatementNode*>(new ReturnNode(GLOBAL_DATA, 0), 0, 0, 0); DBG($$.m_node, @1, @1); AUTO_SEMICOLON; }
    938   | RETURN Expr ';'                     { $$ = createNodeDeclarationInfo<StatementNode*>(new ReturnNode(GLOBAL_DATA, $2.m_node), 0, 0, $2.m_featureInfo); DBG($$.m_node, @1, @3); }
    939   | RETURN Expr error                   { $$ = createNodeDeclarationInfo<StatementNode*>(new ReturnNode(GLOBAL_DATA, $2.m_node), 0, 0, $2.m_featureInfo); DBG($$.m_node, @1, @2); AUTO_SEMICOLON; }
     1023    RETURN ';'                          { ReturnNode* node = new ReturnNode(GLOBAL_DATA, 0);
     1024                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @1.last_column, @1.last_column);
     1025                                          $$ = createNodeDeclarationInfo<StatementNode*>(node, 0, 0, 0); DBG($$.m_node, @1, @2); }
     1026  | RETURN error                        { ReturnNode* node = new ReturnNode(GLOBAL_DATA, 0);
     1027                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @1.last_column, @1.last_column);
     1028                                          $$ = createNodeDeclarationInfo<StatementNode*>(node, 0, 0, 0); DBG($$.m_node, @1, @1); AUTO_SEMICOLON; }
     1029  | RETURN Expr ';'                     { ReturnNode* node = new ReturnNode(GLOBAL_DATA, $2.m_node);
     1030                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @2.last_column, @2.last_column);
     1031                                          $$ = createNodeDeclarationInfo<StatementNode*>(node, 0, 0, $2.m_featureInfo); DBG($$.m_node, @1, @3); }
     1032  | RETURN Expr error                   { ReturnNode* node = new ReturnNode(GLOBAL_DATA, $2.m_node);
     1033                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @2.last_column, @2.last_column);
     1034                                          $$ = createNodeDeclarationInfo<StatementNode*>(node, 0, 0, $2.m_featureInfo); DBG($$.m_node, @1, @2); AUTO_SEMICOLON; }
    9401035;
    9411036
    9421037WithStatement:
    943     WITH '(' Expr ')' Statement         { $$ = createNodeDeclarationInfo<StatementNode*>(new WithNode(GLOBAL_DATA, $3.m_node, $5.m_node), $5.m_varDeclarations, $5.m_funcDeclarations,
    944                                                                                          $3.m_featureInfo | $5.m_featureInfo);
     1038    WITH '(' Expr ')' Statement         { $$ = createNodeDeclarationInfo<StatementNode*>(new WithNode(GLOBAL_DATA, $3.m_node, $5.m_node, @3.last_column, @3.last_column - @3.first_column),
     1039                                                                                         $5.m_varDeclarations, $5.m_funcDeclarations, $3.m_featureInfo | $5.m_featureInfo);
    9451040                                          DBG($$.m_node, @1, @4); }
    9461041;
    … …  
    9921087LabelledStatement:
    9931088    IDENT ':' Statement                 { $3.m_node->pushLabel(*$1);
    994                                           $$ = createNodeDeclarationInfo<StatementNode*>(new LabelNode(GLOBAL_DATA, *$1, $3.m_node), $3.m_varDeclarations, $3.m_funcDeclarations, $3.m_featureInfo); }
     1089                                          LabelNode* node = new LabelNode(GLOBAL_DATA, *$1, $3.m_node);
     1090                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @2.last_column, @2.last_column);
     1091                                          $$ = createNodeDeclarationInfo<StatementNode*>(node, $3.m_varDeclarations, $3.m_funcDeclarations, $3.m_featureInfo); }
    9951092;
    9961093
    9971094ThrowStatement:
    998     THROW Expr ';'                      { $$ = createNodeDeclarationInfo<StatementNode*>(new ThrowNode(GLOBAL_DATA, $2.m_node), 0, 0, $2.m_featureInfo); DBG($$.m_node, @1, @3); }
    999   | THROW Expr error                    { $$ = createNodeDeclarationInfo<StatementNode*>(new ThrowNode(GLOBAL_DATA, $2.m_node), 0, 0, $2.m_featureInfo); DBG($$.m_node, @1, @2); AUTO_SEMICOLON; }
     1095    THROW Expr ';'                      { ThrowNode* node = new ThrowNode(GLOBAL_DATA, $2.m_node);
     1096                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @2.last_column, @2.last_column);
     1097                                          $$ = createNodeDeclarationInfo<StatementNode*>(node, 0, 0, $2.m_featureInfo); DBG($$.m_node, @1, @2);
     1098                                        }
     1099  | THROW Expr error                    { ThrowNode* node = new ThrowNode(GLOBAL_DATA, $2.m_node);
     1100                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @2.last_column, @2.last_column);
     1101                                          $$ = createNodeDeclarationInfo<StatementNode*>(node, 0, 0, $2.m_featureInfo); DBG($$.m_node, @1, @2); AUTO_SEMICOLON;
     1102                                        }
    10001103;
    10011104
    … …  
    10921195%%
    10931196
    1094 static ExpressionNode* makeAssignNode(void* globalPtr, ExpressionNode* loc, Operator op, ExpressionNode* expr, bool locHasAssignments, bool exprHasAssignments)
     1197static ExpressionNode* makeAssignNode(void* globalPtr, ExpressionNode* loc, Operator op, ExpressionNode* expr, bool locHasAssignments, bool exprHasAssignments, int start, int divot, int end)
    10951198{
    10961199    if (!loc->isLocation())
    1097         return new AssignErrorNode(GLOBAL_DATA, loc, op, expr);
     1200        return new AssignErrorNode(GLOBAL_DATA, loc, op, expr, divot, divot - start, end - divot);
    10981201
    10991202    if (loc->isResolveNode()) {
    11001203        ResolveNode* resolve = static_cast<ResolveNode*>(loc);
    1101         if (op == OpEqual)
    1102             return new AssignResolveNode(GLOBAL_DATA, resolve->identifier(), expr, exprHasAssignments);
    1103         else
    1104             return new ReadModifyResolveNode(GLOBAL_DATA, resolve->identifier(), op, expr, exprHasAssignments);
     1204        if (op == OpEqual) {
     1205            AssignResolveNode* node = new AssignResolveNode(GLOBAL_DATA, resolve->identifier(), expr, exprHasAssignments);
     1206            SET_EXCEPTION_LOCATION(node, start, divot, end);
     1207            return node;
     1208        } else
     1209            return new ReadModifyResolveNode(GLOBAL_DATA, resolve->identifier(), op, expr, exprHasAssignments, divot, divot - start, end - divot);
    11051210    }
    11061211    if (loc->isBracketAccessorNode()) {
    11071212        BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(loc);
    11081213        if (op == OpEqual)
    1109             return new AssignBracketNode(GLOBAL_DATA, bracket->base(), bracket->subscript(), expr, locHasAssignments, exprHasAssignments);
    1110         else
    1111             return new ReadModifyBracketNode(GLOBAL_DATA, bracket->base(), bracket->subscript(), op, expr, locHasAssignments, exprHasAssignments);
     1214            return new AssignBracketNode(GLOBAL_DATA, bracket->base(), bracket->subscript(), expr, locHasAssignments, exprHasAssignments, divot, divot - start, end - divot);
     1215        else {
     1216            ReadModifyBracketNode* node = new ReadModifyBracketNode(GLOBAL_DATA, bracket->base(), bracket->subscript(), op, expr, locHasAssignments, exprHasAssignments, divot, divot - start, end - divot);
     1217            node->setSubexpressionInfo(bracket->divot(), bracket->endOffset());
     1218            return node;
     1219        }
    11121220    }
    11131221    ASSERT(loc->isDotAccessorNode());
    11141222    DotAccessorNode* dot = static_cast<DotAccessorNode*>(loc);
    11151223    if (op == OpEqual)
    1116         return new AssignDotNode(GLOBAL_DATA, dot->base(), dot->identifier(), expr, exprHasAssignments);
    1117     return new ReadModifyDotNode(GLOBAL_DATA, dot->base(), dot->identifier(), op, expr, exprHasAssignments);
    1118 }
    1119 
    1120 static ExpressionNode* makePrefixNode(void* globalPtr, ExpressionNode* expr, Operator op)
    1121 {
     1224        return new AssignDotNode(GLOBAL_DATA, dot->base(), dot->identifier(), expr, exprHasAssignments, divot, divot - start, end - divot);
     1225
     1226    ReadModifyDotNode* node = new ReadModifyDotNode(GLOBAL_DATA, dot->base(), dot->identifier(), op, expr, exprHasAssignments, divot, divot - start, end - divot);
     1227    node->setSubexpressionInfo(dot->divot(), dot->endOffset());
     1228    return node;
     1229}
     1230
     1231static ExpressionNode* makePrefixNode(void* globalPtr, ExpressionNode* expr, Operator op, int start, int divot, int end)
     1232{
    11221233    if (!expr->isLocation())
    1123         return new PrefixErrorNode(GLOBAL_DATA, expr, op);
     1234        return new PrefixErrorNode(GLOBAL_DATA, expr, op, divot, divot - start, end - divot);
    11241235   
    11251236    if (expr->isResolveNode()) {
    11261237        ResolveNode* resolve = static_cast<ResolveNode*>(expr);
    1127         return new PrefixResolveNode(GLOBAL_DATA, resolve->identifier(), op);
     1238        return new PrefixResolveNode(GLOBAL_DATA, resolve->identifier(), op, divot, divot - start, end - divot);
    11281239    }
    11291240    if (expr->isBracketAccessorNode()) {
    11301241        BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(expr);
    1131         return new PrefixBracketNode(GLOBAL_DATA, bracket->base(), bracket->subscript(), op);
     1242        PrefixBracketNode* node = new PrefixBracketNode(GLOBAL_DATA, bracket->base(), bracket->subscript(), op, divot, divot - start, end - divot);
     1243        node->setSubexpressionInfo(bracket->divot(), bracket->startOffset());
     1244        return node;
    11321245    }
    11331246    ASSERT(expr->isDotAccessorNode());
    11341247    DotAccessorNode* dot = static_cast<DotAccessorNode*>(expr);
    1135     return new PrefixDotNode(GLOBAL_DATA, dot->base(), dot->identifier(), op);
    1136 }
    1137 
    1138 static ExpressionNode* makePostfixNode(void* globalPtr, ExpressionNode* expr, Operator op)
     1248    PrefixDotNode* node = new PrefixDotNode(GLOBAL_DATA, dot->base(), dot->identifier(), op, divot, divot - start, end - divot);
     1249    node->setSubexpressionInfo(dot->divot(), dot->startOffset());
     1250    return node;
     1251}
     1252
     1253static ExpressionNode* makePostfixNode(void* globalPtr, ExpressionNode* expr, Operator op, int start, int divot, int end)
    11391254{
    11401255    if (!expr->isLocation())
    1141         return new PostfixErrorNode(GLOBAL_DATA, expr, op);
     1256        return new PostfixErrorNode(GLOBAL_DATA, expr, op, divot, divot - start, end - divot);
    11421257   
    11431258    if (expr->isResolveNode()) {
    11441259        ResolveNode* resolve = static_cast<ResolveNode*>(expr);
    1145         return new PostfixResolveNode(GLOBAL_DATA, resolve->identifier(), op);
     1260        return new PostfixResolveNode(GLOBAL_DATA, resolve->identifier(), op, divot, divot - start, end - divot);
    11461261    }
    11471262    if (expr->isBracketAccessorNode()) {
    11481263        BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(expr);
    1149         return new PostfixBracketNode(GLOBAL_DATA, bracket->base(), bracket->subscript(), op);
     1264        PostfixBracketNode* node = new PostfixBracketNode(GLOBAL_DATA, bracket->base(), bracket->subscript(), op, divot, divot - start, end - divot);
     1265        node->setSubexpressionInfo(bracket->divot(), bracket->endOffset());
     1266        return node;
     1267       
    11501268    }
    11511269    ASSERT(expr->isDotAccessorNode());
    11521270    DotAccessorNode* dot = static_cast<DotAccessorNode*>(expr);
    1153     return new PostfixDotNode(GLOBAL_DATA, dot->base(), dot->identifier(), op);
    1154 }
    1155 
    1156 static ExpressionNodeInfo makeFunctionCallNode(void* globalPtr, ExpressionNodeInfo func, ArgumentsNodeInfo args)
     1271    PostfixDotNode* node = new PostfixDotNode(GLOBAL_DATA, dot->base(), dot->identifier(), op, divot, divot - start, end - divot);
     1272    node->setSubexpressionInfo(dot->divot(), dot->endOffset());
     1273    return node;
     1274}
     1275
     1276static ExpressionNodeInfo makeFunctionCallNode(void* globalPtr, ExpressionNodeInfo func, ArgumentsNodeInfo args, int start, int divot, int end)
    11571277{
    11581278    FeatureInfo features = func.m_featureInfo | args.m_featureInfo;
    11591279    if (!func.m_node->isLocation())
    1160         return createNodeFeatureInfo<ExpressionNode*>(new FunctionCallValueNode(GLOBAL_DATA, func.m_node, args.m_node), features);
     1280        return createNodeFeatureInfo<ExpressionNode*>(new FunctionCallValueNode(GLOBAL_DATA, func.m_node, args.m_node, divot, divot - start, end - divot), features);
    11611281    if (func.m_node->isResolveNode()) {
    11621282        ResolveNode* resolve = static_cast<ResolveNode*>(func.m_node);
    11631283        const Identifier& identifier = resolve->identifier();
    11641284        if (identifier == GLOBAL_DATA->propertyNames->eval)
    1165             return createNodeFeatureInfo<ExpressionNode*>(new EvalFunctionCallNode(GLOBAL_DATA, args.m_node), EvalFeature | features);
    1166         return createNodeFeatureInfo<ExpressionNode*>(new FunctionCallResolveNode(GLOBAL_DATA, identifier, args.m_node), features);
     1285            return createNodeFeatureInfo<ExpressionNode*>(new EvalFunctionCallNode(GLOBAL_DATA, args.m_node, divot, divot - start, end - divot), EvalFeature | features);
     1286        return createNodeFeatureInfo<ExpressionNode*>(new FunctionCallResolveNode(GLOBAL_DATA, identifier, args.m_node, divot, divot - start, end - divot), features);
    11671287    }
    11681288    if (func.m_node->isBracketAccessorNode()) {
    11691289        BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(func.m_node);
    1170         return createNodeFeatureInfo<ExpressionNode*>(new FunctionCallBracketNode(GLOBAL_DATA, bracket->base(), bracket->subscript(), args.m_node), features);
     1290        FunctionCallBracketNode* node = new FunctionCallBracketNode(GLOBAL_DATA, bracket->base(), bracket->subscript(), args.m_node, divot, divot - start, end - divot);
     1291        node->setSubexpressionInfo(bracket->divot(), bracket->endOffset());
     1292        return createNodeFeatureInfo<ExpressionNode*>(node, features);
    11711293    }
    11721294    ASSERT(func.m_node->isDotAccessorNode());
    11731295    DotAccessorNode* dot = static_cast<DotAccessorNode*>(func.m_node);
    1174     return createNodeFeatureInfo<ExpressionNode*>(new FunctionCallDotNode(GLOBAL_DATA, dot->base(), dot->identifier(), args.m_node), features);
     1296    FunctionCallDotNode* node = new FunctionCallDotNode(GLOBAL_DATA, dot->base(), dot->identifier(), args.m_node, divot, divot - start, end - divot);
     1297    node->setSubexpressionInfo(dot->divot(), dot->endOffset());
     1298    return createNodeFeatureInfo<ExpressionNode*>(node, features);
    11751299}
    11761300
    … …  
    11841308}
    11851309
    1186 static ExpressionNode* makeDeleteNode(void* globalPtr, ExpressionNode* expr)
     1310static ExpressionNode* makeDeleteNode(void* globalPtr, ExpressionNode* expr, int start, int divot, int end)
    11871311{
    11881312    if (!expr->isLocation())
    … …  
    11901314    if (expr->isResolveNode()) {
    11911315        ResolveNode* resolve = static_cast<ResolveNode*>(expr);
    1192         return new DeleteResolveNode(GLOBAL_DATA, resolve->identifier());
     1316        return new DeleteResolveNode(GLOBAL_DATA, resolve->identifier(), divot, divot - start, end - divot);
    11931317    }
    11941318    if (expr->isBracketAccessorNode()) {
    11951319        BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(expr);
    1196         return new DeleteBracketNode(GLOBAL_DATA, bracket->base(), bracket->subscript());
     1320        return new DeleteBracketNode(GLOBAL_DATA, bracket->base(), bracket->subscript(), divot, divot - start, end - divot);
    11971321    }
    11981322    ASSERT(expr->isDotAccessorNode());
    11991323    DotAccessorNode* dot = static_cast<DotAccessorNode*>(expr);
    1200     return new DeleteDotNode(GLOBAL_DATA, dot->base(), dot->identifier());
     1324    return new DeleteDotNode(GLOBAL_DATA, dot->base(), dot->identifier(), divot, divot - start, end - divot);
    12011325}
    12021326

  • trunk/JavaScriptCore/kjs/lexer.cpp

    r35195 r35245  
    7575    , m_next2(0)
    7676    , m_next3(0)
     77    , m_currentOffset(0)
     78    , m_nextOffset1(0)
     79    , m_nextOffset2(0)
     80    , m_nextOffset3(0)
    7781    , m_globalData(globalData)
    7882    , m_mainTable(KJS::mainTable)
    … …  
    120124        m_next1 = m_next2;
    121125        m_next2 = m_next3;
     126        m_currentOffset = m_nextOffset1;
     127        m_nextOffset1 = m_nextOffset2;
     128        m_nextOffset2 = m_nextOffset3;
    122129        do {
    123130            if (m_position >= m_length) {
     131                m_nextOffset3 = m_position;
    124132                m_position++;
    125133                m_next3 = -1;
    126134                break;
    127135            }
     136            m_nextOffset3 = m_position;
    128137            m_next3 = m_code[m_position++];
    129138        } while (m_next3 == 0xFEFF);
    … …  
    165174        m_stackToken = 0;
    166175    }
    167 
     176    int startOffset = m_currentOffset;
    168177    while (!m_done) {
    169178        if (m_skipLF && m_current != '\n') // found \r but not \n afterwards
    … …  
    178187        switch (m_state) {
    179188            case Start:
     189                startOffset = m_currentOffset;
    180190                if (isWhiteSpace()) {
    181191                    // do nothing
    … …  
    522532    llocp->first_line = yylineno;
    523533    llocp->last_line = yylineno;
    524 
     534    llocp->first_column = startOffset;
     535    llocp->last_column = m_currentOffset;
    525536    switch (m_state) {
    526537        case Eof:

  • trunk/JavaScriptCore/kjs/lexer.h

    r35037 r35245  
    134134        State m_state;
    135135        unsigned int m_position;
    136 
    137136        RefPtr<SourceProvider> m_source;
    138137        const UChar* m_code;
    … …  
    146145        int m_next2;
    147146        int m_next3;
    148 
     147       
     148        int m_currentOffset;
     149        int m_nextOffset1;
     150        int m_nextOffset2;
     151        int m_nextOffset3;
     152       
    149153        Vector<UString*> m_strings;
    150154        Vector<KJS::Identifier*> m_identifiers;

  • trunk/JavaScriptCore/kjs/nodes.cpp

    r35230 r35245  
    163163}
    164164
    165 RegisterID* Node::emitThrowError(CodeGenerator& generator, ErrorType e, const char* msg)
    166 {
     165RegisterID* ThrowableExpressionData::emitThrowError(CodeGenerator& generator, ErrorType e, const char* msg)
     166{
     167    generator.emitExpressionInfo(m_divot, m_startOffset, m_endOffset);
    167168    RegisterID* exception = generator.emitNewError(generator.newTemporary(), e, jsString(generator.globalExec(), msg));
    168169    generator.emitThrow(exception);
    … …  
    170171}
    171172
    172 RegisterID* Node::emitThrowError(CodeGenerator& generator, ErrorType e, const char* msg, const Identifier& label)
     173RegisterID* ThrowableExpressionData::emitThrowError(CodeGenerator& generator, ErrorType e, const char* msg, const Identifier& label)
    173174{
    174175    UString message = msg;
    175176    substitute(message, label.ustring());
     177    generator.emitExpressionInfo(m_divot, m_startOffset, m_endOffset);
    176178    RegisterID* exception = generator.emitNewError(generator.newTemporary(), e, jsString(generator.globalExec(), message));
    177179    generator.emitThrow(exception);
    … …  
    185187    , m_lastLine(-1)
    186188{
    187     m_line = -1;
    188189}
    189190
    … …  
    289290        return generator.moveToDestinationIfNeeded(dst, local);
    290291    }
    291 
     292   
     293    generator.emitExpressionInfo(m_startOffset + m_ident.size(), m_ident.size(), 0);
    292294    return generator.emitResolve(generator.finalDestination(dst), m_ident);
    293295}
    … …  
    376378    RefPtr<RegisterID> base = generator.emitNodeForLeftHandSide(m_base.get(), m_subscriptHasAssignments, m_subscript->isPure(generator));
    377379    RegisterID* property = generator.emitNode(m_subscript.get());
    378 
     380    generator.emitExpressionInfo(m_divot, m_startOffset, m_endOffset);
    379381    return generator.emitGetByVal(generator.finalDestination(dst), base.get(), property);
    380382}
    … …  
    385387{
    386388    RegisterID* base = generator.emitNode(m_base.get());
     389    generator.emitExpressionInfo(m_divot, m_startOffset, m_endOffset);
    387390    return generator.emitGetById(generator.finalDestination(dst), base, m_ident);
    388391}
    … …  
    401404{
    402405    RegisterID* r0 = generator.emitNode(m_expr.get());
     406    generator.emitExpressionInfo(m_divot, m_startOffset, m_endOffset);
    403407    return generator.emitConstruct(generator.finalDestination(dst), r0, m_args.get());
    404408}
    … …  
    409413    RegisterID* func = generator.newTemporary();
    410414    generator.emitResolveWithBase(base.get(), func, generator.propertyNames().eval);
    411     return generator.emitCallEval(generator.finalDestination(dst, base.get()), func, base.get(), m_args.get());
     415    return generator.emitCallEval(generator.finalDestination(dst, base.get()), func, base.get(), m_args.get(), m_divot, m_startOffset, m_endOffset);
    412416}
    413417
    … …  
    415419{
    416420    RegisterID* func = generator.emitNode(m_expr.get());
    417     return generator.emitCall(generator.finalDestination(dst), func, 0, m_args.get());
     421    return generator.emitCall(generator.finalDestination(dst), func, 0, m_args.get(), m_divot, m_startOffset, m_endOffset);
    418422}
    419423
    … …  
    421425{
    422426    if (RegisterID* local = generator.registerForLocal(m_ident))
    423         return generator.emitCall(generator.finalDestination(dst), local, 0, m_args.get());
     427        return generator.emitCall(generator.finalDestination(dst), local, 0, m_args.get(), m_divot, m_startOffset, m_endOffset);
    424428
    425429    int index = 0;
    … …  
    427431    if (generator.findScopedProperty(m_ident, index, depth) && index != missingSymbolMarker()) {
    428432        RegisterID* func = generator.emitGetScopedVar(generator.newTemporary(), depth, index);
    429         return generator.emitCall(generator.finalDestination(dst), func, 0, m_args.get());
     433        return generator.emitCall(generator.finalDestination(dst), func, 0, m_args.get(), m_divot, m_startOffset, m_endOffset);
    430434    }
    431435
    432436    RefPtr<RegisterID> base = generator.tempDestination(dst);
    433437    RegisterID* func = generator.newTemporary();
     438    int identifierStart = m_divot - m_startOffset;
     439    generator.emitExpressionInfo(identifierStart + m_ident.size(), m_ident.size(), 0);
    434440    generator.emitResolveFunction(base.get(), func, m_ident);
    435     return generator.emitCall(generator.finalDestination(dst, base.get()), func, base.get(), m_args.get());
     441    return generator.emitCall(generator.finalDestination(dst, base.get()), func, base.get(), m_args.get(), m_divot, m_startOffset, m_endOffset);
    436442}
    437443
    … …  
    440446    RefPtr<RegisterID> base = generator.emitNode(m_base.get());
    441447    RegisterID* property = generator.emitNode(m_subscript.get());
     448    generator.emitExpressionInfo(m_divot - m_subexpressionDivotOffset, m_startOffset - m_subexpressionDivotOffset, m_subexpressionEndOffset);
    442449    RegisterID* function = generator.emitGetByVal(generator.newTemporary(), base.get(), property);
    443     return generator.emitCall(generator.finalDestination(dst, base.get()), function, base.get(), m_args.get());
     450    return generator.emitCall(generator.finalDestination(dst, base.get()), function, base.get(), m_args.get(), m_divot, m_startOffset, m_endOffset);
    444451}
    445452
    … …  
    447454{
    448455    RefPtr<RegisterID> base = generator.emitNode(m_base.get());
     456    generator.emitExpressionInfo(m_divot - m_subexpressionDivotOffset, m_startOffset - m_subexpressionDivotOffset, m_subexpressionEndOffset);
    449457    RegisterID* function = generator.emitGetById(generator.newTemporary(), base.get(), m_ident);
    450     return generator.emitCall(generator.finalDestination(dst, base.get()), function, base.get(), m_args.get());
     458    return generator.emitCall(generator.finalDestination(dst, base.get()), function, base.get(), m_args.get(), m_divot, m_startOffset, m_endOffset);
    451459}
    452460
    … …  
    492500    }
    493501
     502    generator.emitExpressionInfo(m_divot, m_startOffset, m_endOffset);
    494503    RefPtr<RegisterID> value = generator.newTemporary();
    495504    RefPtr<RegisterID> base = generator.emitResolveWithBase(generator.newTemporary(), value.get(), m_ident);
    … …  
    511520    RefPtr<RegisterID> base = generator.emitNode(m_base.get());
    512521    RefPtr<RegisterID> property = generator.emitNode(m_subscript.get());
     522
     523    generator.emitExpressionInfo(m_divot - m_subexpressionDivotOffset, m_startOffset - m_subexpressionDivotOffset, m_subexpressionEndOffset);
    513524    RefPtr<RegisterID> value = generator.emitGetByVal(generator.newTemporary(), base.get(), property.get());
    514525    RegisterID* oldValue;
    … …  
    522533        oldValue = (m_operator == OpPlusPlus) ? generator.emitPostInc(generator.finalDestination(dst), value.get()) : generator.emitPostDec(generator.finalDestination(dst), value.get());
    523534    }
     535    generator.emitExpressionInfo(m_divot, m_startOffset, m_endOffset);
    524536    generator.emitPutByVal(base.get(), property.get(), value.get());
    525537    return oldValue;
    … …  
    531543{
    532544    RefPtr<RegisterID> base = generator.emitNode(m_base.get());
     545
     546    generator.emitExpressionInfo(m_divot - m_subexpressionDivotOffset, m_startOffset - m_subexpressionDivotOffset, m_subexpressionEndOffset);
    533547    RefPtr<RegisterID> value = generator.emitGetById(generator.newTemporary(), base.get(), m_ident);
    534548    RegisterID* oldValue;
    … …  
    542556        oldValue = (m_operator == OpPlusPlus) ? generator.emitPostInc(generator.finalDestination(dst), value.get()) : generator.emitPostDec(generator.finalDestination(dst), value.get());
    543557    }
     558    generator.emitExpressionInfo(m_divot, m_startOffset, m_endOffset);
    544559    generator.emitPutById(base.get(), m_ident, value.get());
    545560    return oldValue;
    … …  
    560575        return generator.emitLoad(generator.finalDestination(dst), false);
    561576
     577    generator.emitExpressionInfo(m_divot, m_startOffset, m_endOffset);
    562578    RegisterID* base = generator.emitResolveBase(generator.tempDestination(dst), m_ident);
    563579    return generator.emitDeleteById(generator.finalDestination(dst, base), base, m_ident);
    … …  
    570586    RefPtr<RegisterID> r0 = generator.emitNode(m_base.get());
    571587    RefPtr<RegisterID> r1 = generator.emitNode(m_subscript.get());
     588
     589    generator.emitExpressionInfo(m_divot, m_startOffset, m_endOffset);
    572590    return generator.emitDeleteByVal(generator.finalDestination(dst), r0.get(), r1.get());
    573591}
    … …  
    578596{
    579597    RegisterID* r0 = generator.emitNode(m_base.get());
     598
     599    generator.emitExpressionInfo(m_divot, m_startOffset, m_endOffset);
    580600    return generator.emitDeleteById(generator.finalDestination(dst), r0, m_ident);
    581601}
    … …  
    657677    }
    658678
     679    generator.emitExpressionInfo(m_divot, m_startOffset, m_endOffset);
    659680    RefPtr<RegisterID> propDst = generator.tempDestination(dst);
    660681    RefPtr<RegisterID> base = generator.emitResolveWithBase(generator.newTemporary(), propDst.get(), m_ident);
    … …  
    671692    RefPtr<RegisterID> property = generator.emitNode(m_subscript.get());
    672693    RefPtr<RegisterID> propDst = generator.tempDestination(dst);
     694
     695    generator.emitExpressionInfo(m_divot + m_subexpressionDivotOffset, m_subexpressionStartOffset, m_endOffset - m_subexpressionDivotOffset);
    673696    RegisterID* value = generator.emitGetByVal(propDst.get(), base.get(), property.get());
    674697    if (m_operator == OpPlusPlus)
    … …  
    676699    else
    677700        generator.emitPreDec(value);
     701    generator.emitExpressionInfo(m_divot, m_startOffset, m_endOffset);
    678702    generator.emitPutByVal(base.get(), property.get(), value);
    679703    return generator.moveToDestinationIfNeeded(dst, propDst.get());
    … …  
    686710    RefPtr<RegisterID> base = generator.emitNode(m_base.get());
    687711    RefPtr<RegisterID> propDst = generator.tempDestination(dst);
     712
     713    generator.emitExpressionInfo(m_divot + m_subexpressionDivotOffset, m_subexpressionStartOffset, m_endOffset - m_subexpressionDivotOffset);
    688714    RegisterID* value = generator.emitGetById(propDst.get(), base.get(), m_ident);
    689715    if (m_operator == OpPlusPlus)
    … …  
    691717    else
    692718        generator.emitPreDec(value);
     719    generator.emitExpressionInfo(m_divot, m_startOffset, m_endOffset);
    693720    generator.emitPutById(base.get(), m_ident, value);
    694721    return generator.moveToDestinationIfNeeded(dst, propDst.get());
    … …  
    724751    RegisterID* src2 = generator.emitNode(m_term2.get());
    725752    return generator.emitBinaryOp(opcode(), generator.finalDestination(dst, src1.get()), src2, src1.get());
     753}
     754
     755RegisterID* ThrowableBinaryOpNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     756{
     757    RefPtr<RegisterID> src1 = generator.emitNodeForLeftHandSide(m_term1.get(), m_rightHasAssignments, m_term2->isPure(generator));
     758    RegisterID* src2 = generator.emitNode(m_term2.get());
     759    generator.emitExpressionInfo(m_divot, m_startOffset, m_endOffset);
     760    return generator.emitBinaryOp(opcode(), generator.finalDestination(dst, src1.get()), src1.get(), src2);
    726761}
    727762
    … …  
    847882
    848883    RefPtr<RegisterID> src1 = generator.tempDestination(dst);
     884    generator.emitExpressionInfo(m_divot - m_startOffset + m_ident.size(), m_ident.size(), 0);
    849885    RefPtr<RegisterID> base = generator.emitResolveWithBase(generator.newTemporary(), src1.get(), m_ident);
    850886    RegisterID* src2 = generator.emitNode(m_right.get());
     887    generator.emitExpressionInfo(m_divot, m_startOffset, m_endOffset);
    851888    RegisterID* result = emitReadModifyAssignment(generator, generator.finalDestination(dst, src1.get()), src1.get(), src2, m_operator);
    852889    return generator.emitPutById(base.get(), m_ident, result);
    … …  
    879916        dst = 0;
    880917    RegisterID* value = generator.emitNode(dst, m_right.get());
     918    generator.emitExpressionInfo(m_divot, m_startOffset, m_endOffset);
    881919    return generator.emitPutById(base.get(), m_ident, value);
    882920}
    … …  
    889927    RefPtr<RegisterID> value = generator.destinationForAssignResult(dst);
    890928    RegisterID* result = generator.emitNode(value.get(), m_right.get());
     929    generator.emitExpressionInfo(m_divot, m_startOffset, m_endOffset);
    891930    generator.emitPutById(base.get(), m_ident, result);
    892931    return generator.moveToDestinationIfNeeded(dst, result);
    … …  
    898937{
    899938    RefPtr<RegisterID> base = generator.emitNodeForLeftHandSide(m_base.get(), m_rightHasAssignments, m_right->isPure(generator));
     939
     940    generator.emitExpressionInfo(m_divot - m_subexpressionDivotOffset, m_startOffset - m_subexpressionDivotOffset, m_subexpressionEndOffset);
    900941    RefPtr<RegisterID> value = generator.emitGetById(generator.tempDestination(dst), base.get(), m_ident);
    901942    RegisterID* change = generator.emitNode(m_right.get());
    902943    RegisterID* updatedValue = emitReadModifyAssignment(generator, generator.finalDestination(dst, value.get()), value.get(), change, m_operator);
     944
     945    generator.emitExpressionInfo(m_divot, m_startOffset, m_endOffset);
    903946    return generator.emitPutById(base.get(), m_ident, updatedValue);
    904947}
    … …  
    919962    RefPtr<RegisterID> value = generator.destinationForAssignResult(dst);
    920963    RegisterID* result = generator.emitNode(value.get(), m_right.get());
     964
     965    generator.emitExpressionInfo(m_divot, m_startOffset, m_endOffset);
    921966    generator.emitPutByVal(base.get(), property.get(), result);
    922967    return generator.moveToDestinationIfNeeded(dst, result);
    … …  
    928973    RefPtr<RegisterID> property = generator.emitNodeForLeftHandSide(m_subscript.get(), m_rightHasAssignments, m_right->isPure(generator));
    929974
     975    generator.emitExpressionInfo(m_divot - m_subexpressionDivotOffset, m_startOffset - m_subexpressionDivotOffset, m_subexpressionEndOffset);
    930976    RefPtr<RegisterID> value = generator.emitGetByVal(generator.tempDestination(dst), base.get(), property.get());
    931977    RegisterID* change = generator.emitNode(m_right.get());
    932978    RegisterID* updatedValue = emitReadModifyAssignment(generator, generator.finalDestination(dst, value.get()), value.get(), change, m_operator);
    933979
     980    generator.emitExpressionInfo(m_divot, m_startOffset, m_endOffset);
    934981    generator.emitPutByVal(base.get(), property.get(), updatedValue);
    935982
    … …  
    11971244}
    11981245
    1199 ForInNode::ForInNode(JSGlobalData* globalData, const Identifier& ident, ExpressionNode* in, ExpressionNode* expr, StatementNode* statement)
     1246ForInNode::ForInNode(JSGlobalData* globalData, const Identifier& ident, ExpressionNode* in, ExpressionNode* expr, StatementNode* statement, int divot, int startOffset, int endOffset)
    12001247    : StatementNode(globalData)
    12011248    , m_ident(ident)
    1202     , m_lexpr(new ResolveNode(globalData, ident))
     1249    , m_lexpr(new ResolveNode(globalData, ident, divot - startOffset))
    12031250    , m_expr(expr)
    12041251    , m_statement(statement)
    12051252    , m_identIsVarDecl(true)
    12061253{
    1207     if (in)
    1208         m_init = new AssignResolveNode(globalData, ident, in, true);
     1254    if (in) {
     1255        AssignResolveNode* node = new AssignResolveNode(globalData, ident, in, true);
     1256        node->setExceptionSourceRange(divot, divot - startOffset, endOffset - divot);
     1257        m_init = node;
     1258    }
    12091259    // for( var foo = bar in baz )
    12101260}
    … …  
    12301280            RefPtr<RegisterID> protect = propertyName;
    12311281            RegisterID* base = generator.emitResolveBase(generator.newTemporary(), ident);
     1282
     1283            generator.emitExpressionInfo(m_divot, m_startOffset, m_endOffset);
    12321284            generator.emitPutById(base, ident, propertyName);
    12331285        }
    … …  
    12381290        RefPtr<RegisterID> protect = propertyName;
    12391291        RegisterID* base = generator.emitNode(assignNode->base());
     1292
     1293        generator.emitExpressionInfo(assignNode->divot(), assignNode->startOffset(), assignNode->endOffset());
    12401294        generator.emitPutById(base, ident, propertyName);
    12411295    } else {
    … …  
    12461300        RefPtr<RegisterID> base = generator.emitNode(assignNode->base());
    12471301        RegisterID* subscript = generator.emitNode(assignNode->subscript());
     1302       
     1303        generator.emitExpressionInfo(assignNode->divot(), assignNode->startOffset(), assignNode->endOffset());
    12481304        generator.emitPutByVal(base.get(), subscript, propertyName);
    12491305    }   
    … …  
    13301386{
    13311387    RefPtr<RegisterID> scope = generator.emitNode(m_expr.get()); // scope must be protected until popped
     1388    generator.emitExpressionInfo(m_divot, m_expressionLength, 0);
    13321389    generator.emitPushScope(scope.get());
    13331390    RegisterID* result = generator.emitNode(dst, m_statement.get());
    … …  
    14101467    if (generator.jumpContextForBreak(m_label))
    14111468        return emitThrowError(generator, SyntaxError, "Duplicated label %s found.", m_label);
    1412    
     1469
    14131470    RefPtr<LabelID> l0 = generator.newLabel();
    14141471    m_labelStack.push(m_label);
    … …  
    14281485RegisterID* ThrowNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    14291486{
    1430     generator.emitThrow(generator.emitNode(dst, m_expr.get()));
     1487    RefPtr<RegisterID> expr = generator.emitNode(dst, m_expr.get());
     1488    generator.emitExpressionInfo(m_divot, m_startOffset, m_endOffset);
     1489    generator.emitThrow(expr.get());
    14311490    return dst;
    14321491}
    … …  
    15071566// ------------------------------ ProgramNode -----------------------------
    15081567
    1509 ProgramNode::ProgramNode(JSGlobalData* globalData, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, bool usesEval, bool needsClosure)
     1568ProgramNode::ProgramNode(JSGlobalData* globalData, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, SourceProvider* sourceProvider, bool usesEval, bool needsClosure)
    15101569    : ScopeNode(globalData, children, varStack, funcStack, usesEval, needsClosure)
    1511 {
    1512 }
    1513 
    1514 ProgramNode* ProgramNode::create(JSGlobalData* globalData, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, bool usesEval, bool needsClosure)
    1515 {
    1516     return new ProgramNode(globalData, children, varStack, funcStack, usesEval, needsClosure);
     1570    , m_sourceProvider(sourceProvider)
     1571{
     1572}
     1573
     1574ProgramNode* ProgramNode::create(JSGlobalData* globalData, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, SourceProvider* sourceProvider, bool usesEval, bool needsClosure)
     1575{
     1576    return new ProgramNode(globalData, children, varStack, funcStack, sourceProvider, usesEval, needsClosure);
    15171577}
    15181578
    15191579// ------------------------------ EvalNode -----------------------------
    15201580
    1521 EvalNode::EvalNode(JSGlobalData* globalData, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, bool usesEval, bool needsClosure)
     1581EvalNode::EvalNode(JSGlobalData* globalData, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, SourceProvider* sourceProvider, bool usesEval, bool needsClosure)
    15221582    : ScopeNode(globalData, children, varStack, funcStack, usesEval, needsClosure)
     1583    , m_sourceProvider(sourceProvider)
    15231584{
    15241585}
    … …  
    15431604
    15441605    SymbolTable symbolTable;
    1545 
    1546     m_code.set(new EvalCodeBlock(this, globalObject));
     1606    ASSERT(m_sourceProvider);
     1607    m_code.set(new EvalCodeBlock(this, globalObject, m_sourceProvider));
    15471608
    15481609    CodeGenerator generator(this, globalObject->debugger(), scopeChain, &symbolTable, m_code.get());
    … …  
    15501611}
    15511612
    1552 EvalNode* EvalNode::create(JSGlobalData* globalData, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, bool usesEval, bool needsClosure)
    1553 {
    1554     return new EvalNode(globalData, children, varStack, funcStack, usesEval, needsClosure);
     1613EvalNode* EvalNode::create(JSGlobalData* globalData, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, SourceProvider* sourceProvider, bool usesEval, bool needsClosure)
     1614{
     1615    return new EvalNode(globalData, children, varStack, funcStack, sourceProvider, usesEval, needsClosure);
    15551616}
    15561617
    … …  
    15731634}
    15741635
     1636FunctionBodyNode* FunctionBodyNode::create(JSGlobalData* globalData, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, SourceProvider*, bool usesEval, bool needsClosure)
     1637{
     1638    return new FunctionBodyNode(globalData, children, varStack, funcStack, usesEval, needsClosure);
     1639}
     1640
    15751641void FunctionBodyNode::generateCode(ScopeChainNode* sc)
    15761642{
    … …  
    15781644    JSGlobalObject* globalObject = scopeChain.globalObject();
    15791645
    1580     m_code.set(new CodeBlock(this, FunctionCode));
     1646    ASSERT(m_source.sourceProvider());
     1647    m_code.set(new CodeBlock(this, FunctionCode, m_source.sourceProvider(), m_source.startOffset()));
    15811648
    15821649    CodeGenerator generator(this, globalObject->debugger(), scopeChain, &m_symbolTable, m_code.get());
    … …  
    16141681    JSGlobalObject* globalObject = scopeChain.globalObject();
    16151682   
    1616     m_code.set(new ProgramCodeBlock(this, GlobalCode, globalObject));
     1683    ASSERT(m_sourceProvider);
     1684    m_code.set(new ProgramCodeBlock(this, GlobalCode, globalObject, m_sourceProvider));
    16171685   
    16181686    CodeGenerator generator(this, globalObject->debugger(), scopeChain, &globalObject->symbolTable(), m_code.get(), m_varStack, m_functionStack);

  • trunk/JavaScriptCore/kjs/nodes.h

    r35242 r35245  
    176176
    177177        UString toString() const KJS_FAST_CALL;
    178         int lineNo() const KJS_FAST_CALL { return m_line; }
     178        int lineNo() const { return m_line; }
    179179
    180180        virtual bool isReturnNode() const KJS_FAST_CALL { return false; }
    … …  
    187187    protected:
    188188        Node(JSGlobalData*, JSType) KJS_FAST_CALL; // used by ExpressionNode
    189 
    190         RegisterID* emitThrowError(CodeGenerator&, ErrorType, const char* msg);
    191         RegisterID* emitThrowError(CodeGenerator&, ErrorType, const char* msg, const Identifier&);
    192189
    193190        int m_line : 28;
    … …  
    319316        UString m_value;
    320317    };
    321 
    322     class RegExpNode : public ExpressionNode {
     318   
     319    class ThrowableExpressionData {
     320    public:
     321        ThrowableExpressionData()
     322            : m_divot(-1)
     323            , m_startOffset(-1)
     324            , m_endOffset(-1)
     325        {
     326        }
     327       
     328        ThrowableExpressionData(unsigned divot, unsigned startOffset, unsigned endOffset)
     329            : m_divot(divot)
     330            , m_startOffset(startOffset)
     331            , m_endOffset(endOffset)
     332        {
     333        }
     334       
     335        void setExceptionSourceRange(unsigned divot, unsigned startOffset, unsigned endOffset)
     336        {
     337            m_divot = divot;
     338            m_startOffset = startOffset;
     339            m_endOffset = endOffset;
     340        }
     341
     342        uint32_t divot() const { return m_divot; }
     343        uint16_t startOffset() const { return m_startOffset; }
     344        uint16_t endOffset() const { return m_endOffset; }
     345
     346    protected:
     347        RegisterID* emitThrowError(CodeGenerator&, ErrorType, const char* msg);
     348        RegisterID* emitThrowError(CodeGenerator&, ErrorType, const char* msg, const Identifier&);
     349        uint32_t m_divot;
     350        uint16_t m_startOffset;
     351        uint16_t m_endOffset;
     352    };
     353
     354    class ThrowableSubExpressionData : public ThrowableExpressionData {
     355    public:
     356        ThrowableSubExpressionData()
     357            : ThrowableExpressionData()
     358            , m_subexpressionDivotOffset(0)
     359            , m_subexpressionEndOffset(0)
     360        {
     361        }
     362
     363        ThrowableSubExpressionData(unsigned divot, unsigned startOffset, unsigned endOffset)
     364            : ThrowableExpressionData(divot, startOffset, endOffset)
     365            , m_subexpressionDivotOffset(0)
     366            , m_subexpressionEndOffset(0)
     367        {
     368        }
     369
     370        void setSubexpressionInfo(uint32_t subexpressionDivot, uint16_t subexpressionOffset) {
     371            ASSERT(subexpressionDivot <= m_divot);
     372            if ((m_divot - subexpressionDivot) & ~0xFFFF) // Overflow means we can't do this safely, so just point at the primary divot
     373                return;
     374            m_subexpressionDivotOffset = m_divot - subexpressionDivot;
     375            m_subexpressionEndOffset = subexpressionOffset;
     376        }
     377
     378    protected:
     379        uint16_t m_subexpressionDivotOffset;
     380        uint16_t m_subexpressionEndOffset;
     381    };
     382   
     383    class ThrowablePrefixedSubExpressionData : public ThrowableExpressionData {
     384    public:
     385        ThrowablePrefixedSubExpressionData()
     386            : ThrowableExpressionData()
     387            , m_subexpressionDivotOffset(0)
     388            , m_subexpressionStartOffset(0)
     389        {
     390        }
     391
     392        ThrowablePrefixedSubExpressionData(unsigned divot, unsigned startOffset, unsigned endOffset)
     393            : ThrowableExpressionData(divot, startOffset, endOffset)
     394            , m_subexpressionDivotOffset(0)
     395            , m_subexpressionStartOffset(0)
     396        {
     397        }
     398
     399        void setSubexpressionInfo(uint32_t subexpressionDivot, uint16_t subexpressionOffset) {
     400            ASSERT(subexpressionDivot >= m_divot);
     401            if ((subexpressionDivot - m_divot) & ~0xFFFF) // Overflow means we can't do this safely, so just point at the primary divot
     402                return;
     403            m_subexpressionDivotOffset = subexpressionDivot - m_divot;
     404            m_subexpressionStartOffset = subexpressionOffset;
     405        }
     406
     407    protected:
     408        uint16_t m_subexpressionDivotOffset;
     409        uint16_t m_subexpressionStartOffset;
     410    };
     411
     412    class RegExpNode : public ExpressionNode, public ThrowableExpressionData {
    323413    public:
    324414        RegExpNode(JSGlobalData* globalData, const UString& pattern, const UString& flags) KJS_FAST_CALL
    … …  
    352442    class ResolveNode : public ExpressionNode {
    353443    public:
    354         ResolveNode(JSGlobalData* globalData, const Identifier& ident) KJS_FAST_CALL
     444        ResolveNode(JSGlobalData* globalData, const Identifier& ident, int startOffset) KJS_FAST_CALL
    355445            : ExpressionNode(globalData)
    356446            , m_ident(ident)
     447            , m_startOffset(startOffset)
    357448        {
    358449        }
    … …  
    370461    protected:
    371462        Identifier m_ident;
    372         int m_index; // Used by LocalVarAccessNode and ScopedVarAccessNode.
    373         size_t m_scopeDepth; // Used by ScopedVarAccessNode
     463        int32_t m_startOffset;
     464       
    374465    };
    375466
    … …  
    514605        RefPtr<PropertyListNode> m_list;
    515606    };
    516 
    517     class BracketAccessorNode : public ExpressionNode {
     607   
     608    class BracketAccessorNode : public ExpressionNode, public ThrowableExpressionData {
    518609    public:
    519610        BracketAccessorNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, bool subscriptHasAssignments) KJS_FAST_CALL
    … …  
    541632    };
    542633
    543     class DotAccessorNode : public ExpressionNode {
     634    class DotAccessorNode : public ExpressionNode, public ThrowableExpressionData {
    544635    public:
    545636        DotAccessorNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL
    … …  
    608699    };
    609700
    610     class NewExprNode : public ExpressionNode {
     701    class NewExprNode : public ExpressionNode, public ThrowableExpressionData {
    611702    public:
    612703        NewExprNode(JSGlobalData* globalData, ExpressionNode* expr) KJS_FAST_CALL
    … …  
    633724    };
    634725
    635     class EvalFunctionCallNode : public ExpressionNode {
    636     public:
    637         EvalFunctionCallNode(JSGlobalData* globalData, ArgumentsNode* args) KJS_FAST_CALL
    638             : ExpressionNode(globalData)
     726    class EvalFunctionCallNode : public ExpressionNode, public ThrowableExpressionData {
     727    public:
     728        EvalFunctionCallNode(JSGlobalData* globalData, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset) KJS_FAST_CALL
     729            : ExpressionNode(globalData)
     730            , ThrowableExpressionData(divot, startOffset, endOffset)
    639731            , m_args(args)
    640732        {
    … …  
    649741    };
    650742
    651     class FunctionCallValueNode : public ExpressionNode {
    652     public:
    653         FunctionCallValueNode(JSGlobalData* globalData, ExpressionNode* expr, ArgumentsNode* args) KJS_FAST_CALL
    654             : ExpressionNode(globalData)
     743    class FunctionCallValueNode : public ExpressionNode, public ThrowableExpressionData {
     744    public:
     745        FunctionCallValueNode(JSGlobalData* globalData, ExpressionNode* expr, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset) KJS_FAST_CALL
     746            : ExpressionNode(globalData)
     747            , ThrowableExpressionData(divot, startOffset, endOffset)
    655748            , m_expr(expr)
    656749            , m_args(args)
    … …  
    667760    };
    668761
    669     class FunctionCallResolveNode : public ExpressionNode {
    670     public:
    671         FunctionCallResolveNode(JSGlobalData* globalData, const Identifier& ident, ArgumentsNode* args) KJS_FAST_CALL
    672             : ExpressionNode(globalData)
     762    class FunctionCallResolveNode : public ExpressionNode, public ThrowableExpressionData {
     763    public:
     764        FunctionCallResolveNode(JSGlobalData* globalData, const Identifier& ident, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset) KJS_FAST_CALL
     765            : ExpressionNode(globalData)
     766            , ThrowableExpressionData(divot, startOffset, endOffset)
    673767            , m_ident(ident)
    674768            , m_args(args)
    … …  
    688782    };
    689783   
    690     class FunctionCallBracketNode : public ExpressionNode {
    691     public:
    692         FunctionCallBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, ArgumentsNode* args) KJS_FAST_CALL
    693             : ExpressionNode(globalData)
     784    class FunctionCallBracketNode : public ExpressionNode, public ThrowableSubExpressionData {
     785    public:
     786        FunctionCallBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset) KJS_FAST_CALL
     787            : ExpressionNode(globalData)
     788            , ThrowableSubExpressionData(divot, startOffset, endOffset)
    694789            , m_base(base)
    695790            , m_subscript(subscript)
    … …  
    708803    };
    709804
    710     class FunctionCallDotNode : public ExpressionNode {
    711     public:
    712         FunctionCallDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, ArgumentsNode* args) KJS_FAST_CALL
    713             : ExpressionNode(globalData)
     805    class FunctionCallDotNode : public ExpressionNode, public ThrowableSubExpressionData {
     806    public:
     807        FunctionCallDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset) KJS_FAST_CALL
     808            : ExpressionNode(globalData)
     809            , ThrowableSubExpressionData(divot, startOffset, endOffset)
    714810            , m_base(base)
    715811            , m_ident(ident)
    … …  
    728824    };
    729825
    730     class PrePostResolveNode : public ExpressionNode {
    731     public:
    732         PrePostResolveNode(JSGlobalData* globalData, const Identifier& ident) KJS_FAST_CALL
     826    class PrePostResolveNode : public ExpressionNode, public ThrowableExpressionData {
     827    public:
     828        PrePostResolveNode(JSGlobalData* globalData, const Identifier& ident, unsigned divot, unsigned startOffset, unsigned endOffset) KJS_FAST_CALL
    733829            : ExpressionNode(globalData, NumberType)
     830            , ThrowableExpressionData(divot, startOffset, endOffset)
    734831            , m_ident(ident)
    735832        {
    … …  
    738835    protected:
    739836        Identifier m_ident;
    740         size_t m_index; // Used by LocalVarPostfixNode.
    741837    };
    742838
    743839    class PostfixResolveNode : public PrePostResolveNode {
    744840    public:
    745         PostfixResolveNode(JSGlobalData* globalData, const Identifier& ident, Operator oper) KJS_FAST_CALL
    746             : PrePostResolveNode(globalData, ident)
     841        PostfixResolveNode(JSGlobalData* globalData, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) KJS_FAST_CALL
     842            : PrePostResolveNode(globalData, ident, divot, startOffset, endOffset)
    747843            , m_operator(oper)
    748844        {
    … …  
    757853    };
    758854
    759     class PostfixBracketNode : public ExpressionNode {
    760     public:
    761         PostfixBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, Operator oper) KJS_FAST_CALL
    762             : ExpressionNode(globalData)
     855    class PostfixBracketNode : public ExpressionNode, public ThrowableSubExpressionData {
     856    public:
     857        PostfixBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) KJS_FAST_CALL
     858            : ExpressionNode(globalData)
     859            , ThrowableSubExpressionData(divot, startOffset, endOffset)
    763860            , m_base(base)
    764861            , m_subscript(subscript)
    … …  
    777874    };
    778875
    779     class PostfixDotNode : public ExpressionNode {
    780     public:
    781         PostfixDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, Operator oper) KJS_FAST_CALL
    782             : ExpressionNode(globalData)
     876    class PostfixDotNode : public ExpressionNode, public ThrowableSubExpressionData {
     877    public:
     878        PostfixDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) KJS_FAST_CALL
     879            : ExpressionNode(globalData)
     880            , ThrowableSubExpressionData(divot, startOffset, endOffset)
    783881            , m_base(base)
    784882            , m_ident(ident)
    … …  
    797895    };
    798896
    799     class PostfixErrorNode : public ExpressionNode {
    800     public:
    801         PostfixErrorNode(JSGlobalData* globalData, ExpressionNode* expr, Operator oper) KJS_FAST_CALL
    802             : ExpressionNode(globalData)
     897    class PostfixErrorNode : public ExpressionNode, public ThrowableSubExpressionData {
     898    public:
     899        PostfixErrorNode(JSGlobalData* globalData, ExpressionNode* expr, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) KJS_FAST_CALL
     900            : ExpressionNode(globalData)
     901            , ThrowableSubExpressionData(divot, startOffset, endOffset)
    803902            , m_expr(expr)
    804903            , m_operator(oper)
    … …  
    815914    };
    816915
    817     class DeleteResolveNode : public ExpressionNode {
    818     public:
    819         DeleteResolveNode(JSGlobalData* globalData, const Identifier& ident) KJS_FAST_CALL
    820             : ExpressionNode(globalData)
     916    class DeleteResolveNode : public ExpressionNode, public ThrowableExpressionData {
     917    public:
     918        DeleteResolveNode(JSGlobalData* globalData, const Identifier& ident, unsigned divot, unsigned startOffset, unsigned endOffset) KJS_FAST_CALL
     919            : ExpressionNode(globalData)
     920            , ThrowableExpressionData(divot, startOffset, endOffset)
    821921            , m_ident(ident)
    822922        {
    … …  
    832932    };
    833933
    834     class DeleteBracketNode : public ExpressionNode {
    835     public:
    836         DeleteBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
    837             : ExpressionNode(globalData)
     934    class DeleteBracketNode : public ExpressionNode, public ThrowableExpressionData {
     935    public:
     936        DeleteBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, unsigned divot, unsigned startOffset, unsigned endOffset) KJS_FAST_CALL
     937            : ExpressionNode(globalData)
     938            , ThrowableExpressionData(divot, startOffset, endOffset)
    838939            , m_base(base)
    839940            , m_subscript(subscript)
    … …  
    851952    };
    852953
    853     class DeleteDotNode : public ExpressionNode {
    854     public:
    855         DeleteDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL
    856             : ExpressionNode(globalData)
     954    class DeleteDotNode : public ExpressionNode, public ThrowableExpressionData {
     955    public:
     956        DeleteDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, unsigned divot, unsigned startOffset, unsigned endOffset) KJS_FAST_CALL
     957            : ExpressionNode(globalData)
     958            , ThrowableExpressionData(divot, startOffset, endOffset)
    857959            , m_base(base)
    858960            , m_ident(ident)
    … …  
    9431045    class PrefixResolveNode : public PrePostResolveNode {
    9441046    public:
    945         PrefixResolveNode(JSGlobalData* globalData, const Identifier& ident, Operator oper) KJS_FAST_CALL
    946             : PrePostResolveNode(globalData, ident)
     1047        PrefixResolveNode(JSGlobalData* globalData, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) KJS_FAST_CALL
     1048            : PrePostResolveNode(globalData, ident, divot, startOffset, endOffset)
    9471049            , m_operator(oper)
    9481050        {
    … …  
    9581060    };
    9591061
    960     class PrefixBracketNode : public ExpressionNode {
    961     public:
    962         PrefixBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, Operator oper) KJS_FAST_CALL
    963             : ExpressionNode(globalData)
     1062    class PrefixBracketNode : public ExpressionNode, public ThrowablePrefixedSubExpressionData {
     1063    public:
     1064        PrefixBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) KJS_FAST_CALL
     1065            : ExpressionNode(globalData)
     1066            , ThrowablePrefixedSubExpressionData(divot, startOffset, endOffset)
    9641067            , m_base(base)
    9651068            , m_subscript(subscript)
    … …  
    9781081    };
    9791082
    980     class PrefixDotNode : public ExpressionNode {
    981     public:
    982         PrefixDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, Operator oper) KJS_FAST_CALL
    983             : ExpressionNode(globalData)
     1083    class PrefixDotNode : public ExpressionNode, public ThrowablePrefixedSubExpressionData {
     1084    public:
     1085        PrefixDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) KJS_FAST_CALL
     1086            : ExpressionNode(globalData)
     1087            , ThrowablePrefixedSubExpressionData(divot, startOffset, endOffset)
    9841088            , m_base(base)
    9851089            , m_ident(ident)
    … …  
    9981102    };
    9991103
    1000     class PrefixErrorNode : public ExpressionNode {
    1001     public:
    1002         PrefixErrorNode(JSGlobalData* globalData, ExpressionNode* expr, Operator oper) KJS_FAST_CALL
    1003             : ExpressionNode(globalData)
     1104    class PrefixErrorNode : public ExpressionNode, public ThrowableExpressionData {
     1105    public:
     1106        PrefixErrorNode(JSGlobalData* globalData, ExpressionNode* expr, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) KJS_FAST_CALL
     1107            : ExpressionNode(globalData)
     1108            , ThrowableExpressionData(divot, startOffset, endOffset)
    10041109            , m_expr(expr)
    10051110            , m_operator(oper)
    … …  
    12831388    };
    12841389
    1285     class InstanceOfNode : public BinaryOpNode {
     1390    class ThrowableBinaryOpNode : public BinaryOpNode, public ThrowableExpressionData {
     1391    public:
     1392        ThrowableBinaryOpNode(JSGlobalData* globalData, JSType type, ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments) KJS_FAST_CALL
     1393            : BinaryOpNode(globalData, type, term1, term2, rightHasAssignments)
     1394        {
     1395        }
     1396        ThrowableBinaryOpNode(JSGlobalData* globalData, ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments) KJS_FAST_CALL
     1397            : BinaryOpNode(globalData, term1, term2, rightHasAssignments)
     1398        {
     1399        }
     1400        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
     1401    };
     1402   
     1403    class InstanceOfNode : public ThrowableBinaryOpNode {
    12861404    public:
    12871405        InstanceOfNode(JSGlobalData* globalData, ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments) KJS_FAST_CALL
    1288             : BinaryOpNode(globalData, BooleanType, term1, term2, rightHasAssignments)
     1406            : ThrowableBinaryOpNode(globalData, BooleanType, term1, term2, rightHasAssignments)
    12891407        {
    12901408        }
    … …  
    12951413    };
    12961414
    1297     class InNode : public BinaryOpNode {
     1415    class InNode : public ThrowableBinaryOpNode {
    12981416    public:
    12991417        InNode(JSGlobalData* globalData, ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments) KJS_FAST_CALL
    1300             : BinaryOpNode(globalData, term1, term2, rightHasAssignments)
     1418            : ThrowableBinaryOpNode(globalData, term1, term2, rightHasAssignments)
    13011419        {
    13021420        }
    … …  
    14371555    };
    14381556
    1439     class ReadModifyResolveNode : public ExpressionNode {
    1440     public:
    1441         ReadModifyResolveNode(JSGlobalData* globalData, const Identifier& ident, Operator oper, ExpressionNode*  right, bool rightHasAssignments) KJS_FAST_CALL
    1442             : ExpressionNode(globalData)
     1557    class ReadModifyResolveNode : public ExpressionNode, public ThrowableExpressionData {
     1558    public:
     1559        ReadModifyResolveNode(JSGlobalData* globalData, const Identifier& ident, Operator oper, ExpressionNode*  right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset) KJS_FAST_CALL
     1560            : ExpressionNode(globalData)
     1561            , ThrowableExpressionData(divot, startOffset, endOffset)
    14431562            , m_ident(ident)
    14441563            , m_right(right)
    … …  
    14611580    };
    14621581
    1463     class AssignResolveNode : public ExpressionNode {
     1582    class AssignResolveNode : public ExpressionNode, public ThrowableExpressionData {
    14641583    public:
    14651584        AssignResolveNode(JSGlobalData* globalData, const Identifier& ident, ExpressionNode* right, bool rightHasAssignments) KJS_FAST_CALL
    … …  
    14831602    };
    14841603
    1485     class ReadModifyBracketNode : public ExpressionNode {
    1486     public:
    1487         ReadModifyBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, Operator oper, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments) KJS_FAST_CALL
    1488             : ExpressionNode(globalData)
     1604    class ReadModifyBracketNode : public ExpressionNode, public ThrowableSubExpressionData {
     1605    public:
     1606        ReadModifyBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, Operator oper, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset) KJS_FAST_CALL
     1607            : ExpressionNode(globalData)
     1608            , ThrowableSubExpressionData(divot, startOffset, endOffset)
    14891609            , m_base(base)
    14901610            , m_subscript(subscript)
    … …  
    15101630    };
    15111631
    1512     class AssignBracketNode : public ExpressionNode {
    1513     public:
    1514         AssignBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments) KJS_FAST_CALL
    1515             : ExpressionNode(globalData)
     1632    class AssignBracketNode : public ExpressionNode, public ThrowableExpressionData {
     1633    public:
     1634        AssignBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset) KJS_FAST_CALL
     1635            : ExpressionNode(globalData)
     1636            , ThrowableExpressionData(divot, startOffset, endOffset)
    15161637            , m_base(base)
    15171638            , m_subscript(subscript)
    … …  
    15351656    };
    15361657
    1537     class AssignDotNode : public ExpressionNode {
    1538     public:
    1539         AssignDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, ExpressionNode* right, bool rightHasAssignments) KJS_FAST_CALL
    1540             : ExpressionNode(globalData)
     1658    class AssignDotNode : public ExpressionNode, public ThrowableExpressionData {
     1659    public:
     1660        AssignDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset) KJS_FAST_CALL
     1661            : ExpressionNode(globalData)
     1662            , ThrowableExpressionData(divot, startOffset, endOffset)
    15411663            , m_base(base)
    15421664            , m_ident(ident)
    … …  
    15571679    };
    15581680
    1559     class ReadModifyDotNode : public ExpressionNode {
    1560     public:
    1561         ReadModifyDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, Operator oper, ExpressionNode* right, bool rightHasAssignments) KJS_FAST_CALL
    1562             : ExpressionNode(globalData)
     1681    class ReadModifyDotNode : public ExpressionNode, public ThrowableSubExpressionData {
     1682    public:
     1683        ReadModifyDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, Operator oper, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset) KJS_FAST_CALL
     1684            : ExpressionNode(globalData)
     1685            , ThrowableSubExpressionData(divot, startOffset, endOffset)
    15631686            , m_base(base)
    15641687            , m_ident(ident)
    … …  
    15821705    };
    15831706
    1584     class AssignErrorNode : public ExpressionNode {
    1585     public:
    1586         AssignErrorNode(JSGlobalData* globalData, ExpressionNode* left, Operator oper, ExpressionNode* right) KJS_FAST_CALL
    1587             : ExpressionNode(globalData)
     1707    class AssignErrorNode : public ExpressionNode, public ThrowableExpressionData {
     1708    public:
     1709        AssignErrorNode(JSGlobalData* globalData, ExpressionNode* left, Operator oper, ExpressionNode* right, unsigned divot, unsigned startOffset, unsigned endOffset) KJS_FAST_CALL
     1710            : ExpressionNode(globalData)
     1711            , ThrowableExpressionData(divot, startOffset, endOffset)
    15881712            , m_left(left)
    15891713            , m_operator(oper)
    … …  
    18371961    };
    18381962
    1839     class ForInNode : public StatementNode {
     1963    class ForInNode : public StatementNode, public ThrowableExpressionData {
    18401964    public:
    18411965        ForInNode(JSGlobalData*, ExpressionNode*, ExpressionNode*, StatementNode*) KJS_FAST_CALL;
    1842         ForInNode(JSGlobalData*, const Identifier&, ExpressionNode*, ExpressionNode*, StatementNode*) KJS_FAST_CALL;
     1966        ForInNode(JSGlobalData*, const Identifier&, ExpressionNode*, ExpressionNode*, StatementNode*, int divot, int startOffset, int endOffset) KJS_FAST_CALL;
    18431967       
    18441968        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
    … …  
    18541978    };
    18551979
    1856     class ContinueNode : public StatementNode {
     1980    class ContinueNode : public StatementNode, public ThrowableExpressionData {
    18571981    public:
    18581982        ContinueNode(JSGlobalData* globalData) KJS_FAST_CALL
    … …  
    18741998    };
    18751999
    1876     class BreakNode : public StatementNode {
     2000    class BreakNode : public StatementNode, public ThrowableExpressionData {
    18772001    public:
    18782002        BreakNode(JSGlobalData* globalData) KJS_FAST_CALL
    … …  
    18942018    };
    18952019
    1896     class ReturnNode : public StatementNode {
     2020    class ReturnNode : public StatementNode, public ThrowableExpressionData {
    18972021    public:
    18982022        ReturnNode(JSGlobalData* globalData, ExpressionNode* value) KJS_FAST_CALL
    … …  
    19122036    class WithNode : public StatementNode {
    19132037    public:
    1914         WithNode(JSGlobalData* globalData, ExpressionNode* expr, StatementNode* statement) KJS_FAST_CALL
     2038        WithNode(JSGlobalData* globalData, ExpressionNode* expr, StatementNode* statement, uint32_t divot, uint32_t expressionLength) KJS_FAST_CALL
    19152039            : StatementNode(globalData)
    19162040            , m_expr(expr)
    19172041            , m_statement(statement)
     2042            , m_divot(divot)
     2043            , m_expressionLength(expressionLength)
    19182044        {
    19192045        }
    … …  
    19252051        RefPtr<ExpressionNode> m_expr;
    19262052        RefPtr<StatementNode> m_statement;
    1927     };
    1928 
    1929     class LabelNode : public StatementNode {
     2053        uint32_t m_divot;
     2054        uint32_t m_expressionLength;
     2055    };
     2056
     2057    class LabelNode : public StatementNode, public ThrowableExpressionData {
    19302058    public:
    19312059        LabelNode(JSGlobalData* globalData, const Identifier& label, StatementNode* statement) KJS_FAST_CALL
    … …  
    19452073    };
    19462074
    1947     class ThrowNode : public StatementNode {
     2075    class ThrowNode : public StatementNode, public ThrowableExpressionData {
    19482076    public:
    19492077        ThrowNode(JSGlobalData* globalData, ExpressionNode* expr) KJS_FAST_CALL
    … …  
    20232151        VarStack& varStack() { return m_varStack; }
    20242152        FunctionStack& functionStack() { return m_functionStack; }
    2025        
     2153
    20262154    protected:
    20272155        VarStack m_varStack;
    … …  
    20372165    class ProgramNode : public ScopeNode {
    20382166    public:
    2039         static ProgramNode* create(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, bool usesEval, bool needsClosure) KJS_FAST_CALL;
     2167        static ProgramNode* create(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, SourceProvider*, bool usesEval, bool needsClosure) KJS_FAST_CALL;
    20402168
    20412169        ProgramCodeBlock& byteCode(ScopeChainNode* scopeChain) KJS_FAST_CALL
    … …  
    20472175
    20482176    private:
    2049         ProgramNode(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, bool usesEval, bool needsClosure) KJS_FAST_CALL;
     2177        ProgramNode(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, SourceProvider*, bool usesEval, bool needsClosure) KJS_FAST_CALL;
    20502178
    20512179        void generateCode(ScopeChainNode*) KJS_FAST_CALL;
    … …  
    20552183        Vector<size_t> m_functionIndexes; // Storage indexes belonging to the nodes in m_functionStack. (Recorded to avoid double lookup.)
    20562184
     2185        RefPtr<SourceProvider> m_sourceProvider;
     2186
    20572187        OwnPtr<ProgramCodeBlock> m_code;
    20582188    };
    … …  
    20602190    class EvalNode : public ScopeNode {
    20612191    public:
    2062         static EvalNode* create(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, bool usesEval, bool needsClosure) KJS_FAST_CALL;
     2192        static EvalNode* create(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, SourceProvider*, bool usesEval, bool needsClosure) KJS_FAST_CALL;
    20632193
    20642194        EvalCodeBlock& byteCode(ScopeChainNode* scopeChain) KJS_FAST_CALL
    … …  
    20702200
    20712201    private:
    2072         EvalNode(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, bool usesEval, bool needsClosure) KJS_FAST_CALL;
     2202        EvalNode(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, SourceProvider*, bool usesEval, bool needsClosure) KJS_FAST_CALL;
    20732203
    20742204        void generateCode(ScopeChainNode*) KJS_FAST_CALL;
    20752205        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
     2206       
     2207        RefPtr<SourceProvider> m_sourceProvider;
    20762208
    20772209        OwnPtr<EvalCodeBlock> m_code;
    … …  
    20802212    class FunctionBodyNode : public ScopeNode {
    20812213    public:
     2214        static FunctionBodyNode* create(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, SourceProvider*, bool usesEval, bool needsClosure) KJS_FAST_CALL;
    20822215        static FunctionBodyNode* create(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, bool usesEval, bool needsClosure) KJS_FAST_CALL;
    20832216
    … …  
    21072240        void setSource(const SourceRange& source) { m_source = source; }
    21082241        UString toSourceString() const KJS_FAST_CALL { return UString("{") + m_source.toString() + UString("}"); }
    2109 
    21102242    protected:
    21112243        FunctionBodyNode(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, bool usesEval, bool needsClosure) KJS_FAST_CALL;

  • trunk/LayoutTests/ChangeLog

    r35244 r35245  
     12008-07-18  Oliver Hunt  <oliver@apple.com>
     2
     3        Reviewed by Cameron Zwarich.
     4
     5        Update layout tests for new exception text, and add additional test covering the
     6        expression ranges provided.
     7
     8        * fast/css/resources/font-face-descriptor-multiple-values-parsing.js:
     9        * fast/dom/SelectorAPI/dumpNodeList-expected.txt:
     10        * fast/forms/select-namedItem-expected.txt:
     11        * fast/js/exception-expression-offset.html: Added.
     12        * fast/js/resources/exception-expression-offset.js: Added.
     13          New test covering the offset positions given for exceptions
     14        * fast/xsl/transform-xhr-doc-expected.txt:
     15        * http/tests/security/aboutBlank/xss-DENIED-navigate-opener-document-write-expected.txt:
     16        * http/tests/security/aboutBlank/xss-DENIED-navigate-opener-javascript-url-expected.txt:
     17        * http/tests/security/aboutBlank/xss-DENIED-set-opener-expected.txt:
     18        * http/tests/security/cross-frame-access-call.html:
     19        * platform/mac/fast/events/updateLayoutForHitTest-expected.txt:
     20        * platform/mac/svg/custom/createelement-expected.txt:
     21        * platform/mac/tables/mozilla/bugs/bug53690-1-expected.txt:
     22        * platform/mac/tables/mozilla_expected_failures/bugs/bug92868_1-expected.txt:
     23
    1242008-07-18  Adele Peterson & Maxime Britto  <britto@apple.com>
    225

  • trunk/LayoutTests/fast/css/resources/font-face-descriptor-multiple-values-parsing.js

    r34880 r35245  
    1717shouldBe('test("font-weight", "bold, normal")', '"bold, normal"');
    1818shouldBe('test("font-weight", "100, 200, 300, 400, 500, 600, 700, 100")', '"100, 200, 300, 400, 500, 600, 700, 100"');
    19 shouldThrow('test("font-weight", "all, 100")', '"TypeError: Null value"');
    20 shouldThrow('test("font-weight", "bold, normal, all")', '"TypeError: Null value"');
    21 shouldThrow('test("font-weight", "")', '"TypeError: Null value"');
     19shouldThrow('test("font-weight", "all, 100")', '"TypeError: Result of expression \'style.sheet.rules[0].style.getPropertyCSSValue(property)\' [null] is not an object."');
     20shouldThrow('test("font-weight", "bold, normal, all")', '"TypeError: Result of expression \'style.sheet.rules[0].style.getPropertyCSSValue(property)\' [null] is not an object."');
     21shouldThrow('test("font-weight", "")', '"TypeError: Result of expression \'style.sheet.rules[0].style.getPropertyCSSValue(property)\' [null] is not an object."');
    2222
    2323shouldBe('test("font-style", "normal")', '"normal"');
    … …  
    2525shouldBe('test("font-style", "normal, oblique")', '"normal, oblique"');
    2626shouldBe('test("font-style", "all")', '"all"');
    27 shouldThrow('test("font-style", "all, normal")', '"TypeError: Null value"');
    28 shouldThrow('test("font-style", "italic, all")', '"TypeError: Null value"');
    29 shouldThrow('test("font-style", "")', '"TypeError: Null value"');
     27shouldThrow('test("font-style", "all, normal")', '"TypeError: Result of expression \'style.sheet.rules[0].style.getPropertyCSSValue(property)\' [null] is not an object."');
     28shouldThrow('test("font-style", "italic, all")', '"TypeError: Result of expression \'style.sheet.rules[0].style.getPropertyCSSValue(property)\' [null] is not an object."');
     29shouldThrow('test("font-style", "")', '"TypeError: Result of expression \'style.sheet.rules[0].style.getPropertyCSSValue(property)\' [null] is not an object."');
    3030
    3131shouldBe('test("font-variant", "normal")', '"normal"');
    … …  
    3333shouldBe('test("font-variant", "normal, small-caps")', '"normal, small-caps"');
    3434shouldBe('test("font-variant", "all")', '"all"');
    35 shouldThrow('test("font-variant", "all, normal")', '"TypeError: Null value"');
    36 shouldThrow('test("font-variant", "small-caps, all")', '"TypeError: Null value"');
    37 shouldThrow('test("font-variant", "")', '"TypeError: Null value"');
     35shouldThrow('test("font-variant", "all, normal")', '"TypeError: Result of expression \'style.sheet.rules[0].style.getPropertyCSSValue(property)\' [null] is not an object."');
     36shouldThrow('test("font-variant", "small-caps, all")', '"TypeError: Result of expression \'style.sheet.rules[0].style.getPropertyCSSValue(property)\' [null] is not an object."');
     37shouldThrow('test("font-variant", "")', '"TypeError: Result of expression \'style.sheet.rules[0].style.getPropertyCSSValue(property)\' [null] is not an object."');
    3838
    3939var successfullyParsed = true;

  • trunk/LayoutTests/fast/dom/SelectorAPI/dumpNodeList-expected.txt

    r35108 r35245  
    4747Document.querySelector
    4848
    49 TypeError: Null value
    50 TypeError: Null value
     49TypeError: Result of expression 'node.querySelector(selectorString)' [null] is not an object.
     50TypeError: Result of expression 'node.querySelector(selectorString)' [null] is not an object.
    5151[object HTMLDivElement]
    5252[object HTMLDivElement]
    … …  
    5959Element.querySelector
    6060
    61 TypeError: Null value
    62 TypeError: Null value
    63 TypeError: Null value
     61TypeError: Result of expression 'node.querySelector(selectorString)' [null] is not an object.
     62TypeError: Result of expression 'node.querySelector(selectorString)' [null] is not an object.
     63TypeError: Result of expression 'node.querySelector(selectorString)' [null] is not an object.
    6464[object HTMLDivElement]
    6565[object HTMLDivElement]
    … …  
    7272DocumentFragment.querySelector
    7373
    74 TypeError: Null value
    75 TypeError: Null value
    76 TypeError: Null value
     74TypeError: Result of expression 'node.querySelector(selectorString)' [null] is not an object.
     75TypeError: Result of expression 'node.querySelector(selectorString)' [null] is not an object.
     76TypeError: Result of expression 'node.querySelector(selectorString)' [null] is not an object.
    7777[object HTMLDivElement]
    7878[object HTMLDivElement]

  • trunk/LayoutTests/fast/forms/select-namedItem-expected.txt

    r25617 r35245  
    55FOUND ITEM: 1
    66FOUND ITEM: 1
    7 ERROR: Null value
     7ERROR: Result of expression 'item' [null] is not an object.
    88

  • trunk/LayoutTests/fast/xsl/transform-xhr-doc-expected.txt

    r21687 r35245  
    1 CONSOLE MESSAGE: line 20: Undefined value
     1CONSOLE MESSAGE: line 20: Result of expression 'doc' [undefined] is not an object.
    22Test for bug 10313: xsl:import doesn't work in stylesheets loaded via XMLHttpRequest.
    33

  • trunk/LayoutTests/http/tests/security/aboutBlank/xss-DENIED-navigate-opener-document-write-expected.txt

    r29266 r35245  
    11CONSOLE MESSAGE: line 1: Unsafe JavaScript attempt to access frame with URL http://localhost:8000/security/resources/innocent-victim-with-notify.html from frame with URL about:blank. Domains, protocols and ports must match.
    22
    3 CONSOLE MESSAGE: line 1: Undefined value
     3CONSOLE MESSAGE: line 1: Result of expression 'target.document' [undefined] is not an object.
    44This page opens a window to "", injects malicious code, and then navigates its opener to the victim. The opened window then tries to scripts its opener after document.writeing a new document.
    55Code injected into window:

  • trunk/LayoutTests/http/tests/security/aboutBlank/xss-DENIED-navigate-opener-javascript-url-expected.txt

    r34506 r35245  
    11CONSOLE MESSAGE: line 1: Unsafe JavaScript attempt to access frame with URL http://localhost:8000/security/resources/innocent-victim-with-notify.html from frame with URL http://127.0.0.1:8000/security/aboutBlank/xss-DENIED-navigate-opener-javascript-url.html. Domains, protocols and ports must match.
    22
    3 CONSOLE MESSAGE: line 1: Undefined value
     3CONSOLE MESSAGE: line 1: Result of expression 'target.document' [undefined] is not an object.
    44This page opens a window to "", injects malicious code, and then navigates its opener to the victim. The opened window then tries to scripts its opener after reloading itself as a javascript URL.
    55Code injected into window:

  • trunk/LayoutTests/http/tests/security/aboutBlank/xss-DENIED-set-opener-expected.txt

    r30634 r35245  
    33CONSOLE MESSAGE: line 1: Unsafe JavaScript attempt to access frame with URL http://localhost:8000/security/resources/innocent-victim.html from frame with URL about:blank. Domains, protocols and ports must match.
    44
    5 CONSOLE MESSAGE: line 1: Undefined value
     5CONSOLE MESSAGE: line 1: Result of expression 'target.document' [undefined] is not an object.
    66This page opens a window to "", injects malicious code, and then uses window.open.call to set its opener to the victim. The opened window then tries to scripts its opener.
    77Code injected into window:

  • trunk/LayoutTests/http/tests/security/cross-frame-access-call.html

    r34447 r35245  
    5757
    5858    // Throws a TypeError and logs to the error console
    59     shouldBe("window.showModalDialog.call(targetWindow);", "'TypeError: Undefined value'");
     59    shouldBe("window.showModalDialog.call(targetWindow);", "'Result of expression 'window.showModalDialog' [undefined] is not an object.'");
    6060
    6161    // - Tests for the Location object -

  • trunk/LayoutTests/platform/mac/fast/events/updateLayoutForHitTest-expected.txt

    r30635 r35245  
    1 CONSOLE MESSAGE: line 36: Null value
    2 CONSOLE MESSAGE: line 40: Null value
    3 CONSOLE MESSAGE: line 36: Null value
    4 CONSOLE MESSAGE: line 40: Null value
     1CONSOLE MESSAGE: line 36: Result of expression 'triangleSpan.nextSibling.nextSibling.nextSibling.nextSibling' [null] is not an object.
     2CONSOLE MESSAGE: line 40: Result of expression 'triangleSpan.nextSibling.nextSibling.nextSibling.nextSibling' [null] is not an object.
     3CONSOLE MESSAGE: line 36: Result of expression 'triangleSpan.nextSibling.nextSibling.nextSibling.nextSibling' [null] is not an object.
     4CONSOLE MESSAGE: line 40: Result of expression 'triangleSpan.nextSibling.nextSibling.nextSibling.nextSibling' [null] is not an object.
    55layer at (0,0) size 800x600
    66  RenderView at (0,0) size 800x600

  • trunk/LayoutTests/platform/mac/svg/custom/createelement-expected.txt

    r34117 r35245  
    1 CONSOLE MESSAGE: line 13: TypeError: Null value
     1CONSOLE MESSAGE: line 13: TypeError: Result of expression 'green' [null] is not an object.
    22layer at (0,0) size 800x600
    33  RenderView at (0,0) size 800x600

  • trunk/LayoutTests/platform/mac/tables/mozilla/bugs/bug53690-1-expected.txt

    r30635 r35245  
    1 CONSOLE MESSAGE: line 4: TypeError: Undefined value
     1CONSOLE MESSAGE: line 4: TypeError: Result of expression 'document.forms[1]' [undefined] is not an object.
    22layer at (0,0) size 800x600
    33  RenderView at (0,0) size 800x600

  • trunk/LayoutTests/platform/mac/tables/mozilla_expected_failures/bugs/bug92868_1-expected.txt

    r30635 r35245  
    1 CONSOLE MESSAGE: line 14: Undefined value
     1CONSOLE MESSAGE: line 14: Result of expression 'document.styleSheets[1].disabled =' [undefined] is not an object.
    22layer at (0,0) size 800x600
    33  RenderView at (0,0) size 800x600
Note: See TracChangeset for help on using the changeset viewer.