Revised CL for customisable logging (replacing printfs).

runtime/bin/gen_snapshot.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // Generate a snapshot file after loading all the scripts specified on the
 // command line.
 
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 
 #include "include/dart_api.h"
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
 #include "bin/file.h"
+#include "bin/log.h"
+
 #include "platform/globals.h"
 
 #define CHECK_RESULT(result)                                                   \
   if (Dart_IsError(result)) {                                                  \
     free(snapshot_buffer);                                                     \
-    fprintf(stderr, "Error: %s", Dart_GetError(result));                       \
+    Log::PrintErr("Error: %s", Dart_GetError(result));                    \
     Dart_ExitScope();                                                          \
     Dart_ShutdownIsolate();                                                    \
     exit(255);                                                                 \
   }                                                                            \
 
 
 // Global state that indicates whether a snapshot is to be created and
 // if so which file to write the snapshot into.
 static const char* snapshot_filename = NULL;
 static bool script_snapshot = false;
@@ skipping 165 matching lines @@
   Dart_Handle lib;
   // Load the builtin library to make it available in the snapshot
   // for importing.
   lib = Builtin::LoadAndCheckLibrary(id);
   ASSERT(!Dart_IsError(lib));
   return lib;
 }
 
 
 static void PrintUsage() {
-  fprintf(stderr,
-          "dart [<vm-flags>] "
-          "[<dart-script-file>]\n");
+  Log::PrintErr("dart [<vm-flags>] [<dart-script-file>]\n");
 }
 
 
 static void VerifyLoaded(Dart_Handle library) {
   if (Dart_IsError(library)) {
     const char* err_msg = Dart_GetError(library);
-    fprintf(stderr, "Errors encountered while loading: %s\n", err_msg);
+    Log::PrintErr("Errors encountered while loading: %s\n", err_msg);
     Dart_ExitScope();
     Dart_ShutdownIsolate();
     exit(255);
   }
   ASSERT(Dart_IsLibrary(library));
 }
 
 
 static void CreateAndWriteSnapshot(bool script_snapshot) {
   Dart_Handle result;
@@ skipping 16 matching lines @@
 
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
 }
 
 
 static void SetupForGenericSnapshotCreation() {
   // Set up the library tag handler for this isolate.
   Dart_Handle result = Dart_SetLibraryTagHandler(DartUtils::LibraryTagHandler);
   if (Dart_IsError(result)) {
-    fprintf(stderr, "%s", Dart_GetError(result));
+    Log::PrintErr("%s", Dart_GetError(result));
     Dart_ExitScope();
     Dart_ShutdownIsolate();
     exit(255);
   }
   // This is a generic dart snapshot which needs builtin library setup.
   Dart_Handle library =
       LoadGenericSnapshotCreationScript(Builtin::kBuiltinLibrary);
   VerifyLoaded(library);
   library = LoadGenericSnapshotCreationScript(Builtin::kJsonLibrary);
   VerifyLoaded(library);
@@ skipping 18 matching lines @@
   // Parse command line arguments.
   if (ParseArguments(argc,
                      argv,
                      &vm_options,
                      &app_script_name) < 0) {
     PrintUsage();
     return 255;
   }
 
   if (snapshot_filename == NULL) {
-    fprintf(stderr, "No snapshot output file specified\n");
+    Log::PrintErr("No snapshot output file specified\n");
     return 255;
   }
 
   DartUtils::SetOriginalWorkingDirectory();
 
   Dart_SetVMFlags(vm_options.count(), vm_options.arguments());
 
   // Initialize the Dart VM.
   // Note: We don't expect isolates to be created from dart code during
   // snapshot generation.
   if (!Dart_Initialize(NULL, NULL, NULL)) {
-    fprintf(stderr, "VM initialization failed\n");
+    Log::PrintErr("VM initialization failed\n");
     return 255;
   }
 
   char* error;
   Dart_Isolate isolate = Dart_CreateIsolate(NULL, NULL, NULL, NULL, &error);
   if (isolate == NULL) {
-    fprintf(stderr, "Error: %s", error);
+    Log::PrintErr("Error: %s", error);
     free(error);
     exit(255);
   }
 
   Dart_Handle result;
   Dart_Handle library;
   Dart_EnterScope();
 
   ASSERT(snapshot_filename != NULL);
   // Load up the script before a snapshot is created.
@@ skipping 30 matching lines @@
       Dart_ExitScope();
       Dart_ShutdownIsolate();
 
       // Now load the specified script and create a script snapshot.
       Dart_Isolate isolate = Dart_CreateIsolate(NULL,
                                                 NULL,
                                                 snapshot_buffer,
                                                 NULL,
                                                 &error);
       if (isolate == NULL) {
-        fprintf(stderr, "%s", error);
+        Log::PrintErr("%s", error);
         free(error);
         free(snapshot_buffer);
         exit(255);
       }
       Dart_EnterScope();
 
       // Setup generic library tag handler.
       result = Dart_SetLibraryTagHandler(DartUtils::LibraryTagHandler);
       CHECK_RESULT(result);
 
@@ skipping 14 matching lines @@
       CreateAndWriteSnapshot(true);
 
       free(snapshot_buffer);
     }
   } else {
     SetupForGenericSnapshotCreation();
     CreateAndWriteSnapshot(false);
   }
   return 0;
 }