/*
 * Domhan_Samhlaigh - Constructor for Domhan_Samhlaigh class
 * 
 * parameter argc - int &
 * parameter argv - char **&
 * parameter appDefaults - char **&
 */
Domhan_Samhlaigh::Domhan_Samhlaigh(int & argc, char **& argv, char **& appDefaults) :
	Vrui::Application(argc, argv, appDefaults), heightMapPrefix(0), mainMenu(NULL), minimumLevel(0), numberOfHorizontalPatches(0),
			numberOfVerticalPatches(0), scaleToEnvironment(true), scene(NULL), texturePrefix(0) {
	try {
		processCommandLineArguments(argc, argv);
	} catch (std::runtime_error e) {
		std::cerr << "Error: Exception " << e.what() << "!" << std::endl;
	}
	initialize();
}
Ejemplo n.º 2
0
FiberApplication::FiberApplication(int& argc,char**& argv,char**& appDefaults)
    :Vrui::Application(argc,argv,appDefaults),
     mainMenu(0),
     propertiesDialog(0),
     m_showSelectionBox(true),
     m_fiberFileName(""),
     m_anatomyFileName(""),
     m_showVolume(false),
     mIsoSurface(NULL)
{
    //TODO create tool at launch if possible

    processCommandLineArguments(argc,argv);

    if(m_anatomyFileName != "")
    {
        mAnatomy.load(m_anatomyFileName);
        mIsoSurface = new IsoSurface(&mAnatomy,false);
        mIsoSurface->GenerateSurface(0.2f);
    }

    if(m_fiberFileName != "")
    {
        mFibers.load(m_fiberFileName);
    }

    //Create the user interface:
    mainMenu=createMainMenu();

    //create Popup Window
    //propertiesDialog = createPropertiesDialog();

    //Install the main menu:
    Vrui::setMainMenu(mainMenu);

    if(mFibers.getBBMax()[X_AXIS] + mFibers.getBBMax()[Y_AXIS] + mFibers.getBBMax()[Z_AXIS] >
        mAnatomy.getBBMax()[X_AXIS] + mAnatomy.getBBMax()[Y_AXIS] + mAnatomy.getBBMax()[Z_AXIS])
    {
        m_BBMax = mFibers.getBBMax();
    }
    else
    {
        m_BBMax = mAnatomy.getBBMax();
    }

    //Set the navigation transformation:
    resetNavigationCallback(0);

    //Tell Vrui to run in a continuous frame sequence:
    Vrui::updateContinuously();
}
Ejemplo n.º 3
0
void Config::process(int argc, char* argv[])
{
    processCommandLineArguments(argc-1, argv+1);
    if (isSet("config")) {
        string path;
        get("config", path);

        ifstream f(path.c_str());
        if (!f) {
            cerr << "Failed to open config file " << path << endl;
            return;
        }

        while (f) {
            string str;
            getline(f, str);
            boost::trim(str);
            if (str[0] == '#') continue;
            if (str.empty()) continue;
            processArgument(str.c_str());
        }
    }
    processEnvArguments();
}
Ejemplo n.º 4
0
/**
 * Parse command line arguments to find those arguments that
 *   1) affect the starting of the VM,
 *   2) can be handled without starting the VM, or
 *   3) contain quotes
 * then call createVM().
 */
int main(int argc, const char **argv)
{
  int vbufret, j, ret;
  JavaVMInitArgs initArgs;
  JavaVM *mainJavaVM;
  JNIEnv *mainJNIEnv;

  /* Make standard streams unbuffered so that we can use them
     for low level-debugging */
  vbufret = setvbuf(stdout, NULL, _IONBF, 0);
  if (vbufret != 0) {
    printf("Error making stdout unbuffered: %d\n", vbufret);
  }
  vbufret = setvbuf(stderr, NULL, _IONBF, 0);
  if (vbufret != 0) {
    printf("Error making stderr unbuffered: %d\n", vbufret);
  }
  SysErrorFile = stderr;
  SysTraceFile = stdout;
  Me = strrchr(*argv, '/');
  if (Me == NULL) {
    Me = "RVM";
  } else {
    Me++;
  }

  ++argv, --argc;
  initialHeapSize = heap_default_initial_size;
  maximumHeapSize = heap_default_maximum_size;

  // Determine page size information early because
  // it's needed to parse command line options
  pageSize = (Extent) determinePageSize();
  if (pageSize <= 0) {
    ERROR_PRINTF("RunBootImage.main(): invalid page size %u", pageSize);
    exit(EXIT_STATUS_IMPOSSIBLE_LIBRARY_FUNCTION_ERROR);
  }

  /*
   * Debugging: print out command line arguments.
   */
  if (TRACE) {
    TRACE_PRINTF("RunBootImage.main(): process %d command line arguments\n",argc);
    for (j = 0; j < argc; j++) {
      TRACE_PRINTF("\targv[%d] is \"%s\"\n",j, argv[j]);
     }
  }

  /* Initialize JavaArgc, JavaArgs and initArg */
  initArgs.version = JNI_VERSION_1_4;
  initArgs.ignoreUnrecognized = JNI_TRUE;
  JavaArgs = (char **)processCommandLineArguments(&initArgs, argv, argc);

  if (TRACE) {
    TRACE_PRINTF("RunBootImage.main(): after processCommandLineArguments: %d command line arguments\n", JavaArgc);
    for (j = 0; j < JavaArgc; j++) {
      TRACE_PRINTF("\tJavaArgs[%d] is \"%s\"\n", j, JavaArgs[j]);
    }
  }

  /* Verify heap sizes for sanity. */
  if (initialHeapSize == heap_default_initial_size &&
      maximumHeapSize != heap_default_maximum_size &&
      initialHeapSize > maximumHeapSize) {
    initialHeapSize = maximumHeapSize;
  }

  if (maximumHeapSize == heap_default_maximum_size &&
      initialHeapSize != heap_default_initial_size &&
      initialHeapSize > maximumHeapSize) {
    maximumHeapSize = initialHeapSize;
  }

  if (maximumHeapSize < initialHeapSize) {
    CONSOLE_PRINTF( "%s: maximum heap size %lu MiB is less than initial heap size %lu MiB\n",
                    Me, (unsigned long) maximumHeapSize/(1024*1024),
                    (unsigned long) initialHeapSize/(1024*1024));
    return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
  }

  TRACE_PRINTF("\nRunBootImage.main(): VM variable settings\n");
  TRACE_PRINTF("initialHeapSize %lu\nmaxHeapSize %lu\n"
           "bootCodeFileName \"%s\"\nbootDataFileName \"%s\"\n"
           "bootRmapFileName \"%s\"\n"
           "verbose %d\n",
           (unsigned long) initialHeapSize,
           (unsigned long) maximumHeapSize,
           bootCodeFilename, bootDataFilename, bootRMapFilename,
           verbose);

  if (!bootCodeFilename) {
    CONSOLE_PRINTF( "%s: please specify name of boot image code file using \"-X:ic=<filename>\"\n", Me);
    return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
  }

  if (!bootDataFilename) {
    CONSOLE_PRINTF( "%s: please specify name of boot image data file using \"-X:id=<filename>\"\n", Me);
    return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
  }

  if (!bootRMapFilename) {
    CONSOLE_PRINTF( "%s: please specify name of boot image ref map file using \"-X:ir=<filename>\"\n", Me);
    return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
  }

  ret = JNI_CreateJavaVM(&mainJavaVM, &mainJNIEnv, &initArgs);
  if (ret < 0) {
    ERROR_PRINTF("%s: Could not create the virtual machine; goodbye\n", Me);
    exit(EXIT_STATUS_MISC_TROUBLE);
  }
  return 0;
}
Ejemplo n.º 5
0
int main (int argc, char *argv[])
{
  SquareMaze *maze;

  bool showVisualization=false;
  bool showSolutionMode=false;
  double visualizationPauseInSec=0.1;

  // 221 STUDENTS: you may safely ignore (or even delete) the function
  // call to processCommandLineArguments.  We will test your program
  // with no command-line arguments.  (You are free to leave the call
  // here and, e.g., use the visualization for your debugging,
  // however!)
  processCommandLineArguments(argc, argv, 
			      showVisualization, 
			      showSolutionMode, 
			      visualizationPauseInSec);
	   

  // 221 STUDENTS: This reads a square maze from standard input.  You
  // can use this as is.  
  maze = new SquareMaze(cin);


  // 221 STUDENTS: You may safely ignore (or even delete) the
  // visualization code below.  Even if you would like to use it, it
  // should work with no changes on your part.

  // Set up the visualizer, if it has been requested.  If solution
  // visualization has been requested, then the input should include
  // solutions to the maze, and showing the solutions is all this
  // program will do.  (It will not also try to solve the maze.)
  //
  // WARNING: this code does not work on Windows
  VisualizeSquareMazeRunner *visualizer=NULL;
#ifndef WIN32
  if (showVisualization) {
    visualizer=new VisualizeSquareMazeRunner(maze);
    visualizer->setPauseTime(visualizationPauseInSec);
	  
    if (showSolutionMode) {
      while (!cin.eof()) {
	char solutionAlg[256];
	cin.getline(solutionAlg,256);
	if (cin.eof()) {
	  break;
	}
	cout << " Printing solution done by " << solutionAlg << " algorithm\n";
	int x,y;
	visualizer->startSolutionPath();
	while (SquareMaze::SquareMazeNode::readXY(cin,&x,&y)) {
	  visualizer->addNextInSolutionPath(x,y);
	  //cout << "(" << x << "," << y << ")\n";
	}
	visualizer->doneSolutionPath();

	cout << "Click mouse in solution display window to continue...\n";
	cout << flush;
	visualizer->waitForMouseClick();

      }
      return 0;
    }
  }
#endif


  MazeRunner *mazeRunner;

// 221 STUDENTS: You'll want to use your own maze runner rather than
// a RandomMazeRunner.  (Just change the constructor called on the
// right side of the assignment statement.)  You'll also want to run
// two mazerunners (which you can do by copying similar code below).



// cout<< "random"<< endl;
// mazeRunner = new RandomMazeRunner();
// mazeRunner->solveMaze(maze,cout);
// delete mazeRunner;
//

  // Clean up the maze, in case we need to run another maze runner
  maze->reinitializeMaze();

  mazeRunner = new DFSMazeRunner();
  mazeRunner->solveMaze(maze,cout);
  delete mazeRunner;

  // Clean up the maze, in case we need to run another maze runner
  maze->reinitializeMaze();

  mazeRunner = new BFSMazeRunner();
  mazeRunner->solveMaze(maze,cout);
  delete mazeRunner;

  // Clean up the maze, in case we need to run another maze runner
  maze->reinitializeMaze();


  // Clean up and return.
  if (visualizer != NULL)
    delete visualizer;

  delete maze;

  return 0;
}
Ejemplo n.º 6
0
/*
 * Parse command line arguments to find those arguments that
 *   1) affect the starting of the VM,
 *   2) can be handled without starting the VM, or
 *   3) contain quotes
 * then call createVM().
 */
int
main(int argc, const char **argv)
{
    Me            = strrchr(*argv, '/') + 1;
    ++argv, --argc;
    initialHeapSize = heap_default_initial_size;
    maximumHeapSize = heap_default_maximum_size;

    /*
     * Debugging: print out command line arguments.
     */
    if (DEBUG) {
        printf("RunBootImage.main(): process %d command line arguments\n",argc);
        for (int j=0; j<argc; j++) {
            printf("\targv[%d] is \"%s\"\n",j, argv[j]);
        }
    }

    // call processCommandLineArguments().
    bool fastBreak = false;
    // Sets JavaArgc
    JavaArgs = processCommandLineArguments(argv, argc, &fastBreak);
    if (fastBreak) {
        exit(EXIT_STATUS_BOGUS_COMMAND_LINE_ARG);
    }

    if (DEBUG) {
        printf("RunBootImage.main(): after processCommandLineArguments: %d command line arguments\n", JavaArgc);
        for (int j = 0; j < JavaArgc; j++) {
            printf("\tJavaArgs[%d] is \"%s\"\n", j, JavaArgs[j]);
        }
    }


    /* Verify heap sizes for sanity. */
    if (initialHeapSize == heap_default_initial_size &&
        maximumHeapSize != heap_default_maximum_size &&
        initialHeapSize > maximumHeapSize) {
        initialHeapSize = maximumHeapSize;
    }

    if (maximumHeapSize == heap_default_maximum_size &&
        initialHeapSize != heap_default_initial_size &&
        initialHeapSize > maximumHeapSize) {
        maximumHeapSize = initialHeapSize;
    }

    if (maximumHeapSize < initialHeapSize) {
        fprintf(SysTraceFile, "%s: maximum heap size %lu MiB is less than initial heap size %lu MiB\n",
                Me, (unsigned long) maximumHeapSize/(1024*1024),
                (unsigned long) initialHeapSize/(1024*1024));
        return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
    }

    if (DEBUG){
        printf("\nRunBootImage.main(): VM variable settings\n");
        printf("initialHeapSize %lu\nmaxHeapSize %lu\n"
               "bootCodeFileName |%s|\nbootDataFileName |%s|\n"
               "bootRmapFileName |%s|\n"
               "lib_verbose %d\n",
               (unsigned long) initialHeapSize,
               (unsigned long) maximumHeapSize,
               bootCodeFilename, bootDataFilename, bootRMapFilename,
               lib_verbose);
    }

    if (!bootCodeFilename) {
        fprintf(SysTraceFile, "%s: please specify name of boot image code file using \"-X:ic=<filename>\"\n", Me);
        return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
    }

    if (!bootDataFilename) {
        fprintf(SysTraceFile, "%s: please specify name of boot image data file using \"-X:id=<filename>\"\n", Me);
        return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
    }

    if (!bootRMapFilename) {
        fprintf(SysTraceFile, "%s: please specify name of boot image ref map file using \"-X:ir=<filename>\"\n", Me);
        return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
    }

#ifdef __MACH__
    // Initialize timer information on OS/X
    (void) mach_timebase_info(&timebaseInfo);
#endif

    int ret = createVM(0);
    assert(ret == 1);           // must be 1 (error status for this func.)

    fprintf(SysErrorFile, "%s: Could not create the virtual machine; goodbye\n", Me);
    exit(EXIT_STATUS_MISC_TROUBLE);
}
Ejemplo n.º 7
0
/*
 * Parse command line arguments to find those arguments that 
 *   1) affect the starting of the VM, 
 *   2) can be handled without starting the VM, or
 *   3) contain quotes
 * then call createVM().
 */
int
main(int argc, const char **argv)
{
    Me            = strrchr(*argv, '/') + 1;
    ++argv, --argc;
    initialHeapSize = heap_default_initial_size;
    maximumHeapSize = heap_default_maximum_size;

#ifdef RVM_WITH_FLEXIBLE_STACK_SIZES
    const unsigned stack_minimum_size         = 
        VM_Constants_STACK_SIZE_MIN;
    const unsigned stack_default_initial_size = 
        VM_Constants_STACK_SIZE_NORMAL_DEFAULT;
    const unsigned stack_grow_minimum_increment = 
        VM_Constants_STACK_SIZE_GROW_MIN;
    const unsigned stack_default_grow_increment = 
        VM_Constants_STACK_SIZE_GROW_DEFAULT;
    const unsigned stack_default_maximum_size = 
        VM_Constants_STACK_SIZE_MAX_DEFAULT;
    
    initialStackSize = stack_default_initial_size;
    stackGrowIncrement = stack_default_grow_increment;
    maximumStackSize = stack_default_maximum_size;
#endif // RVM_WITH_FLEXIBLE_STACK_SIZES
  
    /*
     * Debugging: print out command line arguments.
     */
    if (DEBUG) {
        printf("RunBootImage.main(): process %d command line arguments\n",argc);
        for (int j=0; j<argc; j++) {
            printf("\targv[%d] is \"%s\"\n",j, argv[j]);
        }
    }
  
    // call processCommandLineArguments().
    bool fastBreak = false;
    // Sets JavaArgc
    JavaArgs = processCommandLineArguments(argv, argc, &fastBreak);
    if (fastBreak) {
        exit(EXIT_STATUS_BOGUS_COMMAND_LINE_ARG);
    }

    if (DEBUG) {
        printf("RunBootImage.main(): after processCommandLineArguments: %d command line arguments\n", JavaArgc);
        for (int j = 0; j < JavaArgc; j++) {
            printf("\tJavaArgs[%d] is \"%s\"\n", j, JavaArgs[j]);
        }
    }
  
            
#ifdef RVM_FOR_LINUX
    if (rvm_singleVirtualProcessor <= -2) {
        if (running_Debian())
            rvm_singleVirtualProcessor = -1;
        else
            rvm_singleVirtualProcessor = 0;
    }
    

    if (rvm_singleVirtualProcessor < 0) // Debian.
        rvm_singleVirtualProcessor = singleVirtualProcessor_for_Debian();
#else
    /* Turn it off for all non-Linux systems.  We could print a diagnostic
     * message here, but that seems like too much work to implement. */
    if (rvm_singleVirtualProcessor < 0)
        rvm_singleVirtualProcessor = 0; 
#endif

    /* Verify heap sizes for sanity. */
    if (initialHeapSize == heap_default_initial_size &&
        maximumHeapSize != heap_default_maximum_size &&
        initialHeapSize > maximumHeapSize) {
        initialHeapSize = maximumHeapSize;
    }

    if (maximumHeapSize == heap_default_maximum_size &&
        initialHeapSize != heap_default_initial_size &&
        initialHeapSize > maximumHeapSize) {
        maximumHeapSize = initialHeapSize;
    }

    if (maximumHeapSize < initialHeapSize) {
        fprintf(SysTraceFile, "%s: maximum heap size %lu MiB is less than initial heap size %lu MiB\n", 
                Me, (unsigned long) maximumHeapSize/(1024*1024), 
                (unsigned long) initialHeapSize/(1024*1024));
        return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
    }

#ifdef RVM_WITH_FLEXIBLE_STACK_SIZES
    /* Verify stack sizes for sanity. */
    if (initialStackSize == stack_default_initial_size &&
        maximumStackSize != stack_default_maximum_size &&
        initialStackSize > maximumStackSize) {
        initialStackSize = maximumStackSize;
    }

    if (maximumStackSize == stack_default_maximum_size &&
        initialStackSize != stack_default_initial_size &&
        initialStackSize > maximumStackSize) {
        maximumStackSize = initialStackSize;
    }

    if (maximumStackSize < initialStackSize) {
        fprintf(SysTraceFile, "%s: maximum stack size %lu KiB is less than initial stack size %lu KiB\n", 
                Me, (unsigned long) maximumStackSize/1024, 
                (unsigned long) initialStackSize/1024);
        return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
    }

    if (initialStackSize < stack_minimum_size) {
        fprintf(SysTraceFile, "%s: initial stack size %lu KiB is less than minimum stack size %lu KiB\n", 
                Me, (unsigned long) initialStackSize/1024, 
                (unsigned long) stack_minimum_size/1024);
        return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
    }

    if (stackGrowIncrement < stack_grow_minimum_increment) {
        fprintf(SysTraceFile, "%s: stack growth increment %lu KiB is less than minimum growth increment %lu KiB\n", 
                Me, (unsigned long) stackGrowIncrement/1024, 
                (unsigned long) stack_grow_minimum_increment/1024);
        return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
    }
#endif // RVM_WITH_FLEXIBLE_STACK_SIZES

    if (DEBUG){
        printf("\nRunBootImage.main(): VM variable settings\n");
        printf("initialHeapSize %lu\nmaxHeapSize %lu\n"
#ifdef RVM_WITH_FLEXIBLE_STACK_SIZES
               "initialStackSize %lu\n"
               "stackGrowIncrement %lu\n"
               "maxStackSize %lu\n"
#endif // RVM_WITH_FLEXIBLE_STACK_SIZES
               "rvm_singleVirtualProcessor %d\n"
               "bootFileName |%s|\nlib_verbose %d\n",
               (unsigned long) initialHeapSize, 
               (unsigned long) maximumHeapSize, 
#ifdef RVM_WITH_FLEXIBLE_STACK_SIZES
               (unsigned long) initialStackSize, 
               (unsigned long) stackGrowIncrement,
               (unsigned long) maximumStackSize,
#endif // RVM_WITH_FLEXIBLE_STACK_SIZES
               rvm_singleVirtualProcessor,
               bootFilename, lib_verbose);
    }

    if (!bootFilename) {
#define STRINGIZE(x) #x
#ifdef RVM_BOOTIMAGE
        bootFilename = STRINGIZE(RVM_BOOTIMAGE);
#endif
    }

    if (!bootFilename) {
        fprintf(SysTraceFile, "%s: please specify name of boot image file using \"-i<filename>\"\n", Me);
        return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
    }

    int ret = createVM(0);
    assert(ret == 1);           // must be 1 (error status for this func.)
    
    fprintf(SysErrorFile, "%s: Could not create the virtual machine; goodbye\n", Me);
    exit(EXIT_STATUS_MISC_TROUBLE);
}
Ejemplo n.º 8
0
Archivo: main.c Proyecto: codehaus/mrp
/**
 * Parse command line arguments to find those arguments that
 *   1) affect the starting of the VM,
 *   2) can be handled without starting the VM, or
 *   3) contain quotes
 * then call createVM().
 */
int main(int argc, const char **argv)
{
  int j, ret;
  JavaVMInitArgs initArgs;
  JavaVM *mainJavaVM;
  JNIEnv *mainJNIEnv;
  SYS_START();
#ifndef RVM_FOR_HARMONY
  SysErrorFile = stderr;
  SysTraceFile = stdout;
  setbuf (SysErrorFile, NULL);
  setbuf (SysTraceFile, NULL);
  setvbuf(stdout,NULL,_IONBF,0);
  setvbuf(stderr,NULL,_IONBF,0);
#endif
#ifndef RVM_FOR_WINDOWS
  Me = strrchr(*argv, '/');
#else
  Me = strrchr(*argv, '\\');
#endif
  if (Me == NULL) {
    Me = "RVM";
  } else {
    Me++;
  }
  ++argv, --argc;
  initialHeapSize = heap_default_initial_size;
  maximumHeapSize = heap_default_maximum_size;

  /* Initialize system call routines and side data structures */
  sysInitialize();

  /*
   * Debugging: print out command line arguments.
   */
  if (TRACE) {
    TRACE_PRINTF("RunBootImage.main(): process %d command line arguments\n",argc);
    for (j=0; j<argc; j++) {
      TRACE_PRINTF("\targv[%d] is \"%s\"\n",j, argv[j]);
    }
  }

  /* Initialize JavaArgc, JavaArgs and initArg */
  initArgs.version = JNI_VERSION_1_4;
  initArgs.ignoreUnrecognized = JNI_TRUE;
  JavaArgs = (char **)processCommandLineArguments(&initArgs, argv, argc);

  if (TRACE) {
    TRACE_PRINTF("RunBootImage.main(): after processCommandLineArguments: %d command line arguments\n", JavaArgc);
    for (j = 0; j < JavaArgc; j++) {
      TRACE_PRINTF("\tJavaArgs[%d] is \"%s\"\n", j, JavaArgs[j]);
    }
  }


  /* Verify heap sizes for sanity. */
  if (initialHeapSize == heap_default_initial_size &&
      maximumHeapSize != heap_default_maximum_size &&
      initialHeapSize > maximumHeapSize) {
    initialHeapSize = maximumHeapSize;
  }

  if (maximumHeapSize == heap_default_maximum_size &&
      initialHeapSize != heap_default_initial_size &&
      initialHeapSize > maximumHeapSize) {
    maximumHeapSize = initialHeapSize;
  }

  if (maximumHeapSize < initialHeapSize) {
    CONSOLE_PRINTF( "%s: maximum heap size %lu MiB is less than initial heap size %lu MiB\n",
                    Me, (unsigned long) maximumHeapSize/(1024*1024),
                    (unsigned long) initialHeapSize/(1024*1024));
    return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
  }


  TRACE_PRINTF("\nRunBootImage.main(): VM variable settings\n");
  TRACE_PRINTF("initialHeapSize %lu\nmaxHeapSize %lu\n"
               "bootCodeFileName \"%s\"\nbootDataFileName \"%s\"\n"
               "bootRmapFileName \"%s\"\n"
               "verbose %d\n",
               (unsigned long) initialHeapSize,
               (unsigned long) maximumHeapSize,
               bootCodeFilename, bootDataFilename, bootRMapFilename,
               verbose);

  if (!bootCodeFilename) {
    CONSOLE_PRINTF( "%s: please specify name of boot image code file using \"-X:ic=<filename>\"\n", Me);
    return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
  }

  if (!bootDataFilename) {
    CONSOLE_PRINTF( "%s: please specify name of boot image data file using \"-X:id=<filename>\"\n", Me);
    return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
  }

  if (!bootRMapFilename) {
    CONSOLE_PRINTF( "%s: please specify name of boot image ref map file using \"-X:ir=<filename>\"\n", Me);
    return EXIT_STATUS_BOGUS_COMMAND_LINE_ARG;
  }

  ret = JNI_CreateJavaVM(&mainJavaVM, &mainJNIEnv, &initArgs);

  if (ret < 0) {
    ERROR_PRINTF("%s: Could not create the virtual machine; goodbye\n", Me);
    sysExit(EXIT_STATUS_MISC_TROUBLE);
  }
  return 0;
}
Ejemplo n.º 9
0
int APIENTRY wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow) {
#else
int main(int argc, char* argv[]) {
#endif

    // Do all the standard CEF setup stuff.
    //-------------------------------------

  void * sandbox_info = nullptr;

#ifdef _WIN32
    // Enable High-DPI support on Windows 7 or newer.
  CefEnableHighDPISupport();

  // Read command line arguments.
  CefMainArgs main_args(hInstance);
#else
    // Read command line arguments.
  CefMainArgs main_args(argc, argv);
#endif

    // Create the process reference.
  CefRefPtr<loot::LootApp> app(new loot::LootApp);

  // Run the process.
  int exit_code = CefExecuteProcess(main_args, app.get(), nullptr);
  if (exit_code >= 0) {
      // The sub-process has completed so return here.
    return exit_code;
  }

#ifdef _WIN32
    // Check if LOOT is already running
    //---------------------------------

  HANDLE hMutex = ::OpenMutex(MUTEX_ALL_ACCESS, FALSE, L"LOOT.Shell.Instance");
  if (hMutex != NULL) {
      // An instance of LOOT is already running, so focus its window then quit.
    HWND hWnd = ::FindWindow(NULL, L"LOOT");
    ::SetForegroundWindow(hWnd);
    return 0;
  } else {
      //Create the mutex so that future instances will not run.
    hMutex = ::CreateMutex(NULL, FALSE, L"LOOT.Shell.Instance");
  }
#endif

  // Handle command line args (not CEF args)
  //----------------------------------------

  processCommandLineArguments(app);

  // Back to CEF
  //------------

  // Initialise CEF settings.
  CefSettings cef_settings = GetCefSettings();

#ifndef _WIN32
    // Install xlib error handlers so that the application won't be terminated
    // on non-fatal errors.
  XSetErrorHandler(XErrorHandlerImpl);
  XSetIOErrorHandler(XIOErrorHandlerImpl);
#endif

    // Initialize CEF.
  CefInitialize(main_args, cef_settings, app.get(), sandbox_info);

  // Run the CEF message loop. This will block until CefQuitMessageLoop() is called.
  CefRunMessageLoop();

  // Shut down CEF.
  CefShutdown();

#ifdef _WIN32
    // Release the program instance mutex.
  if (hMutex != NULL)
    ReleaseMutex(hMutex);
#endif

  return 0;
}