Rename fletch -> dartino

src/vm/multiprogram_test.cc

 // Copyright (c) 2015, the Dartino 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.md file.
 
 #include "src/shared/flags.h"
 #include "src/shared/test_case.h"
 #include "src/shared/platform.h"
 
-#include "include/fletch_api.h"
+#include "include/dartino_api.h"
 
-namespace fletch {
+namespace dartino {
 
-// This multiprogram runner uses only the FletchStartMain() API function.
+// This multiprogram runner uses only the DartinoStartMain() API function.
 class Runner {
  public:
-  Runner(int count, FletchProgram* programs, int* exitcodes)
+  Runner(int count, DartinoProgram* programs, int* exitcodes)
       : monitor_(Platform::CreateMonitor()),
         programs_(programs),
         exitcodes_(exitcodes),
         count_(count),
         started_(0),
         awaited_(0),
         finished_(0) {}
   ~Runner() { delete monitor_; }
 
   // Starts all programs and then waits for all of them.
@@ skipping 24 matching lines @@
     int remaining = count_ - max_parallel;
     for (int i = 0; i < remaining; i++) {
       Wait(1);
       Start(1);
     }
     Wait(max_parallel);
   }
 
  private:
   Monitor* monitor_;
-  FletchProgram* programs_;
+  DartinoProgram* programs_;
   int* exitcodes_;
   int count_;
   int started_;
   int awaited_;
   int finished_;
 
-  static void CaptureExitCode(FletchProgram* program,
+  static void CaptureExitCode(DartinoProgram* program,
                               int exitcode,
                               void* data) {
     Runner* runner = reinterpret_cast<Runner*>(data);
     ScopedMonitorLock locker(runner->monitor_);
     for (int i = 0; i < runner->count_; i++) {
       if (runner->programs_[i] == program) {
         runner->exitcodes_[i] = exitcode;
         runner->finished_++;
         runner->monitor_->NotifyAll();
 
-        FletchDeleteProgram(program);
+        DartinoDeleteProgram(program);
 
         return;
       }
     }
     UNREACHABLE();
   }
 
   void Start(int count) {
     ScopedMonitorLock locker(monitor_);
     for (int i = started_; i < started_ + count; i++) {
-      FletchStartMain(programs_[i], &Runner::CaptureExitCode, this);
+      DartinoStartMain(programs_[i], &Runner::CaptureExitCode, this);
     }
     started_ += count;
   }
 
   void Wait(int count) {
     ScopedMonitorLock locker(monitor_);
     int finished = awaited_ + count;
     while (finished_ < finished) {
       monitor_->Wait();
     }
     awaited_ += count;
   }
 };
 
 static void PrintAndDie(char **argv) {
   FATAL1("Usage: %0 "
          "<parallel|sequence|batch=NUM|overlapped=NUM> "
          "[[<snapshot> <expected-exitcode>] ...]",
          argv[0]);
 }
 
 static int Main(int argc, char** argv) {
   Flags::ExtractFromCommandLine(&argc, argv);
 
-  FletchSetup();
+  DartinoSetup();
 
   if (argc <= 1 || (argc % 2) != 0) PrintAndDie(argv);
 
   bool parallel = strcmp(argv[1], "parallel") == 0;
   bool sequence = strcmp(argv[1], "sequence") == 0;
   bool batch = strncmp(argv[1], "batch=", strlen("batch=")) == 0;
   bool overlapped = strncmp(argv[1], "overlapped=", strlen("overlapped=")) == 0;
   if (!parallel && !sequence && !batch && !overlapped) PrintAndDie(argv);
 
   int program_count = (argc - 2) / 2;
-  FletchProgram* programs = new FletchProgram[program_count];
+  DartinoProgram* programs = new DartinoProgram[program_count];
   int* expected_exit_codes = new int[program_count];
   for (int i = 0; i < program_count; i++) {
     List<uint8> bytes = Platform::LoadFile(argv[2 + 2 * i]);
     if (bytes.is_empty()) FATAL("Invalid snapshot");
-    programs[i] = FletchLoadSnapshot(bytes.data(), bytes.length());
+    programs[i] = DartinoLoadSnapshot(bytes.data(), bytes.length());
     expected_exit_codes[i] = atoi(argv[2 + 2 * i + 1]);
     bytes.Delete();
   }
 
   int* actual_exitcodes = new int[program_count];
   Runner runner(program_count, programs, actual_exitcodes);
   if (parallel) {
     runner.RunInParallel();
   } else if (sequence) {
     runner.RunInSequence();
@@ skipping 13 matching lines @@
       fprintf(stderr, "%s: Expected exitcode: %d, Actual exitcode: %d\n",
           argv[2 + 2 * i], expected_exit_codes[i], actual_exitcodes[i]);
       result++;
     }
   }
 
   delete[] actual_exitcodes;
   delete[] expected_exit_codes;
   delete[] programs;
 
-  FletchTearDown();
+  DartinoTearDown();
 
   return result;
 }
 
-}  // namespace fletch
+}  // namespace dartino
 
-int main(int argc, char** argv) { return fletch::Main(argc, argv); }
+int main(int argc, char** argv) { return dartino::Main(argc, argv); }