QString Location::top() const
{
QString str = filePath();
if (lineNo() >= 1) {
str += QLatin1Char(':');
str += QString::number(lineNo());
}
if (etc())
str += QLatin1String(" (etc.)");
return str;
}
QString Location::top() const
{
QString str = filePath();
if (!QDir::isAbsolutePath(str)) {
QDir path(str);
str = path.absolutePath();
}
if (lineNo() >= 1) {
str += QLatin1Char(':');
str += QString::number(lineNo());
}
if (etc())
str += QLatin1String(" (etc.)");
return str;
}
QString Location::top() const
{
QString str = filePath();
if (lineNo() >= 1) {
str += QLatin1Char(':');
str += QString::number(lineNo());
#if 0
if (columnNo() >= 1)
str += ":" + QString::number(columnNo());
#endif
}
if (etc())
str += QLatin1String(" (etc.)");
return str;
}
LOCAL_C void TestWorkAPIsL(CTestExecuteLogger& aLogger,CConsoleBase*& aConsole)
{
aConsole->Write(_L("Testing logger.Write(16BitText) \r\n"));
aLogger.Write(K16BitText);
aConsole->Write(_L("Testing logger.Write(8BitText) \r\n"));
aLogger.Write(K8BitText);
aConsole->Write(_L("Testing logger.WriteFormat(16BitText) \r\n"));
TBuf<20> buf16(K16BitString);
aLogger.WriteFormat(K16BitFormatText,16,&buf16);
aConsole->Write(_L("Testing logger.WriteFormat(8BitText) \r\n"));
TBuf8<20> buf8(K8BitString);
aLogger.WriteFormat(K8BitFormatText,8,&buf8);
aConsole->Write(_L("Testing logger.LogExtra() \r\n"));
aLogger.LogExtra(((TText8*)__FILE__), __LINE__,ESevrInfo,K16BitFormatText,1,&buf16);
aConsole->Write(_L("Testing logger.PrintCurrentScriptLine() \r\n"));
TBuf<30> output(_L("Testing PrintCurrentScriptLine")) ;
aLogger.PrintCurrentScriptLine(output) ;
aConsole->Write(_L("Testing logger.LogTestCaseResult() \r\n"));
TBuf<30> file(_L("TestExcuteLoggingTest.cpp"));
TInt lineNo(68) ;
TBuf<20> testCsNm(_L("TestCaseSomething"));
aLogger.LogTestCaseResult(file, lineNo, ESevrInfo, KTEFEndTestCaseCommand, testCsNm);
aConsole->Write(_L("Testing logger.LogResult() \r\n"));
TBuf<30> panicStringbuf(_L("Panic string")) ;
TBuf<30> fileRes(_L("TestExcuteLoggingTest.cpp"));
TInt lineNum(70) ;
TInt severity(RFileFlogger::ESevrHigh) ;
aLogger.LogResult(EPass,panicStringbuf,lineNum,KTEFRunTestStepCommand,fileRes,RFileFlogger::ESevrHigh);
}
PassOwnPtr<FunctionCodeBlock> FunctionExecutable::produceCodeBlockFor(JSScope* scope, CodeSpecializationKind specializationKind, JSObject*& exception)
{
if (!!codeBlockFor(specializationKind))
return adoptPtr(new FunctionCodeBlock(CodeBlock::CopyParsedBlock, *codeBlockFor(specializationKind)));
JSGlobalData* globalData = scope->globalData();
JSGlobalObject* globalObject = scope->globalObject();
ParserError error;
DebuggerMode debuggerMode = globalObject->hasDebugger() ? DebuggerOn : DebuggerOff;
ProfilerMode profilerMode = globalObject->hasProfiler() ? ProfilerOn : ProfilerOff;
UnlinkedFunctionCodeBlock* unlinkedCodeBlock = m_unlinkedExecutable->codeBlockFor(*globalData, m_source, specializationKind, debuggerMode, profilerMode, error);
recordParse(m_unlinkedExecutable->features(), m_unlinkedExecutable->hasCapturedVariables(), lineNo(), lastLine());
if (!unlinkedCodeBlock) {
exception = error.toErrorObject(globalObject, m_source);
return nullptr;
}
OwnPtr<FunctionCodeBlock> result = adoptPtr(new FunctionCodeBlock(this, unlinkedCodeBlock, globalObject, source().provider(), source().startOffset()));
result->copyPostParseDataFrom(codeBlockFor(specializationKind).get());
return result.release();
}
JSObject* ProgramExecutable::initializeGlobalProperties(JSGlobalData& globalData, CallFrame* callFrame, JSScope* scope)
{
ASSERT(scope);
JSGlobalObject* globalObject = scope->globalObject();
ASSERT(globalObject);
ASSERT(&globalObject->globalData() == &globalData);
JSObject* exception = 0;
UnlinkedProgramCodeBlock* unlinkedCode = globalObject->createProgramCodeBlock(callFrame, this, &exception);
if (exception)
return exception;
m_unlinkedProgramCodeBlock.set(globalData, this, unlinkedCode);
BatchedTransitionOptimizer optimizer(globalData, globalObject);
const UnlinkedProgramCodeBlock::VariableDeclations& variableDeclarations = unlinkedCode->variableDeclarations();
const UnlinkedProgramCodeBlock::FunctionDeclations& functionDeclarations = unlinkedCode->functionDeclarations();
size_t newGlobals = variableDeclarations.size() + functionDeclarations.size();
if (!newGlobals)
return 0;
globalObject->addRegisters(newGlobals);
CallFrame* globalExec = globalObject->globalExec();
for (size_t i = 0; i < functionDeclarations.size(); ++i) {
bool propertyDidExist = globalObject->removeDirect(globalData, functionDeclarations[i].first); // Newly declared functions overwrite existing properties.
UnlinkedFunctionExecutable* unlinkedFunctionExecutable = functionDeclarations[i].second.get();
JSValue value = JSFunction::create(globalExec, unlinkedFunctionExecutable->link(globalData, m_source, lineNo(), 0), scope);
int index = addGlobalVar(globalObject, functionDeclarations[i].first, IsVariable,
!propertyDidExist ? IsFunctionToSpecialize : NotFunctionOrNotSpecializable);
globalObject->registerAt(index).set(globalData, globalObject, value);
}
for (size_t i = 0; i < variableDeclarations.size(); ++i) {
if (globalObject->hasProperty(globalExec, variableDeclarations[i].first))
continue;
addGlobalVar(globalObject, variableDeclarations[i].first,
(variableDeclarations[i].second & DeclarationStacks::IsConstant) ? IsConstant : IsVariable,
NotFunctionOrNotSpecializable);
}
return 0;
}
JSObject* ProgramExecutable::initializeGlobalProperties(VM& vm, CallFrame* callFrame, JSScope* scope)
{
RELEASE_ASSERT(scope);
JSGlobalObject* globalObject = scope->globalObject();
RELEASE_ASSERT(globalObject);
ASSERT(&globalObject->vm() == &vm);
JSObject* exception = 0;
UnlinkedProgramCodeBlock* unlinkedCodeBlock = globalObject->createProgramCodeBlock(callFrame, this, &exception);
if (exception)
return exception;
m_unlinkedProgramCodeBlock.set(vm, this, unlinkedCodeBlock);
BatchedTransitionOptimizer optimizer(vm, globalObject);
const UnlinkedProgramCodeBlock::VariableDeclations& variableDeclarations = unlinkedCodeBlock->variableDeclarations();
const UnlinkedProgramCodeBlock::FunctionDeclations& functionDeclarations = unlinkedCodeBlock->functionDeclarations();
for (size_t i = 0; i < functionDeclarations.size(); ++i) {
UnlinkedFunctionExecutable* unlinkedFunctionExecutable = functionDeclarations[i].second.get();
JSValue value = JSFunction::create(vm, unlinkedFunctionExecutable->link(vm, m_source, lineNo(), 0), scope);
globalObject->addFunction(callFrame, functionDeclarations[i].first, value);
}
for (size_t i = 0; i < variableDeclarations.size(); ++i) {
if (variableDeclarations[i].second & DeclarationStacks::IsConstant)
globalObject->addConst(callFrame, variableDeclarations[i].first);
else
globalObject->addVar(callFrame, variableDeclarations[i].first);
}
return 0;
}
PassRefPtr<CodeBlock> ScriptExecutable::newCodeBlockFor(
CodeSpecializationKind kind, JSScope* scope, JSObject*& exception)
{
VM* vm = scope->vm();
ASSERT(vm->heap.isDeferred());
ASSERT(startColumn() != UINT_MAX);
ASSERT(endColumn() != UINT_MAX);
if (classInfo() == EvalExecutable::info()) {
EvalExecutable* executable = jsCast<EvalExecutable*>(this);
RELEASE_ASSERT(kind == CodeForCall);
RELEASE_ASSERT(!executable->m_evalCodeBlock);
return adoptRef(new EvalCodeBlock(
executable, executable->m_unlinkedEvalCodeBlock.get(), scope,
executable->source().provider()));
}
if (classInfo() == ProgramExecutable::info()) {
ProgramExecutable* executable = jsCast<ProgramExecutable*>(this);
RELEASE_ASSERT(kind == CodeForCall);
RELEASE_ASSERT(!executable->m_programCodeBlock);
return adoptRef(new ProgramCodeBlock(
executable, executable->m_unlinkedProgramCodeBlock.get(), scope,
executable->source().provider(), executable->source().startColumn()));
}
RELEASE_ASSERT(classInfo() == FunctionExecutable::info());
FunctionExecutable* executable = jsCast<FunctionExecutable*>(this);
RELEASE_ASSERT(!executable->codeBlockFor(kind));
JSGlobalObject* globalObject = scope->globalObject();
ParserError error;
DebuggerMode debuggerMode = globalObject->hasDebugger() ? DebuggerOn : DebuggerOff;
ProfilerMode profilerMode = globalObject->hasProfiler() ? ProfilerOn : ProfilerOff;
UnlinkedFunctionCodeBlock* unlinkedCodeBlock =
executable->m_unlinkedExecutable->codeBlockFor(
*vm, executable->m_source, kind, debuggerMode, profilerMode, error);
recordParse(executable->m_unlinkedExecutable->features(), executable->m_unlinkedExecutable->hasCapturedVariables(), lineNo(), lastLine(), startColumn(), endColumn());
if (!unlinkedCodeBlock) {
exception = vm->throwException(
globalObject->globalExec(),
error.toErrorObject(globalObject, executable->m_source));
return 0;
}
SourceProvider* provider = executable->source().provider();
unsigned sourceOffset = executable->source().startOffset();
unsigned startColumn = executable->source().startColumn();
return adoptRef(new FunctionCodeBlock(
executable, unlinkedCodeBlock, scope, provider, sourceOffset, startColumn));
}
PassRefPtr<CodeBlock> ScriptExecutable::newCodeBlockFor(
CodeSpecializationKind kind, JSFunction* function, JSScope** scope, JSObject*& exception)
{
VM* vm = (*scope)->vm();
ASSERT(vm->heap.isDeferred());
ASSERT(startColumn() != UINT_MAX);
ASSERT(endColumn() != UINT_MAX);
if (classInfo() == EvalExecutable::info()) {
EvalExecutable* executable = jsCast<EvalExecutable*>(this);
RELEASE_ASSERT(kind == CodeForCall);
RELEASE_ASSERT(!executable->m_evalCodeBlock);
RELEASE_ASSERT(!function);
return adoptRef(new EvalCodeBlock(
executable, executable->m_unlinkedEvalCodeBlock.get(), *scope,
executable->source().provider()));
}
if (classInfo() == ProgramExecutable::info()) {
ProgramExecutable* executable = jsCast<ProgramExecutable*>(this);
RELEASE_ASSERT(kind == CodeForCall);
RELEASE_ASSERT(!executable->m_programCodeBlock);
RELEASE_ASSERT(!function);
return adoptRef(new ProgramCodeBlock(
executable, executable->m_unlinkedProgramCodeBlock.get(), *scope,
executable->source().provider(), executable->source().startColumn()));
}
RELEASE_ASSERT(classInfo() == FunctionExecutable::info());
RELEASE_ASSERT(function);
FunctionExecutable* executable = jsCast<FunctionExecutable*>(this);
RELEASE_ASSERT(!executable->codeBlockFor(kind));
JSGlobalObject* globalObject = (*scope)->globalObject();
ParserError error;
DebuggerMode debuggerMode = globalObject->hasDebugger() ? DebuggerOn : DebuggerOff;
ProfilerMode profilerMode = globalObject->hasProfiler() ? ProfilerOn : ProfilerOff;
UnlinkedFunctionCodeBlock* unlinkedCodeBlock =
executable->m_unlinkedExecutable->codeBlockFor(
*vm, executable->m_source, kind, debuggerMode, profilerMode, error);
recordParse(executable->m_unlinkedExecutable->features(), executable->m_unlinkedExecutable->hasCapturedVariables(), lineNo(), lastLine(), startColumn(), endColumn());
if (!unlinkedCodeBlock) {
exception = vm->throwException(
globalObject->globalExec(),
error.toErrorObject(globalObject, executable->m_source));
return 0;
}
// Parsing reveals whether our function uses features that require a separate function name object in the scope chain.
// Be sure to add this scope before linking the bytecode because this scope will change the resolution depth of non-local variables.
if (!executable->m_didParseForTheFirstTime) {
executable->m_didParseForTheFirstTime = true;
function->addNameScopeIfNeeded(*vm);
*scope = function->scope();
}
SourceProvider* provider = executable->source().provider();
unsigned sourceOffset = executable->source().startOffset();
unsigned startColumn = executable->source().startColumn();
return adoptRef(new FunctionCodeBlock(
executable, unlinkedCodeBlock, *scope, provider, sourceOffset, startColumn));
}
PassRefPtr<FunctionCodeBlock> FunctionExecutable::produceCodeBlockFor(JSScope* scope, CodeSpecializationKind specializationKind, JSObject*& exception)
{
RefPtr<FunctionCodeBlock> alternative = codeBlockFor(specializationKind);
if (!!alternative) {
RefPtr<FunctionCodeBlock> result = adoptRef(new FunctionCodeBlock(CodeBlock::CopyParsedBlock, *codeBlockFor(specializationKind)));
result->setAlternative(alternative);
return result.release();
}
VM* vm = scope->vm();
JSGlobalObject* globalObject = scope->globalObject();
ParserError error;
DebuggerMode debuggerMode = globalObject->hasDebugger() ? DebuggerOn : DebuggerOff;
ProfilerMode profilerMode = globalObject->hasProfiler() ? ProfilerOn : ProfilerOff;
UnlinkedFunctionCodeBlock* unlinkedCodeBlock = m_unlinkedExecutable->codeBlockFor(*vm, m_source, specializationKind, debuggerMode, profilerMode, error);
recordParse(m_unlinkedExecutable->features(), m_unlinkedExecutable->hasCapturedVariables(), lineNo(), lastLine(), startColumn());
if (!unlinkedCodeBlock) {
exception = error.toErrorObject(globalObject, m_source);
return 0;
}
SourceProvider* provider = source().provider();
unsigned sourceOffset = source().startOffset();
unsigned startColumn = source().startColumn();
return adoptRef(new FunctionCodeBlock(this, unlinkedCodeBlock, scope, provider, sourceOffset, startColumn));
}
