← Back to branch summary

~ubuntu-branches/ubuntu/precise/cmake/precise-updates

« back to all changes in this revision

Viewing changes to Modules/UseJava.cmake

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2011-11-21 23:30:34 UTC
  • mfrom: (1.13.5)
  • Revision ID: package-import@ubuntu.com-20111121233034-r7r79fmmttg5sn7t
Tags: 2.8.6-0ubuntu1
New upstream release

Show diffs side-by-side

added added

removed removed

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