• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
32 #include <assert.h>
33 #include <fcntl.h>
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <string.h>
37 
38 /**
39  * This sample program shows how to implement a simple javascript shell
40  * based on V8.  This includes initializing V8 with command line options,
41  * creating global functions, compiling and executing strings.
42  *
43  * For a more sophisticated shell, consider using the debug shell D8.
44  */
45 
46 
47 v8::Local<v8::Context> CreateShellContext(v8::Isolate* isolate);
48 void RunShell(v8::Local<v8::Context> context, v8::Platform* platform);
49 int RunMain(v8::Isolate* isolate, v8::Platform* platform, int argc,
50             char* argv[]);
51 bool ExecuteString(v8::Isolate* isolate, v8::Local<v8::String> source,
52                    v8::Local<v8::Value> name, bool print_result,
53                    bool report_exceptions);
54 void Print(const v8::FunctionCallbackInfo<v8::Value>& args);
55 void Read(const v8::FunctionCallbackInfo<v8::Value>& args);
56 void Load(const v8::FunctionCallbackInfo<v8::Value>& args);
57 void Quit(const v8::FunctionCallbackInfo<v8::Value>& args);
58 void Version(const v8::FunctionCallbackInfo<v8::Value>& args);
59 v8::MaybeLocal<v8::String> ReadFile(v8::Isolate* isolate, const char* name);
60 void ReportException(v8::Isolate* isolate, v8::TryCatch* handler);
61 
62 
63 static bool run_shell;
64 
65 
main(int argc,char * argv[])66 int main(int argc, char* argv[]) {
67   v8::V8::InitializeICUDefaultLocation(argv[0]);
68   v8::V8::InitializeExternalStartupData(argv[0]);
69   std::unique_ptr<v8::Platform> platform = v8::platform::NewDefaultPlatform();
70   v8::V8::InitializePlatform(platform.get());
71   v8::V8::Initialize();
72   v8::V8::SetFlagsFromCommandLine(&argc, argv, true);
73   v8::Isolate::CreateParams create_params;
74   create_params.array_buffer_allocator =
75       v8::ArrayBuffer::Allocator::NewDefaultAllocator();
76   v8::Isolate* isolate = v8::Isolate::New(create_params);
77   run_shell = (argc == 1);
78   int result;
79   {
80     v8::Isolate::Scope isolate_scope(isolate);
81     v8::HandleScope handle_scope(isolate);
82     v8::Local<v8::Context> context = CreateShellContext(isolate);
83     if (context.IsEmpty()) {
84       fprintf(stderr, "Error creating context\n");
85       return 1;
86     }
87     v8::Context::Scope context_scope(context);
88     result = RunMain(isolate, platform.get(), argc, argv);
89     if (run_shell) RunShell(context, platform.get());
90   }
91   isolate->Dispose();
92   v8::V8::Dispose();
93   v8::V8::ShutdownPlatform();
94   delete create_params.array_buffer_allocator;
95   return result;
96 }
97 
98 
99 // Extracts a C string from a V8 Utf8Value.
ToCString(const v8::String::Utf8Value & value)100 const char* ToCString(const v8::String::Utf8Value& value) {
101   return *value ? *value : "<string conversion failed>";
102 }
103 
104 
105 // Creates a new execution environment containing the built-in
106 // functions.
CreateShellContext(v8::Isolate * isolate)107 v8::Local<v8::Context> CreateShellContext(v8::Isolate* isolate) {
108   // Create a template for the global object.
109   v8::Local<v8::ObjectTemplate> global = v8::ObjectTemplate::New(isolate);
110   // Bind the global 'print' function to the C++ Print callback.
111   global->Set(
112       v8::String::NewFromUtf8(isolate, "print", v8::NewStringType::kNormal)
113           .ToLocalChecked(),
114       v8::FunctionTemplate::New(isolate, Print));
115   // Bind the global 'read' function to the C++ Read callback.
116   global->Set(v8::String::NewFromUtf8(
117                   isolate, "read", v8::NewStringType::kNormal).ToLocalChecked(),
118               v8::FunctionTemplate::New(isolate, Read));
119   // Bind the global 'load' function to the C++ Load callback.
120   global->Set(v8::String::NewFromUtf8(
121                   isolate, "load", v8::NewStringType::kNormal).ToLocalChecked(),
122               v8::FunctionTemplate::New(isolate, Load));
123   // Bind the 'quit' function
124   global->Set(v8::String::NewFromUtf8(
125                   isolate, "quit", v8::NewStringType::kNormal).ToLocalChecked(),
126               v8::FunctionTemplate::New(isolate, Quit));
127   // Bind the 'version' function
128   global->Set(
129       v8::String::NewFromUtf8(isolate, "version", v8::NewStringType::kNormal)
130           .ToLocalChecked(),
131       v8::FunctionTemplate::New(isolate, Version));
132 
133   return v8::Context::New(isolate, NULL, global);
134 }
135 
136 
137 // The callback that is invoked by v8 whenever the JavaScript 'print'
138 // function is called.  Prints its arguments on stdout separated by
139 // spaces and ending with a newline.
Print(const v8::FunctionCallbackInfo<v8::Value> & args)140 void Print(const v8::FunctionCallbackInfo<v8::Value>& args) {
141   bool first = true;
142   for (int i = 0; i < args.Length(); i++) {
143     v8::HandleScope handle_scope(args.GetIsolate());
144     if (first) {
145       first = false;
146     } else {
147       printf(" ");
148     }
149     v8::String::Utf8Value str(args.GetIsolate(), args[i]);
150     const char* cstr = ToCString(str);
151     printf("%s", cstr);
152   }
153   printf("\n");
154   fflush(stdout);
155 }
156 
157 
158 // The callback that is invoked by v8 whenever the JavaScript 'read'
159 // function is called.  This function loads the content of the file named in
160 // the argument into a JavaScript string.
Read(const v8::FunctionCallbackInfo<v8::Value> & args)161 void Read(const v8::FunctionCallbackInfo<v8::Value>& args) {
162   if (args.Length() != 1) {
163     args.GetIsolate()->ThrowException(
164         v8::String::NewFromUtf8(args.GetIsolate(), "Bad parameters",
165                                 v8::NewStringType::kNormal).ToLocalChecked());
166     return;
167   }
168   v8::String::Utf8Value file(args.GetIsolate(), args[0]);
169   if (*file == NULL) {
170     args.GetIsolate()->ThrowException(
171         v8::String::NewFromUtf8(args.GetIsolate(), "Error loading file",
172                                 v8::NewStringType::kNormal).ToLocalChecked());
173     return;
174   }
175   v8::Local<v8::String> source;
176   if (!ReadFile(args.GetIsolate(), *file).ToLocal(&source)) {
177     args.GetIsolate()->ThrowException(
178         v8::String::NewFromUtf8(args.GetIsolate(), "Error loading file",
179                                 v8::NewStringType::kNormal).ToLocalChecked());
180     return;
181   }
182 
183   args.GetReturnValue().Set(source);
184 }
185 
186 // The callback that is invoked by v8 whenever the JavaScript 'load'
187 // function is called.  Loads, compiles and executes its argument
188 // JavaScript file.
Load(const v8::FunctionCallbackInfo<v8::Value> & args)189 void Load(const v8::FunctionCallbackInfo<v8::Value>& args) {
190   for (int i = 0; i < args.Length(); i++) {
191     v8::HandleScope handle_scope(args.GetIsolate());
192     v8::String::Utf8Value file(args.GetIsolate(), args[i]);
193     if (*file == NULL) {
194       args.GetIsolate()->ThrowException(
195           v8::String::NewFromUtf8(args.GetIsolate(), "Error loading file",
196                                   v8::NewStringType::kNormal).ToLocalChecked());
197       return;
198     }
199     v8::Local<v8::String> source;
200     if (!ReadFile(args.GetIsolate(), *file).ToLocal(&source)) {
201       args.GetIsolate()->ThrowException(
202           v8::String::NewFromUtf8(args.GetIsolate(), "Error loading file",
203                                   v8::NewStringType::kNormal).ToLocalChecked());
204       return;
205     }
206     if (!ExecuteString(args.GetIsolate(), source, args[i], false, false)) {
207       args.GetIsolate()->ThrowException(
208           v8::String::NewFromUtf8(args.GetIsolate(), "Error executing file",
209                                   v8::NewStringType::kNormal).ToLocalChecked());
210       return;
211     }
212   }
213 }
214 
215 
216 // The callback that is invoked by v8 whenever the JavaScript 'quit'
217 // function is called.  Quits.
Quit(const v8::FunctionCallbackInfo<v8::Value> & args)218 void Quit(const v8::FunctionCallbackInfo<v8::Value>& args) {
219   // If not arguments are given args[0] will yield undefined which
220   // converts to the integer value 0.
221   int exit_code =
222       args[0]->Int32Value(args.GetIsolate()->GetCurrentContext()).FromMaybe(0);
223   fflush(stdout);
224   fflush(stderr);
225   exit(exit_code);
226 }
227 
228 
Version(const v8::FunctionCallbackInfo<v8::Value> & args)229 void Version(const v8::FunctionCallbackInfo<v8::Value>& args) {
230   args.GetReturnValue().Set(
231       v8::String::NewFromUtf8(args.GetIsolate(), v8::V8::GetVersion(),
232                               v8::NewStringType::kNormal).ToLocalChecked());
233 }
234 
235 
236 // Reads a file into a v8 string.
ReadFile(v8::Isolate * isolate,const char * name)237 v8::MaybeLocal<v8::String> ReadFile(v8::Isolate* isolate, const char* name) {
238   FILE* file = fopen(name, "rb");
239   if (file == NULL) return v8::MaybeLocal<v8::String>();
240 
241   fseek(file, 0, SEEK_END);
242   size_t size = ftell(file);
243   rewind(file);
244 
245   char* chars = new char[size + 1];
246   chars[size] = '\0';
247   for (size_t i = 0; i < size;) {
248     i += fread(&chars[i], 1, size - i, file);
249     if (ferror(file)) {
250       fclose(file);
251       return v8::MaybeLocal<v8::String>();
252     }
253   }
254   fclose(file);
255   v8::MaybeLocal<v8::String> result = v8::String::NewFromUtf8(
256       isolate, chars, v8::NewStringType::kNormal, static_cast<int>(size));
257   delete[] chars;
258   return result;
259 }
260 
261 
262 // Process remaining command line arguments and execute files
RunMain(v8::Isolate * isolate,v8::Platform * platform,int argc,char * argv[])263 int RunMain(v8::Isolate* isolate, v8::Platform* platform, int argc,
264             char* argv[]) {
265   for (int i = 1; i < argc; i++) {
266     const char* str = argv[i];
267     if (strcmp(str, "--shell") == 0) {
268       run_shell = true;
269     } else if (strcmp(str, "-f") == 0) {
270       // Ignore any -f flags for compatibility with the other stand-
271       // alone JavaScript engines.
272       continue;
273     } else if (strncmp(str, "--", 2) == 0) {
274       fprintf(stderr,
275               "Warning: unknown flag %s.\nTry --help for options\n", str);
276     } else if (strcmp(str, "-e") == 0 && i + 1 < argc) {
277       // Execute argument given to -e option directly.
278       v8::Local<v8::String> file_name =
279           v8::String::NewFromUtf8(isolate, "unnamed",
280                                   v8::NewStringType::kNormal).ToLocalChecked();
281       v8::Local<v8::String> source;
282       if (!v8::String::NewFromUtf8(isolate, argv[++i],
283                                    v8::NewStringType::kNormal)
284                .ToLocal(&source)) {
285         return 1;
286       }
287       bool success = ExecuteString(isolate, source, file_name, false, true);
288       while (v8::platform::PumpMessageLoop(platform, isolate)) continue;
289       if (!success) return 1;
290     } else {
291       // Use all other arguments as names of files to load and run.
292       v8::Local<v8::String> file_name =
293           v8::String::NewFromUtf8(isolate, str, v8::NewStringType::kNormal)
294               .ToLocalChecked();
295       v8::Local<v8::String> source;
296       if (!ReadFile(isolate, str).ToLocal(&source)) {
297         fprintf(stderr, "Error reading '%s'\n", str);
298         continue;
299       }
300       bool success = ExecuteString(isolate, source, file_name, false, true);
301       while (v8::platform::PumpMessageLoop(platform, isolate)) continue;
302       if (!success) return 1;
303     }
304   }
305   return 0;
306 }
307 
308 
309 // The read-eval-execute loop of the shell.
RunShell(v8::Local<v8::Context> context,v8::Platform * platform)310 void RunShell(v8::Local<v8::Context> context, v8::Platform* platform) {
311   fprintf(stderr, "V8 version %s [sample shell]\n", v8::V8::GetVersion());
312   static const int kBufferSize = 256;
313   // Enter the execution environment before evaluating any code.
314   v8::Context::Scope context_scope(context);
315   v8::Local<v8::String> name(
316       v8::String::NewFromUtf8(context->GetIsolate(), "(shell)",
317                               v8::NewStringType::kNormal).ToLocalChecked());
318   while (true) {
319     char buffer[kBufferSize];
320     fprintf(stderr, "> ");
321     char* str = fgets(buffer, kBufferSize, stdin);
322     if (str == NULL) break;
323     v8::HandleScope handle_scope(context->GetIsolate());
324     ExecuteString(
325         context->GetIsolate(),
326         v8::String::NewFromUtf8(context->GetIsolate(), str,
327                                 v8::NewStringType::kNormal).ToLocalChecked(),
328         name, true, true);
329     while (v8::platform::PumpMessageLoop(platform, context->GetIsolate()))
330       continue;
331   }
332   fprintf(stderr, "\n");
333 }
334 
335 
336 // Executes a string within the current v8 context.
ExecuteString(v8::Isolate * isolate,v8::Local<v8::String> source,v8::Local<v8::Value> name,bool print_result,bool report_exceptions)337 bool ExecuteString(v8::Isolate* isolate, v8::Local<v8::String> source,
338                    v8::Local<v8::Value> name, bool print_result,
339                    bool report_exceptions) {
340   v8::HandleScope handle_scope(isolate);
341   v8::TryCatch try_catch(isolate);
342   v8::ScriptOrigin origin(name);
343   v8::Local<v8::Context> context(isolate->GetCurrentContext());
344   v8::Local<v8::Script> script;
345   if (!v8::Script::Compile(context, source, &origin).ToLocal(&script)) {
346     // Print errors that happened during compilation.
347     if (report_exceptions)
348       ReportException(isolate, &try_catch);
349     return false;
350   } else {
351     v8::Local<v8::Value> result;
352     if (!script->Run(context).ToLocal(&result)) {
353       assert(try_catch.HasCaught());
354       // Print errors that happened during execution.
355       if (report_exceptions)
356         ReportException(isolate, &try_catch);
357       return false;
358     } else {
359       assert(!try_catch.HasCaught());
360       if (print_result && !result->IsUndefined()) {
361         // If all went well and the result wasn't undefined then print
362         // the returned value.
363         v8::String::Utf8Value str(isolate, result);
364         const char* cstr = ToCString(str);
365         printf("%s\n", cstr);
366       }
367       return true;
368     }
369   }
370 }
371 
372 
ReportException(v8::Isolate * isolate,v8::TryCatch * try_catch)373 void ReportException(v8::Isolate* isolate, v8::TryCatch* try_catch) {
374   v8::HandleScope handle_scope(isolate);
375   v8::String::Utf8Value exception(isolate, try_catch->Exception());
376   const char* exception_string = ToCString(exception);
377   v8::Local<v8::Message> message = try_catch->Message();
378   if (message.IsEmpty()) {
379     // V8 didn't provide any extra information about this error; just
380     // print the exception.
381     fprintf(stderr, "%s\n", exception_string);
382   } else {
383     // Print (filename):(line number): (message).
384     v8::String::Utf8Value filename(isolate,
385                                    message->GetScriptOrigin().ResourceName());
386     v8::Local<v8::Context> context(isolate->GetCurrentContext());
387     const char* filename_string = ToCString(filename);
388     int linenum = message->GetLineNumber(context).FromJust();
389     fprintf(stderr, "%s:%i: %s\n", filename_string, linenum, exception_string);
390     // Print line of source code.
391     v8::String::Utf8Value sourceline(
392         isolate, message->GetSourceLine(context).ToLocalChecked());
393     const char* sourceline_string = ToCString(sourceline);
394     fprintf(stderr, "%s\n", sourceline_string);
395     // Print wavy underline (GetUnderline is deprecated).
396     int start = message->GetStartColumn(context).FromJust();
397     for (int i = 0; i < start; i++) {
398       fprintf(stderr, " ");
399     }
400     int end = message->GetEndColumn(context).FromJust();
401     for (int i = start; i < end; i++) {
402       fprintf(stderr, "^");
403     }
404     fprintf(stderr, "\n");
405     v8::Local<v8::Value> stack_trace_string;
406     if (try_catch->StackTrace(context).ToLocal(&stack_trace_string) &&
407         stack_trace_string->IsString() &&
408         v8::Local<v8::String>::Cast(stack_trace_string)->Length() > 0) {
409       v8::String::Utf8Value stack_trace(isolate, stack_trace_string);
410       const char* stack_trace_string = ToCString(stack_trace);
411       fprintf(stderr, "%s\n", stack_trace_string);
412     }
413   }
414 }
415