Add explicit null checks after string conversions in the shells.

src/d8.cc

 // Copyright 2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 75 matching lines @@
 
 
 Shell::CounterMap Shell::counter_map_;
 i::OS::MemoryMappedFile* Shell::counters_file_ = NULL;
 CounterCollection Shell::local_counters_;
 CounterCollection* Shell::counters_ = &local_counters_;
 Persistent<Context> Shell::utility_context_;
 Persistent<Context> Shell::evaluation_context_;
 
 
+// Converts a V8 value to a C string.
+const char* ToCString(const v8::String::Utf8Value& value) {
+  return *value ? *value : "<string conversion failed>";
+}
+
+
 // Executes a string within the current v8 context.
 bool Shell::ExecuteString(Handle<String> source,
                           Handle<Value> name,
                           bool print_result,
                           bool report_exceptions) {
   HandleScope handle_scope;
   TryCatch try_catch;
   if (i::FLAG_debugger) {
     // When debugging make exceptions appear to be uncaught.
     try_catch.SetVerbose(true);
   }
   Handle<Script> script = Script::Compile(source, name);
   if (script.IsEmpty()) {
     // Print errors that happened during compilation.
     if (report_exceptions && !i::FLAG_debugger)
       ReportException(&try_catch);
     return false;
   } else {
     Handle<Value> result = script->Run();
     if (result.IsEmpty()) {
       // Print errors that happened during execution.
       if (report_exceptions && !i::FLAG_debugger)
         ReportException(&try_catch);
       return false;
     } else {
       if (print_result && !result->IsUndefined()) {
         // If all went well and the result wasn't undefined then print
         // the returned value.
-        String::Utf8Value str(result);
-        printf("%s\n", *str);
+        v8::String::Utf8Value str(result);
+        const char* cstr = ToCString(str);
+        printf("%s\n", cstr);
       }
       return true;
     }
   }
 }
 
 
 Handle<Value> Shell::Print(const Arguments& args) {
   bool first = true;
   for (int i = 0; i < args.Length(); i++) {
     HandleScope handle_scope;
     if (first) {
       first = false;
     } else {
       printf(" ");
     }
-    String::Utf8Value str(args[i]);
-    printf("%s", *str);
+    v8::String::Utf8Value str(args[i]);
+    const char* cstr = ToCString(str);
+    printf("%s", cstr);
   }
   printf("\n");
   return Undefined();
 }
 
 
 Handle<Value> Shell::Load(const Arguments& args) {
   for (int i = 0; i < args.Length(); i++) {
     HandleScope handle_scope;
     String::Utf8Value file(args[i]);
+    if (*file == NULL) {
+      return ThrowException(String::New("Error loading file"));
+    }
     Handle<String> source = ReadFile(*file);
     if (source.IsEmpty()) {
       return ThrowException(String::New("Error loading file"));
     }
     if (!ExecuteString(source, String::New(*file), false, false)) {
       return ThrowException(String::New("Error executing  file"));
     }
   }
   return Undefined();
 }
 
 
 Handle<Value> Shell::Quit(const Arguments& args) {
   int exit_code = args[0]->Int32Value();
   OnExit();
   exit(exit_code);
   return Undefined();
 }
 
 
 Handle<Value> Shell::Version(const Arguments& args) {
   return String::New(V8::GetVersion());
 }
 
 
 void Shell::ReportException(v8::TryCatch* try_catch) {
   HandleScope handle_scope;
-  String::Utf8Value exception(try_catch->Exception());
+  v8::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.
-    printf("%s\n", *exception);
+    printf("%s\n", exception_string);
   } else {
     // Print (filename):(line number): (message).
-    String::Utf8Value filename(message->GetScriptResourceName());
+    v8::String::Utf8Value filename(message->GetScriptResourceName());
+    const char* filename_string = ToCString(filename);
     int linenum = message->GetLineNumber();
-    printf("%s:%i: %s\n", *filename, linenum, *exception);
+    printf("%s:%i: %s\n", filename_string, linenum, exception_string);
     // Print line of source code.
-    String::Utf8Value sourceline(message->GetSourceLine());
-    printf("%s\n", *sourceline);
+    v8::String::Utf8Value sourceline(message->GetSourceLine());
+    const char* sourceline_string = ToCString(sourceline);
+    printf("%s\n", sourceline_string);
     // Print wavy underline (GetUnderline is deprecated).
     int start = message->GetStartColumn();
     for (int i = 0; i < start; i++) {
       printf(" ");
     }
     int end = message->GetEndColumn();
     for (int i = start; i < end; i++) {
       printf("^");
     }
     printf("\n");
@@ skipping 350 matching lines @@
   return 0;
 }
 
 
 }  // namespace v8
 
 
 int main(int argc, char* argv[]) {
   return v8::Shell::Main(argc, argv);
 }