Send non-JS output (e.g. errors) to stderr, instead of stdout.

samples/shell.cc

 // Copyright 2012 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 54 matching lines @@
 
 
 int main(int argc, char* argv[]) {
   v8::V8::SetFlagsFromCommandLine(&argc, argv, true);
   run_shell = (argc == 1);
   int result;
   {
     v8::HandleScope handle_scope;
     v8::Persistent<v8::Context> context = CreateShellContext();
     if (context.IsEmpty()) {
-      printf("Error creating context\n");
+      fprintf(stderr, "Error creating context\n");
       return 1;
     }
     context->Enter();
     result = RunMain(argc, argv);
     if (run_shell) RunShell(context);
     context->Exit();
     context.Dispose();
   }
   v8::V8::Dispose();
   return result;
@@ skipping 133 matching lines @@
 int RunMain(int argc, char* argv[]) {
   for (int i = 1; i < argc; i++) {
     const char* str = argv[i];
     if (strcmp(str, "--shell") == 0) {
       run_shell = true;
     } else if (strcmp(str, "-f") == 0) {
       // Ignore any -f flags for compatibility with the other stand-
       // alone JavaScript engines.
       continue;
     } else if (strncmp(str, "--", 2) == 0) {
-      printf("Warning: unknown flag %s.\nTry --help for options\n", str);
+      fprintf(stderr,
+          "Warning: unknown flag %s.\nTry --help for options\n", str);
     } else if (strcmp(str, "-e") == 0 && i + 1 < argc) {
       // Execute argument given to -e option directly.
       v8::Handle<v8::String> file_name = v8::String::New("unnamed");
       v8::Handle<v8::String> source = v8::String::New(argv[++i]);
       if (!ExecuteString(source, file_name, false, true)) return 1;
     } else {
       // Use all other arguments as names of files to load and run.
       v8::Handle<v8::String> file_name = v8::String::New(str);
       v8::Handle<v8::String> source = ReadFile(str);
       if (source.IsEmpty()) {
-        printf("Error reading '%s'\n", str);
+        fprintf(stderr, "Error reading '%s'\n", str);
         continue;
       }
       if (!ExecuteString(source, file_name, false, true)) return 1;
     }
   }
   return 0;
 }
 
 
 // The read-eval-execute loop of the shell.
 void RunShell(v8::Handle<v8::Context> context) {
-  printf("V8 version %s [sample shell]\n", v8::V8::GetVersion());
+  fprintf(stderr, "V8 version %s [sample shell]\n", v8::V8::GetVersion());

[Yang, 2012/11/13 08:48:17]

This is the prompt of the interactive shell and must not go to stderr.

[Patrick Dubroy, 2012/11/13 09:56:28]

I thought I mentioned this yesterday, but that is the way that Python does it.

    ~/dev/chromium/src$ python > /tmp/python-output
    Python 2.7.3 (default, Aug  1 2012, 05:14:39) 
    [GCC 4.6.3] on linux2
    Type "help", "copyright", "credits" or "license" for more information.
    >>> def a():
    ...     print 3
    ... 
    >>> a()
    >>> 
    ~/dev/chromium/src$ cat /tmp/python-output 
    3

It seems reasonable to me, but I can change that if you'd like.

   static const int kBufferSize = 256;
   // Enter the execution environment before evaluating any code.
   v8::Context::Scope context_scope(context);
   v8::Local<v8::String> name(v8::String::New("(shell)"));
   while (true) {
     char buffer[kBufferSize];
-    printf("> ");
+    fprintf(stderr, "> ");

[Yang, 2012/11/13 08:48:17]

Ditto.

     char* str = fgets(buffer, kBufferSize, stdin);
     if (str == NULL) break;
     v8::HandleScope handle_scope;
     ExecuteString(v8::String::New(str), name, true, true);
   }
-  printf("\n");
+  fprintf(stderr, "\n");

[Yang, 2012/11/13 08:48:17]

Ditto.

 }
 
 
 // Executes a string within the current v8 context.
 bool ExecuteString(v8::Handle<v8::String> source,
                    v8::Handle<v8::Value> name,
                    bool print_result,
                    bool report_exceptions) {
   v8::HandleScope handle_scope;
   v8::TryCatch try_catch;
@@ skipping 27 matching lines @@
 
 
 void ReportException(v8::TryCatch* try_catch) {
   v8::HandleScope handle_scope;
   v8::String::Utf8Value exception(try_catch->Exception());
   const char* exception_string = ToCString(exception);
   v8::Handle<v8::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_string);
+    fprintf(stderr, "%s\n", exception_string);

[Yang, 2012/11/13 08:48:17]

This reports uncaught exceptions caused in javascript. I think the policy should
be that error messages caused in this shell (like failed read of a file) should
go to stderr and error messages of the javascript runtime should go to stdout.
Same goes for all the output in this function.

[Patrick Dubroy, 2012/11/13 09:56:28]

I disagree. An uncaught exception needs to be logged to stderr, not stdout.  

In the Chromium build use case, we have a script that generates a C++ class by
printing it to stdout, so we capture stdout from the script and send it to a
file. If uncaught exceptions aren't printed to stderr, we have no way of
actually extracting the error message.

Python and Ruby also send messages from uncaught exceptions to stderr:

    ~/dev/chromium/src$ python -c "raise Exception" > /dev/null
    Traceback (most recent call last):
      File "<string>", line 1, in <module>
    Exception

    ~/dev/chromium/src$ ruby -e "raise 'blah'" > /dev/null
    -e:1: blah (RuntimeError)

   } else {
     // Print (filename):(line number): (message).
     v8::String::Utf8Value filename(message->GetScriptResourceName());
     const char* filename_string = ToCString(filename);
     int linenum = message->GetLineNumber();
-    printf("%s:%i: %s\n", filename_string, linenum, exception_string);
+    fprintf(stderr, "%s:%i: %s\n", filename_string, linenum, exception_string);
     // Print line of source code.
     v8::String::Utf8Value sourceline(message->GetSourceLine());
     const char* sourceline_string = ToCString(sourceline);
-    printf("%s\n", sourceline_string);
+    fprintf(stderr, "%s\n", sourceline_string);
     // Print wavy underline (GetUnderline is deprecated).
     int start = message->GetStartColumn();
     for (int i = 0; i < start; i++) {
-      printf(" ");
+      fprintf(stderr, " ");
     }
     int end = message->GetEndColumn();
     for (int i = start; i < end; i++) {
-      printf("^");
+      fprintf(stderr, "^");
     }
-    printf("\n");
+    fprintf(stderr, "\n");
     v8::String::Utf8Value stack_trace(try_catch->StackTrace());
     if (stack_trace.length() > 0) {
       const char* stack_trace_string = ToCString(stack_trace);
-      printf("%s\n", stack_trace_string);
+      fprintf(stderr, "%s\n", stack_trace_string);
     }
   }
 }