amass/qt-build-tools
1
0
Fork 0
mirror of https://github.com/crystalidea/qt-build-tools.git synced 2024-12-02 16:23:06 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
67db56d36a
qt-build-tools/6.5.1/_tools/cmake/share/cmake-3.27/Modules/UseJava.cmake

1702 lines
62 KiB
CMake
Raw Normal View History

qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
# file Copyright.txt or https://cmake.org/licensing for details.
#[=======================================================================[.rst:
UseJava
-------
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
This file provides support for ``Java``. It is assumed that
cmake 3.16.2 is required
2023-11-01 06:20:22 +08:00
:module:`FindJava` has already been loaded. See :module:`FindJava` for
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
information on how to load Java into your CMake project.
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
Synopsis
^^^^^^^^
.. parsed-literal::
`Creating and Installing JARS`_
`add_jar`_ (<target_name> [SOURCES] <source1> [<source2>...] ...)
`install_jar`_ (<target_name> DESTINATION <destination> [COMPONENT <component>])
`install_jni_symlink`_ (<target_name> DESTINATION <destination> [COMPONENT <component>])
`Header Generation`_
`create_javah`_ ((TARGET <target> | GENERATED_FILES <VAR>) CLASSES <class>... ...)
`Exporting JAR Targets`_
`install_jar_exports`_ (TARGETS <jars>... FILE <filename> DESTINATION <destination> ...)
`export_jars`_ (TARGETS <jars>... [NAMESPACE <namespace>] FILE <filename>)
`Finding JARs`_
`find_jar`_ (<VAR> NAMES <name1> [<name2>...] [PATHS <path1> [<path2>... ENV <var>]] ...)
`Creating Java Documentation`_
`create_javadoc`_ (<VAR> (PACKAGES <pkg1> [<pkg2>...] | FILES <file1> [<file2>...]) ...)
cmake 3.16.2 is required
2023-11-01 06:20:22 +08:00
Creating And Installing JARs
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
.. _add_jar:
cmake 3.16.2 is required
2023-11-01 06:20:22 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
.. command:: add_jar
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
Creates a jar file containing java objects and, optionally, resources::
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
add_jar(<target_name>
[SOURCES] <source1> [<source2>...] [<resource1>...]
[RESOURCES NAMESPACE <ns1> <resource1>... [NAMESPACE <nsX> <resourceX>...]... ]
[INCLUDE_JARS <jar1> [<jar2>...]]
[ENTRY_POINT <entry>]
[VERSION <version>]
[MANIFEST <manifest>]
[OUTPUT_NAME <name>]
[OUTPUT_DIR <dir>]
[GENERATE_NATIVE_HEADERS <target>
[DESTINATION (<dir>|INSTALL <dir> [BUILD <dir>])]]
)
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
This command creates a ``<target_name>.jar``. It compiles the given
``<source>`` files and adds the given ``<resource>`` files to
the jar file. Source files can be java files or listing files
(prefixed by ``@``). If only resource files are given then just a jar file
is created.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
``SOURCES``
Compiles the specified source files and adds the result in the jar file.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
.. versionadded:: 3.4
Support for response files, prefixed by ``@``.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
``RESOURCES``
.. versionadded:: 3.21
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
Adds the named ``<resource>`` files to the jar by stripping the source file
path and placing the file beneath ``<ns>`` within the jar.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
For example::
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
RESOURCES NAMESPACE "/com/my/namespace" "a/path/to/resource.txt"
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
results in a resource accessible via ``/com/my/namespace/resource.txt``
within the jar.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
Resources may be added without adjusting the namespace by adding them to
the list of ``SOURCES`` (original behavior), in this case, resource
paths must be relative to ``CMAKE_CURRENT_SOURCE_DIR``. Adding resources
without using the ``RESOURCES`` parameter in out of source builds will
almost certainly result in confusion.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
.. note::
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
Adding resources via the ``SOURCES`` parameter relies upon a hard-coded
list of file extensions which are tested to determine whether they
compile (e.g. File.java). ``SOURCES`` files which match the extensions
are compiled. Files which do not match are treated as resources. To
include uncompiled resources matching those file extensions use
the ``RESOURCES`` parameter.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
``INCLUDE_JARS``
The list of jars are added to the classpath when compiling the java sources
and also to the dependencies of the target. ``INCLUDE_JARS`` also accepts
other target names created by ``add_jar()``. For backwards compatibility,
jar files listed as sources are ignored (as they have been since the first
version of this module).
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
``ENTRY_POINT``
Defines an entry point in the jar file.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
``VERSION``
Adds a version to the target output name.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
The following example will create a jar file with the name
``shibboleet-1.2.0.jar`` and will create a symlink ``shibboleet.jar``
pointing to the jar with the version information.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
.. code-block:: cmake
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
add_jar(shibboleet shibbotleet.java VERSION 1.2.0)
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
``MANIFEST``
Defines a custom manifest for the jar.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
``OUTPUT_NAME``
Specify a different output name for the target.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
``OUTPUT_DIR``
Sets the directory where the jar file will be generated. If not specified,
:variable:`CMAKE_CURRENT_BINARY_DIR` is used as the output directory.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
``GENERATE_NATIVE_HEADERS``
.. versionadded:: 3.11
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
Generates native header files for methods declared as native. These files
provide the connective glue that allow your Java and C code to interact.
An INTERFACE target will be created for an easy usage of generated files.
Sub-option ``DESTINATION`` can be used to specify the output directory for
generated header files.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
This option requires, at least, version 1.8 of the JDK.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
For an optimum usage of this option, it is recommended to include module
JNI before any call to ``add_jar()``. The produced target for native
headers can then be used to compile C/C++ sources with the
:command:`target_link_libraries` command.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
.. code-block:: cmake
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
find_package(JNI)
add_jar(foo foo.java GENERATE_NATIVE_HEADERS foo-native)
add_library(bar bar.cpp)
target_link_libraries(bar PRIVATE foo-native)
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
.. versionadded:: 3.20
``DESTINATION`` sub-option now supports the possibility to specify
different output directories for ``BUILD`` and ``INSTALL`` steps. If
``BUILD`` directory is not specified, a default directory will be used.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
To export the interface target generated by ``GENERATE_NATIVE_HEADERS``
option, sub-option ``INSTALL`` of ``DESTINATION`` is required:
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
.. code-block:: cmake
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
add_jar(foo foo.java GENERATE_NATIVE_HEADERS foo-native
DESTINATION INSTALL include)
install(TARGETS foo-native EXPORT native)
install(DIRECTORY "$<TARGET_PROPERTY:foo-native,NATIVE_HEADERS_DIRECTORY>/"
DESTINATION include)
install(EXPORT native DESTINATION /to/export NAMESPACE foo)
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
Some variables can be set to customize the behavior of ``add_jar()`` as well
as the java compiler:
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
``CMAKE_JAVA_COMPILE_FLAGS``
Specify additional flags to java compiler.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
``CMAKE_JAVA_INCLUDE_PATH``
Specify additional paths to the class path.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
``CMAKE_JNI_TARGET``
If the target is a JNI library, sets this boolean variable to ``TRUE`` to
enable creation of a JNI symbolic link (see also
:ref:`install_jni_symlink() <install_jni_symlink>`).
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
``CMAKE_JAR_CLASSES_PREFIX``
If multiple jars should be produced from the same java source filetree,
to prevent the accumulation of duplicate class files in subsequent jars,
set/reset ``CMAKE_JAR_CLASSES_PREFIX`` prior to calling the ``add_jar()``:
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
.. code-block:: cmake
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
set(CMAKE_JAR_CLASSES_PREFIX com/redhat/foo)
add_jar(foo foo.java)
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
set(CMAKE_JAR_CLASSES_PREFIX com/redhat/bar)
add_jar(bar bar.java)
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
The ``add_jar()`` function sets the following target properties on
``<target_name>``:
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
``INSTALL_FILES``
The files which should be installed. This is used by
:ref:`install_jar() <install_jar>`.
``JNI_SYMLINK``
The JNI symlink which should be installed. This is used by
:ref:`install_jni_symlink() <install_jni_symlink>`.
``JAR_FILE``
The location of the jar file so that you can include it.
``CLASSDIR``
The directory where the class files can be found. For example to use them
with ``javah``.
``NATIVE_HEADERS_DIRECTORY``
.. versionadded:: 3.20
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
The directory where native headers are generated. Defined when option
``GENERATE_NATIVE_HEADERS`` is specified.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
.. _install_jar:
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
.. command:: install_jar
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
This command installs the jar file to the given destination::
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
install_jar(<target_name> <destination>)
install_jar(<target_name> DESTINATION <destination> [COMPONENT <component>])
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
This command installs the ``<target_name>`` file to the given
``<destination>``. It should be called in the same scope as
:ref:`add_jar() <add_jar>` or it will fail.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
.. versionadded:: 3.4
The second signature with ``DESTINATION`` and ``COMPONENT`` options.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
``DESTINATION``
Specify the directory on disk to which a file will be installed.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
``COMPONENT``
Specify an installation component name with which the install rule is
associated, such as "runtime" or "development".
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
The ``install_jar()`` command sets the following target properties
on ``<target_name>``:
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
``INSTALL_DESTINATION``
Holds the ``<destination>`` as described above, and is used by
:ref:`install_jar_exports() <install_jar_exports>`.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
.. _install_jni_symlink:
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
.. command:: install_jni_symlink
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
Installs JNI symlinks for target generated by :ref:`add_jar() <add_jar>`::
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
install_jni_symlink(<target_name> <destination>)
install_jni_symlink(<target_name> DESTINATION <destination> [COMPONENT <component>])
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
This command installs the ``<target_name>`` JNI symlinks to the given
``<destination>``. It should be called in the same scope as
:ref:`add_jar() <add_jar>` or it will fail.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
.. versionadded:: 3.4
The second signature with ``DESTINATION`` and ``COMPONENT`` options.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
``DESTINATION``
Specify the directory on disk to which a file will be installed.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
``COMPONENT``
Specify an installation component name with which the install rule is
associated, such as "runtime" or "development".
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
Utilize the following commands to create a JNI symbolic link:
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
.. code-block:: cmake
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
set(CMAKE_JNI_TARGET TRUE)
add_jar(shibboleet shibbotleet.java VERSION 1.2.0)
install_jar(shibboleet ${LIB_INSTALL_DIR}/shibboleet)
install_jni_symlink(shibboleet ${JAVA_LIB_INSTALL_DIR})
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
cmake 3.16.2 is required
2023-11-01 06:20:22 +08:00
Header Generation
^^^^^^^^^^^^^^^^^
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
.. _create_javah:
.. command:: create_javah
.. versionadded:: 3.4
Generates C header files for java classes::
create_javah(TARGET <target> | GENERATED_FILES <VAR>
CLASSES <class>...
[CLASSPATH <classpath>...]
[DEPENDS <depend>...]
[OUTPUT_NAME <path>|OUTPUT_DIR <path>]
)
.. deprecated:: 3.11
This command will no longer be supported starting with version 10 of the JDK
due to the `suppression of javah tool <https://openjdk.org/jeps/313>`_.
The :ref:`add_jar(GENERATE_NATIVE_HEADERS) <add_jar>` command should be
used instead.
Create C header files from java classes. These files provide the connective
glue that allow your Java and C code to interact.
There are two main signatures for ``create_javah()``. The first signature
returns generated files through variable specified by the ``GENERATED_FILES``
option. For example:
.. code-block:: cmake
create_javah(GENERATED_FILES files_headers
CLASSES org.cmake.HelloWorld
CLASSPATH hello.jar
)
The second signature for ``create_javah()`` creates a target which
encapsulates header files generation. E.g.
.. code-block:: cmake
create_javah(TARGET target_headers
CLASSES org.cmake.HelloWorld
CLASSPATH hello.jar
)
Both signatures share same options.
``CLASSES``
Specifies Java classes used to generate headers.
``CLASSPATH``
Specifies various paths to look up classes. Here ``.class`` files, jar
files or targets created by command add_jar can be used.
``DEPENDS``
Targets on which the javah target depends.
``OUTPUT_NAME``
Concatenates the resulting header files for all the classes listed by
option ``CLASSES`` into ``<path>``. Same behavior as option ``-o`` of
``javah`` tool.
``OUTPUT_DIR``
Sets the directory where the header files will be generated. Same behavior
as option ``-d`` of ``javah`` tool. If not specified,
:variable:`CMAKE_CURRENT_BINARY_DIR` is used as the output directory.
Exporting JAR Targets
^^^^^^^^^^^^^^^^^^^^^
.. _install_jar_exports:
.. command:: install_jar_exports
.. versionadded:: 3.7
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
Installs a target export file::
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
install_jar_exports(TARGETS <jars>...
[NAMESPACE <namespace>]
FILE <filename>
DESTINATION <destination> [COMPONENT <component>])
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
This command installs a target export file ``<filename>`` for the named jar
targets to the given ``<destination>`` directory. Its function is similar to
that of :command:`install(EXPORT)`.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
``TARGETS``
List of targets created by :ref:`add_jar() <add_jar>` command.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
``NAMESPACE``
.. versionadded:: 3.9
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
The ``<namespace>`` value will be prepend to the target names as they are
written to the import file.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
``FILE``
Specify name of the export file.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
``DESTINATION``
Specify the directory on disk to which a file will be installed.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
``COMPONENT``
Specify an installation component name with which the install rule is
associated, such as "runtime" or "development".
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
.. _export_jars:
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
.. command:: export_jars
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
.. versionadded:: 3.7
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
Writes a target export file::
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
export_jars(TARGETS <jars>...
[NAMESPACE <namespace>]
FILE <filename>)
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
This command writes a target export file ``<filename>`` for the named ``<jars>``
targets. Its function is similar to that of :command:`export`.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
``TARGETS``
List of targets created by :ref:`add_jar() <add_jar>` command.
``NAMESPACE``
.. versionadded:: 3.9
The ``<namespace>`` value will be prepend to the target names as they are
written to the import file.
``FILE``
Specify name of the export file.
Finding JARs
^^^^^^^^^^^^
.. _find_jar:
.. command:: find_jar
Finds the specified jar file::
find_jar(<VAR>
<name> | NAMES <name1> [<name2>...]
[PATHS <path1> [<path2>... ENV <var>]]
[VERSIONS <version1> [<version2>]]
[DOC "cache documentation string"]
)
This command is used to find a full path to the named jar. A cache
entry named by ``<VAR>`` is created to store the result of this command.
If the full path to a jar is found the result is stored in the
variable and the search will not repeated unless the variable is
cleared. If nothing is found, the result will be ``<VAR>-NOTFOUND``, and
the search will be attempted again next time ``find_jar()`` is invoked with
the same variable.
``NAMES``
Specify one or more possible names for the jar file.
``PATHS``
Specify directories to search in addition to the default locations.
The ``ENV`` var sub-option reads paths from a system environment variable.
``VERSIONS``
Specify jar versions.
``DOC``
Specify the documentation string for the ``<VAR>`` cache entry.
Creating Java Documentation
^^^^^^^^^^^^^^^^^^^^^^^^^^^
.. _create_javadoc:
.. command:: create_javadoc
Creates java documentation based on files and packages::
create_javadoc(<VAR>
(PACKAGES <pkg1> [<pkg2>...] | FILES <file1> [<file2>...])
[SOURCEPATH <sourcepath>]
[CLASSPATH <classpath>]
[INSTALLPATH <install path>]
[DOCTITLE <the documentation title>]
[WINDOWTITLE <the title of the document>]
[AUTHOR (TRUE|FALSE)]
[USE (TRUE|FALSE)]
[VERSION (TRUE|FALSE)]
)
The ``create_javadoc()`` command can be used to create java documentation.
There are two main signatures for ``create_javadoc()``.
The first signature works with package names on a path with source files:
.. code-block:: cmake
create_javadoc(my_example_doc
PACKAGES com.example.foo com.example.bar
SOURCEPATH "${CMAKE_CURRENT_SOURCE_DIR}"
CLASSPATH ${CMAKE_JAVA_INCLUDE_PATH}
WINDOWTITLE "My example"
DOCTITLE "<h1>My example</h1>"
AUTHOR TRUE
USE TRUE
VERSION TRUE
)
The second signature for ``create_javadoc()`` works on a given list of files:
.. code-block:: cmake
create_javadoc(my_example_doc
FILES java/A.java java/B.java
CLASSPATH ${CMAKE_JAVA_INCLUDE_PATH}
WINDOWTITLE "My example"
DOCTITLE "<h1>My example</h1>"
AUTHOR TRUE
USE TRUE
VERSION TRUE
)
Both signatures share most of the options. For more details please read the
javadoc manpage.
``PACKAGES``
Specify java packages.
``FILES``
Specify java source files. If relative paths are specified, they are
relative to :variable:`CMAKE_CURRENT_SOURCE_DIR`.
``SOURCEPATH``
Specify the directory where to look for packages. By default,
:variable:`CMAKE_CURRENT_SOURCE_DIR` directory is used.
``CLASSPATH``
Specify where to find user class files. Same behavior as option
``-classpath`` of ``javadoc`` tool.
``INSTALLPATH``
Specify where to install the java documentation. If you specified, the
documentation will be installed to
``${CMAKE_INSTALL_PREFIX}/share/javadoc/<VAR>``.
``DOCTITLE``
Specify the title to place near the top of the overview summary file.
Same behavior as option ``-doctitle`` of ``javadoc`` tool.
``WINDOWTITLE``
Specify the title to be placed in the HTML ``<title>`` tag. Same behavior
as option ``-windowtitle`` of ``javadoc`` tool.
``AUTHOR``
When value ``TRUE`` is specified, includes the ``@author`` text in the
generated docs. Same behavior as option ``-author`` of ``javadoc`` tool.
``USE``
When value ``TRUE`` is specified, creates class and package usage pages.
Includes one Use page for each documented class and package. Same behavior
as option ``-use`` of ``javadoc`` tool.
``VERSION``
When value ``TRUE`` is specified, includes the version text in the
generated docs. Same behavior as option ``-version`` of ``javadoc`` tool.
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
#]=======================================================================]
function (__java_copy_file src dest comment)
add_custom_command(
OUTPUT ${dest}
COMMAND ${CMAKE_COMMAND} -E copy_if_different
ARGS ${src}
${dest}
DEPENDS ${src}
qr 6.5.1: still missed with cmake version, trying 3.18.3
2023-11-01 06:36:59 +08:00
COMMENT ${comment}
VERBATIM
)
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
endfunction ()
function(__java_lcat VAR)
foreach(_line IN LISTS ARGN)
string(APPEND ${VAR} "${_line}\n")
endforeach()
set(${VAR} "${${VAR}}" PARENT_SCOPE)
endfunction()
function(__java_export_jar VAR TARGET PATH)
get_target_property(_jarpath ${TARGET} JAR_FILE)
get_filename_component(_jarname ${_jarpath} NAME)
set(_target "${_jar_NAMESPACE}${TARGET}")
__java_lcat(${VAR}
"# Create imported target ${_target}"
"add_library(${_target} IMPORTED STATIC)"
"set_target_properties(${_target} PROPERTIES"
" IMPORTED_LOCATION \"${PATH}/${_jarname}\""
" JAR_FILE \"${PATH}/${_jarname}\")"
""
)
set(${VAR} "${${VAR}}" PARENT_SCOPE)
endfunction()
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
function(__java_copy_resource_namespaces VAR DEST JAVA_RESOURCE_FILES JAVA_RESOURCE_FILES_RELATIVE)
set(_ns_ID "")
set(_ns_VAL "")
foreach(_item IN LISTS VAR)
if(NOT _ns_ID)
if(NOT _item STREQUAL "NAMESPACE")
message(FATAL_ERROR "UseJava: Expecting \"NAMESPACE\", got\t\"${_item}\"")
return()
endif()
endif()
if(_item STREQUAL "NAMESPACE")
set(_ns_VAL "") # Prepare for next namespace
set(_ns_ID "${_item}")
continue()
endif()
if( NOT _ns_VAL)
# we're expecting the next token to be a namespace value
# whatever it is, we're treating it like a namespace
set(_ns_VAL "${_item}")
continue()
endif()
if(_ns_ID AND _ns_VAL)
# We're expecting a file name, check to see if we got one
cmake_path(ABSOLUTE_PATH _item OUTPUT_VARIABLE _test_file_name)
if (NOT EXISTS "${_test_file_name}")
message(FATAL_ERROR "UseJava: File does not exist:\t${_item}")
return()
endif()
endif()
cmake_path(ABSOLUTE_PATH _item OUTPUT_VARIABLE _abs_file_name)
cmake_path(GET _item FILENAME _resource_file_name)
set(_dest_resource_file_name "${_ns_VAL}/${_resource_file_name}" )
__java_copy_file( ${_abs_file_name}
${DEST}/${_dest_resource_file_name}
"Copying ${_item} to the build directory")
list(APPEND RESOURCE_FILES_LIST ${DEST}/${_dest_resource_file_name})
list(APPEND RELATIVE_RESOURCE_FILES_LIST ${_dest_resource_file_name})
endforeach()
set(${JAVA_RESOURCE_FILES} "${RESOURCE_FILES_LIST}" PARENT_SCOPE)
set(${JAVA_RESOURCE_FILES_RELATIVE} "${RELATIVE_RESOURCE_FILES_LIST}" PARENT_SCOPE)
endfunction()
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
# define helper scripts
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
set(_JAVA_EXPORT_TARGETS_SCRIPT ${CMAKE_CURRENT_LIST_DIR}/UseJava/javaTargets.cmake.in)
set(_JAVA_SYMLINK_SCRIPT ${CMAKE_CURRENT_LIST_DIR}/UseJava/Symlinks.cmake)
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
well, looks like cmake 3.17 is required though
2023-11-01 06:34:31 +08:00
if (CMAKE_HOST_WIN32 AND NOT CYGWIN AND CMAKE_HOST_SYSTEM_NAME MATCHES "Windows")
set(_UseJava_PATH_SEP "$<SEMICOLON>")
else ()
set(_UseJava_PATH_SEP ":")
endif()
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
function(add_jar _TARGET_NAME)
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
set(options) # currently there are no zero value args (aka: options)
set(oneValueArgs "ENTRY_POINT;MANIFEST;OUTPUT_DIR;;OUTPUT_NAME;VERSION" )
set(multiValueArgs "GENERATE_NATIVE_HEADERS;INCLUDE_JARS;RESOURCES;SOURCES" )
cmake_parse_arguments(PARSE_ARGV 1 _add_jar
"${options}"
"${oneValueArgs}"
"${multiValueArgs}" )
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
# In CMake < 2.8.12, add_jar used variables which were set prior to calling
# add_jar for customizing the behavior of add_jar. In order to be backwards
# compatible, check if any of those variables are set, and use them to
# initialize values of the named arguments. (Giving the corresponding named
# argument will override the value set here.)
#
# New features should use named arguments only.
if(NOT DEFINED _add_jar_VERSION AND DEFINED CMAKE_JAVA_TARGET_VERSION)
set(_add_jar_VERSION "${CMAKE_JAVA_TARGET_VERSION}")
endif()
if(NOT DEFINED _add_jar_OUTPUT_DIR AND DEFINED CMAKE_JAVA_TARGET_OUTPUT_DIR)
set(_add_jar_OUTPUT_DIR "${CMAKE_JAVA_TARGET_OUTPUT_DIR}")
endif()
if(NOT DEFINED _add_jar_OUTPUT_NAME AND DEFINED CMAKE_JAVA_TARGET_OUTPUT_NAME)
set(_add_jar_OUTPUT_NAME "${CMAKE_JAVA_TARGET_OUTPUT_NAME}")
# reset
set(CMAKE_JAVA_TARGET_OUTPUT_NAME)
endif()
if(NOT DEFINED _add_jar_ENTRY_POINT AND DEFINED CMAKE_JAVA_JAR_ENTRY_POINT)
set(_add_jar_ENTRY_POINT "${CMAKE_JAVA_JAR_ENTRY_POINT}")
endif()
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
# This *should* still work if <resources1>... are included without a
# named RESOURCES argument. In that case, the old behavior of potentially
# misplacing the within the Jar will behave as previously (incorrectly)
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
set(_JAVA_SOURCE_FILES ${_add_jar_SOURCES} ${_add_jar_UNPARSED_ARGUMENTS})
if (NOT DEFINED _add_jar_OUTPUT_DIR)
set(_add_jar_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR})
else()
get_filename_component(_add_jar_OUTPUT_DIR ${_add_jar_OUTPUT_DIR} ABSOLUTE)
endif()
# ensure output directory exists
file (MAKE_DIRECTORY "${_add_jar_OUTPUT_DIR}")
if (_add_jar_ENTRY_POINT)
set(_ENTRY_POINT_OPTION e)
set(_ENTRY_POINT_VALUE ${_add_jar_ENTRY_POINT})
endif ()
if (_add_jar_MANIFEST)
set(_MANIFEST_OPTION m)
get_filename_component (_MANIFEST_VALUE "${_add_jar_MANIFEST}" ABSOLUTE)
endif ()
unset (_GENERATE_NATIVE_HEADERS)
if (_add_jar_GENERATE_NATIVE_HEADERS)
# Raise an error if JDK version is less than 1.8 because javac -h is not supported
# by earlier versions.
if (Java_VERSION VERSION_LESS 1.8)
message (FATAL_ERROR "ADD_JAR: GENERATE_NATIVE_HEADERS is not supported with this version of Java.")
endif()
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
unset (_GENERATE_NATIVE_HEADERS_OUTPUT_DESC)
cmake_parse_arguments (_add_jar_GENERATE_NATIVE_HEADERS "" "" "DESTINATION" ${_add_jar_GENERATE_NATIVE_HEADERS})
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
if (NOT _add_jar_GENERATE_NATIVE_HEADERS_UNPARSED_ARGUMENTS)
message (FATAL_ERROR "ADD_JAR: GENERATE_NATIVE_HEADERS: missing required argument.")
endif()
list (LENGTH _add_jar_GENERATE_NATIVE_HEADERS_UNPARSED_ARGUMENTS length)
if (length GREATER 1)
list (REMOVE_AT _add_jar_GENERATE_NATIVE_HEADERS_UNPARSED_ARGUMENTS 0)
message (FATAL_ERROR "ADD_JAR: GENERATE_NATIVE_HEADERS: ${_add_jar_GENERATE_NATIVE_HEADERS_UNPARSED_ARGUMENTS}: unexpected argument(s).")
endif()
if (NOT _add_jar_GENERATE_NATIVE_HEADERS_DESTINATION)
set (_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/${_TARGET_NAME}.dir/native_headers")
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
else()
list (LENGTH _add_jar_GENERATE_NATIVE_HEADERS_DESTINATION length)
if (NOT length EQUAL 1)
cmake_parse_arguments (_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION "" "BUILD;INSTALL" "" "${_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION}")
if (_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION_UNPARSED_ARGUMENTS)
message (FATAL_ERROR "ADD_JAR: GENERATE_NATIVE_HEADERS: DESTINATION: ${_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION_UNPARSED_ARGUMENTS}: unexpected argument(s).")
endif()
if (NOT _add_jar_GENERATE_NATIVE_HEADERS_DESTINATION_INSTALL)
message (FATAL_ERROR "ADD_JAR: GENERATE_NATIVE_HEADERS: DESTINATION: INSTALL sub-option is required.")
endif()
if (NOT _add_jar_GENERATE_NATIVE_HEADERS_DESTINATION_BUILD)
set(_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION_BUILD "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/${_TARGET_NAME}.dir/native_headers")
endif()
set(_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION "${_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION_BUILD}")
set(_GENERATE_NATIVE_HEADERS_OUTPUT_DESC "$<BUILD_INTERFACE:${_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION_BUILD}>" "$<INSTALL_INTERFACE:${_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION_INSTALL}>")
endif()
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
endif()
set (_GENERATE_NATIVE_HEADERS_TARGET ${_add_jar_GENERATE_NATIVE_HEADERS_UNPARSED_ARGUMENTS})
set (_GENERATE_NATIVE_HEADERS_OUTPUT_DIR "${_add_jar_GENERATE_NATIVE_HEADERS_DESTINATION}")
set (_GENERATE_NATIVE_HEADERS -h "${_GENERATE_NATIVE_HEADERS_OUTPUT_DIR}")
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
if(NOT _GENERATE_NATIVE_HEADERS_OUTPUT_DESC)
set(_GENERATE_NATIVE_HEADERS_OUTPUT_DESC "${_GENERATE_NATIVE_HEADERS_OUTPUT_DIR}")
endif()
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
endif()
if (LIBRARY_OUTPUT_PATH)
set(CMAKE_JAVA_LIBRARY_OUTPUT_PATH ${LIBRARY_OUTPUT_PATH})
else ()
set(CMAKE_JAVA_LIBRARY_OUTPUT_PATH ${_add_jar_OUTPUT_DIR})
endif ()
set(CMAKE_JAVA_INCLUDE_PATH
${CMAKE_JAVA_INCLUDE_PATH}
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_JAVA_OBJECT_OUTPUT_PATH}
${CMAKE_JAVA_LIBRARY_OUTPUT_PATH}
)
foreach (JAVA_INCLUDE_DIR IN LISTS CMAKE_JAVA_INCLUDE_PATH)
well, looks like cmake 3.17 is required though
2023-11-01 06:34:31 +08:00
string(APPEND CMAKE_JAVA_INCLUDE_PATH_FINAL "${_UseJava_PATH_SEP}${JAVA_INCLUDE_DIR}")
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
endforeach()
set(CMAKE_JAVA_CLASS_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/${_TARGET_NAME}.dir")
set(_JAVA_TARGET_OUTPUT_NAME "${_TARGET_NAME}.jar")
if (_add_jar_OUTPUT_NAME AND _add_jar_VERSION)
set(_JAVA_TARGET_OUTPUT_NAME "${_add_jar_OUTPUT_NAME}-${_add_jar_VERSION}.jar")
set(_JAVA_TARGET_OUTPUT_LINK "${_add_jar_OUTPUT_NAME}.jar")
elseif (_add_jar_VERSION)
set(_JAVA_TARGET_OUTPUT_NAME "${_TARGET_NAME}-${_add_jar_VERSION}.jar")
set(_JAVA_TARGET_OUTPUT_LINK "${_TARGET_NAME}.jar")
elseif (_add_jar_OUTPUT_NAME)
set(_JAVA_TARGET_OUTPUT_NAME "${_add_jar_OUTPUT_NAME}.jar")
endif ()
set(_JAVA_CLASS_FILES)
set(_JAVA_COMPILE_FILES)
set(_JAVA_COMPILE_FILELISTS)
set(_JAVA_DEPENDS)
set(_JAVA_COMPILE_DEPENDS)
set(_JAVA_RESOURCE_FILES)
set(_JAVA_RESOURCE_FILES_RELATIVE)
foreach(_JAVA_SOURCE_FILE IN LISTS _JAVA_SOURCE_FILES)
get_filename_component(_JAVA_EXT ${_JAVA_SOURCE_FILE} EXT)
get_filename_component(_JAVA_FILE ${_JAVA_SOURCE_FILE} NAME_WE)
get_filename_component(_JAVA_PATH ${_JAVA_SOURCE_FILE} PATH)
get_filename_component(_JAVA_FULL ${_JAVA_SOURCE_FILE} ABSOLUTE)
if (_JAVA_SOURCE_FILE MATCHES "^@(.+)$")
get_filename_component(_JAVA_FULL ${CMAKE_MATCH_1} ABSOLUTE)
list(APPEND _JAVA_COMPILE_FILELISTS ${_JAVA_FULL})
elseif (_JAVA_EXT MATCHES ".java")
file(RELATIVE_PATH _JAVA_REL_BINARY_PATH ${CMAKE_CURRENT_BINARY_DIR} ${_JAVA_FULL})
file(RELATIVE_PATH _JAVA_REL_SOURCE_PATH ${CMAKE_CURRENT_SOURCE_DIR} ${_JAVA_FULL})
string(LENGTH ${_JAVA_REL_BINARY_PATH} _BIN_LEN)
string(LENGTH ${_JAVA_REL_SOURCE_PATH} _SRC_LEN)
if (_BIN_LEN LESS _SRC_LEN)
set(_JAVA_REL_PATH ${_JAVA_REL_BINARY_PATH})
else ()
set(_JAVA_REL_PATH ${_JAVA_REL_SOURCE_PATH})
endif ()
get_filename_component(_JAVA_REL_PATH ${_JAVA_REL_PATH} PATH)
list(APPEND _JAVA_COMPILE_FILES ${_JAVA_SOURCE_FILE})
set(_JAVA_CLASS_FILE "${CMAKE_JAVA_CLASS_OUTPUT_PATH}/${_JAVA_REL_PATH}/${_JAVA_FILE}.class")
set(_JAVA_CLASS_FILES ${_JAVA_CLASS_FILES} ${_JAVA_CLASS_FILE})
elseif (_JAVA_EXT MATCHES ".jar"
OR _JAVA_EXT MATCHES ".war"
OR _JAVA_EXT MATCHES ".ear"
OR _JAVA_EXT MATCHES ".sar")
# Ignored for backward compatibility
elseif (_JAVA_EXT STREQUAL "")
list(APPEND CMAKE_JAVA_INCLUDE_PATH ${JAVA_JAR_TARGET_${_JAVA_SOURCE_FILE}} ${JAVA_JAR_TARGET_${_JAVA_SOURCE_FILE}_CLASSPATH})
list(APPEND _JAVA_DEPENDS ${JAVA_JAR_TARGET_${_JAVA_SOURCE_FILE}})
else ()
__java_copy_file(${CMAKE_CURRENT_SOURCE_DIR}/${_JAVA_SOURCE_FILE}
${CMAKE_JAVA_CLASS_OUTPUT_PATH}/${_JAVA_SOURCE_FILE}
"Copying ${_JAVA_SOURCE_FILE} to the build directory")
list(APPEND _JAVA_RESOURCE_FILES ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/${_JAVA_SOURCE_FILE})
list(APPEND _JAVA_RESOURCE_FILES_RELATIVE ${_JAVA_SOURCE_FILE})
endif ()
endforeach()
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
if(_add_jar_RESOURCES) # Process RESOURCES if it exists
__java_copy_resource_namespaces("${_add_jar_RESOURCES}"
${CMAKE_JAVA_CLASS_OUTPUT_PATH}
_JAVA_RESOURCE_FILES
_JAVA_RESOURCE_FILES_RELATIVE)
endif()
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
foreach(_JAVA_INCLUDE_JAR IN LISTS _add_jar_INCLUDE_JARS)
if (TARGET ${_JAVA_INCLUDE_JAR})
get_target_property(_JAVA_JAR_PATH ${_JAVA_INCLUDE_JAR} JAR_FILE)
if (_JAVA_JAR_PATH)
well, looks like cmake 3.17 is required though
2023-11-01 06:34:31 +08:00
string(APPEND CMAKE_JAVA_INCLUDE_PATH_FINAL "${_UseJava_PATH_SEP}${_JAVA_JAR_PATH}")
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
list(APPEND CMAKE_JAVA_INCLUDE_PATH ${_JAVA_JAR_PATH})
list(APPEND _JAVA_DEPENDS ${_JAVA_INCLUDE_JAR})
list(APPEND _JAVA_COMPILE_DEPENDS ${_JAVA_JAR_PATH})
else ()
message(SEND_ERROR "add_jar: INCLUDE_JARS target ${_JAVA_INCLUDE_JAR} is not a jar")
endif ()
else ()
well, looks like cmake 3.17 is required though
2023-11-01 06:34:31 +08:00
string(APPEND CMAKE_JAVA_INCLUDE_PATH_FINAL "${_UseJava_PATH_SEP}${_JAVA_INCLUDE_JAR}")
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
list(APPEND CMAKE_JAVA_INCLUDE_PATH "${_JAVA_INCLUDE_JAR}")
list(APPEND _JAVA_DEPENDS "${_JAVA_INCLUDE_JAR}")
list(APPEND _JAVA_COMPILE_DEPENDS "${_JAVA_INCLUDE_JAR}")
endif ()
endforeach()
if (_JAVA_COMPILE_FILES OR _JAVA_COMPILE_FILELISTS)
set (_JAVA_SOURCES_FILELISTS)
if (_JAVA_COMPILE_FILES)
# Create the list of files to compile.
set(_JAVA_SOURCES_FILE ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_sources)
string(REPLACE ";" "\"\n\"" _JAVA_COMPILE_STRING "\"${_JAVA_COMPILE_FILES}\"")
qr 6.5.1: still missed with cmake version, trying 3.18.3
2023-11-01 06:36:59 +08:00
set(CMAKE_CONFIGURABLE_FILE_CONTENT "${_JAVA_COMPILE_STRING}")
configure_file("${CMAKE_ROOT}/Modules/CMakeConfigurableFile.in"
"${_JAVA_SOURCES_FILE}" @ONLY)
unset(CMAKE_CONFIGURABLE_FILE_CONTENT)
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
list (APPEND _JAVA_SOURCES_FILELISTS "@${_JAVA_SOURCES_FILE}")
endif()
if (_JAVA_COMPILE_FILELISTS)
foreach (_JAVA_FILELIST IN LISTS _JAVA_COMPILE_FILELISTS)
list (APPEND _JAVA_SOURCES_FILELISTS "@${_JAVA_FILELIST}")
endforeach()
endif()
# Compile the java files and create a list of class files
add_custom_command(
# NOTE: this command generates an artificial dependency file
OUTPUT ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_compiled_${_TARGET_NAME}
qr 6.5.1: still missed with cmake version, trying 3.18.3
2023-11-01 06:36:59 +08:00
COMMAND ${CMAKE_COMMAND}
-DCMAKE_JAVA_CLASS_OUTPUT_PATH=${CMAKE_JAVA_CLASS_OUTPUT_PATH}
-DCMAKE_JAR_CLASSES_PREFIX=${CMAKE_JAR_CLASSES_PREFIX}
-P ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/UseJava/ClearClassFiles.cmake
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
COMMAND ${Java_JAVAC_EXECUTABLE}
${CMAKE_JAVA_COMPILE_FLAGS}
-classpath "${CMAKE_JAVA_INCLUDE_PATH_FINAL}"
-d ${CMAKE_JAVA_CLASS_OUTPUT_PATH}
${_GENERATE_NATIVE_HEADERS}
${_JAVA_SOURCES_FILELISTS}
COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_compiled_${_TARGET_NAME}
qr 6.5.1: still missed with cmake version, trying 3.18.3
2023-11-01 06:36:59 +08:00
DEPENDS ${_JAVA_COMPILE_FILES} ${_JAVA_COMPILE_FILELISTS} ${_JAVA_COMPILE_DEPENDS} ${_JAVA_SOURCES_FILE}
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
COMMENT "Building Java objects for ${_TARGET_NAME}.jar"
qr 6.5.1: still missed with cmake version, trying 3.18.3
2023-11-01 06:36:59 +08:00
VERBATIM
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
)
add_custom_command(
OUTPUT ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist
COMMAND ${CMAKE_COMMAND}
-DCMAKE_JAVA_CLASS_OUTPUT_PATH=${CMAKE_JAVA_CLASS_OUTPUT_PATH}
qr 6.5.1: still missed with cmake version, trying 3.18.3
2023-11-01 06:36:59 +08:00
-DCMAKE_JAR_CLASSES_PREFIX=${CMAKE_JAR_CLASSES_PREFIX}
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
-P ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/UseJava/ClassFilelist.cmake
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
DEPENDS ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_compiled_${_TARGET_NAME}
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
qr 6.5.1: still missed with cmake version, trying 3.18.3
2023-11-01 06:36:59 +08:00
VERBATIM
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
)
else ()
# create an empty java_class_filelist
if (NOT EXISTS ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist)
file(WRITE ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist "")
endif()
endif ()
# create the jar file
set(_JAVA_JAR_OUTPUT_PATH
"${_add_jar_OUTPUT_DIR}/${_JAVA_TARGET_OUTPUT_NAME}")
if (CMAKE_JNI_TARGET)
add_custom_command(
OUTPUT ${_JAVA_JAR_OUTPUT_PATH}
COMMAND ${Java_JAR_EXECUTABLE}
-cf${_ENTRY_POINT_OPTION}${_MANIFEST_OPTION} ${_JAVA_JAR_OUTPUT_PATH} ${_ENTRY_POINT_VALUE} ${_MANIFEST_VALUE}
${_JAVA_RESOURCE_FILES_RELATIVE} @java_class_filelist
COMMAND ${CMAKE_COMMAND}
-D_JAVA_TARGET_DIR=${_add_jar_OUTPUT_DIR}
-D_JAVA_TARGET_OUTPUT_NAME=${_JAVA_TARGET_OUTPUT_NAME}
-D_JAVA_TARGET_OUTPUT_LINK=${_JAVA_TARGET_OUTPUT_LINK}
-P ${_JAVA_SYMLINK_SCRIPT}
COMMAND ${CMAKE_COMMAND}
-D_JAVA_TARGET_DIR=${_add_jar_OUTPUT_DIR}
-D_JAVA_TARGET_OUTPUT_NAME=${_JAVA_JAR_OUTPUT_PATH}
-D_JAVA_TARGET_OUTPUT_LINK=${_JAVA_TARGET_OUTPUT_LINK}
-P ${_JAVA_SYMLINK_SCRIPT}
DEPENDS ${_JAVA_RESOURCE_FILES} ${_JAVA_DEPENDS} ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist
WORKING_DIRECTORY ${CMAKE_JAVA_CLASS_OUTPUT_PATH}
COMMENT "Creating Java archive ${_JAVA_TARGET_OUTPUT_NAME}"
qr 6.5.1: still missed with cmake version, trying 3.18.3
2023-11-01 06:36:59 +08:00
VERBATIM
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
)
else ()
add_custom_command(
OUTPUT ${_JAVA_JAR_OUTPUT_PATH}
COMMAND ${Java_JAR_EXECUTABLE}
-cf${_ENTRY_POINT_OPTION}${_MANIFEST_OPTION} ${_JAVA_JAR_OUTPUT_PATH} ${_ENTRY_POINT_VALUE} ${_MANIFEST_VALUE}
${_JAVA_RESOURCE_FILES_RELATIVE} @java_class_filelist
COMMAND ${CMAKE_COMMAND}
-D_JAVA_TARGET_DIR=${_add_jar_OUTPUT_DIR}
-D_JAVA_TARGET_OUTPUT_NAME=${_JAVA_TARGET_OUTPUT_NAME}
-D_JAVA_TARGET_OUTPUT_LINK=${_JAVA_TARGET_OUTPUT_LINK}
-P ${_JAVA_SYMLINK_SCRIPT}
WORKING_DIRECTORY ${CMAKE_JAVA_CLASS_OUTPUT_PATH}
DEPENDS ${_JAVA_RESOURCE_FILES} ${_JAVA_DEPENDS} ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist
COMMENT "Creating Java archive ${_JAVA_TARGET_OUTPUT_NAME}"
qr 6.5.1: still missed with cmake version, trying 3.18.3
2023-11-01 06:36:59 +08:00
VERBATIM
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
)
endif ()
# Add the target and make sure we have the latest resource files.
add_custom_target(${_TARGET_NAME} ALL DEPENDS ${_JAVA_JAR_OUTPUT_PATH})
set_property(
TARGET
${_TARGET_NAME}
PROPERTY
INSTALL_FILES
${_JAVA_JAR_OUTPUT_PATH}
)
if (_JAVA_TARGET_OUTPUT_LINK)
set_property(
TARGET
${_TARGET_NAME}
PROPERTY
INSTALL_FILES
${_JAVA_JAR_OUTPUT_PATH}
${_add_jar_OUTPUT_DIR}/${_JAVA_TARGET_OUTPUT_LINK}
)
if (CMAKE_JNI_TARGET)
set_property(
TARGET
${_TARGET_NAME}
PROPERTY
JNI_SYMLINK
${_add_jar_OUTPUT_DIR}/${_JAVA_TARGET_OUTPUT_LINK}
)
endif ()
endif ()
set_property(
TARGET
${_TARGET_NAME}
PROPERTY
JAR_FILE
${_JAVA_JAR_OUTPUT_PATH}
)
set_property(
TARGET
${_TARGET_NAME}
PROPERTY
CLASSDIR
${CMAKE_JAVA_CLASS_OUTPUT_PATH}
)
if (_GENERATE_NATIVE_HEADERS)
# create an INTERFACE library encapsulating include directory for generated headers
add_library (${_GENERATE_NATIVE_HEADERS_TARGET} INTERFACE)
target_include_directories (${_GENERATE_NATIVE_HEADERS_TARGET} INTERFACE
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
"${_GENERATE_NATIVE_HEADERS_OUTPUT_DESC}"
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
${JNI_INCLUDE_DIRS})
qt 6.5.1: use cmake portable 3.27.7
2023-11-01 08:44:24 +08:00
set_property(TARGET ${_GENERATE_NATIVE_HEADERS_TARGET} PROPERTY NATIVE_HEADERS_DIRECTORY "${_GENERATE_NATIVE_HEADERS_OUTPUT_DIR}")
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
# this INTERFACE library depends on jar generation
add_dependencies (${_GENERATE_NATIVE_HEADERS_TARGET} ${_TARGET_NAME})
cmake 3.16.2 is required
2023-11-01 06:20:22 +08:00
set_property (DIRECTORY APPEND PROPERTY ADDITIONAL_CLEAN_FILES
"${_GENERATE_NATIVE_HEADERS_OUTPUT_DIR}")
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
endif()
endfunction()
function(INSTALL_JAR _TARGET_NAME)
if (ARGC EQUAL 2)
set (_DESTINATION ${ARGV1})
else()
cmake_parse_arguments(_install_jar
""
"DESTINATION;COMPONENT"
""
${ARGN})
if (_install_jar_DESTINATION)
set (_DESTINATION ${_install_jar_DESTINATION})
else()
message(SEND_ERROR "install_jar: ${_TARGET_NAME}: DESTINATION must be specified.")
endif()
if (_install_jar_COMPONENT)
set (_COMPONENT COMPONENT ${_install_jar_COMPONENT})
endif()
endif()
get_property(__FILES
TARGET
${_TARGET_NAME}
PROPERTY
INSTALL_FILES
)
set_property(
TARGET
${_TARGET_NAME}
PROPERTY
INSTALL_DESTINATION
${_DESTINATION}
)
if (__FILES)
install(
FILES
${__FILES}
DESTINATION
${_DESTINATION}
${_COMPONENT}
)
else ()
message(SEND_ERROR "install_jar: The target ${_TARGET_NAME} is not known in this scope.")
endif ()
endfunction()
function(INSTALL_JNI_SYMLINK _TARGET_NAME)
if (ARGC EQUAL 2)
set (_DESTINATION ${ARGV1})
else()
cmake_parse_arguments(_install_jni_symlink
""
"DESTINATION;COMPONENT"
""
${ARGN})
if (_install_jni_symlink_DESTINATION)
set (_DESTINATION ${_install_jni_symlink_DESTINATION})
else()
message(SEND_ERROR "install_jni_symlink: ${_TARGET_NAME}: DESTINATION must be specified.")
endif()
if (_install_jni_symlink_COMPONENT)
set (_COMPONENT COMPONENT ${_install_jni_symlink_COMPONENT})
endif()
endif()
get_property(__SYMLINK
TARGET
${_TARGET_NAME}
PROPERTY
JNI_SYMLINK
)
if (__SYMLINK)
install(
FILES
${__SYMLINK}
DESTINATION
${_DESTINATION}
${_COMPONENT}
)
else ()
message(SEND_ERROR "install_jni_symlink: The target ${_TARGET_NAME} is not known in this scope.")
endif ()
endfunction()
function (find_jar VARIABLE)
set(_jar_names)
set(_jar_files)
set(_jar_versions)
set(_jar_paths
/usr/share/java/
/usr/local/share/java/
${Java_JAR_PATHS})
set(_jar_doc "NOTSET")
set(_state "name")
foreach (arg IN LISTS ARGN)
if (_state STREQUAL "name")
if (arg STREQUAL "VERSIONS")
set(_state "versions")
elseif (arg STREQUAL "NAMES")
set(_state "names")
elseif (arg STREQUAL "PATHS")
set(_state "paths")
elseif (arg STREQUAL "DOC")
set(_state "doc")
else ()
set(_jar_names ${arg})
if (_jar_doc STREQUAL "NOTSET")
set(_jar_doc "Finding ${arg} jar")
endif ()
endif ()
elseif (_state STREQUAL "versions")
if (arg STREQUAL "NAMES")
set(_state "names")
elseif (arg STREQUAL "PATHS")
set(_state "paths")
elseif (arg STREQUAL "DOC")
set(_state "doc")
else ()
set(_jar_versions ${_jar_versions} ${arg})
endif ()
elseif (_state STREQUAL "names")
if (arg STREQUAL "VERSIONS")
set(_state "versions")
elseif (arg STREQUAL "PATHS")
set(_state "paths")
elseif (arg STREQUAL "DOC")
set(_state "doc")
else ()
set(_jar_names ${_jar_names} ${arg})
if (_jar_doc STREQUAL "NOTSET")
set(_jar_doc "Finding ${arg} jar")
endif ()
endif ()
elseif (_state STREQUAL "paths")
if (arg STREQUAL "VERSIONS")
set(_state "versions")
elseif (arg STREQUAL "NAMES")
set(_state "names")
elseif (arg STREQUAL "DOC")
set(_state "doc")
else ()
set(_jar_paths ${_jar_paths} ${arg})
endif ()
elseif (_state STREQUAL "doc")
if (arg STREQUAL "VERSIONS")
set(_state "versions")
elseif (arg STREQUAL "NAMES")
set(_state "names")
elseif (arg STREQUAL "PATHS")
set(_state "paths")
else ()
set(_jar_doc ${arg})
endif ()
endif ()
endforeach ()
if (NOT _jar_names)
message(FATAL_ERROR "find_jar: No name to search for given")
endif ()
foreach (jar_name IN LISTS _jar_names)
foreach (version IN LISTS _jar_versions)
set(_jar_files ${_jar_files} ${jar_name}-${version}.jar)
endforeach ()
set(_jar_files ${_jar_files} ${jar_name}.jar)
endforeach ()
find_file(${VARIABLE}
NAMES ${_jar_files}
PATHS ${_jar_paths}
DOC ${_jar_doc}
NO_DEFAULT_PATH)
endfunction ()
function(create_javadoc _target)
set(_javadoc_packages)
set(_javadoc_files)
set(_javadoc_sourcepath)
set(_javadoc_classpath)
set(_javadoc_installpath "${CMAKE_INSTALL_PREFIX}/share/javadoc")
set(_javadoc_doctitle)
set(_javadoc_windowtitle)
set(_javadoc_author FALSE)
set(_javadoc_version FALSE)
set(_javadoc_use FALSE)
set(_state "package")
foreach (arg IN LISTS ARGN)
if (_state STREQUAL "package")
if (arg STREQUAL "PACKAGES")
set(_state "packages")
elseif (arg STREQUAL "FILES")
set(_state "files")
elseif (arg STREQUAL "SOURCEPATH")
set(_state "sourcepath")
elseif (arg STREQUAL "CLASSPATH")
set(_state "classpath")
elseif (arg STREQUAL "INSTALLPATH")
set(_state "installpath")
elseif (arg STREQUAL "DOCTITLE")
set(_state "doctitle")
elseif (arg STREQUAL "WINDOWTITLE")
set(_state "windowtitle")
elseif (arg STREQUAL "AUTHOR")
set(_state "author")
elseif (arg STREQUAL "USE")
set(_state "use")
elseif (arg STREQUAL "VERSION")
set(_state "version")
else ()
set(_javadoc_packages ${arg})
set(_state "packages")
endif ()
elseif (_state STREQUAL "packages")
if (arg STREQUAL "FILES")
set(_state "files")
elseif (arg STREQUAL "SOURCEPATH")
set(_state "sourcepath")
elseif (arg STREQUAL "CLASSPATH")
set(_state "classpath")
elseif (arg STREQUAL "INSTALLPATH")
set(_state "installpath")
elseif (arg STREQUAL "DOCTITLE")
set(_state "doctitle")
elseif (arg STREQUAL "WINDOWTITLE")
set(_state "windowtitle")
elseif (arg STREQUAL "AUTHOR")
set(_state "author")
elseif (arg STREQUAL "USE")
set(_state "use")
elseif (arg STREQUAL "VERSION")
set(_state "version")
else ()
list(APPEND _javadoc_packages ${arg})
endif ()
elseif (_state STREQUAL "files")
if (arg STREQUAL "PACKAGES")
set(_state "packages")
elseif (arg STREQUAL "SOURCEPATH")
set(_state "sourcepath")
elseif (arg STREQUAL "CLASSPATH")
set(_state "classpath")
elseif (arg STREQUAL "INSTALLPATH")
set(_state "installpath")
elseif (arg STREQUAL "DOCTITLE")
set(_state "doctitle")
elseif (arg STREQUAL "WINDOWTITLE")
set(_state "windowtitle")
elseif (arg STREQUAL "AUTHOR")
set(_state "author")
elseif (arg STREQUAL "USE")
set(_state "use")
elseif (arg STREQUAL "VERSION")
set(_state "version")
else ()
list(APPEND _javadoc_files ${arg})
endif ()
elseif (_state STREQUAL "sourcepath")
if (arg STREQUAL "PACKAGES")
set(_state "packages")
elseif (arg STREQUAL "FILES")
set(_state "files")
elseif (arg STREQUAL "CLASSPATH")
set(_state "classpath")
elseif (arg STREQUAL "INSTALLPATH")
set(_state "installpath")
elseif (arg STREQUAL "DOCTITLE")
set(_state "doctitle")
elseif (arg STREQUAL "WINDOWTITLE")
set(_state "windowtitle")
elseif (arg STREQUAL "AUTHOR")
set(_state "author")
elseif (arg STREQUAL "USE")
set(_state "use")
elseif (arg STREQUAL "VERSION")
set(_state "version")
else ()
list(APPEND _javadoc_sourcepath ${arg})
endif ()
elseif (_state STREQUAL "classpath")
if (arg STREQUAL "PACKAGES")
set(_state "packages")
elseif (arg STREQUAL "FILES")
set(_state "files")
elseif (arg STREQUAL "SOURCEPATH")
set(_state "sourcepath")
elseif (arg STREQUAL "INSTALLPATH")
set(_state "installpath")
elseif (arg STREQUAL "DOCTITLE")
set(_state "doctitle")
elseif (arg STREQUAL "WINDOWTITLE")
set(_state "windowtitle")
elseif (arg STREQUAL "AUTHOR")
set(_state "author")
elseif (arg STREQUAL "USE")
set(_state "use")
elseif (arg STREQUAL "VERSION")
set(_state "version")
else ()
list(APPEND _javadoc_classpath ${arg})
endif ()
elseif (_state STREQUAL "installpath")
if (arg STREQUAL "PACKAGES")
set(_state "packages")
elseif (arg STREQUAL "FILES")
set(_state "files")
elseif (arg STREQUAL "SOURCEPATH")
set(_state "sourcepath")
elseif (arg STREQUAL "DOCTITLE")
set(_state "doctitle")
elseif (arg STREQUAL "WINDOWTITLE")
set(_state "windowtitle")
elseif (arg STREQUAL "AUTHOR")
set(_state "author")
elseif (arg STREQUAL "USE")
set(_state "use")
elseif (arg STREQUAL "VERSION")
set(_state "version")
else ()
set(_javadoc_installpath ${arg})
endif ()
elseif (_state STREQUAL "doctitle")
if (${arg} STREQUAL "PACKAGES")
set(_state "packages")
elseif (arg STREQUAL "FILES")
set(_state "files")
elseif (arg STREQUAL "SOURCEPATH")
set(_state "sourcepath")
elseif (arg STREQUAL "INSTALLPATH")
set(_state "installpath")
elseif (arg STREQUAL "CLASSPATH")
set(_state "classpath")
elseif (arg STREQUAL "WINDOWTITLE")
set(_state "windowtitle")
elseif (arg STREQUAL "AUTHOR")
set(_state "author")
elseif (arg STREQUAL "USE")
set(_state "use")
elseif (arg STREQUAL "VERSION")
set(_state "version")
else ()
set(_javadoc_doctitle ${arg})
endif ()
elseif (_state STREQUAL "windowtitle")
if (${arg} STREQUAL "PACKAGES")
set(_state "packages")
elseif (arg STREQUAL "FILES")
set(_state "files")
elseif (arg STREQUAL "SOURCEPATH")
set(_state "sourcepath")
elseif (arg STREQUAL "CLASSPATH")
set(_state "classpath")
elseif (arg STREQUAL "INSTALLPATH")
set(_state "installpath")
elseif (arg STREQUAL "DOCTITLE")
set(_state "doctitle")
elseif (arg STREQUAL "AUTHOR")
set(_state "author")
elseif (arg STREQUAL "USE")
set(_state "use")
elseif (arg STREQUAL "VERSION")
set(_state "version")
else ()
set(_javadoc_windowtitle ${arg})
endif ()
elseif (_state STREQUAL "author")
if (arg STREQUAL "PACKAGES")
set(_state "packages")
elseif (arg STREQUAL "FILES")
set(_state "files")
elseif (arg STREQUAL "SOURCEPATH")
set(_state "sourcepath")
elseif (arg STREQUAL "CLASSPATH")
set(_state "classpath")
elseif (arg STREQUAL "INSTALLPATH")
set(_state "installpath")
elseif (arg STREQUAL "DOCTITLE")
set(_state "doctitle")
elseif (arg STREQUAL "WINDOWTITLE")
set(_state "windowtitle")
elseif (arg STREQUAL "AUTHOR")
set(_state "author")
elseif (arg STREQUAL "USE")
set(_state "use")
elseif (arg STREQUAL "VERSION")
set(_state "version")
else ()
set(_javadoc_author ${arg})
endif ()
elseif (_state STREQUAL "use")
if (arg STREQUAL "PACKAGES")
set(_state "packages")
elseif (arg STREQUAL "FILES")
set(_state "files")
elseif (arg STREQUAL "SOURCEPATH")
set(_state "sourcepath")
elseif (arg STREQUAL "CLASSPATH")
set(_state "classpath")
elseif (arg STREQUAL "INSTALLPATH")
set(_state "installpath")
elseif (arg STREQUAL "DOCTITLE")
set(_state "doctitle")
elseif (arg STREQUAL "WINDOWTITLE")
set(_state "windowtitle")
elseif (arg STREQUAL "AUTHOR")
set(_state "author")
elseif (arg STREQUAL "USE")
set(_state "use")
elseif (arg STREQUAL "VERSION")
set(_state "version")
else ()
set(_javadoc_use ${arg})
endif ()
elseif (_state STREQUAL "version")
if (arg STREQUAL "PACKAGES")
set(_state "packages")
elseif (arg STREQUAL "FILES")
set(_state "files")
elseif (arg STREQUAL "SOURCEPATH")
set(_state "sourcepath")
elseif (arg STREQUAL "CLASSPATH")
set(_state "classpath")
elseif (arg STREQUAL "INSTALLPATH")
set(_state "installpath")
elseif (arg STREQUAL "DOCTITLE")
set(_state "doctitle")
elseif (arg STREQUAL "WINDOWTITLE")
set(_state "windowtitle")
elseif (arg STREQUAL "AUTHOR")
set(_state "author")
elseif (arg STREQUAL "USE")
set(_state "use")
elseif (arg STREQUAL "VERSION")
set(_state "version")
else ()
set(_javadoc_version ${arg})
endif ()
endif ()
endforeach ()
set(_javadoc_builddir ${CMAKE_CURRENT_BINARY_DIR}/javadoc/${_target})
set(_javadoc_options -d ${_javadoc_builddir})
if (_javadoc_sourcepath)
well, looks like cmake 3.17 is required though
2023-11-01 06:34:31 +08:00
list(JOIN _javadoc_sourcepath "${_UseJava_PATH_SEP}" _javadoc_sourcepath)
list(APPEND _javadoc_options -sourcepath "\"${_javadoc_sourcepath}\"")
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
endif ()
if (_javadoc_classpath)
well, looks like cmake 3.17 is required though
2023-11-01 06:34:31 +08:00
list(JOIN _javadoc_classpath "${_UseJava_PATH_SEP}" _javadoc_classpath)
list(APPEND _javadoc_options -classpath "\"${_javadoc_classpath}\"")
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
endif ()
if (_javadoc_doctitle)
well, looks like cmake 3.17 is required though
2023-11-01 06:34:31 +08:00
list(APPEND _javadoc_options -doctitle '${_javadoc_doctitle}')
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
endif ()
if (_javadoc_windowtitle)
well, looks like cmake 3.17 is required though
2023-11-01 06:34:31 +08:00
list(APPEND _javadoc_options -windowtitle '${_javadoc_windowtitle}')
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
endif ()
if (_javadoc_author)
well, looks like cmake 3.17 is required though
2023-11-01 06:34:31 +08:00
list(APPEND _javadoc_options -author)
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
endif ()
if (_javadoc_use)
well, looks like cmake 3.17 is required though
2023-11-01 06:34:31 +08:00
list(APPEND _javadoc_options -use)
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
endif ()
if (_javadoc_version)
well, looks like cmake 3.17 is required though
2023-11-01 06:34:31 +08:00
list(APPEND _javadoc_options -version)
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
endif ()
add_custom_target(${_target}_javadoc ALL
well, looks like cmake 3.17 is required though
2023-11-01 06:34:31 +08:00
COMMAND ${Java_JAVADOC_EXECUTABLE}
${_javadoc_options}
${_javadoc_files}
${_javadoc_packages}
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
)
install(
DIRECTORY ${_javadoc_builddir}
DESTINATION ${_javadoc_installpath}
)
endfunction()
function (create_javah)
if (Java_VERSION VERSION_GREATER_EQUAL 10)
message (FATAL_ERROR "create_javah: not supported with this Java version. Use add_jar(GENERATE_NATIVE_HEADERS) instead.")
elseif (Java_VERSION VERSION_GREATER_EQUAL 1.8)
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.")
endif()
cmake_parse_arguments(_create_javah
""
"TARGET;GENERATED_FILES;OUTPUT_NAME;OUTPUT_DIR"
"CLASSES;CLASSPATH;DEPENDS"
${ARGN})
# ckeck parameters
if (NOT _create_javah_TARGET AND NOT _create_javah_GENERATED_FILES)
message (FATAL_ERROR "create_javah: TARGET or GENERATED_FILES must be specified.")
endif()
if (_create_javah_OUTPUT_NAME AND _create_javah_OUTPUT_DIR)
message (FATAL_ERROR "create_javah: OUTPUT_NAME and OUTPUT_DIR are mutually exclusive.")
endif()
if (NOT _create_javah_CLASSES)
message (FATAL_ERROR "create_javah: CLASSES is a required parameter.")
endif()
set (_output_files)
# handle javah options
set (_javah_options)
if (_create_javah_CLASSPATH)
# CLASSPATH can specify directories, jar files or targets created with add_jar command
set (_classpath)
foreach (_path IN LISTS _create_javah_CLASSPATH)
if (TARGET ${_path})
get_target_property (_jar_path ${_path} JAR_FILE)
if (_jar_path)
list (APPEND _classpath "${_jar_path}")
list (APPEND _create_javah_DEPENDS "${_path}")
else()
message(SEND_ERROR "create_javah: CLASSPATH target ${_path} is not a jar.")
endif()
elseif (EXISTS "${_path}")
list (APPEND _classpath "${_path}")
if (NOT IS_DIRECTORY "${_path}")
list (APPEND _create_javah_DEPENDS "${_path}")
endif()
else()
message(SEND_ERROR "create_javah: CLASSPATH entry ${_path} does not exist.")
endif()
endforeach()
well, looks like cmake 3.17 is required though
2023-11-01 06:34:31 +08:00
string (REPLACE ";" "${_UseJava_PATH_SEP}" _classpath "${_classpath}")
qt 6.5.1 builds
2023-11-01 06:11:15 +08:00
list (APPEND _javah_options -classpath "${_classpath}")
endif()
if (_create_javah_OUTPUT_DIR)
list (APPEND _javah_options -d "${_create_javah_OUTPUT_DIR}")
endif()
if (_create_javah_OUTPUT_NAME)
list (APPEND _javah_options -o "${_create_javah_OUTPUT_NAME}")
set (_output_files "${_create_javah_OUTPUT_NAME}")
get_filename_component (_create_javah_OUTPUT_DIR "${_create_javah_OUTPUT_NAME}" DIRECTORY)
get_filename_component (_create_javah_OUTPUT_DIR "${_create_javah_OUTPUT_DIR}" ABSOLUTE)
endif()
if (NOT _create_javah_OUTPUT_DIR)
set (_create_javah_OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}")
endif()
if (NOT _create_javah_OUTPUT_NAME)
# compute output names
foreach (_class IN LISTS _create_javah_CLASSES)
string (REPLACE "." "_" _c_header "${_class}")
set (_c_header "${_create_javah_OUTPUT_DIR}/${_c_header}.h")
list (APPEND _output_files "${_c_header}")
endforeach()
endif()
# finalize custom command arguments
if (_create_javah_DEPENDS)
list (INSERT _create_javah_DEPENDS 0 DEPENDS)
endif()
add_custom_command (OUTPUT ${_output_files}
COMMAND "${Java_JAVAH_EXECUTABLE}" ${_javah_options} -jni ${_create_javah_CLASSES}
${_create_javah_DEPENDS}
WORKING_DIRECTORY ${_create_javah_OUTPUT_DIR}
COMMENT "Building C header files from classes...")
if (_create_javah_TARGET)
add_custom_target (${_create_javah_TARGET} ALL DEPENDS ${_output_files})
endif()
if (_create_javah_GENERATED_FILES)
set (${_create_javah_GENERATED_FILES} ${_output_files} PARENT_SCOPE)
endif()
endfunction()
function(export_jars)
# Parse and validate arguments
cmake_parse_arguments(_export_jars
""
"FILE;NAMESPACE"
"TARGETS"
${ARGN}
)
if (NOT _export_jars_FILE)
message(SEND_ERROR "export_jars: FILE must be specified.")
endif()
if (NOT _export_jars_TARGETS)
message(SEND_ERROR "export_jars: TARGETS must be specified.")
endif()
set(_jar_NAMESPACE "${_export_jars_NAMESPACE}")
# Set content of generated exports file
string(REPLACE ";" " " __targets__ "${_export_jars_TARGETS}")
set(__targetdefs__ "")
foreach(_target IN LISTS _export_jars_TARGETS)
get_target_property(_jarpath ${_target} JAR_FILE)
get_filename_component(_jarpath ${_jarpath} PATH)
__java_export_jar(__targetdefs__ ${_target} "${_jarpath}")
endforeach()
# Generate exports file
configure_file(
${_JAVA_EXPORT_TARGETS_SCRIPT}
${_export_jars_FILE}
@ONLY
)
endfunction()
function(install_jar_exports)
# Parse and validate arguments
cmake_parse_arguments(_install_jar_exports
""
"FILE;DESTINATION;COMPONENT;NAMESPACE"
"TARGETS"
${ARGN}
)
if (NOT _install_jar_exports_FILE)
message(SEND_ERROR "install_jar_exports: FILE must be specified.")
endif()
if (NOT _install_jar_exports_DESTINATION)
message(SEND_ERROR "install_jar_exports: DESTINATION must be specified.")
endif()
if (NOT _install_jar_exports_TARGETS)
message(SEND_ERROR "install_jar_exports: TARGETS must be specified.")
endif()
set(_jar_NAMESPACE "${_install_jar_exports_NAMESPACE}")
if (_install_jar_exports_COMPONENT)
set (_COMPONENT COMPONENT ${_install_jar_exports_COMPONENT})
endif()
# Determine relative path from installed export file to install prefix
if(IS_ABSOLUTE "${_install_jar_exports_DESTINATION}")
file(RELATIVE_PATH _relpath
${_install_jar_exports_DESTINATION}
${CMAKE_INSTALL_PREFIX}
)
else()
file(RELATIVE_PATH _relpath
${CMAKE_INSTALL_PREFIX}/${_install_jar_exports_DESTINATION}
${CMAKE_INSTALL_PREFIX}
)
endif()
# Set up unique location for generated exports file
string(SHA256 _hash "${_install_jar_exports_DESTINATION}")
set(_tmpdir ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/JavaExports/${_hash})
# Set content of generated exports file
string(REPLACE ";" " " __targets__ "${_install_jar_exports_TARGETS}")
set(__targetdefs__ "set(_prefix \${CMAKE_CURRENT_LIST_DIR}/${_relpath})\n\n")
foreach(_target IN LISTS _install_jar_exports_TARGETS)
get_target_property(_dir ${_target} INSTALL_DESTINATION)
__java_export_jar(__targetdefs__ ${_target} "\${_prefix}/${_dir}")
endforeach()
__java_lcat(__targetdefs__ "\nunset(_prefix)")
# Generate and install exports file
configure_file(
${_JAVA_EXPORT_TARGETS_SCRIPT}
${_tmpdir}/${_install_jar_exports_FILE}
@ONLY
)
install(FILES ${_tmpdir}/${_install_jar_exports_FILE}
DESTINATION ${_install_jar_exports_DESTINATION}
${_COMPONENT})
endfunction()
Reference in New Issue Copy Permalink