1 // Copyright 2011 the V8 project authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "src/v8.h" 6 7 #include "src/api.h" 8 #include "src/execution.h" 9 #include "src/heap/spaces-inl.h" 10 #include "src/messages.h" 11 12 namespace v8 { 13 namespace internal { 14 15 16 // If no message listeners have been registered this one is called 17 // by default. 18 void MessageHandler::DefaultMessageReport(Isolate* isolate, 19 const MessageLocation* loc, 20 Handle<Object> message_obj) { 21 SmartArrayPointer<char> str = GetLocalizedMessage(isolate, message_obj); 22 if (loc == NULL) { 23 PrintF("%s\n", str.get()); 24 } else { 25 HandleScope scope(isolate); 26 Handle<Object> data(loc->script()->name(), isolate); 27 SmartArrayPointer<char> data_str; 28 if (data->IsString()) 29 data_str = Handle<String>::cast(data)->ToCString(DISALLOW_NULLS); 30 PrintF("%s:%i: %s\n", data_str.get() ? data_str.get() : "<unknown>", 31 loc->start_pos(), str.get()); 32 } 33 } 34 35 36 Handle<JSMessageObject> MessageHandler::MakeMessageObject( 37 Isolate* isolate, 38 const char* type, 39 MessageLocation* loc, 40 Vector< Handle<Object> > args, 41 Handle<JSArray> stack_frames) { 42 Factory* factory = isolate->factory(); 43 Handle<String> type_handle = factory->InternalizeUtf8String(type); 44 Handle<FixedArray> arguments_elements = 45 factory->NewFixedArray(args.length()); 46 for (int i = 0; i < args.length(); i++) { 47 arguments_elements->set(i, *args[i]); 48 } 49 Handle<JSArray> arguments_handle = 50 factory->NewJSArrayWithElements(arguments_elements); 51 52 int start = 0; 53 int end = 0; 54 Handle<Object> script_handle = factory->undefined_value(); 55 if (loc) { 56 start = loc->start_pos(); 57 end = loc->end_pos(); 58 script_handle = Script::GetWrapper(loc->script()); 59 } 60 61 Handle<Object> stack_frames_handle = stack_frames.is_null() 62 ? Handle<Object>::cast(factory->undefined_value()) 63 : Handle<Object>::cast(stack_frames); 64 65 Handle<JSMessageObject> message = 66 factory->NewJSMessageObject(type_handle, 67 arguments_handle, 68 start, 69 end, 70 script_handle, 71 stack_frames_handle); 72 73 return message; 74 } 75 76 77 void MessageHandler::ReportMessage(Isolate* isolate, 78 MessageLocation* loc, 79 Handle<Object> message) { 80 // We are calling into embedder's code which can throw exceptions. 81 // Thus we need to save current exception state, reset it to the clean one 82 // and ignore scheduled exceptions callbacks can throw. 83 84 // We pass the exception object into the message handler callback though. 85 Object* exception_object = isolate->heap()->undefined_value(); 86 if (isolate->has_pending_exception()) { 87 exception_object = isolate->pending_exception(); 88 } 89 Handle<Object> exception_handle(exception_object, isolate); 90 91 Isolate::ExceptionScope exception_scope(isolate); 92 isolate->clear_pending_exception(); 93 isolate->set_external_caught_exception(false); 94 95 v8::Local<v8::Message> api_message_obj = v8::Utils::MessageToLocal(message); 96 v8::Local<v8::Value> api_exception_obj = v8::Utils::ToLocal(exception_handle); 97 98 v8::NeanderArray global_listeners(isolate->factory()->message_listeners()); 99 int global_length = global_listeners.length(); 100 if (global_length == 0) { 101 DefaultMessageReport(isolate, loc, message); 102 if (isolate->has_scheduled_exception()) { 103 isolate->clear_scheduled_exception(); 104 } 105 } else { 106 for (int i = 0; i < global_length; i++) { 107 HandleScope scope(isolate); 108 if (global_listeners.get(i)->IsUndefined()) continue; 109 v8::NeanderObject listener(JSObject::cast(global_listeners.get(i))); 110 Handle<Foreign> callback_obj(Foreign::cast(listener.get(0))); 111 v8::MessageCallback callback = 112 FUNCTION_CAST<v8::MessageCallback>(callback_obj->foreign_address()); 113 Handle<Object> callback_data(listener.get(1), isolate); 114 { 115 // Do not allow exceptions to propagate. 116 v8::TryCatch try_catch; 117 callback(api_message_obj, callback_data->IsUndefined() 118 ? api_exception_obj 119 : v8::Utils::ToLocal(callback_data)); 120 } 121 if (isolate->has_scheduled_exception()) { 122 isolate->clear_scheduled_exception(); 123 } 124 } 125 } 126 } 127 128 129 Handle<String> MessageHandler::GetMessage(Isolate* isolate, 130 Handle<Object> data) { 131 Factory* factory = isolate->factory(); 132 Handle<String> fmt_str = 133 factory->InternalizeOneByteString(STATIC_CHAR_VECTOR("FormatMessage")); 134 Handle<JSFunction> fun = Handle<JSFunction>::cast(Object::GetProperty( 135 isolate->js_builtins_object(), fmt_str).ToHandleChecked()); 136 Handle<JSMessageObject> message = Handle<JSMessageObject>::cast(data); 137 Handle<Object> argv[] = { Handle<Object>(message->type(), isolate), 138 Handle<Object>(message->arguments(), isolate) }; 139 140 MaybeHandle<Object> maybe_result = Execution::TryCall( 141 fun, isolate->js_builtins_object(), arraysize(argv), argv); 142 Handle<Object> result; 143 if (!maybe_result.ToHandle(&result) || !result->IsString()) { 144 return factory->InternalizeOneByteString(STATIC_CHAR_VECTOR("<error>")); 145 } 146 Handle<String> result_string = Handle<String>::cast(result); 147 // A string that has been obtained from JS code in this way is 148 // likely to be a complicated ConsString of some sort. We flatten it 149 // here to improve the efficiency of converting it to a C string and 150 // other operations that are likely to take place (see GetLocalizedMessage 151 // for example). 152 result_string = String::Flatten(result_string); 153 return result_string; 154 } 155 156 157 SmartArrayPointer<char> MessageHandler::GetLocalizedMessage( 158 Isolate* isolate, 159 Handle<Object> data) { 160 HandleScope scope(isolate); 161 return GetMessage(isolate, data)->ToCString(DISALLOW_NULLS); 162 } 163 164 165 } } // namespace v8::internal 166