git.saurik.com Git - apple/javascriptcore.git/blob

1 /*

4 *

5 * This library is free software; you can redistribute it and/or

6 * modify it under the terms of the GNU Lesser General Public

7 * License as published by the Free Software Foundation; either

8 * version 2 of the License, or (at your option) any later version.

9 *

10 * This library is distributed in the hope that it will be useful,

11 * but WITHOUT ANY WARRANTY; without even the implied warranty of

12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

13 * Lesser General Public License for more details.

14 *

15 * You should have received a copy of the GNU Lesser General Public

16 * License along with this library; if not, write to the Free Software

17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

18 *

19 */

21 #include "config.h"

22 #include "ErrorInstance.h"

24 #include "JSScope.h"

25 #include "JSCInlines.h"

26 #include "JSGlobalObjectFunctions.h"

27 #include <wtf/Vector.h>

29 namespace JSC {

31 STATIC_ASSERT_IS_TRIVIALLY_DESTRUCTIBLE(ErrorInstance);

 const ClassInfo ErrorInstance::s_info = { "Error", &JSNonFinalObject::s_info, 0, CREATE_METHOD_TABLE(ErrorInstance) };

 ErrorInstance::ErrorInstance(VM& vm, Structure* structure)

     : JSNonFinalObject(vm, structure)

37 {

38 }

 static void appendSourceToError(CallFrame* callFrame, ErrorInstance* exception, unsigned bytecodeOffset)

41 {

     ErrorInstance::SourceAppender appender = exception->sourceAppender();

43 exception->clearSourceAppender();

44 RuntimeType type = exception->runtimeTypeForCause();

45 exception->clearRuntimeTypeForCause();

     if (!callFrame->codeBlock()->hasExpressionInfo())

48 return;

50 int startOffset = 0;

51 int endOffset = 0;

52 int divotPoint = 0;

53 unsigned line = 0;

54 unsigned column = 0;

     CodeBlock* codeBlock = callFrame->codeBlock();

     codeBlock->expressionRangeForBytecodeOffset(bytecodeOffset, divotPoint, startOffset, endOffset, line, column);

59 int expressionStart = divotPoint - startOffset;

60 int expressionStop = divotPoint + endOffset;

     const String& sourceString = codeBlock->source()->source();

     if (!expressionStop || expressionStart > static_cast<int>(sourceString.length()))

64 return;

     VM* vm = &callFrame->vm();

     JSValue jsMessage = exception->getDirect(*vm, vm->propertyNames->message);

     if (!jsMessage || !jsMessage.isString())

69 return;

     String message = asString(jsMessage)->value(callFrame);

72 if (expressionStart < expressionStop)

         message = appender(message, codeBlock->source()->getRange(expressionStart, expressionStop) , type, ErrorInstance::FoundExactSource);

74 else {

75 // No range information, so give a few characters of context.

         const StringImpl* data = sourceString.impl();

         int dataLength = sourceString.length();

78 int start = expressionStart;

79 int stop = expressionStart;

80 // Get up to 20 characters of context to the left and right of the divot, clamping to the line.

81 // Then strip whitespace.

         while (start > 0 && (expressionStart - start < 20) && (*data)[start - 1] != '\n')

83 start--;

         while (start < (expressionStart - 1) && isStrWhiteSpace((*data)[start]))

85 start++;

         while (stop < dataLength && (stop - expressionStart < 20) && (*data)[stop] != '\n')

87 stop++;

         while (stop > expressionStart && isStrWhiteSpace((*data)[stop - 1]))

89 stop--;

         message = appender(message, codeBlock->source()->getRange(start, stop), type, ErrorInstance::FoundApproximateSource);

91 }

     exception->putDirect(*vm, vm->propertyNames->message, jsString(vm, message));

94 }

96 class FindFirstCallerFrameWithCodeblockFunctor {

97 public:

98 FindFirstCallerFrameWithCodeblockFunctor(CallFrame* startCallFrame)

99 : m_startCallFrame(startCallFrame)

         , m_foundCallFrame(nullptr)

         , m_foundStartCallFrame(false)

         , m_index(0)

103 { }

104

     StackVisitor::Status operator()(StackVisitor& visitor)

106 {

         if (!m_foundStartCallFrame && (visitor->callFrame() == m_startCallFrame))

108 m_foundStartCallFrame = true;

109

110 if (m_foundStartCallFrame) {

             if (visitor->callFrame()->codeBlock()) {

112 m_foundCallFrame = visitor->callFrame();

113 return StackVisitor::Done;

114 }

115 m_index++;

116 }

117

118 return StackVisitor::Continue;

119 }

120

     CallFrame* foundCallFrame() const { return m_foundCallFrame; }

     unsigned index() const { return m_index; }

123

124 private:

125 CallFrame* m_startCallFrame;

126 CallFrame* m_foundCallFrame;

127 bool m_foundStartCallFrame;

128 unsigned m_index;

129 };

130

 static bool addErrorInfoAndGetBytecodeOffset(ExecState* exec, VM& vm, JSObject* obj, bool useCurrentFrame, CallFrame*& callFrame, unsigned &bytecodeOffset)

132 {

     Vector<StackFrame> stackTrace = Vector<StackFrame>();

134

     if (exec && stackTrace.isEmpty())

         vm.interpreter->getStackTrace(stackTrace);

137

     if (!stackTrace.isEmpty()) {

139

         ASSERT(exec == vm.topCallFrame || exec == exec->lexicalGlobalObject()->globalExec() || exec == exec->vmEntryGlobalObject()->globalExec());

141

142 StackFrame* stackFrame;

         for (unsigned i = 0 ; i < stackTrace.size(); ++i) {

             stackFrame = &stackTrace.at(i);

145 if (stackFrame->bytecodeOffset)

146 break;

147 }

148

149 if (bytecodeOffset) {

150 FindFirstCallerFrameWithCodeblockFunctor functor(exec);

             vm.topCallFrame->iterate(functor);

152 callFrame = functor.foundCallFrame();

             unsigned stackIndex = functor.index();

             bytecodeOffset = stackTrace.at(stackIndex).bytecodeOffset;

155 }

156

157 unsigned line;

158 unsigned column;

         stackFrame->computeLineAndColumn(line, column);

         obj->putDirect(vm, vm.propertyNames->line, jsNumber(line), ReadOnly | DontDelete);

         obj->putDirect(vm, vm.propertyNames->column, jsNumber(column), ReadOnly | DontDelete);

162

         if (!stackFrame->sourceURL.isEmpty())

             obj->putDirect(vm, vm.propertyNames->sourceURL, jsString(&vm, stackFrame->sourceURL), ReadOnly | DontDelete);

165

166 if (!useCurrentFrame)

             stackTrace.remove(0);

         obj->putDirect(vm, vm.propertyNames->stack, vm.interpreter->stackTraceAsString(vm.topCallFrame, stackTrace), DontEnum);

169

170 return true;

171 }

172 return false;

173 }

174

 void ErrorInstance::finishCreation(ExecState* exec, VM& vm, const String& message, bool useCurrentFrame)

176 {

     Base::finishCreation(vm);

     ASSERT(inherits(info()));

     if (!message.isNull())

         putDirect(vm, vm.propertyNames->message, jsString(&vm, message), DontEnum);

181

182 unsigned bytecodeOffset = hasSourceAppender();

183 CallFrame* callFrame = nullptr;

     bool hasTrace = addErrorInfoAndGetBytecodeOffset(exec, vm, this, useCurrentFrame, callFrame, bytecodeOffset);

185

     if (hasTrace && callFrame && hasSourceAppender()) {

         if (callFrame && callFrame->codeBlock()) 

             appendSourceToError(callFrame, this, bytecodeOffset);

189 }

190 }

191

192 } // namespace JSC