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