1 # Distributed under the OSI-approved BSD 3-Clause License. See accompanying
2 # file Copyright.txt or https://cmake.org/licensing for details.
4 #[=======================================================================[.rst:
8 This file provides support for ``Java``. It is assumed that
9 :module:`FindJava` has already been loaded. See :module:`FindJava` for
10 information on how to load Java into your CMake project.
17 `Creating and Installing JARS`_
18 `add_jar`_ (<target_name> [SOURCES] <source1> [<source2>...] ...)
19 `install_jar`_ (<target_name> DESTINATION <destination> [COMPONENT <component>])
20 `install_jni_symlink`_ (<target_name> DESTINATION <destination> [COMPONENT <component>])
23 `create_javah`_ ((TARGET <target> | GENERATED_FILES <VAR>) CLASSES <class>... ...)
25 `Exporting JAR Targets`_
26 `install_jar_exports`_ (TARGETS <jars>... FILE <filename> DESTINATION <destination> ...)
27 `export_jars`_ (TARGETS <jars>... [NAMESPACE <namespace>] FILE <filename>)
30 `find_jar`_ (<VAR> NAMES <name1> [<name2>...] [PATHS <path1> [<path2>... ENV <var>]] ...)
32 `Creating Java Documentation`_
33 `create_javadoc`_ (<VAR> (PACKAGES <pkg1> [<pkg2>...] | FILES <file1> [<file2>...]) ...)
35 Creating And Installing JARs
36 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
42 Creates a jar file containing java objects and, optionally, resources::
45 [SOURCES] <source1> [<source2>...] [<resource1>...]
46 [RESOURCES NAMESPACE <ns1> <resource1>... [NAMESPACE <nsX> <resourceX>...]... ]
47 [INCLUDE_JARS <jar1> [<jar2>...]]
53 [GENERATE_NATIVE_HEADERS <target>
54 [DESTINATION (<dir>|INSTALL <dir> [BUILD <dir>])]]
57 This command creates a ``<target_name>.jar``. It compiles the given
58 ``<source>`` files and adds the given ``<resource>`` files to
59 the jar file. Source files can be java files or listing files
60 (prefixed by ``@``). If only resource files are given then just a jar file
64 Compiles the specified source files and adds the result in the jar file.
67 Support for response files, prefixed by ``@``.
70 .. versionadded:: 3.21
72 Adds the named ``<resource>`` files to the jar by stripping the source file
73 path and placing the file beneath ``<ns>`` within the jar.
77 RESOURCES NAMESPACE "/com/my/namespace" "a/path/to/resource.txt"
79 results in a resource accessible via ``/com/my/namespace/resource.txt``
82 Resources may be added without adjusting the namespace by adding them to
83 the list of ``SOURCES`` (original behavior), in this case, resource
84 paths must be relative to ``CMAKE_CURRENT_SOURCE_DIR``. Adding resources
85 without using the ``RESOURCES`` parameter in out of source builds will
86 almost certainly result in confusion.
90 Adding resources via the ``SOURCES`` parameter relies upon a hard-coded
91 list of file extensions which are tested to determine whether they
92 compile (e.g. File.java). ``SOURCES`` files which match the extensions
93 are compiled. Files which do not match are treated as resources. To
94 include uncompiled resources matching those file extensions use
95 the ``RESOURCES`` parameter.
98 The list of jars are added to the classpath when compiling the java sources
99 and also to the dependencies of the target. ``INCLUDE_JARS`` also accepts
100 other target names created by ``add_jar()``. For backwards compatibility,
101 jar files listed as sources are ignored (as they have been since the first
102 version of this module).
105 Defines an entry point in the jar file.
108 Adds a version to the target output name.
110 The following example will create a jar file with the name
111 ``shibboleet-1.2.0.jar`` and will create a symlink ``shibboleet.jar``
112 pointing to the jar with the version information.
114 .. code-block:: cmake
116 add_jar(shibboleet shibbotleet.java VERSION 1.2.0)
119 Defines a custom manifest for the jar.
122 Specify a different output name for the target.
125 Sets the directory where the jar file will be generated. If not specified,
126 :variable:`CMAKE_CURRENT_BINARY_DIR` is used as the output directory.
128 ``GENERATE_NATIVE_HEADERS``
129 .. versionadded:: 3.11
131 Generates native header files for methods declared as native. These files
132 provide the connective glue that allow your Java and C code to interact.
133 An INTERFACE target will be created for an easy usage of generated files.
134 Sub-option ``DESTINATION`` can be used to specify the output directory for
135 generated header files.
137 This option requires, at least, version 1.8 of the JDK.
139 For an optimum usage of this option, it is recommended to include module
140 JNI before any call to ``add_jar()``. The produced target for native
141 headers can then be used to compile C/C++ sources with the
142 :command:`target_link_libraries` command.
144 .. code-block:: cmake
147 add_jar(foo foo.java GENERATE_NATIVE_HEADERS foo-native)
148 add_library(bar bar.cpp)
149 target_link_libraries(bar PRIVATE foo-native)
151 .. versionadded:: 3.20
152 ``DESTINATION`` sub-option now supports the possibility to specify
153 different output directories for ``BUILD`` and ``INSTALL`` steps. If
154 ``BUILD`` directory is not specified, a default directory will be used.
156 To export the interface target generated by ``GENERATE_NATIVE_HEADERS``
157 option, sub-option ``INSTALL`` of ``DESTINATION`` is required:
159 .. code-block:: cmake
161 add_jar(foo foo.java GENERATE_NATIVE_HEADERS foo-native
162 DESTINATION INSTALL include)
163 install(TARGETS foo-native EXPORT native)
164 install(DIRECTORY "$<TARGET_PROPERTY:foo-native,NATIVE_HEADERS_DIRECTORY>/"
166 install(EXPORT native DESTINATION /to/export NAMESPACE foo)
168 Some variables can be set to customize the behavior of ``add_jar()`` as well
169 as the java compiler:
171 ``CMAKE_JAVA_COMPILE_FLAGS``
172 Specify additional flags to java compiler.
174 ``CMAKE_JAVA_INCLUDE_PATH``
175 Specify additional paths to the class path.
178 If the target is a JNI library, sets this boolean variable to ``TRUE`` to
179 enable creation of a JNI symbolic link (see also
180 :ref:`install_jni_symlink() <install_jni_symlink>`).
182 ``CMAKE_JAR_CLASSES_PREFIX``
183 If multiple jars should be produced from the same java source filetree,
184 to prevent the accumulation of duplicate class files in subsequent jars,
185 set/reset ``CMAKE_JAR_CLASSES_PREFIX`` prior to calling the ``add_jar()``:
187 .. code-block:: cmake
189 set(CMAKE_JAR_CLASSES_PREFIX com/redhat/foo)
190 add_jar(foo foo.java)
192 set(CMAKE_JAR_CLASSES_PREFIX com/redhat/bar)
193 add_jar(bar bar.java)
195 The ``add_jar()`` function sets the following target properties on
199 The files which should be installed. This is used by
200 :ref:`install_jar() <install_jar>`.
202 The JNI symlink which should be installed. This is used by
203 :ref:`install_jni_symlink() <install_jni_symlink>`.
205 The location of the jar file so that you can include it.
207 The directory where the class files can be found. For example to use them
209 ``NATIVE_HEADERS_DIRECTORY``
210 .. versionadded:: 3.20
212 The directory where native headers are generated. Defined when option
213 ``GENERATE_NATIVE_HEADERS`` is specified.
217 .. command:: install_jar
219 This command installs the jar file to the given destination::
221 install_jar(<target_name> <destination>)
222 install_jar(<target_name> DESTINATION <destination> [COMPONENT <component>])
224 This command installs the ``<target_name>`` file to the given
225 ``<destination>``. It should be called in the same scope as
226 :ref:`add_jar() <add_jar>` or it will fail.
228 .. versionadded:: 3.4
229 The second signature with ``DESTINATION`` and ``COMPONENT`` options.
232 Specify the directory on disk to which a file will be installed.
235 Specify an installation component name with which the install rule is
236 associated, such as "runtime" or "development".
238 The ``install_jar()`` command sets the following target properties
239 on ``<target_name>``:
241 ``INSTALL_DESTINATION``
242 Holds the ``<destination>`` as described above, and is used by
243 :ref:`install_jar_exports() <install_jar_exports>`.
245 .. _install_jni_symlink:
247 .. command:: install_jni_symlink
249 Installs JNI symlinks for target generated by :ref:`add_jar() <add_jar>`::
251 install_jni_symlink(<target_name> <destination>)
252 install_jni_symlink(<target_name> DESTINATION <destination> [COMPONENT <component>])
254 This command installs the ``<target_name>`` JNI symlinks to the given
255 ``<destination>``. It should be called in the same scope as
256 :ref:`add_jar() <add_jar>` or it will fail.
258 .. versionadded:: 3.4
259 The second signature with ``DESTINATION`` and ``COMPONENT`` options.
262 Specify the directory on disk to which a file will be installed.
265 Specify an installation component name with which the install rule is
266 associated, such as "runtime" or "development".
268 Utilize the following commands to create a JNI symbolic link:
270 .. code-block:: cmake
272 set(CMAKE_JNI_TARGET TRUE)
273 add_jar(shibboleet shibbotleet.java VERSION 1.2.0)
274 install_jar(shibboleet ${LIB_INSTALL_DIR}/shibboleet)
275 install_jni_symlink(shibboleet ${JAVA_LIB_INSTALL_DIR})
282 .. command:: create_javah
284 .. versionadded:: 3.4
286 Generates C header files for java classes::
288 create_javah(TARGET <target> | GENERATED_FILES <VAR>
290 [CLASSPATH <classpath>...]
291 [DEPENDS <depend>...]
292 [OUTPUT_NAME <path>|OUTPUT_DIR <path>]
296 This command will no longer be supported starting with version 10 of the JDK
297 due to the `suppression of javah tool <https://openjdk.org/jeps/313>`_.
298 The :ref:`add_jar(GENERATE_NATIVE_HEADERS) <add_jar>` command should be
301 Create C header files from java classes. These files provide the connective
302 glue that allow your Java and C code to interact.
304 There are two main signatures for ``create_javah()``. The first signature
305 returns generated files through variable specified by the ``GENERATED_FILES``
308 .. code-block:: cmake
310 create_javah(GENERATED_FILES files_headers
311 CLASSES org.cmake.HelloWorld
315 The second signature for ``create_javah()`` creates a target which
316 encapsulates header files generation. E.g.
318 .. code-block:: cmake
320 create_javah(TARGET target_headers
321 CLASSES org.cmake.HelloWorld
325 Both signatures share same options.
328 Specifies Java classes used to generate headers.
331 Specifies various paths to look up classes. Here ``.class`` files, jar
332 files or targets created by command add_jar can be used.
335 Targets on which the javah target depends.
338 Concatenates the resulting header files for all the classes listed by
339 option ``CLASSES`` into ``<path>``. Same behavior as option ``-o`` of
343 Sets the directory where the header files will be generated. Same behavior
344 as option ``-d`` of ``javah`` tool. If not specified,
345 :variable:`CMAKE_CURRENT_BINARY_DIR` is used as the output directory.
347 Exporting JAR Targets
348 ^^^^^^^^^^^^^^^^^^^^^
350 .. _install_jar_exports:
352 .. command:: install_jar_exports
354 .. versionadded:: 3.7
356 Installs a target export file::
358 install_jar_exports(TARGETS <jars>...
359 [NAMESPACE <namespace>]
361 DESTINATION <destination> [COMPONENT <component>])
363 This command installs a target export file ``<filename>`` for the named jar
364 targets to the given ``<destination>`` directory. Its function is similar to
365 that of :command:`install(EXPORT)`.
368 List of targets created by :ref:`add_jar() <add_jar>` command.
371 .. versionadded:: 3.9
373 The ``<namespace>`` value will be prepend to the target names as they are
374 written to the import file.
377 Specify name of the export file.
381 Specify the directory on disk to which a file will be installed.
384 Specify an installation component name with which the install rule is
385 associated, such as "runtime" or "development".
389 .. command:: export_jars
391 .. versionadded:: 3.7
393 Writes a target export file::
395 export_jars(TARGETS <jars>...
396 [NAMESPACE <namespace>]
399 This command writes a target export file ``<filename>`` for the named ``<jars>``
400 targets. Its function is similar to that of :command:`export`.
403 List of targets created by :ref:`add_jar() <add_jar>` command.
406 .. versionadded:: 3.9
408 The ``<namespace>`` value will be prepend to the target names as they are
409 written to the import file.
412 Specify name of the export file.
419 .. command:: find_jar
421 Finds the specified jar file::
424 <name> | NAMES <name1> [<name2>...]
425 [PATHS <path1> [<path2>... ENV <var>]]
426 [VERSIONS <version1> [<version2>]]
427 [DOC "cache documentation string"]
430 This command is used to find a full path to the named jar. A cache
431 entry named by ``<VAR>`` is created to store the result of this command.
432 If the full path to a jar is found the result is stored in the
433 variable and the search will not repeated unless the variable is
434 cleared. If nothing is found, the result will be ``<VAR>-NOTFOUND``, and
435 the search will be attempted again next time ``find_jar()`` is invoked with
439 Specify one or more possible names for the jar file.
442 Specify directories to search in addition to the default locations.
443 The ``ENV`` var sub-option reads paths from a system environment variable.
446 Specify jar versions.
449 Specify the documentation string for the ``<VAR>`` cache entry.
451 Creating Java Documentation
452 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
456 .. command:: create_javadoc
458 Creates java documentation based on files and packages::
461 (PACKAGES <pkg1> [<pkg2>...] | FILES <file1> [<file2>...])
462 [SOURCEPATH <sourcepath>]
463 [CLASSPATH <classpath>]
464 [INSTALLPATH <install path>]
465 [DOCTITLE <the documentation title>]
466 [WINDOWTITLE <the title of the document>]
467 [AUTHOR (TRUE|FALSE)]
469 [VERSION (TRUE|FALSE)]
472 The ``create_javadoc()`` command can be used to create java documentation.
473 There are two main signatures for ``create_javadoc()``.
475 The first signature works with package names on a path with source files:
477 .. code-block:: cmake
479 create_javadoc(my_example_doc
480 PACKAGES com.example.foo com.example.bar
481 SOURCEPATH "${CMAKE_CURRENT_SOURCE_DIR}"
482 CLASSPATH ${CMAKE_JAVA_INCLUDE_PATH}
483 WINDOWTITLE "My example"
484 DOCTITLE "<h1>My example</h1>"
490 The second signature for ``create_javadoc()`` works on a given list of files:
492 .. code-block:: cmake
494 create_javadoc(my_example_doc
495 FILES java/A.java java/B.java
496 CLASSPATH ${CMAKE_JAVA_INCLUDE_PATH}
497 WINDOWTITLE "My example"
498 DOCTITLE "<h1>My example</h1>"
504 Both signatures share most of the options. For more details please read the
508 Specify java packages.
511 Specify java source files. If relative paths are specified, they are
512 relative to :variable:`CMAKE_CURRENT_SOURCE_DIR`.
515 Specify the directory where to look for packages. By default,
516 :variable:`CMAKE_CURRENT_SOURCE_DIR` directory is used.
519 Specify where to find user class files. Same behavior as option
520 ``-classpath`` of ``javadoc`` tool.
523 Specify where to install the java documentation. If you specified, the
524 documentation will be installed to
525 ``${CMAKE_INSTALL_PREFIX}/share/javadoc/<VAR>``.
528 Specify the title to place near the top of the overview summary file.
529 Same behavior as option ``-doctitle`` of ``javadoc`` tool.
532 Specify the title to be placed in the HTML ``<title>`` tag. Same behavior
533 as option ``-windowtitle`` of ``javadoc`` tool.
536 When value ``TRUE`` is specified, includes the ``@author`` text in the
537 generated docs. Same behavior as option ``-author`` of ``javadoc`` tool.
540 When value ``TRUE`` is specified, creates class and package usage pages.
541 Includes one Use page for each documented class and package. Same behavior
542 as option ``-use`` of ``javadoc`` tool.
545 When value ``TRUE`` is specified, includes the version text in the
546 generated docs. Same behavior as option ``-version`` of ``javadoc`` tool.
547 #]=======================================================================]
549 function (__java_copy_file src dest comment)
552 COMMAND ${CMAKE_COMMAND} -E copy_if_different
561 function(__java_lcat VAR)
562 foreach(_line IN LISTS ARGN)
563 string(APPEND ${VAR} "${_line}\n")
566 set(${VAR} "${${VAR}}" PARENT_SCOPE)
569 function(__java_export_jar VAR TARGET PATH)
570 get_target_property(_jarpath ${TARGET} JAR_FILE)
571 get_filename_component(_jarname ${_jarpath} NAME)
572 set(_target "${_jar_NAMESPACE}${TARGET}")
574 "# Create imported target ${_target}"
575 "add_library(${_target} IMPORTED STATIC)"
576 "set_target_properties(${_target} PROPERTIES"
577 " IMPORTED_LOCATION \"${PATH}/${_jarname}\""
578 " JAR_FILE \"${PATH}/${_jarname}\")"
581 set(${VAR} "${${VAR}}" PARENT_SCOPE)
584 function(__java_copy_resource_namespaces VAR DEST JAVA_RESOURCE_FILES JAVA_RESOURCE_FILES_RELATIVE)
589 foreach(_item IN LISTS VAR)
591 if(NOT _item STREQUAL "NAMESPACE")
592 message(FATAL_ERROR "UseJava: Expecting \"NAMESPACE\", got\t\"${_item}\"")
597 if(_item STREQUAL "NAMESPACE")
598 set(_ns_VAL "") # Prepare for next namespace
599 set(_ns_ID "${_item}")
604 # we're expecting the next token to be a namespace value
605 # whatever it is, we're treating it like a namespace
606 set(_ns_VAL "${_item}")
610 if(_ns_ID AND _ns_VAL)
611 # We're expecting a file name, check to see if we got one
612 cmake_path(ABSOLUTE_PATH _item OUTPUT_VARIABLE _test_file_name)
613 if (NOT EXISTS "${_test_file_name}")
614 message(FATAL_ERROR "UseJava: File does not exist:\t${_item}")
619 cmake_path(ABSOLUTE_PATH _item OUTPUT_VARIABLE _abs_file_name)
620 cmake_path(GET _item FILENAME _resource_file_name)
621 set(_dest_resource_file_name "${_ns_VAL}/${_resource_file_name}" )
623 __java_copy_file( ${_abs_file_name}
624 ${DEST}/${_dest_resource_file_name}
625 "Copying ${_item} to the build directory")
627 list(APPEND RESOURCE_FILES_LIST ${DEST}/${_dest_resource_file_name})
628 list(APPEND RELATIVE_RESOURCE_FILES_LIST ${_dest_resource_file_name})
632 set(${JAVA_RESOURCE_FILES} "${RESOURCE_FILES_LIST}" PARENT_SCOPE)
633 set(${JAVA_RESOURCE_FILES_RELATIVE} "${RELATIVE_RESOURCE_FILES_LIST}" PARENT_SCOPE)
636 # define helper scripts
637 set(_JAVA_EXPORT_TARGETS_SCRIPT ${CMAKE_CURRENT_LIST_DIR}/UseJava/javaTargets.cmake.in)
638 set(_JAVA_SYMLINK_SCRIPT ${CMAKE_CURRENT_LIST_DIR}/UseJava/Symlinks.cmake)
640 if (CMAKE_HOST_WIN32 AND NOT CYGWIN AND CMAKE_HOST_SYSTEM_NAME MATCHES "Windows")
641 set(_UseJava_PATH_SEP "$<SEMICOLON>")
643 set(_UseJava_PATH_SEP ":")
646 function(add_jar _TARGET_NAME)
648 set(options) # currently there are no zero value args (aka: options)
649 set(oneValueArgs "ENTRY_POINT;MANIFEST;OUTPUT_DIR;;OUTPUT_NAME;VERSION" )
650 set(multiValueArgs "GENERATE_NATIVE_HEADERS;INCLUDE_JARS;RESOURCES;SOURCES" )
652 cmake_parse_arguments(PARSE_ARGV 1 _add_jar
655 "${multiValueArgs}" )
657 # In CMake < 2.8.12, add_jar used variables which were set prior to calling
658 # add_jar for customizing the behavior of add_jar. In order to be backwards
659 # compatible, check if any of those variables are set, and use them to
660 # initialize values of the named arguments. (Giving the corresponding named
661 # argument will override the value set here.)
663 # New features should use named arguments only.
664 if(NOT DEFINED _add_jar_VERSION AND DEFINED CMAKE_JAVA_TARGET_VERSION)
665 set(_add_jar_VERSION "${CMAKE_JAVA_TARGET_VERSION}")
667 if(NOT DEFINED _add_jar_OUTPUT_DIR AND DEFINED CMAKE_JAVA_TARGET_OUTPUT_DIR)
668 set(_add_jar_OUTPUT_DIR "${CMAKE_JAVA_TARGET_OUTPUT_DIR}")
670 if(NOT DEFINED _add_jar_OUTPUT_NAME AND DEFINED CMAKE_JAVA_TARGET_OUTPUT_NAME)
671 set(_add_jar_OUTPUT_NAME "${CMAKE_JAVA_TARGET_OUTPUT_NAME}")
673 set(CMAKE_JAVA_TARGET_OUTPUT_NAME)
675 if(NOT DEFINED _add_jar_ENTRY_POINT AND DEFINED CMAKE_JAVA_JAR_ENTRY_POINT)
676 set(_add_jar_ENTRY_POINT "${CMAKE_JAVA_JAR_ENTRY_POINT}")
679 # This *should* still work if <resources1>... are included without a
680 # named RESOURCES argument. In that case, the old behavior of potentially
681 # misplacing the within the Jar will behave as previously (incorrectly)
682 set(_JAVA_SOURCE_FILES ${_add_jar_SOURCES} ${_add_jar_UNPARSED_ARGUMENTS})
684 if (NOT DEFINED _add_jar_OUTPUT_DIR)
685 set(_add_jar_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR})
687 get_filename_component(_add_jar_OUTPUT_DIR ${_add_jar_OUTPUT_DIR} ABSOLUTE)
689 # ensure output directory exists
690 file (MAKE_DIRECTORY "${_add_jar_OUTPUT_DIR}")
692 if (_add_jar_ENTRY_POINT)
693 set(_ENTRY_POINT_OPTION e)
694 set(_ENTRY_POINT_VALUE ${_add_jar_ENTRY_POINT})
697 if (_add_jar_MANIFEST)
698 set(_MANIFEST_OPTION m)
699 get_filename_component (_MANIFEST_VALUE "${_add_jar_MANIFEST}" ABSOLUTE)
702 unset (_GENERATE_NATIVE_HEADERS)
703 if (_add_jar_GENERATE_NATIVE_HEADERS)
704 # Raise an error if JDK version is less than 1.8 because javac -h is not supported
705 # by earlier versions.
706 if (Java_VERSION VERSION_LESS 1.8)
707 message (FATAL_ERROR "ADD_JAR: GENERATE_NATIVE_HEADERS is not supported with this version of Java.")
710 unset (_GENERATE_NATIVE_HEADERS_OUTPUT_DESC)
712 cmake_parse_arguments (_add_jar_GENERATE_NATIVE_HEADERS "" "" "DESTINATION" ${_add_jar_GENERATE_NATIVE_HEADERS})
713 if (NOT _add_jar_GENERATE_NATIVE_HEADERS_UNPARSED_ARGUMENTS)
714 message (FATAL_ERROR "ADD_JAR: GENERATE_NATIVE_HEADERS: missing required argument.")
716 list (LENGTH _add_jar_GENERATE_NATIVE_HEADERS_UNPARSED_ARGUMENTS length)
717 if (length GREATER 1)
718 list (REMOVE_AT _add_jar_GENERATE_NATIVE_HEADERS_UNPARSED_ARGUMENTS 0)
719 message (FATAL_ERROR "ADD_JAR: GENERATE_NATIVE_HEADERS: ${_add_jar_GENERATE_NATIVE_HEADERS_UNPARSED_ARGUMENTS}: unexpected argument(s).")
721 if (NOT _add_jar_GENERATE_NATIVE_HEADERS_DESTINATION)
722 set (_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/${_TARGET_NAME}.dir/native_headers")
724 list (LENGTH _add_jar_GENERATE_NATIVE_HEADERS_DESTINATION length)
725 if (NOT length EQUAL 1)
726 cmake_parse_arguments (_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION "" "BUILD;INSTALL" "" "${_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION}")
727 if (_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION_UNPARSED_ARGUMENTS)
728 message (FATAL_ERROR "ADD_JAR: GENERATE_NATIVE_HEADERS: DESTINATION: ${_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION_UNPARSED_ARGUMENTS}: unexpected argument(s).")
730 if (NOT _add_jar_GENERATE_NATIVE_HEADERS_DESTINATION_INSTALL)
731 message (FATAL_ERROR "ADD_JAR: GENERATE_NATIVE_HEADERS: DESTINATION: INSTALL sub-option is required.")
733 if (NOT _add_jar_GENERATE_NATIVE_HEADERS_DESTINATION_BUILD)
734 set(_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION_BUILD "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/${_TARGET_NAME}.dir/native_headers")
736 set(_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION "${_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION_BUILD}")
737 set(_GENERATE_NATIVE_HEADERS_OUTPUT_DESC "$<BUILD_INTERFACE:${_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION_BUILD}>" "$<INSTALL_INTERFACE:${_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION_INSTALL}>")
741 set (_GENERATE_NATIVE_HEADERS_TARGET ${_add_jar_GENERATE_NATIVE_HEADERS_UNPARSED_ARGUMENTS})
742 set (_GENERATE_NATIVE_HEADERS_OUTPUT_DIR "${_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION}")
743 set (_GENERATE_NATIVE_HEADERS -h "${_GENERATE_NATIVE_HEADERS_OUTPUT_DIR}")
744 if(NOT _GENERATE_NATIVE_HEADERS_OUTPUT_DESC)
745 set(_GENERATE_NATIVE_HEADERS_OUTPUT_DESC "${_GENERATE_NATIVE_HEADERS_OUTPUT_DIR}")
749 if (LIBRARY_OUTPUT_PATH)
750 set(CMAKE_JAVA_LIBRARY_OUTPUT_PATH ${LIBRARY_OUTPUT_PATH})
752 set(CMAKE_JAVA_LIBRARY_OUTPUT_PATH ${_add_jar_OUTPUT_DIR})
755 set(CMAKE_JAVA_INCLUDE_PATH
756 ${CMAKE_JAVA_INCLUDE_PATH}
757 ${CMAKE_CURRENT_SOURCE_DIR}
758 ${CMAKE_JAVA_OBJECT_OUTPUT_PATH}
759 ${CMAKE_JAVA_LIBRARY_OUTPUT_PATH}
762 foreach (JAVA_INCLUDE_DIR IN LISTS CMAKE_JAVA_INCLUDE_PATH)
763 string(APPEND CMAKE_JAVA_INCLUDE_PATH_FINAL "${_UseJava_PATH_SEP}${JAVA_INCLUDE_DIR}")
766 set(CMAKE_JAVA_CLASS_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/${_TARGET_NAME}.dir")
768 set(_JAVA_TARGET_OUTPUT_NAME "${_TARGET_NAME}.jar")
769 if (_add_jar_OUTPUT_NAME AND _add_jar_VERSION)
770 set(_JAVA_TARGET_OUTPUT_NAME "${_add_jar_OUTPUT_NAME}-${_add_jar_VERSION}.jar")
771 set(_JAVA_TARGET_OUTPUT_LINK "${_add_jar_OUTPUT_NAME}.jar")
772 elseif (_add_jar_VERSION)
773 set(_JAVA_TARGET_OUTPUT_NAME "${_TARGET_NAME}-${_add_jar_VERSION}.jar")
774 set(_JAVA_TARGET_OUTPUT_LINK "${_TARGET_NAME}.jar")
775 elseif (_add_jar_OUTPUT_NAME)
776 set(_JAVA_TARGET_OUTPUT_NAME "${_add_jar_OUTPUT_NAME}.jar")
779 set(_JAVA_CLASS_FILES)
780 set(_JAVA_COMPILE_FILES)
781 set(_JAVA_COMPILE_FILELISTS)
783 set(_JAVA_COMPILE_DEPENDS)
784 set(_JAVA_RESOURCE_FILES)
785 set(_JAVA_RESOURCE_FILES_RELATIVE)
786 foreach(_JAVA_SOURCE_FILE IN LISTS _JAVA_SOURCE_FILES)
787 get_filename_component(_JAVA_EXT ${_JAVA_SOURCE_FILE} EXT)
788 get_filename_component(_JAVA_FILE ${_JAVA_SOURCE_FILE} NAME_WE)
789 get_filename_component(_JAVA_PATH ${_JAVA_SOURCE_FILE} PATH)
790 get_filename_component(_JAVA_FULL ${_JAVA_SOURCE_FILE} ABSOLUTE)
792 if (_JAVA_SOURCE_FILE MATCHES "^@(.+)$")
793 get_filename_component(_JAVA_FULL ${CMAKE_MATCH_1} ABSOLUTE)
794 list(APPEND _JAVA_COMPILE_FILELISTS ${_JAVA_FULL})
796 elseif (_JAVA_EXT MATCHES ".java")
797 file(RELATIVE_PATH _JAVA_REL_BINARY_PATH ${CMAKE_CURRENT_BINARY_DIR} ${_JAVA_FULL})
798 file(RELATIVE_PATH _JAVA_REL_SOURCE_PATH ${CMAKE_CURRENT_SOURCE_DIR} ${_JAVA_FULL})
799 string(LENGTH ${_JAVA_REL_BINARY_PATH} _BIN_LEN)
800 string(LENGTH ${_JAVA_REL_SOURCE_PATH} _SRC_LEN)
801 if (_BIN_LEN LESS _SRC_LEN)
802 set(_JAVA_REL_PATH ${_JAVA_REL_BINARY_PATH})
804 set(_JAVA_REL_PATH ${_JAVA_REL_SOURCE_PATH})
806 get_filename_component(_JAVA_REL_PATH ${_JAVA_REL_PATH} PATH)
808 list(APPEND _JAVA_COMPILE_FILES ${_JAVA_SOURCE_FILE})
809 set(_JAVA_CLASS_FILE "${CMAKE_JAVA_CLASS_OUTPUT_PATH}/${_JAVA_REL_PATH}/${_JAVA_FILE}.class")
810 set(_JAVA_CLASS_FILES ${_JAVA_CLASS_FILES} ${_JAVA_CLASS_FILE})
812 elseif (_JAVA_EXT MATCHES ".jar"
813 OR _JAVA_EXT MATCHES ".war"
814 OR _JAVA_EXT MATCHES ".ear"
815 OR _JAVA_EXT MATCHES ".sar")
816 # Ignored for backward compatibility
818 elseif (_JAVA_EXT STREQUAL "")
819 list(APPEND CMAKE_JAVA_INCLUDE_PATH ${JAVA_JAR_TARGET_${_JAVA_SOURCE_FILE}} ${JAVA_JAR_TARGET_${_JAVA_SOURCE_FILE}_CLASSPATH})
820 list(APPEND _JAVA_DEPENDS ${JAVA_JAR_TARGET_${_JAVA_SOURCE_FILE}})
823 __java_copy_file(${CMAKE_CURRENT_SOURCE_DIR}/${_JAVA_SOURCE_FILE}
824 ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/${_JAVA_SOURCE_FILE}
825 "Copying ${_JAVA_SOURCE_FILE} to the build directory")
826 list(APPEND _JAVA_RESOURCE_FILES ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/${_JAVA_SOURCE_FILE})
827 list(APPEND _JAVA_RESOURCE_FILES_RELATIVE ${_JAVA_SOURCE_FILE})
831 if(_add_jar_RESOURCES) # Process RESOURCES if it exists
832 __java_copy_resource_namespaces("${_add_jar_RESOURCES}"
833 ${CMAKE_JAVA_CLASS_OUTPUT_PATH}
835 _JAVA_RESOURCE_FILES_RELATIVE)
838 foreach(_JAVA_INCLUDE_JAR IN LISTS _add_jar_INCLUDE_JARS)
839 if (TARGET ${_JAVA_INCLUDE_JAR})
840 get_target_property(_JAVA_JAR_PATH ${_JAVA_INCLUDE_JAR} JAR_FILE)
842 string(APPEND CMAKE_JAVA_INCLUDE_PATH_FINAL "${_UseJava_PATH_SEP}${_JAVA_JAR_PATH}")
843 list(APPEND CMAKE_JAVA_INCLUDE_PATH ${_JAVA_JAR_PATH})
844 list(APPEND _JAVA_DEPENDS ${_JAVA_INCLUDE_JAR})
845 list(APPEND _JAVA_COMPILE_DEPENDS ${_JAVA_JAR_PATH})
847 message(SEND_ERROR "add_jar: INCLUDE_JARS target ${_JAVA_INCLUDE_JAR} is not a jar")
850 string(APPEND CMAKE_JAVA_INCLUDE_PATH_FINAL "${_UseJava_PATH_SEP}${_JAVA_INCLUDE_JAR}")
851 list(APPEND CMAKE_JAVA_INCLUDE_PATH "${_JAVA_INCLUDE_JAR}")
852 list(APPEND _JAVA_DEPENDS "${_JAVA_INCLUDE_JAR}")
853 list(APPEND _JAVA_COMPILE_DEPENDS "${_JAVA_INCLUDE_JAR}")
857 if (_JAVA_COMPILE_FILES OR _JAVA_COMPILE_FILELISTS)
858 set (_JAVA_SOURCES_FILELISTS)
860 if (_JAVA_COMPILE_FILES)
861 # Create the list of files to compile.
862 set(_JAVA_SOURCES_FILE ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_sources)
863 string(REPLACE ";" "\"\n\"" _JAVA_COMPILE_STRING "\"${_JAVA_COMPILE_FILES}\"")
864 set(CMAKE_CONFIGURABLE_FILE_CONTENT "${_JAVA_COMPILE_STRING}")
865 configure_file("${CMAKE_ROOT}/Modules/CMakeConfigurableFile.in"
866 "${_JAVA_SOURCES_FILE}" @ONLY)
867 unset(CMAKE_CONFIGURABLE_FILE_CONTENT)
868 list (APPEND _JAVA_SOURCES_FILELISTS "@${_JAVA_SOURCES_FILE}")
870 if (_JAVA_COMPILE_FILELISTS)
871 foreach (_JAVA_FILELIST IN LISTS _JAVA_COMPILE_FILELISTS)
872 list (APPEND _JAVA_SOURCES_FILELISTS "@${_JAVA_FILELIST}")
876 # Compile the java files and create a list of class files
878 # NOTE: this command generates an artificial dependency file
879 OUTPUT ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_compiled_${_TARGET_NAME}
880 COMMAND ${CMAKE_COMMAND}
881 -DCMAKE_JAVA_CLASS_OUTPUT_PATH=${CMAKE_JAVA_CLASS_OUTPUT_PATH}
882 -DCMAKE_JAR_CLASSES_PREFIX=${CMAKE_JAR_CLASSES_PREFIX}
883 -P ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/UseJava/ClearClassFiles.cmake
884 COMMAND ${Java_JAVAC_EXECUTABLE}
885 ${CMAKE_JAVA_COMPILE_FLAGS}
886 -classpath "${CMAKE_JAVA_INCLUDE_PATH_FINAL}"
887 -d ${CMAKE_JAVA_CLASS_OUTPUT_PATH}
888 ${_GENERATE_NATIVE_HEADERS}
889 ${_JAVA_SOURCES_FILELISTS}
890 COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_compiled_${_TARGET_NAME}
891 DEPENDS ${_JAVA_COMPILE_FILES} ${_JAVA_COMPILE_FILELISTS} ${_JAVA_COMPILE_DEPENDS} ${_JAVA_SOURCES_FILE}
892 WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
893 COMMENT "Building Java objects for ${_TARGET_NAME}.jar"
897 OUTPUT ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist
898 COMMAND ${CMAKE_COMMAND}
899 -DCMAKE_JAVA_CLASS_OUTPUT_PATH=${CMAKE_JAVA_CLASS_OUTPUT_PATH}
900 -DCMAKE_JAR_CLASSES_PREFIX=${CMAKE_JAR_CLASSES_PREFIX}
901 -P ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/UseJava/ClassFilelist.cmake
902 DEPENDS ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_compiled_${_TARGET_NAME}
903 WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
907 # create an empty java_class_filelist
908 if (NOT EXISTS ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist)
909 file(WRITE ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist "")
913 # create the jar file
914 set(_JAVA_JAR_OUTPUT_PATH
915 "${_add_jar_OUTPUT_DIR}/${_JAVA_TARGET_OUTPUT_NAME}")
916 if (CMAKE_JNI_TARGET)
918 OUTPUT ${_JAVA_JAR_OUTPUT_PATH}
919 COMMAND ${Java_JAR_EXECUTABLE}
920 -cf${_ENTRY_POINT_OPTION}${_MANIFEST_OPTION} ${_JAVA_JAR_OUTPUT_PATH} ${_ENTRY_POINT_VALUE} ${_MANIFEST_VALUE}
921 ${_JAVA_RESOURCE_FILES_RELATIVE} @java_class_filelist
922 COMMAND ${CMAKE_COMMAND}
923 -D_JAVA_TARGET_DIR=${_add_jar_OUTPUT_DIR}
924 -D_JAVA_TARGET_OUTPUT_NAME=${_JAVA_TARGET_OUTPUT_NAME}
925 -D_JAVA_TARGET_OUTPUT_LINK=${_JAVA_TARGET_OUTPUT_LINK}
926 -P ${_JAVA_SYMLINK_SCRIPT}
927 COMMAND ${CMAKE_COMMAND}
928 -D_JAVA_TARGET_DIR=${_add_jar_OUTPUT_DIR}
929 -D_JAVA_TARGET_OUTPUT_NAME=${_JAVA_JAR_OUTPUT_PATH}
930 -D_JAVA_TARGET_OUTPUT_LINK=${_JAVA_TARGET_OUTPUT_LINK}
931 -P ${_JAVA_SYMLINK_SCRIPT}
932 DEPENDS ${_JAVA_RESOURCE_FILES} ${_JAVA_DEPENDS} ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist
933 WORKING_DIRECTORY ${CMAKE_JAVA_CLASS_OUTPUT_PATH}
934 COMMENT "Creating Java archive ${_JAVA_TARGET_OUTPUT_NAME}"
939 OUTPUT ${_JAVA_JAR_OUTPUT_PATH}
940 COMMAND ${Java_JAR_EXECUTABLE}
941 -cf${_ENTRY_POINT_OPTION}${_MANIFEST_OPTION} ${_JAVA_JAR_OUTPUT_PATH} ${_ENTRY_POINT_VALUE} ${_MANIFEST_VALUE}
942 ${_JAVA_RESOURCE_FILES_RELATIVE} @java_class_filelist
943 COMMAND ${CMAKE_COMMAND}
944 -D_JAVA_TARGET_DIR=${_add_jar_OUTPUT_DIR}
945 -D_JAVA_TARGET_OUTPUT_NAME=${_JAVA_TARGET_OUTPUT_NAME}
946 -D_JAVA_TARGET_OUTPUT_LINK=${_JAVA_TARGET_OUTPUT_LINK}
947 -P ${_JAVA_SYMLINK_SCRIPT}
948 WORKING_DIRECTORY ${CMAKE_JAVA_CLASS_OUTPUT_PATH}
949 DEPENDS ${_JAVA_RESOURCE_FILES} ${_JAVA_DEPENDS} ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist
950 COMMENT "Creating Java archive ${_JAVA_TARGET_OUTPUT_NAME}"
955 # Add the target and make sure we have the latest resource files.
956 add_custom_target(${_TARGET_NAME} ALL DEPENDS ${_JAVA_JAR_OUTPUT_PATH})
963 ${_JAVA_JAR_OUTPUT_PATH}
966 if (_JAVA_TARGET_OUTPUT_LINK)
972 ${_JAVA_JAR_OUTPUT_PATH}
973 ${_add_jar_OUTPUT_DIR}/${_JAVA_TARGET_OUTPUT_LINK}
976 if (CMAKE_JNI_TARGET)
982 ${_add_jar_OUTPUT_DIR}/${_JAVA_TARGET_OUTPUT_LINK}
992 ${_JAVA_JAR_OUTPUT_PATH}
1000 ${CMAKE_JAVA_CLASS_OUTPUT_PATH}
1003 if (_GENERATE_NATIVE_HEADERS)
1004 # create an INTERFACE library encapsulating include directory for generated headers
1005 add_library (${_GENERATE_NATIVE_HEADERS_TARGET} INTERFACE)
1006 target_include_directories (${_GENERATE_NATIVE_HEADERS_TARGET} INTERFACE
1007 "${_GENERATE_NATIVE_HEADERS_OUTPUT_DESC}"
1008 ${JNI_INCLUDE_DIRS})
1009 set_property(TARGET ${_GENERATE_NATIVE_HEADERS_TARGET} PROPERTY NATIVE_HEADERS_DIRECTORY "${_GENERATE_NATIVE_HEADERS_OUTPUT_DIR}")
1010 # this INTERFACE library depends on jar generation
1011 add_dependencies (${_GENERATE_NATIVE_HEADERS_TARGET} ${_TARGET_NAME})
1013 set_property (DIRECTORY APPEND PROPERTY ADDITIONAL_CLEAN_FILES
1014 "${_GENERATE_NATIVE_HEADERS_OUTPUT_DIR}")
1018 function(INSTALL_JAR _TARGET_NAME)
1020 set (_DESTINATION ${ARGV1})
1022 cmake_parse_arguments(_install_jar
1024 "DESTINATION;COMPONENT"
1027 if (_install_jar_DESTINATION)
1028 set (_DESTINATION ${_install_jar_DESTINATION})
1030 message(SEND_ERROR "install_jar: ${_TARGET_NAME}: DESTINATION must be specified.")
1033 if (_install_jar_COMPONENT)
1034 set (_COMPONENT COMPONENT ${_install_jar_COMPONENT})
1038 get_property(__FILES
1061 message(SEND_ERROR "install_jar: The target ${_TARGET_NAME} is not known in this scope.")
1065 function(INSTALL_JNI_SYMLINK _TARGET_NAME)
1067 set (_DESTINATION ${ARGV1})
1069 cmake_parse_arguments(_install_jni_symlink
1071 "DESTINATION;COMPONENT"
1074 if (_install_jni_symlink_DESTINATION)
1075 set (_DESTINATION ${_install_jni_symlink_DESTINATION})
1077 message(SEND_ERROR "install_jni_symlink: ${_TARGET_NAME}: DESTINATION must be specified.")
1080 if (_install_jni_symlink_COMPONENT)
1081 set (_COMPONENT COMPONENT ${_install_jni_symlink_COMPONENT})
1085 get_property(__SYMLINK
1101 message(SEND_ERROR "install_jni_symlink: The target ${_TARGET_NAME} is not known in this scope.")
1105 function (find_jar VARIABLE)
1111 /usr/local/share/java/
1113 set(_jar_doc "NOTSET")
1117 foreach (arg IN LISTS ARGN)
1118 if (_state STREQUAL "name")
1119 if (arg STREQUAL "VERSIONS")
1120 set(_state "versions")
1121 elseif (arg STREQUAL "NAMES")
1123 elseif (arg STREQUAL "PATHS")
1125 elseif (arg STREQUAL "DOC")
1128 set(_jar_names ${arg})
1129 if (_jar_doc STREQUAL "NOTSET")
1130 set(_jar_doc "Finding ${arg} jar")
1133 elseif (_state STREQUAL "versions")
1134 if (arg STREQUAL "NAMES")
1136 elseif (arg STREQUAL "PATHS")
1138 elseif (arg STREQUAL "DOC")
1141 set(_jar_versions ${_jar_versions} ${arg})
1143 elseif (_state STREQUAL "names")
1144 if (arg STREQUAL "VERSIONS")
1145 set(_state "versions")
1146 elseif (arg STREQUAL "PATHS")
1148 elseif (arg STREQUAL "DOC")
1151 set(_jar_names ${_jar_names} ${arg})
1152 if (_jar_doc STREQUAL "NOTSET")
1153 set(_jar_doc "Finding ${arg} jar")
1156 elseif (_state STREQUAL "paths")
1157 if (arg STREQUAL "VERSIONS")
1158 set(_state "versions")
1159 elseif (arg STREQUAL "NAMES")
1161 elseif (arg STREQUAL "DOC")
1164 set(_jar_paths ${_jar_paths} ${arg})
1166 elseif (_state STREQUAL "doc")
1167 if (arg STREQUAL "VERSIONS")
1168 set(_state "versions")
1169 elseif (arg STREQUAL "NAMES")
1171 elseif (arg STREQUAL "PATHS")
1174 set(_jar_doc ${arg})
1180 message(FATAL_ERROR "find_jar: No name to search for given")
1183 foreach (jar_name IN LISTS _jar_names)
1184 foreach (version IN LISTS _jar_versions)
1185 set(_jar_files ${_jar_files} ${jar_name}-${version}.jar)
1187 set(_jar_files ${_jar_files} ${jar_name}.jar)
1190 find_file(${VARIABLE}
1197 function(create_javadoc _target)
1198 set(_javadoc_packages)
1200 set(_javadoc_sourcepath)
1201 set(_javadoc_classpath)
1202 set(_javadoc_installpath "${CMAKE_INSTALL_PREFIX}/share/javadoc")
1203 set(_javadoc_doctitle)
1204 set(_javadoc_windowtitle)
1205 set(_javadoc_author FALSE)
1206 set(_javadoc_version FALSE)
1207 set(_javadoc_use FALSE)
1209 set(_state "package")
1211 foreach (arg IN LISTS ARGN)
1212 if (_state STREQUAL "package")
1213 if (arg STREQUAL "PACKAGES")
1214 set(_state "packages")
1215 elseif (arg STREQUAL "FILES")
1217 elseif (arg STREQUAL "SOURCEPATH")
1218 set(_state "sourcepath")
1219 elseif (arg STREQUAL "CLASSPATH")
1220 set(_state "classpath")
1221 elseif (arg STREQUAL "INSTALLPATH")
1222 set(_state "installpath")
1223 elseif (arg STREQUAL "DOCTITLE")
1224 set(_state "doctitle")
1225 elseif (arg STREQUAL "WINDOWTITLE")
1226 set(_state "windowtitle")
1227 elseif (arg STREQUAL "AUTHOR")
1228 set(_state "author")
1229 elseif (arg STREQUAL "USE")
1231 elseif (arg STREQUAL "VERSION")
1232 set(_state "version")
1234 set(_javadoc_packages ${arg})
1235 set(_state "packages")
1237 elseif (_state STREQUAL "packages")
1238 if (arg STREQUAL "FILES")
1240 elseif (arg STREQUAL "SOURCEPATH")
1241 set(_state "sourcepath")
1242 elseif (arg STREQUAL "CLASSPATH")
1243 set(_state "classpath")
1244 elseif (arg STREQUAL "INSTALLPATH")
1245 set(_state "installpath")
1246 elseif (arg STREQUAL "DOCTITLE")
1247 set(_state "doctitle")
1248 elseif (arg STREQUAL "WINDOWTITLE")
1249 set(_state "windowtitle")
1250 elseif (arg STREQUAL "AUTHOR")
1251 set(_state "author")
1252 elseif (arg STREQUAL "USE")
1254 elseif (arg STREQUAL "VERSION")
1255 set(_state "version")
1257 list(APPEND _javadoc_packages ${arg})
1259 elseif (_state STREQUAL "files")
1260 if (arg STREQUAL "PACKAGES")
1261 set(_state "packages")
1262 elseif (arg STREQUAL "SOURCEPATH")
1263 set(_state "sourcepath")
1264 elseif (arg STREQUAL "CLASSPATH")
1265 set(_state "classpath")
1266 elseif (arg STREQUAL "INSTALLPATH")
1267 set(_state "installpath")
1268 elseif (arg STREQUAL "DOCTITLE")
1269 set(_state "doctitle")
1270 elseif (arg STREQUAL "WINDOWTITLE")
1271 set(_state "windowtitle")
1272 elseif (arg STREQUAL "AUTHOR")
1273 set(_state "author")
1274 elseif (arg STREQUAL "USE")
1276 elseif (arg STREQUAL "VERSION")
1277 set(_state "version")
1279 list(APPEND _javadoc_files ${arg})
1281 elseif (_state STREQUAL "sourcepath")
1282 if (arg STREQUAL "PACKAGES")
1283 set(_state "packages")
1284 elseif (arg STREQUAL "FILES")
1286 elseif (arg STREQUAL "CLASSPATH")
1287 set(_state "classpath")
1288 elseif (arg STREQUAL "INSTALLPATH")
1289 set(_state "installpath")
1290 elseif (arg STREQUAL "DOCTITLE")
1291 set(_state "doctitle")
1292 elseif (arg STREQUAL "WINDOWTITLE")
1293 set(_state "windowtitle")
1294 elseif (arg STREQUAL "AUTHOR")
1295 set(_state "author")
1296 elseif (arg STREQUAL "USE")
1298 elseif (arg STREQUAL "VERSION")
1299 set(_state "version")
1301 list(APPEND _javadoc_sourcepath ${arg})
1303 elseif (_state STREQUAL "classpath")
1304 if (arg STREQUAL "PACKAGES")
1305 set(_state "packages")
1306 elseif (arg STREQUAL "FILES")
1308 elseif (arg STREQUAL "SOURCEPATH")
1309 set(_state "sourcepath")
1310 elseif (arg STREQUAL "INSTALLPATH")
1311 set(_state "installpath")
1312 elseif (arg STREQUAL "DOCTITLE")
1313 set(_state "doctitle")
1314 elseif (arg STREQUAL "WINDOWTITLE")
1315 set(_state "windowtitle")
1316 elseif (arg STREQUAL "AUTHOR")
1317 set(_state "author")
1318 elseif (arg STREQUAL "USE")
1320 elseif (arg STREQUAL "VERSION")
1321 set(_state "version")
1323 list(APPEND _javadoc_classpath ${arg})
1325 elseif (_state STREQUAL "installpath")
1326 if (arg STREQUAL "PACKAGES")
1327 set(_state "packages")
1328 elseif (arg STREQUAL "FILES")
1330 elseif (arg STREQUAL "SOURCEPATH")
1331 set(_state "sourcepath")
1332 elseif (arg STREQUAL "DOCTITLE")
1333 set(_state "doctitle")
1334 elseif (arg STREQUAL "WINDOWTITLE")
1335 set(_state "windowtitle")
1336 elseif (arg STREQUAL "AUTHOR")
1337 set(_state "author")
1338 elseif (arg STREQUAL "USE")
1340 elseif (arg STREQUAL "VERSION")
1341 set(_state "version")
1343 set(_javadoc_installpath ${arg})
1345 elseif (_state STREQUAL "doctitle")
1346 if (${arg} STREQUAL "PACKAGES")
1347 set(_state "packages")
1348 elseif (arg STREQUAL "FILES")
1350 elseif (arg STREQUAL "SOURCEPATH")
1351 set(_state "sourcepath")
1352 elseif (arg STREQUAL "INSTALLPATH")
1353 set(_state "installpath")
1354 elseif (arg STREQUAL "CLASSPATH")
1355 set(_state "classpath")
1356 elseif (arg STREQUAL "WINDOWTITLE")
1357 set(_state "windowtitle")
1358 elseif (arg STREQUAL "AUTHOR")
1359 set(_state "author")
1360 elseif (arg STREQUAL "USE")
1362 elseif (arg STREQUAL "VERSION")
1363 set(_state "version")
1365 set(_javadoc_doctitle ${arg})
1367 elseif (_state STREQUAL "windowtitle")
1368 if (${arg} STREQUAL "PACKAGES")
1369 set(_state "packages")
1370 elseif (arg STREQUAL "FILES")
1372 elseif (arg STREQUAL "SOURCEPATH")
1373 set(_state "sourcepath")
1374 elseif (arg STREQUAL "CLASSPATH")
1375 set(_state "classpath")
1376 elseif (arg STREQUAL "INSTALLPATH")
1377 set(_state "installpath")
1378 elseif (arg STREQUAL "DOCTITLE")
1379 set(_state "doctitle")
1380 elseif (arg STREQUAL "AUTHOR")
1381 set(_state "author")
1382 elseif (arg STREQUAL "USE")
1384 elseif (arg STREQUAL "VERSION")
1385 set(_state "version")
1387 set(_javadoc_windowtitle ${arg})
1389 elseif (_state STREQUAL "author")
1390 if (arg STREQUAL "PACKAGES")
1391 set(_state "packages")
1392 elseif (arg STREQUAL "FILES")
1394 elseif (arg STREQUAL "SOURCEPATH")
1395 set(_state "sourcepath")
1396 elseif (arg STREQUAL "CLASSPATH")
1397 set(_state "classpath")
1398 elseif (arg STREQUAL "INSTALLPATH")
1399 set(_state "installpath")
1400 elseif (arg STREQUAL "DOCTITLE")
1401 set(_state "doctitle")
1402 elseif (arg STREQUAL "WINDOWTITLE")
1403 set(_state "windowtitle")
1404 elseif (arg STREQUAL "AUTHOR")
1405 set(_state "author")
1406 elseif (arg STREQUAL "USE")
1408 elseif (arg STREQUAL "VERSION")
1409 set(_state "version")
1411 set(_javadoc_author ${arg})
1413 elseif (_state STREQUAL "use")
1414 if (arg STREQUAL "PACKAGES")
1415 set(_state "packages")
1416 elseif (arg STREQUAL "FILES")
1418 elseif (arg STREQUAL "SOURCEPATH")
1419 set(_state "sourcepath")
1420 elseif (arg STREQUAL "CLASSPATH")
1421 set(_state "classpath")
1422 elseif (arg STREQUAL "INSTALLPATH")
1423 set(_state "installpath")
1424 elseif (arg STREQUAL "DOCTITLE")
1425 set(_state "doctitle")
1426 elseif (arg STREQUAL "WINDOWTITLE")
1427 set(_state "windowtitle")
1428 elseif (arg STREQUAL "AUTHOR")
1429 set(_state "author")
1430 elseif (arg STREQUAL "USE")
1432 elseif (arg STREQUAL "VERSION")
1433 set(_state "version")
1435 set(_javadoc_use ${arg})
1437 elseif (_state STREQUAL "version")
1438 if (arg STREQUAL "PACKAGES")
1439 set(_state "packages")
1440 elseif (arg STREQUAL "FILES")
1442 elseif (arg STREQUAL "SOURCEPATH")
1443 set(_state "sourcepath")
1444 elseif (arg STREQUAL "CLASSPATH")
1445 set(_state "classpath")
1446 elseif (arg STREQUAL "INSTALLPATH")
1447 set(_state "installpath")
1448 elseif (arg STREQUAL "DOCTITLE")
1449 set(_state "doctitle")
1450 elseif (arg STREQUAL "WINDOWTITLE")
1451 set(_state "windowtitle")
1452 elseif (arg STREQUAL "AUTHOR")
1453 set(_state "author")
1454 elseif (arg STREQUAL "USE")
1456 elseif (arg STREQUAL "VERSION")
1457 set(_state "version")
1459 set(_javadoc_version ${arg})
1464 set(_javadoc_builddir ${CMAKE_CURRENT_BINARY_DIR}/javadoc/${_target})
1465 set(_javadoc_options -d ${_javadoc_builddir})
1467 if (_javadoc_sourcepath)
1468 list(JOIN _javadoc_sourcepath "${_UseJava_PATH_SEP}" _javadoc_sourcepath)
1469 list(APPEND _javadoc_options -sourcepath "\"${_javadoc_sourcepath}\"")
1472 if (_javadoc_classpath)
1473 list(JOIN _javadoc_classpath "${_UseJava_PATH_SEP}" _javadoc_classpath)
1474 list(APPEND _javadoc_options -classpath "\"${_javadoc_classpath}\"")
1477 if (_javadoc_doctitle)
1478 list(APPEND _javadoc_options -doctitle '${_javadoc_doctitle}')
1481 if (_javadoc_windowtitle)
1482 list(APPEND _javadoc_options -windowtitle '${_javadoc_windowtitle}')
1485 if (_javadoc_author)
1486 list(APPEND _javadoc_options -author)
1490 list(APPEND _javadoc_options -use)
1493 if (_javadoc_version)
1494 list(APPEND _javadoc_options -version)
1497 add_custom_target(${_target}_javadoc ALL
1498 COMMAND ${Java_JAVADOC_EXECUTABLE}
1501 ${_javadoc_packages}
1502 WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
1506 DIRECTORY ${_javadoc_builddir}
1507 DESTINATION ${_javadoc_installpath}
1511 function (create_javah)
1512 if (Java_VERSION VERSION_GREATER_EQUAL 10)
1513 message (FATAL_ERROR "create_javah: not supported with this Java version. Use add_jar(GENERATE_NATIVE_HEADERS) instead.")
1514 elseif (Java_VERSION VERSION_GREATER_EQUAL 1.8)
1515 message (DEPRECATION "create_javah: this command will no longer be supported starting with version 10 of JDK. Update your project by using command add_jar(GENERATE_NATIVE_HEADERS) instead.")
1518 cmake_parse_arguments(_create_javah
1520 "TARGET;GENERATED_FILES;OUTPUT_NAME;OUTPUT_DIR"
1521 "CLASSES;CLASSPATH;DEPENDS"
1525 if (NOT _create_javah_TARGET AND NOT _create_javah_GENERATED_FILES)
1526 message (FATAL_ERROR "create_javah: TARGET or GENERATED_FILES must be specified.")
1528 if (_create_javah_OUTPUT_NAME AND _create_javah_OUTPUT_DIR)
1529 message (FATAL_ERROR "create_javah: OUTPUT_NAME and OUTPUT_DIR are mutually exclusive.")
1532 if (NOT _create_javah_CLASSES)
1533 message (FATAL_ERROR "create_javah: CLASSES is a required parameter.")
1538 # handle javah options
1539 set (_javah_options)
1541 if (_create_javah_CLASSPATH)
1542 # CLASSPATH can specify directories, jar files or targets created with add_jar command
1544 foreach (_path IN LISTS _create_javah_CLASSPATH)
1545 if (TARGET ${_path})
1546 get_target_property (_jar_path ${_path} JAR_FILE)
1548 list (APPEND _classpath "${_jar_path}")
1549 list (APPEND _create_javah_DEPENDS "${_path}")
1551 message(SEND_ERROR "create_javah: CLASSPATH target ${_path} is not a jar.")
1553 elseif (EXISTS "${_path}")
1554 list (APPEND _classpath "${_path}")
1555 if (NOT IS_DIRECTORY "${_path}")
1556 list (APPEND _create_javah_DEPENDS "${_path}")
1559 message(SEND_ERROR "create_javah: CLASSPATH entry ${_path} does not exist.")
1562 string (REPLACE ";" "${_UseJava_PATH_SEP}" _classpath "${_classpath}")
1563 list (APPEND _javah_options -classpath "${_classpath}")
1566 if (_create_javah_OUTPUT_DIR)
1567 list (APPEND _javah_options -d "${_create_javah_OUTPUT_DIR}")
1570 if (_create_javah_OUTPUT_NAME)
1571 list (APPEND _javah_options -o "${_create_javah_OUTPUT_NAME}")
1572 set (_output_files "${_create_javah_OUTPUT_NAME}")
1574 get_filename_component (_create_javah_OUTPUT_DIR "${_create_javah_OUTPUT_NAME}" DIRECTORY)
1575 get_filename_component (_create_javah_OUTPUT_DIR "${_create_javah_OUTPUT_DIR}" ABSOLUTE)
1578 if (NOT _create_javah_OUTPUT_DIR)
1579 set (_create_javah_OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}")
1582 if (NOT _create_javah_OUTPUT_NAME)
1583 # compute output names
1584 foreach (_class IN LISTS _create_javah_CLASSES)
1585 string (REPLACE "." "_" _c_header "${_class}")
1586 set (_c_header "${_create_javah_OUTPUT_DIR}/${_c_header}.h")
1587 list (APPEND _output_files "${_c_header}")
1591 # finalize custom command arguments
1592 if (_create_javah_DEPENDS)
1593 list (INSERT _create_javah_DEPENDS 0 DEPENDS)
1596 add_custom_command (OUTPUT ${_output_files}
1597 COMMAND "${Java_JAVAH_EXECUTABLE}" ${_javah_options} -jni ${_create_javah_CLASSES}
1598 ${_create_javah_DEPENDS}
1599 WORKING_DIRECTORY ${_create_javah_OUTPUT_DIR}
1600 COMMENT "Building C header files from classes...")
1602 if (_create_javah_TARGET)
1603 add_custom_target (${_create_javah_TARGET} ALL DEPENDS ${_output_files})
1605 if (_create_javah_GENERATED_FILES)
1606 set (${_create_javah_GENERATED_FILES} ${_output_files} PARENT_SCOPE)
1610 function(export_jars)
1611 # Parse and validate arguments
1612 cmake_parse_arguments(_export_jars
1618 if (NOT _export_jars_FILE)
1619 message(SEND_ERROR "export_jars: FILE must be specified.")
1621 if (NOT _export_jars_TARGETS)
1622 message(SEND_ERROR "export_jars: TARGETS must be specified.")
1624 set(_jar_NAMESPACE "${_export_jars_NAMESPACE}")
1626 # Set content of generated exports file
1627 string(REPLACE ";" " " __targets__ "${_export_jars_TARGETS}")
1628 set(__targetdefs__ "")
1629 foreach(_target IN LISTS _export_jars_TARGETS)
1630 get_target_property(_jarpath ${_target} JAR_FILE)
1631 get_filename_component(_jarpath ${_jarpath} PATH)
1632 __java_export_jar(__targetdefs__ ${_target} "${_jarpath}")
1635 # Generate exports file
1637 ${_JAVA_EXPORT_TARGETS_SCRIPT}
1638 ${_export_jars_FILE}
1643 function(install_jar_exports)
1644 # Parse and validate arguments
1645 cmake_parse_arguments(_install_jar_exports
1647 "FILE;DESTINATION;COMPONENT;NAMESPACE"
1651 if (NOT _install_jar_exports_FILE)
1652 message(SEND_ERROR "install_jar_exports: FILE must be specified.")
1654 if (NOT _install_jar_exports_DESTINATION)
1655 message(SEND_ERROR "install_jar_exports: DESTINATION must be specified.")
1657 if (NOT _install_jar_exports_TARGETS)
1658 message(SEND_ERROR "install_jar_exports: TARGETS must be specified.")
1660 set(_jar_NAMESPACE "${_install_jar_exports_NAMESPACE}")
1662 if (_install_jar_exports_COMPONENT)
1663 set (_COMPONENT COMPONENT ${_install_jar_exports_COMPONENT})
1666 # Determine relative path from installed export file to install prefix
1667 if(IS_ABSOLUTE "${_install_jar_exports_DESTINATION}")
1668 file(RELATIVE_PATH _relpath
1669 ${_install_jar_exports_DESTINATION}
1670 ${CMAKE_INSTALL_PREFIX}
1673 file(RELATIVE_PATH _relpath
1674 ${CMAKE_INSTALL_PREFIX}/${_install_jar_exports_DESTINATION}
1675 ${CMAKE_INSTALL_PREFIX}
1679 # Set up unique location for generated exports file
1680 string(SHA256 _hash "${_install_jar_exports_DESTINATION}")
1681 set(_tmpdir ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/JavaExports/${_hash})
1683 # Set content of generated exports file
1684 string(REPLACE ";" " " __targets__ "${_install_jar_exports_TARGETS}")
1685 set(__targetdefs__ "set(_prefix \${CMAKE_CURRENT_LIST_DIR}/${_relpath})\n\n")
1686 foreach(_target IN LISTS _install_jar_exports_TARGETS)
1687 get_target_property(_dir ${_target} INSTALL_DESTINATION)
1688 __java_export_jar(__targetdefs__ ${_target} "\${_prefix}/${_dir}")
1690 __java_lcat(__targetdefs__ "\nunset(_prefix)")
1692 # Generate and install exports file
1694 ${_JAVA_EXPORT_TARGETS_SCRIPT}
1695 ${_tmpdir}/${_install_jar_exports_FILE}
1698 install(FILES ${_tmpdir}/${_install_jar_exports_FILE}
1699 DESTINATION ${_install_jar_exports_DESTINATION}