std::ostream& operator<<( std::ostream &s, const v8::TryCatch * try_catch ){
HandleScope handle_scope;
v8::String::Utf8Value exception(try_catch->Exception());
Handle<v8::Message> message = try_catch->Message();
if (message.IsEmpty()) {
s << *exception << endl;
}
else {
v8::String::Utf8Value filename(message->GetScriptResourceName());
int linenum = message->GetLineNumber();
cout << *filename << ":" << linenum << " " << *exception << endl;
v8::String::Utf8Value sourceline(message->GetSourceLine());
cout << *sourceline << endl;
int start = message->GetStartColumn();
for (int i = 0; i < start; i++)
cout << " ";
int end = message->GetEndColumn();
for (int i = start; i < end; i++)
cout << "^";
cout << endl;
}
//if ( try_catch->next_ ) // disabled for v8 bleeding edge
// s << try_catch->next_;
return s;
}
void V8Util::openJSErrorDialog(TryCatch &tryCatch)
{
JNIEnv *env = JNIUtil::getJNIEnv();
if (!env) {
return;
}
Handle<Message> message = tryCatch.Message();
jstring title = env->NewStringUTF("Runtime Error");
jstring errorMessage = TypeConverter::jsValueToJavaString(message->Get());
jstring resourceName = TypeConverter::jsValueToJavaString(message->GetScriptResourceName());
jstring sourceLine = TypeConverter::jsValueToJavaString(message->GetSourceLine());
env->CallStaticVoidMethod(
JNIUtil::krollRuntimeClass,
JNIUtil::krollRuntimeDispatchExceptionMethod,
title,
errorMessage,
resourceName,
message->GetLineNumber(),
sourceLine,
message->GetEndColumn());
env->DeleteLocalRef(title);
env->DeleteLocalRef(errorMessage);
env->DeleteLocalRef(resourceName);
env->DeleteLocalRef(sourceLine);
}
/* Handler for Javascript Exceptions. Not exposed to JavaScript, used internally.
Most of the code from v8 shell example.
*/
void msV8ReportException(TryCatch* try_catch, const char *msg = "")
{
HandleScope handle_scope;
if (!try_catch || !try_catch->HasCaught()) {
msSetError(MS_V8ERR, "%s.", "msV8ReportException()", msg);
return;
}
String::Utf8Value exception(try_catch->Exception());
const char* exception_string = *exception;
Handle<Message> message = try_catch->Message();
if (message.IsEmpty()) {
msSetError(MS_V8ERR, "Javascript Exception: %s.", "msV8ReportException()",
exception_string);
} else {
String::Utf8Value filename(message->GetScriptResourceName());
const char* filename_string = *filename;
int linenum = message->GetLineNumber();
msSetError(MS_V8ERR, "Javascript Exception: %s:%i: %s", "msV8ReportException()",
filename_string, linenum, exception_string);
String::Utf8Value sourceline(message->GetSourceLine());
const char* sourceline_string = *sourceline;
msSetError(MS_V8ERR, "Exception source line: %s", "msV8ReportException()",
sourceline_string);
String::Utf8Value stack_trace(try_catch->StackTrace());
if (stack_trace.length() > 0) {
const char* stack_trace_string = *stack_trace;
msSetError(MS_V8ERR, "Exception StackTrace: %s", "msV8ReportException()",
stack_trace_string);
}
}
}
bool MetadataNode::GetExtendLocation(string& extendLocation)
{
stringstream extendLocationStream;
Local<StackTrace> stackTrace = StackTrace::CurrentStackTrace(Isolate::GetCurrent(), 1, StackTrace::kOverview);
if (!stackTrace.IsEmpty())
{
Handle<StackFrame> frame = stackTrace->GetFrame(0);
if (!frame.IsEmpty())
{
auto scriptName = frame->GetScriptName();
if (scriptName.IsEmpty())
{
extendLocationStream << "unkown location";
extendLocation = extendLocationStream.str();
return false;
}
string srcFileName = ConvertToString(scriptName);
string hardcodedPathToSkip = Constants::APP_ROOT_FOLDER_PATH;
int startIndex = hardcodedPathToSkip.length();
int strToTakeLen = (srcFileName.length() - startIndex - 3); // 3 refers to .js at the end of file name
string fullPathToFile = srcFileName.substr(startIndex, strToTakeLen);
std::replace(fullPathToFile.begin(), fullPathToFile.end(), '/', '_');
std::replace(fullPathToFile.begin(), fullPathToFile.end(), '.', '_');
int lineNumber = frame->GetLineNumber();
if (lineNumber < 0)
{
extendLocationStream << fullPathToFile.c_str() << " unkown line number";
extendLocation = extendLocationStream.str();
return false;
}
if (lineNumber > Constants::MODULE_LINES_OFFSET)
{
lineNumber -= Constants::MODULE_LINES_OFFSET;
}
int column = frame->GetColumn();
if (column < 0)
{
extendLocationStream << fullPathToFile.c_str() << " line:" << lineNumber << " unkown column number";
extendLocation = extendLocationStream.str();
return false;
}
extendLocationStream << "f" << fullPathToFile.c_str() << "_l" << lineNumber << "_c" << column << "__";
//DEBUG_WRITE("EXTEND_LOCATION %s", extendLocationStream.str().c_str());
}
}
extendLocation = extendLocationStream.str();
return true;
}
static void logV8Exception(Handle<Message> msg, Handle<Value> data)
{
HandleScope scope;
// Log reason and location of the error.
LOGD(TAG, *String::Utf8Value(msg->Get()));
LOGD(TAG, "%s @ %d >>> %s",
*String::Utf8Value(msg->GetScriptResourceName()),
msg->GetLineNumber(),
*String::Utf8Value(msg->GetSourceLine()));
}
void ReportException(TryCatch* tryCatch)
{
// HandleScope handleScope;
String::Utf8Value exception(tryCatch->Exception());
const char* exceptionString = ToCString(exception);
Handle<Message> message = tryCatch->Message();
if (message.IsEmpty()) {
// V8 didn't provide any extra information about this error; just
// print the exception.
throw std::runtime_error("Unknown error "+ std::string(exceptionString));
} else {
// Print (filename):(line number): (message).
String::Utf8Value filename(message->GetScriptResourceName());
const char* filenameString = ToCString(filename);
int linenum = message->GetLineNumber();
std::stringstream ss;
// Print filename and linenum if applicable
if(!message->GetScriptResourceName()->IsUndefined()) {
ss << filenameString <<":"<< linenum <<" ";
}
ss << exceptionString << std::endl;
// Print line of source code.
String::Utf8Value sourceline(message->GetSourceLine());
const char* sourceline_string = ToCString(sourceline);
ss << sourceline_string << std::endl;
// Print wavy underline (GetUnderline is deprecated).
int start = message->GetStartColumn();
for (int i = 0; i < start; i++) {
ss << " ";
}
int end = message->GetEndColumn();
for (int i = start; i < end; i++) {
ss << "^";
}
ss << std::endl;
String::Utf8Value stack_trace(tryCatch->StackTrace());
if (stack_trace.length() > 0) {
const char* stack_trace_string = ToCString(stack_trace);
ss << stack_trace_string;
}
throw std::runtime_error(ss.str());
}
}
void report_error(TryCatch * err) {
String::Utf8Value exception(err->Exception());
String::Utf8Value stack(err->StackTrace());
Handle<Message> message = err->Message();
fprintf(stderr, "%s\n", *exception);
if(! message.IsEmpty()) {
String::Utf8Value file(message->GetScriptResourceName());
int line = message->GetLineNumber();
fprintf(stderr, "%s:%d\n", *file, line);
}
if(stack.length() > 0)
fprintf(stderr, "%s\n", *stack);
}
void DisplayExceptionLine (TryCatch &try_catch, std::string& err_msg) {
// Prevent re-entry into this function.
static bool displayed_error = false;
if (displayed_error) return;
displayed_error = true;
HandleScope scope;
Handle<Message> message = try_catch.Message();
fprintf(stderr, "\n");
err_msg = "JavaScript Exception\n\n";
if (!message.IsEmpty()) {
// Print (filename):(line number): (message).
String::Utf8Value filename(message->GetScriptResourceName());
const char* filename_string = *filename;
int linenum = message->GetLineNumber();
fprintf(stderr, "%s:%i\n", filename_string, linenum);
err_msg += filename_string;
err_msg += ":";
char num_conv[10];
sprintf(num_conv, "%i", linenum);
err_msg += num_conv;
err_msg += "\n";
// Print line of source code.
String::Utf8Value sourceline(message->GetSourceLine());
const char* sourceline_string = *sourceline;
int start = message->GetStartColumn();
int end = message->GetEndColumn();
// fprintf(stderr, "---\nsourceline:%s\noffset:%d\nstart:%d\nend:%d\n---\n", sourceline_string, start, end);
fprintf(stderr, "%s\n", sourceline_string);
err_msg += sourceline_string;
err_msg += "\n";
// Print wavy underline (GetUnderline is deprecated).
for (int i = 0; i < start; i++) {
fputc((sourceline_string[i] == '\t') ? '\t' : ' ', stderr);
}
for (int i = start; i < end; i++) {
fputc('^', stderr);
}
fputc('\n', stderr);
err_msg += "\n";
}
}
////////////////////////////////////////////////////////////////////////////////
// lifted from node.js file node.cc
void ReportException(TryCatch *try_catch)
{
HandleScope scope;
Handle<Message> message = try_catch->Message();
std::string filename_string = "";
std::string sourceline_string = "";
int linenum = 0;
int start = 0;
int end = 0;
if (!message.IsEmpty()) {
String::Utf8Value filename(message->GetScriptResourceName());
filename_string = *filename;
linenum = message->GetLineNumber();
String::Utf8Value sourceline(message->GetSourceLine());
sourceline_string = *sourceline;
start = message->GetStartColumn();
end = message->GetEndColumn();
}
String::Utf8Value trace(try_catch->StackTrace());
std::string tracestr;
if(trace.length() != 0)
{
tracestr = *trace;
}
std::ostringstream os;
os << std::endl << sourceline_string << std::endl;
for (int i = 0; i < start; i++)
{
os << " ";
}
for (int i = start; i < end; i++)
{
os << "^";
}
os << tracestr << "\n";
std::string msg = os.str();
dtEntity::LogManager::GetInstance().LogMessage(dtEntity::LogLevel::LVL_ERROR, filename_string, "", linenum, msg);
}
void set_perl_error(const TryCatch& try_catch) {
Handle<Message> msg = try_catch.Message();
char message[1024];
snprintf(
message,
1024,
"%s at %s:%d",
*(String::Utf8Value(try_catch.Exception())),
!msg.IsEmpty() ? *(String::AsciiValue(msg->GetScriptResourceName())) : "EVAL",
!msg.IsEmpty() ? msg->GetLineNumber() : 0
);
sv_setpv(ERRSV, message);
sv_utf8_upgrade(ERRSV);
}
std::string stringifyException(const v8::TryCatch& try_catch, bool suppressBacktrace) {
HandleScope scope;
std::string output = "";
Handle<Message> message = try_catch.Message();
if (suppressBacktrace || message.IsEmpty()) {
std::string exception_string = V8::stringToStdString(try_catch.Exception().As<String>());
// V8 didn't provide any extra information about this error; just
// print the exception.
output += exception_string;
output += "\n";
} else {
// filename:line
output += V8::stringToStdString(
message->GetScriptResourceName().As<String>()
) + ":" + boost::lexical_cast<std::string>(
message->GetLineNumber()
) + "\n";
// Print line of source code.
output += V8::stringToStdString(message->GetSourceLine()) + "\n";
// Print wavy underline (GetUnderline is deprecated).
int start = message->GetStartColumn();
for (int i = 0; i < start; i++) {
output += " ";
}
int end = message->GetEndColumn();
for (int i = start; i < end; i++) {
output += "^";
}
output += "\n";
// Print out the stack trace.
std::string stackTrace = V8::stringToStdString(try_catch.StackTrace().As<String>());
if (stackTrace.length() > 0) {
output += stackTrace + "\n";
}
}
return output;
}
~ScriptScopeImpl ()
{
GumScriptPrivate * priv = parent->priv;
if (trycatch.HasCaught ())
{
Handle<Message> message = trycatch.Message ();
Handle<Value> exception = trycatch.Exception ();
String::Utf8Value exception_str (exception);
gchar * exception_str_escaped = g_strescape (*exception_str, "");
gchar * error = g_strdup_printf (
"{\"type\":\"error\",\"lineNumber\":%d,\"description\":\"%s\"}",
message->GetLineNumber (), exception_str_escaped);
_gum_script_core_emit_message (&priv->core, error, NULL, 0);
g_free (exception_str_escaped);
g_free (error);
}
}
const string JSMain::GetExceptionInfo(Isolate* isolate, TryCatch* try_catch)
{
HandleScope handle_scope(isolate);
String::Utf8Value exception(try_catch->Exception());
const char *exception_string = js_safe_str(*exception);
Handle<Message> message = try_catch->Message();
string res;
if (message.IsEmpty()) {
// V8 didn't provide any extra information about this error; just return the exception.
res = exception_string;
} else {
String::Utf8Value filename(message->GetScriptResourceName());
const char *filename_string = js_safe_str(*filename);
int linenum = message->GetLineNumber();
ostringstream ss;
ss << filename_string << ":" << linenum << ": " << exception_string << "\r\n";
// Print line of source code.
String::Utf8Value sourceline(message->GetSourceLine());
const char *sourceline_string = js_safe_str(*sourceline);
ss << sourceline_string << "\r\n";
// Print wavy underline.
int start = message->GetStartColumn();
for (int i = 0; i < start; i++) {
ss << " ";
}
int end = message->GetEndColumn();
for (int i = start; i < end; i++) {
ss << "^";
}
res = ss.str();
}
return res;
}
void V8Util::reportException(TryCatch &tryCatch, bool showLine)
{
HandleScope scope;
Handle<Message> message = tryCatch.Message();
if (nameSymbol.IsEmpty()) {
nameSymbol = SYMBOL_LITERAL("name");
messageSymbol = SYMBOL_LITERAL("message");
}
if (showLine) {
Handle<Message> message = tryCatch.Message();
if (!message.IsEmpty()) {
String::Utf8Value filename(message->GetScriptResourceName());
String::Utf8Value msg(message->Get());
int linenum = message->GetLineNumber();
LOGE(EXC_TAG, "Exception occurred at %s:%i: %s", *filename, linenum, *msg);
}
}
Local<Value> stackTrace = tryCatch.StackTrace();
String::Utf8Value trace(tryCatch.StackTrace());
if (trace.length() > 0 && !stackTrace->IsUndefined()) {
LOGD(EXC_TAG, *trace);
} else {
Local<Value> exception = tryCatch.Exception();
if (exception->IsObject()) {
Handle<Object> exceptionObj = exception->ToObject();
Handle<Value> message = exceptionObj->Get(messageSymbol);
Handle<Value> name = exceptionObj->Get(nameSymbol);
if (!message->IsUndefined() && !name->IsUndefined()) {
String::Utf8Value nameValue(name);
String::Utf8Value messageValue(message);
LOGE(EXC_TAG, "%s: %s", *nameValue, *messageValue);
}
} else {
String::Utf8Value error(exception);
LOGE(EXC_TAG, *error);
}
}
}
void SMJS_Plugin::ReportException(TryCatch* try_catch){
HandleScope handle_scope(isolate);
fprintf(stderr, "----------------------------- JAVASCRIPT EXCEPTION -----------------------------");
String::Utf8Value exception(try_catch->Exception());
const char* exception_string = ToCString(exception);
Handle<Message> message = try_catch->Message();
if (message.IsEmpty()) {
// V8 didn't provide any extra information about this error; just
// print the exception.
fprintf(stderr, "%s\n", exception_string);
} else {
// Print (filename):(line number): (message).
String::Utf8Value filename(message->GetScriptResourceName());
const char* filename_string = ToCString(filename);
int linenum = message->GetLineNumber();
fprintf(stderr, "%s:%d: %s\n", filename_string, linenum, exception_string);
// Print line of source code.
String::Utf8Value sourceline(message->GetSourceLine());
const char* sourceline_string = ToCString(sourceline);
fprintf(stderr, "%s\n", sourceline_string);
// Print wavy underline (GetUnderline is deprecated).
int start = message->GetStartColumn();
for (int i = 0; i < start; i++) {
fprintf(stderr, " ");
}
int end = message->GetEndColumn();
for (int i = start; i < end; i++) {
fprintf(stderr, "^");
}
fprintf(stderr, "\n");
String::Utf8Value stack_trace(try_catch->StackTrace());
if (stack_trace.length() > 0) {
const char* stack_trace_string = ToCString(stack_trace);
fprintf(stderr, "%s\n", stack_trace_string);
}
}
fprintf(stderr, "--------------------------------------------------------------------------------");
}
std::string toSTLString( const v8::TryCatch * try_catch ) {
stringstream ss;
//while ( try_catch ){ // disabled for v8 bleeding edge
v8::String::Utf8Value exception(try_catch->Exception());
Handle<v8::Message> message = try_catch->Message();
if (message.IsEmpty()) {
ss << *exception << endl;
}
else {
v8::String::Utf8Value filename(message->GetScriptResourceName());
if (*filename) {
int linenum = message->GetLineNumber();
ss << *filename << ":" << linenum << " ";
}
ss << *exception << endl;
v8::String::Utf8Value sourceline(message->GetSourceLine());
ss << *sourceline << endl;
int start = message->GetStartColumn();
for (int i = 0; i < start; i++)
ss << " ";
int end = message->GetEndColumn();
for (int i = start; i < end; i++)
ss << "^";
ss << endl;
}
//try_catch = try_catch->next_;
//}
return ss.str();
}
int ReportError(TryCatch& try_catch){
cs::String str;
HandleScope handle_scope;
v8::String::Value exception(try_catch.Exception());
const wchar_t* exception_string = ToCString(exception);
Handle<v8::Message> message = try_catch.Message();
if (message.IsEmpty()) {
str.Format(L"%s\n",exception_string);
} else {
cs::String buf;
v8::String::Value filename(message->GetScriptResourceName());
const wchar_t* filename_string = ToCString(filename);
int linenum = message->GetLineNumber();
buf.Format(L"file:\t%s\r\nline:\t%i\r\n%s\r\n\r\n", filename_string, linenum, exception_string);
str += buf;
v8::String::Value sourceline(message->GetSourceLine());
const wchar_t* sourceline_string = ToCString(sourceline);
buf.Format(L"%s", sourceline_string);
int start = message->GetStartColumn();
for (int i = 0; i < start; i++) {
//str += L" ";
}
buf.Insert('^',start);
buf.Trim();
str += buf;
int end = message->GetEndColumn();
for (int i = start; i < end; i++) {
//str += L"^";
}
/*str += L"\n";
v8::String::Value stack_trace(try_catch.StackTrace());
if (stack_trace.length() > 0) {
const wchar_t* stack_trace_string = ToCString(stack_trace);
buf.Format(L"%s\n", stack_trace_string);
str += buf;
}*/
}
return MessageBox(0,str,L"Error",MB_ICONERROR);
}
// Taken from Google's Shell example.
void PrettyPrinter::prettyPrintException(v8::TryCatch *try_catch, std::string *ex_string) {
ex_string->clear();
HandleScope handle_scope;
String::Utf8Value exception(try_catch->Exception());
const char* exception_string = toCString(exception);
Handle<Message> message = try_catch->Message();
if (message.IsEmpty()) {
ex_string->append(exception_string);
ex_string->append("\n");
} else {
String::Utf8Value filename(message->GetScriptResourceName());
const char* filename_string = toCString(filename);
int linenum = message->GetLineNumber();
ex_string->append(filename_string);
ex_string->append(":");
ex_string->append(intToString(linenum));
ex_string->append(": ");
ex_string->append(exception_string);
ex_string->append("\n");
String::Utf8Value sourceline(message->GetSourceLine());
const char* sourceline_string = toCString(sourceline);
ex_string->append(sourceline_string);
int start = message->GetStartColumn();
for (int i = 0; i < start; i++) {
ex_string->append(" ");
}
int end = message->GetEndColumn();
for (int i = start; i < end; i++) {
ex_string->append("^");
}
ex_string->append("\n");
String::Utf8Value stack_trace(try_catch->StackTrace());
if (stack_trace.length() > 0) {
const char* stack_trace_string = toCString(stack_trace);
ex_string->append(stack_trace_string);
ex_string->append("\n");
}
}
}
// Slight modification to an original function found in the V8 sample shell.cc.
void Global::reportException(TryCatch* tryCatch) {
HandleScope handleScope(fIsolate);
String::Utf8Value exception(tryCatch->Exception());
const char* exceptionString = to_cstring(exception);
Handle<Message> message = tryCatch->Message();
if (message.IsEmpty()) {
// V8 didn't provide any extra information about this error; just
// print the exception.
fprintf(stderr, "%s\n", exceptionString);
} else {
// Print (filename):(line number): (message).
String::Utf8Value filename(message->GetScriptOrigin().ResourceName());
const char* filenameString = to_cstring(filename);
int linenum = message->GetLineNumber();
fprintf(stderr,
"%s:%i: %s\n", filenameString, linenum, exceptionString);
// Print line of source code.
String::Utf8Value sourceline(message->GetSourceLine());
const char* sourceLineString = to_cstring(sourceline);
fprintf(stderr, "%s\n", sourceLineString);
// Print wavy underline.
int start = message->GetStartColumn();
for (int i = 0; i < start; i++) {
fprintf(stderr, " ");
}
int end = message->GetEndColumn();
for (int i = start; i < end; i++) {
fprintf(stderr, "^");
}
fprintf(stderr, "\n");
String::Utf8Value stackTrace(tryCatch->StackTrace());
if (stackTrace.length() > 0) {
const char* stackTraceString = to_cstring(stackTrace);
fprintf(stderr, "%s\n", stackTraceString);
}
}
}
static gboolean
gum_script_create_context (GumScript * self,
GError ** error)
{
GumScriptPrivate * priv = self->priv;
g_assert (priv->context == NULL);
{
Locker locker (priv->isolate);
Isolate::Scope isolate_scope (priv->isolate);
HandleScope handle_scope (priv->isolate);
Handle<ObjectTemplate> global_templ = ObjectTemplate::New ();
_gum_script_core_init (&priv->core, self, priv->main_context, priv->isolate,
global_templ);
_gum_script_memory_init (&priv->memory, &priv->core, global_templ);
_gum_script_process_init (&priv->process, &priv->core, global_templ);
_gum_script_thread_init (&priv->thread, &priv->core, global_templ);
_gum_script_module_init (&priv->module, &priv->core, global_templ);
_gum_script_file_init (&priv->file, &priv->core, global_templ);
_gum_script_socket_init (&priv->socket, &priv->core, global_templ);
_gum_script_interceptor_init (&priv->interceptor, &priv->core,
global_templ);
_gum_script_stalker_init (&priv->stalker, &priv->core, global_templ);
_gum_script_instruction_init (&priv->instruction, &priv->core,
global_templ);
Local<Context> context (Context::New (priv->isolate, NULL, global_templ));
priv->context = new GumPersistent<Context>::type (priv->isolate, context);
Context::Scope context_scope (context);
_gum_script_core_realize (&priv->core);
_gum_script_memory_realize (&priv->memory);
_gum_script_process_realize (&priv->process);
_gum_script_thread_realize (&priv->thread);
_gum_script_module_realize (&priv->module);
_gum_script_file_realize (&priv->file);
_gum_script_socket_realize (&priv->socket);
_gum_script_interceptor_realize (&priv->interceptor);
_gum_script_stalker_realize (&priv->stalker);
_gum_script_instruction_realize (&priv->instruction);
gchar * combined_source = g_strconcat (
#include "gumscript-runtime.h"
"\n",
priv->source,
static_cast<void *> (NULL));
Local<String> source_value (String::NewFromUtf8 (priv->isolate, combined_source));
g_free (combined_source);
TryCatch trycatch;
Handle<Script> raw_script = Script::Compile (source_value);
if (raw_script.IsEmpty ())
{
Handle<Message> message = trycatch.Message ();
Handle<Value> exception = trycatch.Exception ();
String::Utf8Value exception_str (exception);
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Script(line %d): %s",
message->GetLineNumber () - GUM_SCRIPT_RUNTIME_SOURCE_LINE_COUNT,
*exception_str);
}
else
{
priv->raw_script =
new GumPersistent<Script>::type (priv->isolate, raw_script);
}
}
if (priv->raw_script == NULL)
{
gum_script_destroy_context (self);
return FALSE;
}
return TRUE;
}
static void reportException(v8::TryCatch &try_catch, bool show_line)
{
using namespace v8;
Handle<Message> message = try_catch.Message();
v8::String::Utf8Value error(try_catch.Exception());
if (error.length() > 0)
{
std::ostringstream errorMsg;
/*
02:50:22.863: [CID=00000000] JS: File undefined:12
[CID=00000000] JS: Source Line var notheetoo = nothere.subst(0, 10);
[CID=00000000] JS:
^
[CID=00000000] JS:
{TypeError: Cannot call method 'subst' of undefined
at RouteProfile.isTellMeRoutable (unknown source)
at RouteProfile.isRoutable (unknown source)
at handle_request (unknown source)
}
*/
if (show_line && !message.IsEmpty())
{
// Print (filename):(line number): (message).
String::Utf8Value filename(message->GetScriptResourceName());
const char* filename_string = toCString(filename);
int linenum = message->GetLineNumber();
//fprintf(stderr, "%s:%i\n", filename_string, linenum);
errorMsg << filename_string << ":" << linenum << std::endl;
// Print line of source code.
String::Utf8Value sourceline(message->GetSourceLine());
const char* sourceline_string = toCString(sourceline);
// HACK HACK HACK
//
// FIXME
//
// Because of how CommonJS modules work, all scripts are wrapped with a
// "function (function (exports, __filename, ...) {"
// to provide script local variables.
//
// When reporting errors on the first line of a script, this wrapper
// function is leaked to the user. This HACK is to remove it. The length
// of the wrapper is 62. That wrapper is defined in src/node.js
//
// If that wrapper is ever changed, then this number also has to be
// updated. Or - someone could clean this up so that the two peices
// don't need to be changed.
//
// Even better would be to get support into V8 for wrappers that
// shouldn't be reported to users.
int offset = linenum == 1 ? 62 : 0;
//fprintf(stderr, "%s\n", sourceline_string + offset);
errorMsg << sourceline_string + offset << std::endl;
// Print wavy underline (GetUnderline is deprecated).
int start = message->GetStartColumn();
for (int i = offset; i < start; i++)
{
errorMsg << " ";
}
int end = message->GetEndColumn();
for (int i = start; i < end; i++)
{
errorMsg << "^";
}
errorMsg << std::endl;
}
String::Utf8Value trace(try_catch.StackTrace());
if (trace.length() > 0)
{
errorMsg << *trace;
}
OSS_LOG_ERROR("\t[CID=00000000] JS: " << *error << std::endl << "{" << std::endl << errorMsg.str() << std::endl << "}");
}
}
static gboolean
gum_script_create_context (GumScript * self,
GError ** error)
{
GumScriptPrivate * priv = self->priv;
g_assert (priv->context == NULL);
{
Handle<ObjectTemplate> global_templ = ObjectTemplate::New ();
_gum_script_core_init (&priv->core, self, gum_script_emit_message,
gum_script_get_scheduler (), priv->isolate, global_templ);
_gum_script_memory_init (&priv->memory, &priv->core, global_templ);
_gum_script_process_init (&priv->process, &priv->core, global_templ);
_gum_script_thread_init (&priv->thread, &priv->core, global_templ);
_gum_script_module_init (&priv->module, &priv->core, global_templ);
_gum_script_file_init (&priv->file, &priv->core, global_templ);
_gum_script_socket_init (&priv->socket, &priv->core, global_templ);
_gum_script_interceptor_init (&priv->interceptor, &priv->core,
global_templ);
_gum_script_stalker_init (&priv->stalker, &priv->core, global_templ);
_gum_script_symbol_init (&priv->symbol, &priv->core, global_templ);
_gum_script_instruction_init (&priv->instruction, &priv->core,
global_templ);
Local<Context> context (Context::New (priv->isolate, NULL, global_templ));
priv->context = new GumPersistent<Context>::type (priv->isolate, context);
Context::Scope context_scope (context);
_gum_script_core_realize (&priv->core);
_gum_script_memory_realize (&priv->memory);
_gum_script_process_realize (&priv->process);
_gum_script_thread_realize (&priv->thread);
_gum_script_module_realize (&priv->module);
_gum_script_file_realize (&priv->file);
_gum_script_socket_realize (&priv->socket);
_gum_script_interceptor_realize (&priv->interceptor);
_gum_script_stalker_realize (&priv->stalker);
_gum_script_symbol_realize (&priv->symbol);
_gum_script_instruction_realize (&priv->instruction);
gchar * resource_name_str = g_strconcat (priv->name, ".js",
(gpointer) NULL);
Local<String> resource_name (String::NewFromUtf8 (priv->isolate,
resource_name_str));
ScriptOrigin origin (resource_name);
g_free (resource_name_str);
Local<String> source (String::NewFromUtf8 (priv->isolate,
priv->source));
TryCatch trycatch;
MaybeLocal<Script> maybe_code =
Script::Compile (context, source, &origin);
Local<Script> code;
if (maybe_code.ToLocal (&code))
{
priv->code =
new GumPersistent<Script>::type (priv->isolate, code);
}
else
{
Handle<Message> message = trycatch.Message ();
Handle<Value> exception = trycatch.Exception ();
String::Utf8Value exception_str (exception);
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Script(line %d): %s",
message->GetLineNumber (), *exception_str);
}
}
if (priv->code == NULL)
{
gum_script_destroy_context (self);
return FALSE;
}
return TRUE;
}
int TiRootObject::executeScript(NativeObjectFactory* objectFactory, const char* javaScript,
MESSAGELOOPENTRY messageLoopEntry, void* context)
{
HandleScope handleScope;
objectFactory_ = objectFactory;
globalTemplate_ = ObjectTemplate::New();
TiV8EventContainerFactory* eventFactory = TiV8EventContainerFactory::createEventContainerFactory(globalTemplate_);
objectFactory->setEventContainerFactory(eventFactory);
onSetGetPropertyCallback(&globalTemplate_);
onSetFunctionCallback(&globalTemplate_);
g_rootTemplate = ObjectTemplate::New();
context_ = Context::New(NULL, g_rootTemplate);
forceSetValue(context_->Global());
context_->Global()->SetHiddenValue(String::New("globalTemplate_"), External::New(&globalTemplate_));
context_->Global()->SetHiddenValue(String::New("context_"), External::New(&context_));
setTiObjectToJsObject(context_->Global(), this);
Context::Scope context_scope(context_);
initializeTiObject(NULL);
const char* bootstrapFilename = "bootstrap.js";
string bootstrapJavascript;
{
ifstream ifs((string("app/native/framework/") + bootstrapFilename).c_str());
if (!ifs)
{
TiLogger::getInstance().log(Ti::Msg::ERROR__Cannot_load_bootstrap_js);
return -1;
}
getline(ifs, bootstrapJavascript, string::traits_type::to_char_type(string::traits_type::eof()));
ifs.close();
}
TryCatch tryCatch;
Handle<Script> compiledBootstrapScript = Script::Compile(String::New(bootstrapJavascript.c_str()), String::New(bootstrapFilename));
if (compiledBootstrapScript.IsEmpty())
{
String::Utf8Value error(tryCatch.Exception());
TiLogger::getInstance().log(*error);
return -1;
}
Handle<Value> bootstrapResult = compiledBootstrapScript->Run();
if (bootstrapResult.IsEmpty())
{
Local<Value> exception = tryCatch.Exception();
// FIXME: need a way to prevent double "filename + line" output
Handle<Message> msg = tryCatch.Message();
stringstream ss;
ss << bootstrapFilename << " line ";
if (msg.IsEmpty())
{
ss << "?";
}
else
{
ss << msg->GetLineNumber();
}
ss << ": " << *String::Utf8Value(exception);
TiLogger::getInstance().log(ss.str().c_str());
return -1;
}
const char* filename = "app.js";
Handle<Script> compiledScript = Script::Compile(String::New(javaScript), String::New(filename));
if (compiledScript.IsEmpty())
{
ReportException(tryCatch, true);
return 1;
}
compiledScript->Run();
if (tryCatch.HasCaught())
{
ReportException(tryCatch, true);
return 1;
}
onStartMessagePump();
return (messageLoopEntry)(context);
}