| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2012 the V8 project authors. All rights reserved. | |
| 2 // Redistribution and use in source and binary forms, with or without | |
| 3 // modification, are permitted provided that the following conditions are | |
| 4 // met: | |
| 5 // | |
| 6 // * Redistributions of source code must retain the above copyright | |
| 7 // notice, this list of conditions and the following disclaimer. | |
| 8 // * Redistributions in binary form must reproduce the above | |
| 9 // copyright notice, this list of conditions and the following | |
| 10 // disclaimer in the documentation and/or other materials provided | |
| 11 // with the distribution. | |
| 12 // * Neither the name of Google Inc. nor the names of its | |
| 13 // contributors may be used to endorse or promote products derived | |
| 14 // from this software without specific prior written permission. | |
| 15 // | |
| 16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
| 17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
| 18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
| 19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
| 20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
| 21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
| 22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
| 23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
| 24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| 25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| 26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| 27 | |
| 28 #include <include/v8.h> | |
| 29 | |
| 30 #include <include/libplatform/libplatform.h> | |
| 31 #include <include/v8-debug.h> | |
| 32 | |
| 33 #include <fcntl.h> | |
| 34 #include <stdio.h> | |
| 35 #include <stdlib.h> | |
| 36 #include <string.h> | |
| 37 | |
| 38 /** | |
| 39 * This sample program should demonstrate certain aspects of debugging | |
| 40 * standalone V8-based application. | |
| 41 * | |
| 42 * The program reads input stream, processes it line by line and print | |
| 43 * the result to output. The actual processing is done by custom JavaScript | |
| 44 * script. The script is specified with command line parameters. | |
| 45 * | |
| 46 * The main cycle of the program will sequentially read lines from standard | |
| 47 * input, process them and print to standard output until input closes. | |
| 48 * There are 2 possible configuration in regard to main cycle. | |
| 49 * | |
| 50 * 1. The main cycle is on C++ side. Program should be run with | |
| 51 * --main-cycle-in-cpp option. Script must declare a function named | |
| 52 * "ProcessLine". The main cycle in C++ reads lines and calls this function | |
| 53 * for processing every time. This is a sample script: | |
| 54 | |
| 55 function ProcessLine(input_line) { | |
| 56 return ">>>" + input_line + "<<<"; | |
| 57 } | |
| 58 | |
| 59 * | |
| 60 * 2. The main cycle is in JavaScript. Program should be run with | |
| 61 * --main-cycle-in-js option. Script gets run one time at all and gets | |
| 62 * API of 2 global functions: "read_line" and "print". It should read input | |
| 63 * and print converted lines to output itself. This a sample script: | |
| 64 | |
| 65 while (true) { | |
| 66 var line = read_line(); | |
| 67 if (!line) { | |
| 68 break; | |
| 69 } | |
| 70 var res = line + " | " + line; | |
| 71 print(res); | |
| 72 } | |
| 73 */ | |
| 74 | |
| 75 enum MainCycleType { | |
| 76 CycleInCpp, | |
| 77 CycleInJs | |
| 78 }; | |
| 79 | |
| 80 const char* ToCString(const v8::String::Utf8Value& value); | |
| 81 void ReportException(v8::Isolate* isolate, v8::TryCatch* handler); | |
| 82 v8::Handle<v8::String> ReadFile(v8::Isolate* isolate, const char* name); | |
| 83 v8::Handle<v8::String> ReadLine(); | |
| 84 | |
| 85 void Print(const v8::FunctionCallbackInfo<v8::Value>& args); | |
| 86 void ReadLine(const v8::FunctionCallbackInfo<v8::Value>& args); | |
| 87 bool RunCppCycle(v8::Handle<v8::Script> script, | |
| 88 v8::Local<v8::Context> context, | |
| 89 bool report_exceptions); | |
| 90 | |
| 91 | |
| 92 v8::Persistent<v8::Context> debug_message_context; | |
| 93 | |
| 94 int RunMain(int argc, char* argv[]) { | |
| 95 v8::V8::SetFlagsFromCommandLine(&argc, argv, true); | |
| 96 v8::Isolate* isolate = v8::Isolate::New(); | |
| 97 v8::Isolate::Scope isolate_scope(isolate); | |
| 98 v8::HandleScope handle_scope(isolate); | |
| 99 | |
| 100 v8::Handle<v8::String> script_source; | |
| 101 v8::Handle<v8::Value> script_name; | |
| 102 int script_param_counter = 0; | |
| 103 | |
| 104 MainCycleType cycle_type = CycleInCpp; | |
| 105 | |
| 106 for (int i = 1; i < argc; i++) { | |
| 107 const char* str = argv[i]; | |
| 108 if (strcmp(str, "-f") == 0) { | |
| 109 // Ignore any -f flags for compatibility with the other stand- | |
| 110 // alone JavaScript engines. | |
| 111 continue; | |
| 112 } else if (strcmp(str, "--main-cycle-in-cpp") == 0) { | |
| 113 cycle_type = CycleInCpp; | |
| 114 } else if (strcmp(str, "--main-cycle-in-js") == 0) { | |
| 115 cycle_type = CycleInJs; | |
| 116 } else if (strncmp(str, "--", 2) == 0) { | |
| 117 printf("Warning: unknown flag %s.\nTry --help for options\n", str); | |
| 118 } else if (strcmp(str, "-e") == 0 && i + 1 < argc) { | |
| 119 script_source = v8::String::NewFromUtf8(isolate, argv[i + 1]); | |
| 120 script_name = v8::String::NewFromUtf8(isolate, "unnamed"); | |
| 121 i++; | |
| 122 script_param_counter++; | |
| 123 } else { | |
| 124 // Use argument as a name of file to load. | |
| 125 script_source = ReadFile(isolate, str); | |
| 126 script_name = v8::String::NewFromUtf8(isolate, str); | |
| 127 if (script_source.IsEmpty()) { | |
| 128 printf("Error reading '%s'\n", str); | |
| 129 return 1; | |
| 130 } | |
| 131 script_param_counter++; | |
| 132 } | |
| 133 } | |
| 134 | |
| 135 if (script_param_counter == 0) { | |
| 136 printf("Script is not specified\n"); | |
| 137 return 1; | |
| 138 } | |
| 139 if (script_param_counter != 1) { | |
| 140 printf("Only one script may be specified\n"); | |
| 141 return 1; | |
| 142 } | |
| 143 | |
| 144 // Create a template for the global object. | |
| 145 v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New(isolate); | |
| 146 | |
| 147 // Bind the global 'print' function to the C++ Print callback. | |
| 148 global->Set(v8::String::NewFromUtf8(isolate, "print"), | |
| 149 v8::FunctionTemplate::New(isolate, Print)); | |
| 150 | |
| 151 if (cycle_type == CycleInJs) { | |
| 152 // Bind the global 'read_line' function to the C++ Print callback. | |
| 153 global->Set(v8::String::NewFromUtf8(isolate, "read_line"), | |
| 154 v8::FunctionTemplate::New(isolate, ReadLine)); | |
| 155 } | |
| 156 | |
| 157 // Create a new execution environment containing the built-in | |
| 158 // functions | |
| 159 v8::Handle<v8::Context> context = v8::Context::New(isolate, NULL, global); | |
| 160 // Enter the newly created execution environment. | |
| 161 v8::Context::Scope context_scope(context); | |
| 162 | |
| 163 debug_message_context.Reset(isolate, context); | |
| 164 | |
| 165 bool report_exceptions = true; | |
| 166 | |
| 167 v8::Handle<v8::Script> script; | |
| 168 { | |
| 169 // Compile script in try/catch context. | |
| 170 v8::TryCatch try_catch; | |
| 171 v8::ScriptOrigin origin(script_name); | |
| 172 script = v8::Script::Compile(script_source, &origin); | |
| 173 if (script.IsEmpty()) { | |
| 174 // Print errors that happened during compilation. | |
| 175 if (report_exceptions) | |
| 176 ReportException(isolate, &try_catch); | |
| 177 return 1; | |
| 178 } | |
| 179 } | |
| 180 | |
| 181 { | |
| 182 v8::TryCatch try_catch; | |
| 183 | |
| 184 script->Run(); | |
| 185 if (try_catch.HasCaught()) { | |
| 186 if (report_exceptions) | |
| 187 ReportException(isolate, &try_catch); | |
| 188 return 1; | |
| 189 } | |
| 190 } | |
| 191 | |
| 192 if (cycle_type == CycleInCpp) { | |
| 193 bool res = RunCppCycle(script, | |
| 194 isolate->GetCurrentContext(), | |
| 195 report_exceptions); | |
| 196 return !res; | |
| 197 } else { | |
| 198 // All is already done. | |
| 199 } | |
| 200 return 0; | |
| 201 } | |
| 202 | |
| 203 | |
| 204 bool RunCppCycle(v8::Handle<v8::Script> script, | |
| 205 v8::Local<v8::Context> context, | |
| 206 bool report_exceptions) { | |
| 207 v8::Isolate* isolate = context->GetIsolate(); | |
| 208 | |
| 209 v8::Handle<v8::String> fun_name = | |
| 210 v8::String::NewFromUtf8(isolate, "ProcessLine"); | |
| 211 v8::Handle<v8::Value> process_val = context->Global()->Get(fun_name); | |
| 212 | |
| 213 // If there is no Process function, or if it is not a function, | |
| 214 // bail out | |
| 215 if (!process_val->IsFunction()) { | |
| 216 printf("Error: Script does not declare 'ProcessLine' global function.\n"); | |
| 217 return 1; | |
| 218 } | |
| 219 | |
| 220 // It is a function; cast it to a Function | |
| 221 v8::Handle<v8::Function> process_fun = | |
| 222 v8::Handle<v8::Function>::Cast(process_val); | |
| 223 | |
| 224 | |
| 225 while (!feof(stdin)) { | |
| 226 v8::HandleScope handle_scope(isolate); | |
| 227 | |
| 228 v8::Handle<v8::String> input_line = ReadLine(); | |
| 229 if (input_line == v8::Undefined(isolate)) { | |
| 230 continue; | |
| 231 } | |
| 232 | |
| 233 const int argc = 1; | |
| 234 v8::Handle<v8::Value> argv[argc] = { input_line }; | |
| 235 | |
| 236 v8::Handle<v8::Value> result; | |
| 237 { | |
| 238 v8::TryCatch try_catch; | |
| 239 result = process_fun->Call(isolate->GetCurrentContext()->Global(), | |
| 240 argc, argv); | |
| 241 if (try_catch.HasCaught()) { | |
| 242 if (report_exceptions) | |
| 243 ReportException(isolate, &try_catch); | |
| 244 return false; | |
| 245 } | |
| 246 } | |
| 247 v8::String::Utf8Value str(result); | |
| 248 const char* cstr = ToCString(str); | |
| 249 printf("%s\n", cstr); | |
| 250 } | |
| 251 | |
| 252 return true; | |
| 253 } | |
| 254 | |
| 255 | |
| 256 int main(int argc, char* argv[]) { | |
| 257 v8::V8::InitializeICU(); | |
| 258 v8::Platform* platform = v8::platform::CreateDefaultPlatform(); | |
| 259 v8::V8::InitializePlatform(platform); | |
| 260 v8::V8::Initialize(); | |
| 261 int result = RunMain(argc, argv); | |
| 262 v8::V8::Dispose(); | |
| 263 v8::V8::ShutdownPlatform(); | |
| 264 delete platform; | |
| 265 return result; | |
| 266 } | |
| 267 | |
| 268 | |
| 269 // Extracts a C string from a V8 Utf8Value. | |
| 270 const char* ToCString(const v8::String::Utf8Value& value) { | |
| 271 return *value ? *value : "<string conversion failed>"; | |
| 272 } | |
| 273 | |
| 274 | |
| 275 // Reads a file into a v8 string. | |
| 276 v8::Handle<v8::String> ReadFile(v8::Isolate* isolate, const char* name) { | |
| 277 FILE* file = fopen(name, "rb"); | |
| 278 if (file == NULL) return v8::Handle<v8::String>(); | |
| 279 | |
| 280 fseek(file, 0, SEEK_END); | |
| 281 int size = ftell(file); | |
| 282 rewind(file); | |
| 283 | |
| 284 char* chars = new char[size + 1]; | |
| 285 chars[size] = '\0'; | |
| 286 for (int i = 0; i < size;) { | |
| 287 int read = static_cast<int>(fread(&chars[i], 1, size - i, file)); | |
| 288 i += read; | |
| 289 } | |
| 290 fclose(file); | |
| 291 v8::Handle<v8::String> result = | |
| 292 v8::String::NewFromUtf8(isolate, chars, v8::String::kNormalString, size); | |
| 293 delete[] chars; | |
| 294 return result; | |
| 295 } | |
| 296 | |
| 297 | |
| 298 void ReportException(v8::Isolate* isolate, v8::TryCatch* try_catch) { | |
| 299 v8::HandleScope handle_scope(isolate); | |
| 300 v8::String::Utf8Value exception(try_catch->Exception()); | |
| 301 const char* exception_string = ToCString(exception); | |
| 302 v8::Handle<v8::Message> message = try_catch->Message(); | |
| 303 if (message.IsEmpty()) { | |
| 304 // V8 didn't provide any extra information about this error; just | |
| 305 // print the exception. | |
| 306 printf("%s\n", exception_string); | |
| 307 } else { | |
| 308 // Print (filename):(line number): (message). | |
| 309 v8::String::Utf8Value filename(message->GetScriptOrigin().ResourceName()); | |
| 310 const char* filename_string = ToCString(filename); | |
| 311 int linenum = message->GetLineNumber(); | |
| 312 printf("%s:%i: %s\n", filename_string, linenum, exception_string); | |
| 313 // Print line of source code. | |
| 314 v8::String::Utf8Value sourceline(message->GetSourceLine()); | |
| 315 const char* sourceline_string = ToCString(sourceline); | |
| 316 printf("%s\n", sourceline_string); | |
| 317 // Print wavy underline (GetUnderline is deprecated). | |
| 318 int start = message->GetStartColumn(); | |
| 319 for (int i = 0; i < start; i++) { | |
| 320 printf(" "); | |
| 321 } | |
| 322 int end = message->GetEndColumn(); | |
| 323 for (int i = start; i < end; i++) { | |
| 324 printf("^"); | |
| 325 } | |
| 326 printf("\n"); | |
| 327 } | |
| 328 } | |
| 329 | |
| 330 | |
| 331 // The callback that is invoked by v8 whenever the JavaScript 'print' | |
| 332 // function is called. Prints its arguments on stdout separated by | |
| 333 // spaces and ending with a newline. | |
| 334 void Print(const v8::FunctionCallbackInfo<v8::Value>& args) { | |
| 335 bool first = true; | |
| 336 for (int i = 0; i < args.Length(); i++) { | |
| 337 v8::HandleScope handle_scope(args.GetIsolate()); | |
| 338 if (first) { | |
| 339 first = false; | |
| 340 } else { | |
| 341 printf(" "); | |
| 342 } | |
| 343 v8::String::Utf8Value str(args[i]); | |
| 344 const char* cstr = ToCString(str); | |
| 345 printf("%s", cstr); | |
| 346 } | |
| 347 printf("\n"); | |
| 348 fflush(stdout); | |
| 349 } | |
| 350 | |
| 351 | |
| 352 // The callback that is invoked by v8 whenever the JavaScript 'read_line' | |
| 353 // function is called. Reads a string from standard input and returns. | |
| 354 void ReadLine(const v8::FunctionCallbackInfo<v8::Value>& args) { | |
| 355 if (args.Length() > 0) { | |
| 356 args.GetIsolate()->ThrowException( | |
| 357 v8::String::NewFromUtf8(args.GetIsolate(), "Unexpected arguments")); | |
| 358 return; | |
| 359 } | |
| 360 args.GetReturnValue().Set(ReadLine()); | |
| 361 } | |
| 362 | |
| 363 | |
| 364 v8::Handle<v8::String> ReadLine() { | |
| 365 const int kBufferSize = 1024 + 1; | |
| 366 char buffer[kBufferSize]; | |
| 367 | |
| 368 char* res; | |
| 369 { | |
| 370 res = fgets(buffer, kBufferSize, stdin); | |
| 371 } | |
| 372 v8::Isolate* isolate = v8::Isolate::GetCurrent(); | |
| 373 if (res == NULL) { | |
| 374 v8::Handle<v8::Primitive> t = v8::Undefined(isolate); | |
| 375 return v8::Handle<v8::String>::Cast(t); | |
| 376 } | |
| 377 // Remove newline char | |
| 378 for (char* pos = buffer; *pos != '\0'; pos++) { | |
| 379 if (*pos == '\n') { | |
| 380 *pos = '\0'; | |
| 381 break; | |
| 382 } | |
| 383 } | |
| 384 return v8::String::NewFromUtf8(isolate, buffer); | |
| 385 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 754043002:
Remove lineprocessor sample. (Closed)
Base URL: https://chromium.googlesource.com/v8/v8.git@master