Call exit instead of returning from main

runtime/bin/main.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.
 
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 
 #include "include/dart_api.h"
 #include "include/dart_debugger_api.h"
@@ skipping 671 matching lines @@
   return buffer;
 }
 
 
 // Exit code indicating a compilation error.
 static const int kCompilationErrorExitCode = 254;
 
 // Exit code indicating an unhandled error that is not a compilation error.
 static const int kErrorExitCode = 255;
 
+static void Exit(int exit_code) {

[Ivan Posva, 2013/11/26 18:05:53]

Seems like extra unneeded abstraction.

+  exit(exit_code);
+}
 
-static int ErrorExit(int exit_code, const char* format, ...) {
+static void ErrorExit(int exit_code, const char* format, ...) {
   va_list arguments;
   va_start(arguments, format);
   Log::VPrintErr(format, arguments);
   va_end(arguments);
   fflush(stderr);
 
   Dart_ExitScope();
   Dart_ShutdownIsolate();
 
   Dart_Cleanup();
 
-  return exit_code;
+  Exit(exit_code);
 }
 
 
-static int DartErrorExit(Dart_Handle error) {
+static void DartErrorExit(Dart_Handle error) {

[Ivan Posva, 2013/11/26 18:05:53]

How about DartExitOnError(Dart_Handle result)? To avoid the if
(Dart_IsError(xyz)) DartErrorExit(xyz); sequences.

   const int exit_code = Dart_IsCompilationError(error) ?
       kCompilationErrorExitCode : kErrorExitCode;
-  return ErrorExit(exit_code, "%s\n", Dart_GetError(error));
+  ErrorExit(exit_code, "%s\n", Dart_GetError(error));
 }
 
 
 static void ShutdownIsolate(void* callback_data) {
   VmService::VmServiceShutdownCallback(callback_data);
   IsolateData* isolate_data = reinterpret_cast<IsolateData*>(callback_data);
   delete isolate_data;
 }
 
 
@@ skipping 24 matching lines @@
     result = Dart_StringToCString(result, &script_source);
     if (Dart_IsError(result)) {
       return result;
     }
     Log::Print("%s\n", script_source);
   }
   return Dart_True();
 }
 
 
-int main(int argc, char** argv) {
+void main(int argc, char** argv) {
   char* script_name;
   CommandLineOptions vm_options(argc);
   CommandLineOptions dart_options(argc);
   bool print_flags_seen = false;
   bool verbose_debug_seen = false;
 
   // Perform platform specific initialization.
   if (!Platform::Initialize()) {
     Log::PrintErr("Initialization failed\n");
   }
 
   // On Windows, the argv strings are code page encoded and not
   // utf8. We need to convert them to utf8.
   bool argv_converted = Utf8ConvertArgv(argc, argv);
 
   // Parse command line arguments.
   if (ParseArguments(argc,
                      argv,
                      &vm_options,
                      &script_name,
                      &dart_options,
                      &print_flags_seen,
                      &verbose_debug_seen) < 0) {
     if (has_help_option) {
       PrintUsage();
-      return 0;
+      Exit(0);
     } else if (has_version_option) {
       PrintVersion();
-      return 0;
+      Exit(0);
     } else if (print_flags_seen) {
       // Will set the VM flags, print them out and then we exit as no
       // script was specified on the command line.
       Dart_SetVMFlags(vm_options.count(), vm_options.arguments());
-      return 0;
+      Exit(0);
     } else {
       PrintUsage();
-      return kErrorExitCode;
+      Exit(kErrorExitCode);
     }
   }
 
   if (!DartUtils::SetOriginalWorkingDirectory()) {
     OSError err;
     fprintf(stderr, "Error determinig current directory: %s\n", err.message());
     fflush(stderr);
-    return kErrorExitCode;
+    Exit(kErrorExitCode);
   }
 
   Dart_SetVMFlags(vm_options.count(), vm_options.arguments());
 
   // Initialize the Dart VM.
   if (!Dart_Initialize(CreateIsolateAndSetup, NULL, NULL, ShutdownIsolate,
                        DartUtils::OpenFile,
                        DartUtils::ReadFile,
                        DartUtils::WriteFile,
                        DartUtils::CloseFile,
                        DartUtils::EntropySource)) {
     fprintf(stderr, "%s", "VM initialization failed\n");
     fflush(stderr);
-    return kErrorExitCode;
+    Exit(kErrorExitCode);
   }
 
   // Start the debugger wire protocol handler if necessary.
   if (start_debugger) {
     ASSERT(debug_port >= 0);
     bool print_msg = verbose_debug_seen || (debug_port == 0);
     debug_port = DebuggerConnectionHandler::StartHandler(debug_ip, debug_port);
     if (print_msg) {
       Log::Print("Debugger listening on port %d\n", debug_port);
     }
@@ skipping 20 matching lines @@
   IsolateData* isolate_data = new IsolateData(script_name);
   Dart_Isolate isolate = CreateIsolateAndSetupHelper(script_name,
                                                      "main",
                                                      isolate_data,
                                                      &error,
                                                      &is_compile_error);
   if (isolate == NULL) {
     Log::PrintErr("%s\n", error);
     free(error);
     delete [] isolate_name;
-    return is_compile_error ? kCompilationErrorExitCode : kErrorExitCode;
+    Exit(is_compile_error ? kCompilationErrorExitCode : kErrorExitCode);
   }
   delete [] isolate_name;
 
   Dart_EnterIsolate(isolate);
   ASSERT(isolate == Dart_CurrentIsolate());
   ASSERT(isolate != NULL);
   Dart_Handle result;
 
   Dart_EnterScope();
 
   if (generate_script_snapshot) {
     // First create a snapshot.
     Dart_Handle result;
     uint8_t* buffer = NULL;
     intptr_t size = 0;
     result = Dart_CreateScriptSnapshot(&buffer, &size);
     if (Dart_IsError(result)) {
       Log::PrintErr("%s\n", Dart_GetError(result));
-      return DartErrorExit(result);
+      DartErrorExit(result);
     }
 
     // Write the magic number to indicate file is a script snapshot.
     DartUtils::WriteMagicNumber(snapshot_file);
 
     // Now write the snapshot out to specified file.
     bool bytes_written = snapshot_file->WriteFully(buffer, size);
     ASSERT(bytes_written);
     delete snapshot_file;
   } else {
     // Lookup the library of the root script.
     Dart_Handle root_lib = Dart_RootLibrary();
     // Import the root library into the builtin library so that we can easily
     // lookup the main entry point exported from the root library.
     Dart_Handle builtin_lib =
         Builtin::LoadAndCheckLibrary(Builtin::kBuiltinLibrary);
     result = Dart_LibraryImportLibrary(builtin_lib, root_lib, Dart_Null());
 
     if (has_compile_all) {
       result = Dart_CompileAll();
       if (Dart_IsError(result)) {
-        return DartErrorExit(result);
+        DartErrorExit(result);
       }
     }
 
     if (Dart_IsNull(root_lib)) {
-      return ErrorExit(kErrorExitCode,
-                       "Unable to find root library for '%s'\n",
-                       script_name);
+      ErrorExit(kErrorExitCode,
+                "Unable to find root library for '%s'\n",
+                script_name);
     }
     if (has_print_script) {
       result = GenerateScriptSource();
       if (Dart_IsError(result)) {
-        return DartErrorExit(result);
+        DartErrorExit(result);
       }
     } else {
       // The helper function _getMainClosure creates a closure for the main
       // entry point which is either explicitly or implictly exported from the
       // root library.
       Dart_Handle main_closure = Dart_Invoke(
           builtin_lib, Dart_NewStringFromCString("_getMainClosure"), 0, NULL);
       if (Dart_IsError(main_closure)) {
-        return DartErrorExit(result);
+        DartErrorExit(result);

[Ivan Posva, 2013/11/26 18:05:53]

?

       }
 
       // Set debug breakpoint if specified on the command line before calling
       // the main function.
       if (breakpoint_at != NULL) {
         result = SetBreakpoint(breakpoint_at, root_lib);
         if (Dart_IsError(result)) {
-          return ErrorExit(kErrorExitCode,
-                           "Error setting breakpoint at '%s': %s\n",
-                           breakpoint_at,
-                           Dart_GetError(result));
+          ErrorExit(kErrorExitCode,
+                    "Error setting breakpoint at '%s': %s\n",
+                    breakpoint_at,
+                    Dart_GetError(result));
         }
       }
 
       // Call _startIsolate in the isolate library to enable dispatching the
       // initial startup message.
       Dart_Handle isolate_args[2];
       isolate_args[0] = main_closure;
       isolate_args[1] = Dart_True();
 
       Dart_Handle isolate_lib = Dart_LookupLibrary(
           Dart_NewStringFromCString("dart:isolate"));
       result = Dart_Invoke(isolate_lib,
                            Dart_NewStringFromCString("_startIsolate"),
                            2, isolate_args);
 
       // Setup the arguments in the initial startup message and leave the
       // replyTo and message fields empty.
       Dart_Handle initial_startup_msg = Dart_NewList(3);
       result = Dart_ListSetAt(initial_startup_msg, 1,
                               CreateRuntimeOptions(&dart_options));
       if (Dart_IsError(result)) {
-        return DartErrorExit(result);
+        DartErrorExit(result);
       }
       Dart_Port main_port = Dart_GetMainPortId();
       bool posted = Dart_Post(main_port, initial_startup_msg);
       if (!posted) {
-        return ErrorExit(kErrorExitCode,
-                         "Failed posting startup message to main "
-                         "isolate control port.");
+        ErrorExit(kErrorExitCode,
+                  "Failed posting startup message to main "
+                  "isolate control port.");
       }
 
       // Keep handling messages until the last active receive port is closed.
       result = Dart_RunLoop();
       if (Dart_IsError(result)) {
-        return DartErrorExit(result);
+        DartErrorExit(result);
       }
     }
   }
 
   Dart_ExitScope();
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
   // Terminate process exit-code handler.
   Process::TerminateExitCodeHandler();
 
@@ skipping 10 matching lines @@
          p != NULL;
          p = environment->Next(p)) {
       free(p->key);
       free(p->value);
     }
     free(environment);
   }
 
   Platform::Cleanup();
 
-  return Process::GlobalExitCode();
+  Exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
-  return dart::bin::main(argc, argv);
+  dart::bin::main(argc, argv);
+  UNREACHABLE();
 }