Add java support

Modules/CMakeDetermineJavaCompiler.cmake

@@ -0,0 +1,75 @@
+# determine the compiler to use for Java programs
+# NOTE, a generator may set CMAKE_JAVA_COMPILER before
+# loading this file to force a compiler.
+
+IF(NOT CMAKE_JAVA_COMPILER)
+  # prefer the environment variable CC
+  IF($ENV{JAVA_COMPILER} MATCHES ".+")
+    GET_FILENAME_COMPONENT(CMAKE_JAVA_COMPILER_INIT $ENV{JAVA_COMPILER} PROGRAM PROGRAM_ARGS CMAKE_JAVA_FLAGS_ENV_INIT)
+    IF(EXISTS ${CMAKE_JAVA_COMPILER_INIT})
+    ELSE(EXISTS ${CMAKE_JAVA_COMPILER_INIT})
+      MESSAGE(SEND_ERROR "Could not find compiler set in environment variable JAVA_COMPILER:\n$ENV{JAVA_COMPILER}.") 
+    ENDIF(EXISTS ${CMAKE_JAVA_COMPILER_INIT})
+  ENDIF($ENV{JAVA_COMPILER} MATCHES ".+")
+
+  IF($ENV{JAVA_RUNTIME} MATCHES ".+")
+    GET_FILENAME_COMPONENT(CMAKE_JAVA_RUNTIME_INIT $ENV{JAVA_RUNTIME} PROGRAM PROGRAM_ARGS CMAKE_JAVA_FLAGS_ENV_INIT)
+    IF(EXISTS ${CMAKE_JAVA_RUNTIME_INIT})
+    ELSE(EXISTS ${CMAKE_JAVA_RUNTIME_INIT})
+      MESSAGE(SEND_ERROR "Could not find compiler set in environment variable JAVA_RUNTIME:\n$ENV{JAVA_RUNTIME}.") 
+    ENDIF(EXISTS ${CMAKE_JAVA_RUNTIME_INIT})
+  ENDIF($ENV{JAVA_RUNTIME} MATCHES ".+")
+
+  IF($ENV{JAVA_ARCHIVE} MATCHES ".+")
+    GET_FILENAME_COMPONENT(CMAKE_JAVA_ARCHIVE_INIT $ENV{JAVA_ARCHIVE} PROGRAM PROGRAM_ARGS CMAKE_JAVA_FLAGS_ENV_INIT)
+    IF(EXISTS ${CMAKE_JAVA_ARCHIVE_INIT})
+    ELSE(EXISTS ${CMAKE_JAVA_ARCHIVE_INIT})
+      MESSAGE(SEND_ERROR "Could not find compiler set in environment variable JAVA_ARCHIVE:\n$ENV{JAVA_ARCHIVE}.") 
+    ENDIF(EXISTS ${CMAKE_JAVA_ARCHIVE_INIT})
+  ENDIF($ENV{JAVA_ARCHIVE} MATCHES ".+")
+
+  SET(JAVA_BIN_PATH
+    /usr/bin
+    /usr/lib/java/bin
+    /usr/share/java/bin
+    /usr/local/bin
+    /usr/local/java/bin
+    "[HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft\\Java Development Kit\\1.4;JavaHome]/bin"
+    "[HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft\\Java Development Kit\\1.3;JavaHome]/bin"
+    )
+  # if no compiler has been specified yet, then look for one
+  IF(CMAKE_JAVA_COMPILER_INIT)
+    SET(CMAKE_JAVA_COMPILER ${CMAKE_JAVA_COMPILER_INIT} CACHE PATH "Java Compiler")
+  ELSE(CMAKE_JAVA_COMPILER_INIT)
+    FIND_PROGRAM(CMAKE_JAVA_COMPILER
+      NAMES javac
+      PATHS ${JAVA_BIN_PATH}
+    )    
+  ENDIF(CMAKE_JAVA_COMPILER_INIT)
+
+  # if no runtime has been specified yet, then look for one
+  IF(CMAKE_JAVA_RUNTIME_INIT)
+    SET(CMAKE_JAVA_RUNTIME ${CMAKE_JAVA_RUNTIME_INIT} CACHE PATH "Java Compiler")
+  ELSE(CMAKE_JAVA_RUNTIME_INIT)
+    FIND_PROGRAM(CMAKE_JAVA_RUNTIME
+      NAMES java
+      PATHS ${JAVA_BIN_PATH}
+    )    
+  ENDIF(CMAKE_JAVA_RUNTIME_INIT)
+
+  # if no archive has been specified yet, then look for one
+  IF(CMAKE_JAVA_ARCHIVE_INIT)
+    SET(CMAKE_JAVA_ARCHIVE ${CMAKE_JAVA_ARCHIVE_INIT} CACHE PATH "Java Compiler")
+  ELSE(CMAKE_JAVA_ARCHIVE_INIT)
+    FIND_PROGRAM(CMAKE_JAVA_ARCHIVE
+      NAMES jar
+      PATHS ${JAVA_BIN_PATH}
+    )    
+  ENDIF(CMAKE_JAVA_ARCHIVE_INIT)
+ENDIF(NOT CMAKE_JAVA_COMPILER)
+MARK_AS_ADVANCED(CMAKE_JAVA_COMPILER)  
+
+# configure variables set in this file for fast reload later on
+CONFIGURE_FILE(${CMAKE_ROOT}/Modules/CMakeJavaCompiler.cmake.in 
+               ${PROJECT_BINARY_DIR}/CMakeJavaCompiler.cmake IMMEDIATE @ONLY)
+MARK_AS_ADVANCED(CMAKE_AR CMAKE_JAVA_COMPILER_FULLPATH)

Modules/CMakeJavaCompiler.cmake.in

@@ -0,0 +1,62 @@
+SET(CMAKE_JAVA_COMPILER "@CMAKE_JAVA_COMPILER@")
+SET(CMAKE_JAVA_RUNTIME  "@CMAKE_JAVA_RUNTIME@")
+SET(CMAKE_JAVA_ARCHIVE  "@CMAKE_JAVA_ARCHIVE@")
+SET(CMAKE_JAVA_COMPILER_LOADED 1)
+SET(CMAKE_JAVA_RUNTIME_LOADED 1)
+SET(CMAKE_JAVA_ARCHIVE_LOADED 1)
+
+MACRO(ADD_JAVA_LIBRARY LIBRARYNAME SOURCES)
+  SET(CMAKE_JAVA_INCLUDE_PATH ${CMAKE_JAVA_INCLUDE_PATH}
+                        ${CMAKE_CURRENT_SOURCE_DIR} 
+                        ${CMAKE_CURRENT_BINARY_DIR}
+                        ${LIBRARY_OUTPUT_PATH})
+  SET(CMAKE_JAVA_INCLUDE_PATH_TOTAL "")
+
+  FOREACH(DIR ${CMAKE_JAVA_INCLUDE_PATH})
+     SET(CMAKE_JAVA_INCLUDE_PATH_TOTAL "${CMAKE_JAVA_INCLUDE_PATH_TOTAL}:${DIR}")
+  ENDFOREACH(DIR)
+  IF(WIN32)
+    STRING(REGEX REPLACE "/" "\\\\" CMAKE_JAVA_INCLUDE_PATH_TOTAL 
+           ${CMAKE_JAVA_INCLUDE_PATH_TOTAL})
+    STRING(REGEX REPLACE "/" "\\\\" CMAKE_JAVA_CLASS_OUTPUT_PATH
+           ${CMAKE_CURRENT_BINARY_DIR})
+    STRING(REGEX REPLACE ":([^\\/])" "\\\\;\\1" CMAKE_JAVA_INCLUDE_PATH_TOTAL
+           ${CMAKE_JAVA_INCLUDE_PATH_TOTAL})
+  ELSE(WIN32)
+    SET(CMAKE_JAVA_CLASS_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR})
+  ENDIF(WIN32)
+
+  ADD_CUSTOM_TARGET(${LIBRARYNAME}_target ALL)
+
+  SET(CMAKE_JAVA_ALL_CLASS_FILES "")
+  FOREACH(SOURCE ${SOURCES})
+    GET_FILENAME_COMPONENT(CLASS_FILE ${SOURCE} NAME_WE)
+    ADD_CUSTOM_COMMAND(SOURCE ${CMAKE_CURRENT_SOURCE_DIR}/${SOURCE}
+                       COMMAND ${CMAKE_JAVA_COMPILER}
+                       ARGS ${CMAKE_JAVA_COMPILE_FLAGS} 
+                            -classpath ${CMAKE_JAVA_INCLUDE_PATH_TOTAL} 
+                            ${CMAKE_CURRENT_SOURCE_DIR}/${SOURCE}
+                            -d ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/
+                       TARGET ${LIBRARYNAME}_target
+                       OUTPUTS ${CLASS_FILE}.class
+                       COMMENT "Java File" )
+    SET(CMAKE_JAVA_ALL_CLASS_FILES ${CMAKE_JAVA_ALL_CLASS_FILES} ${CLASS_FILE}.class)
+  ENDFOREACH(SOURCE)
+  IF(LIBRARY_OUTPUT_PATH)
+    SET(CMAKE_JAVA_LIBRARY_OUTPUT_PATH ${LIBRARY_OUTPUT_PATH}) 
+  ELSE(LIBRARY_OUTPUT_PATH)
+    SET(CMAKE_JAVA_LIBRARY_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR})
+  ENDIF(LIBRARY_OUTPUT_PATH)
+  ADD_CUSTOM_COMMAND(SOURCE ${CMAKE_JAVA_ALL_CLASS_FILES}
+                     COMMAND ${CMAKE_COMMAND}
+                     ARGS -E chdir ${CMAKE_CURRENT_BINARY_DIR}
+                          ${CMAKE_JAVA_ARCHIVE} 
+                          -cvf ${CMAKE_JAVA_LIBRARY_OUTPUT_PATH}/${LIBRARYNAME}.jar *.class
+                     TARGET ${LIBRARYNAME}_target
+                     DEPENDS ${CMAKE_JAVA_ALL_CLASS_FILES}
+                     OUTPUTS ${CMAKE_JAVA_LIBRARY_OUTPUT_PATH}/${LIBRARYNAME}.jar
+                     COMMENT "Java Archive")
+  ADD_CUSTOM_COMMAND(SOURCE ${LIBRARYNAME}_target
+                     TARGET ${LIBRARYNAME}_target
+                     DEPENDS ${CMAKE_JAVA_LIBRARY_OUTPUT_PATH}/${LIBRARYNAME}.jar)
+ENDMACRO(ADD_JAVA_LIBRARY LIBRARYNAME SOURCES)

Source/cmGlobalGenerator.cxx

@@ -81,6 +81,16 @@ void cmGlobalGenerator::EnableLanguage(const char* lang,
     }
   bool needCBackwards = false;
   bool needCXXBackwards = false;
+
+  if (!isLocal &&
+      !this->GetLanguageEnabled("C") && !this->GetLanguageEnabled("CXX") &&
+      !this->GetLanguageEnabled("JAVA"))
+    {
+    // Read the DetermineSystem file
+    std::string systemFile = root;
+    systemFile += "/Modules/CMakeDetermineSystem.cmake";
+    mf->ReadListFile(0, systemFile.c_str());
+    }
   
   // check for a C compiler and configure it
   if(!isLocal &&
@@ -95,10 +105,6 @@ void cmGlobalGenerator::EnableLanguage(const char* lang,
                            "CMake");
       }
     needCBackwards = true;
-    // Read the DetermineSystem file
-    std::string systemFile = root;
-    systemFile += "/Modules/CMakeDetermineSystem.cmake";
-    mf->ReadListFile(0, systemFile.c_str());
     // read determine C compiler
     std::string determineCFile = root;
     determineCFile += "/Modules/CMakeDetermineCCompiler.cmake";
@@ -142,7 +148,17 @@ void cmGlobalGenerator::EnableLanguage(const char* lang,
       }
     }
  
-    
+   // check for a Java compiler and configure it
+  if(!isLocal &&
+     !this->GetLanguageEnabled("JAVA") &&
+     strcmp(lang, "JAVA") == 0)
+    {
+    std::string determineCFile = root;
+    determineCFile += "/Modules/CMakeDetermineJavaCompiler.cmake";
+    mf->ReadListFile(0,determineCFile.c_str());
+    this->SetLanguageEnabled("JAVA");
+    }
+   
   std::string fpath = rootBin;
   if(!mf->GetDefinition("CMAKE_SYSTEM_LOADED"))
     {
@@ -162,7 +178,13 @@ void cmGlobalGenerator::EnableLanguage(const char* lang,
     fpath += "/CMakeCXXCompiler.cmake";
     mf->ReadListFile(0,fpath.c_str());
     }
-  if(!mf->GetDefinition("CMAKE_SYSTEM_SPECIFIC_INFORMATION_LOADED"))
+  if(strcmp(lang, "JAVA") == 0 && !mf->GetDefinition("CMAKE_JAVA_COMPILER_LOADED"))
+    {
+    fpath = rootBin;
+    fpath += "/CMakeJavaCompiler.cmake";
+    mf->ReadListFile(0,fpath.c_str());
+    }
+  if ( lang[0] == 'C' && !mf->GetDefinition("CMAKE_SYSTEM_SPECIFIC_INFORMATION_LOADED"))
     {
     fpath = root;
     fpath += "/Modules/CMakeSystemSpecificInformation.cmake";