Modules/UseJava.cmake

   1 # - Use Module for Java
   2 # This file provides functions for Java. It is assumed that FindJava.cmake
   3 # has already been loaded.  See FindJava.cmake for information on how to
   4 # load Java into your CMake project.
   5 #
   6 # add_jar(TARGET_NAME SRC1 SRC2 .. SRCN RCS1 RCS2 .. RCSN)
   7 #
   8 # This command creates a <TARGET_NAME>.jar. It compiles the given source
   9 # files (SRC) and adds the given resource files (RCS) to the jar file.
  10 # If only resource files are given then just a jar file is created.
  11 #
  12 # Additional instructions:
  13 #   To add compile flags to the target you can set these flags with
  14 #   the following variable:
  15 #
  16 #       set(CMAKE_JAVA_COMPILE_FLAGS -nowarn)
  17 #
  18 #   To add a path or a jar file to the class path you can do this
  19 #   with the CMAKE_JAVA_INCLUDE_PATH variable.
  20 #
  21 #       set(CMAKE_JAVA_INCLUDE_PATH /usr/share/java/shibboleet.jar)
  22 #
  23 #   To use a different output name for the target you can set it with:
  24 #
  25 #       set(CMAKE_JAVA_TARGET_OUTPUT_NAME shibboleet.jar)
  26 #       add_jar(foobar foobar.java)
  27 #
  28 #   To use a different output directory than CMAKE_CURRENT_BINARY_DIR
  29 #   you can set it with:
  30 #
  31 #       set(CMAKE_JAVA_TARGET_OUTPUT_DIR ${PROJECT_BINARY_DIR}/bin)
  32 #
  33 #   To define an entry point in your jar you can set it with:
  34 #
  35 #       set(CMAKE_JAVA_JAR_ENTRY_POINT com/examples/MyProject/Main)
  36 #
  37 #   To add a VERSION to the target output name you can set it using
  38 #   CMAKE_JAVA_TARGET_VERSION. This will create a jar file with the name
  39 #   shibboleet-1.0.0.jar and will create a symlink shibboleet.jar
  40 #   pointing to the jar with the version information.
  41 #
  42 #       set(CMAKE_JAVA_TARGET_VERSION 1.2.0)
  43 #       add_jar(shibboleet shibbotleet.java)
  44 #
  45 #    If the target is a JNI library, utilize the following commands to
  46 #    create a JNI symbolic link:
  47 #
  48 #       set(CMAKE_JNI_TARGET TRUE)
  49 #       set(CMAKE_JAVA_TARGET_VERSION 1.2.0)
  50 #       add_jar(shibboleet shibbotleet.java)
  51 #       install_jar(shibboleet ${LIB_INSTALL_DIR}/shibboleet)
  52 #       install_jni_symlink(shibboleet ${JAVA_LIB_INSTALL_DIR})
  53 #
  54 #    If a single target needs to produce more than one jar from its
  55 #    java source code, to prevent the accumulation of duplicate class
  56 #    files in subsequent jars, set/reset CMAKE_JAR_CLASSES_PREFIX prior
  57 #    to calling the add_jar() function:
  58 #
  59 #       set(CMAKE_JAR_CLASSES_PREFIX com/redhat/foo)
  60 #       add_jar(foo foo.java)
  61 #
  62 #       set(CMAKE_JAR_CLASSES_PREFIX com/redhat/bar)
  63 #       add_jar(bar bar.java)
  64 #
  65 # Target Properties:
  66 #   The add_jar() functions sets some target properties. You can get these
  67 #   properties with the
  68 #      get_property(TARGET <target_name> PROPERTY <propery_name>)
  69 #   command.
  70 #
  71 #   INSTALL_FILES      The files which should be installed. This is used by
  72 #                      install_jar().
  73 #   JNI_SYMLINK        The JNI symlink which should be installed.
  74 #                      This is used by install_jni_symlink().
  75 #   JAR_FILE           The location of the jar file so that you can include
  76 #                      it.
  77 #   CLASS_DIR          The directory where the class files can be found. For
  78 #                      example to use them with javah.
  79 #
  80 # find_jar(<VAR>
  81 #          name | NAMES name1 [name2 ...]
  82 #          [PATHS path1 [path2 ... ENV var]]
  83 #          [VERSIONS version1 [version2]]
  84 #          [DOC "cache documentation string"]
  85 #         )
  86 #
  87 # This command is used to find a full path to the named jar. A cache
  88 # entry named by <VAR> is created to stor the result of this command. If
  89 # the full path to a jar is found the result is stored in the variable
  90 # and the search will not repeated unless the variable is cleared. If
  91 # nothing is found, the result will be <VAR>-NOTFOUND, and the search
  92 # will be attempted again next time find_jar is invoked with the same
  93 # variable.
  94 # The name of the full path to a file that is searched for is specified
  95 # by the names listed after NAMES argument. Additional search locations
  96 # can be specified after the PATHS argument. If you require special a
  97 # version of a jar file you can specify it with the VERSIONS argument.
  98 # The argument after DOC will be used for the documentation string in
  99 # the cache.
 100 #
 101 # install_jar(TARGET_NAME DESTINATION)
 102 #
 103 # This command installs the TARGET_NAME files to the given DESTINATION.
 104 # It should be called in the same scope as add_jar() or it will fail.
 105 #
 106 # install_jni_symlink(TARGET_NAME DESTINATION)
 107 #
 108 # This command installs the TARGET_NAME JNI symlinks to the given
 109 # DESTINATION. It should be called in the same scope as add_jar()
 110 # or it will fail.
 111 #
 112 # create_javadoc(<VAR>
 113 #                PACKAGES pkg1 [pkg2 ...]
 114 #                [SOURCEPATH <sourcepath>]
 115 #                [CLASSPATH <classpath>]
 116 #                [INSTALLPATH <install path>]
 117 #                [DOCTITLE "the documentation title"]
 118 #                [WINDOWTITLE "the title of the document"]
 119 #                [AUTHOR TRUE|FALSE]
 120 #                [USE TRUE|FALSE]
 121 #                [VERSION TRUE|FALSE]
 122 #               )
 123 #
 124 # Create java documentation based on files or packages. For more
 125 # details please read the javadoc manpage.
 126 #
 127 # There are two main signatures for create_javadoc. The first
 128 # signature works with package names on a path with source files:
 129 #
 130 #   Example:
 131 #   create_javadoc(my_example_doc
 132 #     PACKAGES com.exmaple.foo com.example.bar
 133 #     SOURCEPATH "${CMAKE_CURRENT_SOURCE_DIR}"
 134 #     CLASSPATH ${CMAKE_JAVA_INCLUDE_PATH}
 135 #     WINDOWTITLE "My example"
 136 #     DOCTITLE "<h1>My example</h1>"
 137 #     AUTHOR TRUE
 138 #     USE TRUE
 139 #     VERSION TRUE
 140 #   )
 141 #
 142 # The second signature for create_javadoc works on a given list of
 143 # files.
 144 #
 145 #   create_javadoc(<VAR>
 146 #                  FILES file1 [file2 ...]
 147 #                  [CLASSPATH <classpath>]
 148 #                  [INSTALLPATH <install path>]
 149 #                  [DOCTITLE "the documentation title"]
 150 #                  [WINDOWTITLE "the title of the document"]
 151 #                  [AUTHOR TRUE|FALSE]
 152 #                  [USE TRUE|FALSE]
 153 #                  [VERSION TRUE|FALSE]
 154 #                 )
 155 #
 156 # Example:
 157 #   create_javadoc(my_example_doc
 158 #     FILES ${example_SRCS}
 159 #     CLASSPATH ${CMAKE_JAVA_INCLUDE_PATH}
 160 #     WINDOWTITLE "My example"
 161 #     DOCTITLE "<h1>My example</h1>"
 162 #     AUTHOR TRUE
 163 #     USE TRUE
 164 #     VERSION TRUE
 165 #   )
 166 #
 167 # Both signatures share most of the options. These options are the
 168 # same as what you can find in the javadoc manpage. Please look at
 169 # the manpage for CLASSPATH, DOCTITLE, WINDOWTITLE, AUTHOR, USE and
 170 # VERSION.
 171 #
 172 # The documentation will be by default installed to
 173 #
 174 #   ${CMAKE_INSTALL_PREFIX}/share/javadoc/<VAR>
 175 #
 176 # if you don't set the INSTALLPATH.
 177 #
 178
 179 #=============================================================================
 180 # Copyright 2010-2011 Andreas schneider <asn@redhat.com>
 181 # Copyright 2010 Ben Boeckel <ben.boeckel@kitware.com>
 182 #
 183 # Distributed under the OSI-approved BSD License (the "License");
 184 # see accompanying file Copyright.txt for details.
 185 #
 186 # This software is distributed WITHOUT ANY WARRANTY; without even the
 187 # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 188 # See the License for more information.
 189 #=============================================================================
 190 # (To distribute this file outside of CMake, substitute the full
 191 #  License text for the above reference.)
 192
 193 function (__java_copy_file src dest comment)
 194     add_custom_command(
 195         OUTPUT  ${dest}
 196         COMMAND cmake -E copy_if_different
 197         ARGS    ${src}
 198                 ${dest}
 199         DEPENDS ${src}
 200         COMMENT ${comment})
 201 endfunction ()
 202
 203 # define helper scripts
 204 set(_JAVA_CLASS_FILELIST_SCRIPT ${CMAKE_CURRENT_LIST_DIR}/UseJavaClassFilelist.cmake)
 205 set(_JAVA_SYMLINK_SCRIPT ${CMAKE_CURRENT_LIST_DIR}/UseJavaSymlinks.cmake)
 206
 207 function(add_jar _TARGET_NAME)
 208     set(_JAVA_SOURCE_FILES ${ARGN})
 209
 210     if (NOT DEFINED CMAKE_JAVA_TARGET_OUTPUT_DIR)
 211       set(CMAKE_JAVA_TARGET_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR})
 212     endif()
 213
 214     if (CMAKE_JAVA_JAR_ENTRY_POINT)
 215       set(_ENTRY_POINT_OPTION e)
 216       set(_ENTRY_POINT_VALUE ${CMAKE_JAVA_JAR_ENTRY_POINT})
 217     endif ()
 218
 219     if (LIBRARY_OUTPUT_PATH)
 220         set(CMAKE_JAVA_LIBRARY_OUTPUT_PATH ${LIBRARY_OUTPUT_PATH})
 221     else ()
 222         set(CMAKE_JAVA_LIBRARY_OUTPUT_PATH ${CMAKE_JAVA_TARGET_OUTPUT_DIR})
 223     endif ()
 224
 225     set(CMAKE_JAVA_INCLUDE_PATH
 226         ${CMAKE_JAVA_INCLUDE_PATH}
 227         ${CMAKE_CURRENT_SOURCE_DIR}
 228         ${CMAKE_JAVA_OBJECT_OUTPUT_PATH}
 229         ${CMAKE_JAVA_LIBRARY_OUTPUT_PATH}
 230     )
 231
 232     if (WIN32 AND NOT CYGWIN)
 233         set(CMAKE_JAVA_INCLUDE_FLAG_SEP ";")
 234     else ()
 235         set(CMAKE_JAVA_INCLUDE_FLAG_SEP ":")
 236     endif()
 237
 238     foreach (JAVA_INCLUDE_DIR ${CMAKE_JAVA_INCLUDE_PATH})
 239        set(CMAKE_JAVA_INCLUDE_PATH_FINAL "${CMAKE_JAVA_INCLUDE_PATH_FINAL}${CMAKE_JAVA_INCLUDE_FLAG_SEP}${JAVA_INCLUDE_DIR}")
 240     endforeach()
 241
 242     set(CMAKE_JAVA_CLASS_OUTPUT_PATH "${CMAKE_JAVA_TARGET_OUTPUT_DIR}${CMAKE_FILES_DIRECTORY}/${_TARGET_NAME}.dir")
 243
 244     set(_JAVA_TARGET_OUTPUT_NAME "${_TARGET_NAME}.jar")
 245     if (CMAKE_JAVA_TARGET_OUTPUT_NAME AND CMAKE_JAVA_TARGET_VERSION)
 246         set(_JAVA_TARGET_OUTPUT_NAME "${CMAKE_JAVA_TARGET_OUTPUT_NAME}-${CMAKE_JAVA_TARGET_VERSION}.jar")
 247         set(_JAVA_TARGET_OUTPUT_LINK "${CMAKE_JAVA_TARGET_OUTPUT_NAME}.jar")
 248     elseif (CMAKE_JAVA_TARGET_VERSION)
 249         set(_JAVA_TARGET_OUTPUT_NAME "${_TARGET_NAME}-${CMAKE_JAVA_TARGET_VERSION}.jar")
 250         set(_JAVA_TARGET_OUTPUT_LINK "${_TARGET_NAME}.jar")
 251     elseif (CMAKE_JAVA_TARGET_OUTPUT_NAME)
 252         set(_JAVA_TARGET_OUTPUT_NAME "${CMAKE_JAVA_TARGET_OUTPUT_NAME}.jar")
 253     endif ()
 254     # reset
 255     set(CMAKE_JAVA_TARGET_OUTPUT_NAME)
 256
 257     set(_JAVA_CLASS_FILES)
 258     set(_JAVA_COMPILE_FILES)
 259     set(_JAVA_DEPENDS)
 260     set(_JAVA_RESOURCE_FILES)
 261     foreach(_JAVA_SOURCE_FILE ${_JAVA_SOURCE_FILES})
 262         get_filename_component(_JAVA_EXT ${_JAVA_SOURCE_FILE} EXT)
 263         get_filename_component(_JAVA_FILE ${_JAVA_SOURCE_FILE} NAME_WE)
 264         get_filename_component(_JAVA_PATH ${_JAVA_SOURCE_FILE} PATH)
 265         get_filename_component(_JAVA_FULL ${_JAVA_SOURCE_FILE} ABSOLUTE)
 266
 267         file(RELATIVE_PATH _JAVA_REL_BINARY_PATH ${CMAKE_JAVA_TARGET_OUTPUT_DIR} ${_JAVA_FULL})
 268         file(RELATIVE_PATH _JAVA_REL_SOURCE_PATH ${CMAKE_CURRENT_SOURCE_DIR} ${_JAVA_FULL})
 269         string(LENGTH ${_JAVA_REL_BINARY_PATH} _BIN_LEN)
 270         string(LENGTH ${_JAVA_REL_SOURCE_PATH} _SRC_LEN)
 271         if (${_BIN_LEN} LESS ${_SRC_LEN})
 272             set(_JAVA_REL_PATH ${_JAVA_REL_BINARY_PATH})
 273         else ()
 274             set(_JAVA_REL_PATH ${_JAVA_REL_SOURCE_PATH})
 275         endif ()
 276         get_filename_component(_JAVA_REL_PATH ${_JAVA_REL_PATH} PATH)
 277
 278         if (_JAVA_EXT MATCHES ".java")
 279             list(APPEND _JAVA_COMPILE_FILES ${_JAVA_SOURCE_FILE})
 280             set(_JAVA_CLASS_FILE "${CMAKE_JAVA_CLASS_OUTPUT_PATH}/${_JAVA_REL_PATH}/${_JAVA_FILE}.class")
 281             set(_JAVA_CLASS_FILES ${_JAVA_CLASS_FILES} ${_JAVA_CLASS_FILE})
 282
 283         elseif (_JAVA_EXT MATCHES ".jar"
 284                 OR _JAVA_EXT MATCHES ".war"
 285                 OR _JAVA_EXT MATCHES ".ear"
 286                 OR _JAVA_EXT MATCHES ".sar")
 287             list(APPEND CMAKE_JAVA_INCLUDE_PATH ${_JAVA_SOURCE_FILE})
 288
 289         elseif (_JAVA_EXT STREQUAL "")
 290             list(APPEND CMAKE_JAVA_INCLUDE_PATH ${JAVA_JAR_TARGET_${_JAVA_SOURCE_FILE}} ${JAVA_JAR_TARGET_${_JAVA_SOURCE_FILE}_CLASSPATH})
 291             list(APPEND _JAVA_DEPENDS ${JAVA_JAR_TARGET_${_JAVA_SOURCE_FILE}})
 292
 293         else ()
 294             __java_copy_file(${CMAKE_CURRENT_SOURCE_DIR}/${_JAVA_SOURCE_FILE}
 295                              ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/${_JAVA_SOURCE_FILE}
 296                              "Copying ${_JAVA_SOURCE_FILE} to the build directory")
 297             list(APPEND _JAVA_RESOURCE_FILES ${_JAVA_SOURCE_FILE})
 298         endif ()
 299     endforeach()
 300
 301     # create an empty java_class_filelist
 302     if (NOT EXISTS ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist)
 303         file(WRITE ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist "")
 304     endif()
 305
 306     if (_JAVA_COMPILE_FILES)
 307         # Compile the java files and create a list of class files
 308         add_custom_command(
 309             # NOTE: this command generates an artificial dependency file
 310             OUTPUT ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_compiled_${_TARGET_NAME}
 311             COMMAND ${Java_JAVAC_EXECUTABLE}
 312                 ${CMAKE_JAVA_COMPILE_FLAGS}
 313                 -classpath "${CMAKE_JAVA_INCLUDE_PATH_FINAL}"
 314                 -d ${CMAKE_JAVA_CLASS_OUTPUT_PATH}
 315                 ${_JAVA_COMPILE_FILES}
 316             COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_compiled_${_TARGET_NAME}
 317             DEPENDS ${_JAVA_COMPILE_FILES}
 318             WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
 319             COMMENT "Building Java objects for ${_TARGET_NAME}.jar"
 320         )
 321         add_custom_command(
 322             OUTPUT ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist
 323             COMMAND ${CMAKE_COMMAND}
 324                 -DCMAKE_JAVA_CLASS_OUTPUT_PATH=${CMAKE_JAVA_CLASS_OUTPUT_PATH}
 325                 -DCMAKE_JAR_CLASSES_PREFIX="${CMAKE_JAR_CLASSES_PREFIX}"
 326                 -P ${_JAVA_CLASS_FILELIST_SCRIPT}
 327             DEPENDS ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_compiled_${_TARGET_NAME}
 328             WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
 329         )
 330     endif ()
 331
 332     # create the jar file
 333     set(_JAVA_JAR_OUTPUT_PATH
 334       ${CMAKE_JAVA_TARGET_OUTPUT_DIR}/${_JAVA_TARGET_OUTPUT_NAME})
 335     if (CMAKE_JNI_TARGET)
 336         add_custom_command(
 337             OUTPUT ${_JAVA_JAR_OUTPUT_PATH}
 338             COMMAND ${Java_JAR_EXECUTABLE}
 339                 -cf${_ENTRY_POINT_OPTION} ${_JAVA_JAR_OUTPUT_PATH} ${_ENTRY_POINT_VALUE}
 340                 ${_JAVA_RESOURCE_FILES} @java_class_filelist
 341             COMMAND ${CMAKE_COMMAND}
 342                 -D_JAVA_TARGET_DIR=${CMAKE_JAVA_TARGET_OUTPUT_DIR}
 343                 -D_JAVA_TARGET_OUTPUT_NAME=${_JAVA_TARGET_OUTPUT_NAME}
 344                 -D_JAVA_TARGET_OUTPUT_LINK=${_JAVA_TARGET_OUTPUT_LINK}
 345                 -P ${_JAVA_SYMLINK_SCRIPT}
 346             COMMAND ${CMAKE_COMMAND}
 347                 -D_JAVA_TARGET_DIR=${CMAKE_JAVA_TARGET_OUTPUT_DIR}
 348                 -D_JAVA_TARGET_OUTPUT_NAME=${_JAVA_JAR_OUTPUT_PATH}
 349                 -D_JAVA_TARGET_OUTPUT_LINK=${_JAVA_TARGET_OUTPUT_LINK}
 350                 -P ${_JAVA_SYMLINK_SCRIPT}
 351             DEPENDS ${_JAVA_RESOURCE_FILES} ${_JAVA_DEPENDS} ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist
 352             WORKING_DIRECTORY ${CMAKE_JAVA_CLASS_OUTPUT_PATH}
 353             COMMENT "Creating Java archive ${_JAVA_TARGET_OUTPUT_NAME}"
 354         )
 355     else ()
 356         add_custom_command(
 357             OUTPUT ${_JAVA_JAR_OUTPUT_PATH}
 358             COMMAND ${Java_JAR_EXECUTABLE}
 359                 -cf${_ENTRY_POINT_OPTION} ${_JAVA_JAR_OUTPUT_PATH} ${_ENTRY_POINT_VALUE}
 360                 ${_JAVA_RESOURCE_FILES} @java_class_filelist
 361             COMMAND ${CMAKE_COMMAND}
 362                 -D_JAVA_TARGET_DIR=${CMAKE_JAVA_TARGET_OUTPUT_DIR}
 363                 -D_JAVA_TARGET_OUTPUT_NAME=${_JAVA_TARGET_OUTPUT_NAME}
 364                 -D_JAVA_TARGET_OUTPUT_LINK=${_JAVA_TARGET_OUTPUT_LINK}
 365                 -P ${_JAVA_SYMLINK_SCRIPT}
 366             WORKING_DIRECTORY ${CMAKE_JAVA_CLASS_OUTPUT_PATH}
 367             DEPENDS ${_JAVA_RESOURCE_FILES} ${_JAVA_DEPENDS} ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist
 368             COMMENT "Creating Java archive ${_JAVA_TARGET_OUTPUT_NAME}"
 369         )
 370     endif ()
 371
 372     # Add the target and make sure we have the latest resource files.
 373     add_custom_target(${_TARGET_NAME} ALL DEPENDS ${_JAVA_JAR_OUTPUT_PATH})
 374
 375     set_property(
 376         TARGET
 377             ${_TARGET_NAME}
 378         PROPERTY
 379             INSTALL_FILES
 380                 ${_JAVA_JAR_OUTPUT_PATH}
 381     )
 382
 383     if (_JAVA_TARGET_OUTPUT_LINK)
 384         set_property(
 385             TARGET
 386                 ${_TARGET_NAME}
 387             PROPERTY
 388                 INSTALL_FILES
 389                     ${_JAVA_JAR_OUTPUT_PATH}
 390                     ${CMAKE_JAVA_TARGET_OUTPUT_DIR}/${_JAVA_TARGET_OUTPUT_LINK}
 391         )
 392
 393         if (CMAKE_JNI_TARGET)
 394             set_property(
 395                 TARGET
 396                     ${_TARGET_NAME}
 397                 PROPERTY
 398                     JNI_SYMLINK
 399                         ${CMAKE_JAVA_TARGET_OUTPUT_DIR}/${_JAVA_TARGET_OUTPUT_LINK}
 400             )
 401         endif ()
 402     endif ()
 403
 404     set_property(
 405         TARGET
 406             ${_TARGET_NAME}
 407         PROPERTY
 408             JAR_FILE
 409                 ${_JAVA_JAR_OUTPUT_PATH}
 410     )
 411
 412     set_property(
 413         TARGET
 414             ${_TARGET_NAME}
 415         PROPERTY
 416             CLASSDIR
 417                 ${CMAKE_JAVA_CLASS_OUTPUT_PATH}
 418     )
 419
 420 endfunction()
 421
 422 function(INSTALL_JAR _TARGET_NAME _DESTINATION)
 423     get_property(__FILES
 424         TARGET
 425             ${_TARGET_NAME}
 426         PROPERTY
 427             INSTALL_FILES
 428     )
 429
 430     if (__FILES)
 431         install(
 432             FILES
 433                 ${__FILES}
 434             DESTINATION
 435                 ${_DESTINATION}
 436         )
 437     else ()
 438         message(SEND_ERROR "The target ${_TARGET_NAME} is not known in this scope.")
 439     endif ()
 440 endfunction()
 441
 442 function(INSTALL_JNI_SYMLINK _TARGET_NAME _DESTINATION)
 443     get_property(__SYMLINK
 444         TARGET
 445             ${_TARGET_NAME}
 446         PROPERTY
 447             JNI_SYMLINK
 448     )
 449
 450     if (__SYMLINK)
 451         install(
 452             FILES
 453                 ${__SYMLINK}
 454             DESTINATION
 455                 ${_DESTINATION}
 456         )
 457     else ()
 458         message(SEND_ERROR "The target ${_TARGET_NAME} is not known in this scope.")
 459     endif ()
 460 endfunction()
 461
 462 function (find_jar VARIABLE)
 463     set(_jar_names)
 464     set(_jar_files)
 465     set(_jar_versions)
 466     set(_jar_paths
 467         /usr/share/java/
 468         /usr/local/share/java/
 469         ${Java_JAR_PATHS})
 470     set(_jar_doc "NOTSET")
 471
 472     set(_state "name")
 473
 474     foreach (arg ${ARGN})
 475         if (${_state} STREQUAL "name")
 476             if (${arg} STREQUAL "VERSIONS")
 477                 set(_state "versions")
 478             elseif (${arg} STREQUAL "NAMES")
 479                 set(_state "names")
 480             elseif (${arg} STREQUAL "PATHS")
 481                 set(_state "paths")
 482             elseif (${arg} STREQUAL "DOC")
 483                 set(_state "doc")
 484             else ()
 485                 set(_jar_names ${arg})
 486                 if (_jar_doc STREQUAL "NOTSET")
 487                     set(_jar_doc "Finding ${arg} jar")
 488                 endif ()
 489             endif ()
 490         elseif (${_state} STREQUAL "versions")
 491             if (${arg} STREQUAL "NAMES")
 492                 set(_state "names")
 493             elseif (${arg} STREQUAL "PATHS")
 494                 set(_state "paths")
 495             elseif (${arg} STREQUAL "DOC")
 496                 set(_state "doc")
 497             else ()
 498                 set(_jar_versions ${_jar_versions} ${arg})
 499             endif ()
 500         elseif (${_state} STREQUAL "names")
 501             if (${arg} STREQUAL "VERSIONS")
 502                 set(_state "versions")
 503             elseif (${arg} STREQUAL "PATHS")
 504                 set(_state "paths")
 505             elseif (${arg} STREQUAL "DOC")
 506                 set(_state "doc")
 507             else ()
 508                 set(_jar_names ${_jar_names} ${arg})
 509                 if (_jar_doc STREQUAL "NOTSET")
 510                     set(_jar_doc "Finding ${arg} jar")
 511                 endif ()
 512             endif ()
 513         elseif (${_state} STREQUAL "paths")
 514             if (${arg} STREQUAL "VERSIONS")
 515                 set(_state "versions")
 516             elseif (${arg} STREQUAL "NAMES")
 517                 set(_state "names")
 518             elseif (${arg} STREQUAL "DOC")
 519                 set(_state "doc")
 520             else ()
 521                 set(_jar_paths ${_jar_paths} ${arg})
 522             endif ()
 523         elseif (${_state} STREQUAL "doc")
 524             if (${arg} STREQUAL "VERSIONS")
 525                 set(_state "versions")
 526             elseif (${arg} STREQUAL "NAMES")
 527                 set(_state "names")
 528             elseif (${arg} STREQUAL "PATHS")
 529                 set(_state "paths")
 530             else ()
 531                 set(_jar_doc ${arg})
 532             endif ()
 533         endif ()
 534     endforeach ()
 535
 536     if (NOT _jar_names)
 537         message(FATAL_ERROR "find_jar: No name to search for given")
 538     endif ()
 539
 540     foreach (jar_name ${_jar_names})
 541         foreach (version ${_jar_versions})
 542             set(_jar_files ${_jar_files} ${jar_name}-${version}.jar)
 543         endforeach ()
 544         set(_jar_files ${_jar_files} ${jar_name}.jar)
 545     endforeach ()
 546
 547     find_file(${VARIABLE}
 548         NAMES   ${_jar_files}
 549         PATHS   ${_jar_paths}
 550         DOC     ${_jar_doc}
 551         NO_DEFAULT_PATH)
 552 endfunction ()
 553
 554 function(create_javadoc _target)
 555     set(_javadoc_packages)
 556     set(_javadoc_files)
 557     set(_javadoc_sourcepath)
 558     set(_javadoc_classpath)
 559     set(_javadoc_installpath "${CMAKE_INSTALL_PREFIX}/share/javadoc")
 560     set(_javadoc_doctitle)
 561     set(_javadoc_windowtitle)
 562     set(_javadoc_author FALSE)
 563     set(_javadoc_version FALSE)
 564     set(_javadoc_use FALSE)
 565
 566     set(_state "package")
 567
 568     foreach (arg ${ARGN})
 569         if (${_state} STREQUAL "package")
 570             if (${arg} STREQUAL "PACKAGES")
 571                 set(_state "packages")
 572             elseif (${arg} STREQUAL "FILES")
 573                 set(_state "files")
 574             elseif (${arg} STREQUAL "SOURCEPATH")
 575                 set(_state "sourcepath")
 576             elseif (${arg} STREQUAL "CLASSPATH")
 577                 set(_state "classpath")
 578             elseif (${arg} STREQUAL "INSTALLPATH")
 579                 set(_state "installpath")
 580             elseif (${arg} STREQUAL "DOCTITLE")
 581                 set(_state "doctitle")
 582             elseif (${arg} STREQUAL "WINDOWTITLE")
 583                 set(_state "windowtitle")
 584             elseif (${arg} STREQUAL "AUTHOR")
 585                 set(_state "author")
 586             elseif (${arg} STREQUAL "USE")
 587                 set(_state "use")
 588             elseif (${arg} STREQUAL "VERSION")
 589                 set(_state "version")
 590             else ()
 591                 set(_javadoc_packages ${arg})
 592                 set(_state "packages")
 593             endif ()
 594         elseif (${_state} STREQUAL "packages")
 595             if (${arg} STREQUAL "FILES")
 596                 set(_state "files")
 597             elseif (${arg} STREQUAL "SOURCEPATH")
 598                 set(_state "sourcepath")
 599             elseif (${arg} STREQUAL "CLASSPATH")
 600                 set(_state "classpath")
 601             elseif (${arg} STREQUAL "INSTALLPATH")
 602                 set(_state "installpath")
 603             elseif (${arg} STREQUAL "DOCTITLE")
 604                 set(_state "doctitle")
 605             elseif (${arg} STREQUAL "WINDOWTITLE")
 606                 set(_state "windowtitle")
 607             elseif (${arg} STREQUAL "AUTHOR")
 608                 set(_state "author")
 609             elseif (${arg} STREQUAL "USE")
 610                 set(_state "use")
 611             elseif (${arg} STREQUAL "VERSION")
 612                 set(_state "version")
 613             else ()
 614                 list(APPEND _javadoc_packages ${arg})
 615             endif ()
 616         elseif (${_state} STREQUAL "files")
 617             if (${arg} STREQUAL "PACKAGES")
 618                 set(_state "packages")
 619             elseif (${arg} STREQUAL "SOURCEPATH")
 620                 set(_state "sourcepath")
 621             elseif (${arg} STREQUAL "CLASSPATH")
 622                 set(_state "classpath")
 623             elseif (${arg} STREQUAL "INSTALLPATH")
 624                 set(_state "installpath")
 625             elseif (${arg} STREQUAL "DOCTITLE")
 626                 set(_state "doctitle")
 627             elseif (${arg} STREQUAL "WINDOWTITLE")
 628                 set(_state "windowtitle")
 629             elseif (${arg} STREQUAL "AUTHOR")
 630                 set(_state "author")
 631             elseif (${arg} STREQUAL "USE")
 632                 set(_state "use")
 633             elseif (${arg} STREQUAL "VERSION")
 634                 set(_state "version")
 635             else ()
 636                 list(APPEND _javadoc_files ${arg})
 637             endif ()
 638         elseif (${_state} STREQUAL "sourcepath")
 639             if (${arg} STREQUAL "PACKAGES")
 640                 set(_state "packages")
 641             elseif (${arg} STREQUAL "FILES")
 642                 set(_state "files")
 643             elseif (${arg} STREQUAL "CLASSPATH")
 644                 set(_state "classpath")
 645             elseif (${arg} STREQUAL "INSTALLPATH")
 646                 set(_state "installpath")
 647             elseif (${arg} STREQUAL "DOCTITLE")
 648                 set(_state "doctitle")
 649             elseif (${arg} STREQUAL "WINDOWTITLE")
 650                 set(_state "windowtitle")
 651             elseif (${arg} STREQUAL "AUTHOR")
 652                 set(_state "author")
 653             elseif (${arg} STREQUAL "USE")
 654                 set(_state "use")
 655             elseif (${arg} STREQUAL "VERSION")
 656                 set(_state "version")
 657             else ()
 658                 list(APPEND _javadoc_sourcepath ${arg})
 659             endif ()
 660         elseif (${_state} STREQUAL "classpath")
 661             if (${arg} STREQUAL "PACKAGES")
 662                 set(_state "packages")
 663             elseif (${arg} STREQUAL "FILES")
 664                 set(_state "files")
 665             elseif (${arg} STREQUAL "SOURCEPATH")
 666                 set(_state "sourcepath")
 667             elseif (${arg} STREQUAL "INSTALLPATH")
 668                 set(_state "installpath")
 669             elseif (${arg} STREQUAL "DOCTITLE")
 670                 set(_state "doctitle")
 671             elseif (${arg} STREQUAL "WINDOWTITLE")
 672                 set(_state "windowtitle")
 673             elseif (${arg} STREQUAL "AUTHOR")
 674                 set(_state "author")
 675             elseif (${arg} STREQUAL "USE")
 676                 set(_state "use")
 677             elseif (${arg} STREQUAL "VERSION")
 678                 set(_state "version")
 679             else ()
 680                 list(APPEND _javadoc_classpath ${arg})
 681             endif ()
 682         elseif (${_state} STREQUAL "installpath")
 683             if (${arg} STREQUAL "PACKAGES")
 684                 set(_state "packages")
 685             elseif (${arg} STREQUAL "FILES")
 686                 set(_state "files")
 687             elseif (${arg} STREQUAL "SOURCEPATH")
 688                 set(_state "sourcepath")
 689             elseif (${arg} STREQUAL "DOCTITLE")
 690                 set(_state "doctitle")
 691             elseif (${arg} STREQUAL "WINDOWTITLE")
 692                 set(_state "windowtitle")
 693             elseif (${arg} STREQUAL "AUTHOR")
 694                 set(_state "author")
 695             elseif (${arg} STREQUAL "USE")
 696                 set(_state "use")
 697             elseif (${arg} STREQUAL "VERSION")
 698                 set(_state "version")
 699             else ()
 700                 set(_javadoc_installpath ${arg})
 701             endif ()
 702         elseif (${_state} STREQUAL "doctitle")
 703             if (${arg} STREQUAL "PACKAGES")
 704                 set(_state "packages")
 705             elseif (${arg} STREQUAL "FILES")
 706                 set(_state "files")
 707             elseif (${arg} STREQUAL "SOURCEPATH")
 708                 set(_state "sourcepath")
 709             elseif (${arg} STREQUAL "INSTALLPATH")
 710                 set(_state "installpath")
 711             elseif (${arg} STREQUAL "CLASSPATH")
 712                 set(_state "classpath")
 713             elseif (${arg} STREQUAL "WINDOWTITLE")
 714                 set(_state "windowtitle")
 715             elseif (${arg} STREQUAL "AUTHOR")
 716                 set(_state "author")
 717             elseif (${arg} STREQUAL "USE")
 718                 set(_state "use")
 719             elseif (${arg} STREQUAL "VERSION")
 720                 set(_state "version")
 721             else ()
 722                 set(_javadoc_doctitle ${arg})
 723             endif ()
 724         elseif (${_state} STREQUAL "windowtitle")
 725             if (${arg} STREQUAL "PACKAGES")
 726                 set(_state "packages")
 727             elseif (${arg} STREQUAL "FILES")
 728                 set(_state "files")
 729             elseif (${arg} STREQUAL "SOURCEPATH")
 730                 set(_state "sourcepath")
 731             elseif (${arg} STREQUAL "CLASSPATH")
 732                 set(_state "classpath")
 733             elseif (${arg} STREQUAL "INSTALLPATH")
 734                 set(_state "installpath")
 735             elseif (${arg} STREQUAL "DOCTITLE")
 736                 set(_state "doctitle")
 737             elseif (${arg} STREQUAL "AUTHOR")
 738                 set(_state "author")
 739             elseif (${arg} STREQUAL "USE")
 740                 set(_state "use")
 741             elseif (${arg} STREQUAL "VERSION")
 742                 set(_state "version")
 743             else ()
 744                 set(_javadoc_windowtitle ${arg})
 745             endif ()
 746         elseif (${_state} STREQUAL "author")
 747             if (${arg} STREQUAL "PACKAGES")
 748                 set(_state "packages")
 749             elseif (${arg} STREQUAL "FILES")
 750                 set(_state "files")
 751             elseif (${arg} STREQUAL "SOURCEPATH")
 752                 set(_state "sourcepath")
 753             elseif (${arg} STREQUAL "CLASSPATH")
 754                 set(_state "classpath")
 755             elseif (${arg} STREQUAL "INSTALLPATH")
 756                 set(_state "installpath")
 757             elseif (${arg} STREQUAL "DOCTITLE")
 758                 set(_state "doctitle")
 759             elseif (${arg} STREQUAL "WINDOWTITLE")
 760                 set(_state "windowtitle")
 761             elseif (${arg} STREQUAL "AUTHOR")
 762                 set(_state "author")
 763             elseif (${arg} STREQUAL "USE")
 764                 set(_state "use")
 765             elseif (${arg} STREQUAL "VERSION")
 766                 set(_state "version")
 767             else ()
 768                 set(_javadoc_author ${arg})
 769             endif ()
 770         elseif (${_state} STREQUAL "use")
 771             if (${arg} STREQUAL "PACKAGES")
 772                 set(_state "packages")
 773             elseif (${arg} STREQUAL "FILES")
 774                 set(_state "files")
 775             elseif (${arg} STREQUAL "SOURCEPATH")
 776                 set(_state "sourcepath")
 777             elseif (${arg} STREQUAL "CLASSPATH")
 778                 set(_state "classpath")
 779             elseif (${arg} STREQUAL "INSTALLPATH")
 780                 set(_state "installpath")
 781             elseif (${arg} STREQUAL "DOCTITLE")
 782                 set(_state "doctitle")
 783             elseif (${arg} STREQUAL "WINDOWTITLE")
 784                 set(_state "windowtitle")
 785             elseif (${arg} STREQUAL "AUTHOR")
 786                 set(_state "author")
 787             elseif (${arg} STREQUAL "USE")
 788                 set(_state "use")
 789             elseif (${arg} STREQUAL "VERSION")
 790                 set(_state "version")
 791             else ()
 792                 set(_javadoc_use ${arg})
 793             endif ()
 794         elseif (${_state} STREQUAL "version")
 795             if (${arg} STREQUAL "PACKAGES")
 796                 set(_state "packages")
 797             elseif (${arg} STREQUAL "FILES")
 798                 set(_state "files")
 799             elseif (${arg} STREQUAL "SOURCEPATH")
 800                 set(_state "sourcepath")
 801             elseif (${arg} STREQUAL "CLASSPATH")
 802                 set(_state "classpath")
 803             elseif (${arg} STREQUAL "INSTALLPATH")
 804                 set(_state "installpath")
 805             elseif (${arg} STREQUAL "DOCTITLE")
 806                 set(_state "doctitle")
 807             elseif (${arg} STREQUAL "WINDOWTITLE")
 808                 set(_state "windowtitle")
 809             elseif (${arg} STREQUAL "AUTHOR")
 810                 set(_state "author")
 811             elseif (${arg} STREQUAL "USE")
 812                 set(_state "use")
 813             elseif (${arg} STREQUAL "VERSION")
 814                 set(_state "version")
 815             else ()
 816                 set(_javadoc_version ${arg})
 817             endif ()
 818         endif ()
 819     endforeach ()
 820
 821     set(_javadoc_builddir ${CMAKE_CURRENT_BINARY_DIR}/javadoc/${_target})
 822     set(_javadoc_options -d ${_javadoc_builddir})
 823
 824     if (_javadoc_sourcepath)
 825         set(_start TRUE)
 826         foreach(_path ${_javadoc_sourcepath})
 827             if (_start)
 828                 set(_sourcepath ${_path})
 829                 set(_start FALSE)
 830             else ()
 831                 set(_sourcepath ${_sourcepath}:${_path})
 832             endif ()
 833         endforeach()
 834         set(_javadoc_options ${_javadoc_options} -sourcepath ${_sourcepath})
 835     endif ()
 836
 837     if (_javadoc_classpath)
 838         set(_start TRUE)
 839         foreach(_path ${_javadoc_classpath})
 840             if (_start)
 841                 set(_classpath ${_path})
 842                 set(_start FALSE)
 843             else ()
 844                 set(_classpath ${_classpath}:${_path})
 845             endif ()
 846         endforeach()
 847         set(_javadoc_options ${_javadoc_options} -classpath "${_classpath}")
 848     endif ()
 849
 850     if (_javadoc_doctitle)
 851         set(_javadoc_options ${_javadoc_options} -doctitle '${_javadoc_doctitle}')
 852     endif ()
 853
 854     if (_javadoc_windowtitle)
 855         set(_javadoc_options ${_javadoc_options} -windowtitle '${_javadoc_windowtitle}')
 856     endif ()
 857
 858     if (_javadoc_author)
 859         set(_javadoc_options ${_javadoc_options} -author)
 860     endif ()
 861
 862     if (_javadoc_use)
 863         set(_javadoc_options ${_javadoc_options} -use)
 864     endif ()
 865
 866     if (_javadoc_version)
 867         set(_javadoc_options ${_javadoc_options} -version)
 868     endif ()
 869
 870     add_custom_target(${_target}_javadoc ALL
 871         COMMAND ${Java_JAVADOC_EXECUTABLE} ${_javadoc_options}
 872                             ${_javadoc_files}
 873                             ${_javadoc_packages}
 874         WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
 875     )
 876
 877     install(
 878         DIRECTORY ${_javadoc_builddir}
 879         DESTINATION ${_javadoc_installpath}
 880     )
 881 endfunction()