void JEDIIEngine::initializeJavaVM()

in src/framework/internal_jedii_engine.cpp [519:608]
73 lines of code
6 McCabe index (conditional complexity)

    void JEDIIEngine::initializeJavaVM() {
      util::Trace clTrace(util::enTraceDetailLow, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ENGINE);

      JavaVM* vms[1];
      vms[0] = NULL;
      jsize existingVMs = 0;
      iv_createdVM = false;

      UIMA_TPRINT("check if VM exists");
      assert( EXISTS(iv_getCreatedJavaVMsFunc) );
      jint existingVMsRes = (*iv_getCreatedJavaVMsFunc)(vms, 1, & existingVMs);
      UIMA_TPRINT("JNI return code of getCreatedVMs: " << existingVMsRes);
      if (existingVMsRes != JNI_OK) {
        handleJNIError(existingVMsRes);
      }
      UIMA_TPRINT("existing VMs: " << existingVMs);

      // if we don't already run within a Java context
      if (existingVMs == 0) {
        UIMA_TPRINT("new VM must be created");
        iv_createdVM = true;
        // get classpath from environment
        util::EnvironmentVariableQueryOnly envVar("CLASSPATH");
        char const * classpath = envVar.getValue();
        char const * cpOption = "-Djava.class.path=";
        char const * emptyString = "";
        if (classpath == NULL) {
          classpath = emptyString;
        }

        size_t cpBufLen = strlen(classpath) + strlen(cpOption) + 1;
        auto_array<char> cpBuf( new char[cpBufLen] );
        cpBuf[0] = 0;
        strcat( strcat(cpBuf.get(), cpOption), classpath );

        // create and initialize Java VM
        char * optionStrings[] = {
                                   cpBuf.get(),
                                   strdup("-Xmx256MB"),
#ifndef NDEBUG
                                   strdup("-Xcheck:jni"),
                                   strdup("-Xcheck:nabounds"),
#endif
                                 };

        JavaVMInitArgs vmArgs;

        vmArgs.version = USED_JAVA_VERSION;

        JavaVMOption options[NUMBEROF(optionStrings)];
        size_t i;
        for (i=0; i<NUMBEROF(optionStrings); ++i) {
          options[i].optionString = optionStrings[i];
        }
        vmArgs.nOptions = NUMBEROF(optionStrings);
        vmArgs.options = options;

        vmArgs.ignoreUnrecognized = JNI_FALSE;

        UIMA_TPRINT("creating VM");
        assert( iv_createJavaVMFunc != NULL);
        jint vmCreationRes = (*iv_createJavaVMFunc)(& iv_vm, (void **)& iv_env, &vmArgs);
        UIMA_TPRINT("VM created");
        if (vmCreationRes != JNI_OK) {
          clTrace.dump("Java VM could not be created, return code:", vmCreationRes);
          iv_vm = NULL;
          iv_env = NULL;
          UIMA_EXC_THROW_NEW(JavaException,
                             UIMA_ERR_JAVA_EXCEPTION,
                             ErrorMessage(UIMA_MSG_ID_EXC_JAVA_VM_COULD_NOT_BE_CREATED, javaErrorToString(vmCreationRes)),
                             UIMA_MSG_ID_EXCON_PROCESSING_JAVA_TAE,
                             ErrorInfo::unrecoverable);
        }
        UIMA_TPRINT("VM created");
      } else {
        // re-use existing VM
        UIMA_TPRINT("Using existing VM: " << vms[0]);
        assert( existingVMsRes == JNI_OK );
        assert( existingVMs == 1);

        jint getenvRes = vms[0]->GetEnv((void**) & iv_env, USED_JAVA_VERSION);
        handleJNIError(getenvRes);
        assert( getenvRes == JNI_OK );
        iv_vm = vms[0];
      }

      assert( EXISTS(iv_env) );
      assert( EXISTS(iv_vm) );

    }