/[gentoo-x86]/eclass/java-utils-2.eclass
Gentoo

Contents of /eclass/java-utils-2.eclass

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.165 - (show annotations) (download)
Sun Jun 28 13:33:48 2015 UTC (3 years ago) by chewi
Branch: MAIN
Changes since 1.164: +7 -14 lines
The -source flag was added in 1.3 or 1.4 (not sure) and we have
special code to handle this but no one in their right mind would build
with 1.2 or 1.3 now. Removing this code allows the ecj-gcj ebuild to
call java-pkg_javac-args without a proper VM present.

1 # Base eclass for Java packages
2 #
3 # Copyright (c) 2004-2005, Thomas Matthijs <axxo@gentoo.org>
4 # Copyright (c) 2004, Karl Trygve Kalleberg <karltk@gentoo.org>
5 # Copyright (c) 2004-2015, Gentoo Foundation
6 #
7 # Licensed under the GNU General Public License, v2
8 #
9 # $Header: /var/cvsroot/gentoo-x86/eclass/java-utils-2.eclass,v 1.164 2015/06/19 14:11:24 chewi Exp $
10
11 # @ECLASS: java-utils-2.eclass
12 # @MAINTAINER:
13 # java@gentoo.org
14 # @AUTHOR:
15 # Thomas Matthijs <axxo@gentoo.org>, Karl Trygve Kalleberg <karltk@gentoo.org>
16 # @BLURB: Base eclass for Java packages
17 # @DESCRIPTION:
18 # This eclass provides functionality which is used by java-pkg-2.eclass,
19 # java-pkg-opt-2.eclass and java-ant-2 eclass, as well as from ebuilds.
20 #
21 # This eclass should not be inherited this directly from an ebuild. Instead,
22 # you should inherit java-pkg-2 for Java packages or java-pkg-opt-2 for packages
23 # that have optional Java support. In addition you can inherit java-ant-2 for
24 # Ant-based packages.
25 inherit eutils versionator multilib
26
27 IUSE="elibc_FreeBSD"
28
29 # Make sure we use java-config-2
30 export WANT_JAVA_CONFIG="2"
31
32 # @VARIABLE: JAVA_PKG_PORTAGE_DEP
33 # @INTERNAL
34 # @DESCRIPTION:
35 # The version of portage we need to function properly. Previously it was
36 # portage with phase hooks support but now we use a version with proper env
37 # saving. For EAPI 2 we have new enough stuff so let's have cleaner deps.
38 has "${EAPI}" 0 1 && JAVA_PKG_PORTAGE_DEP=">=sys-apps/portage-2.1.2.7"
39
40 # @VARIABLE: JAVA_PKG_E_DEPEND
41 # @INTERNAL
42 # @DESCRIPTION:
43 # This is a convience variable to be used from the other java eclasses. This is
44 # the version of java-config we want to use. Usually the latest stable version
45 # so that ebuilds can use new features without depending on specific versions.
46 JAVA_PKG_E_DEPEND=">=dev-java/java-config-2.2.0 ${JAVA_PKG_PORTAGE_DEP}"
47 has source ${JAVA_PKG_IUSE} && JAVA_PKG_E_DEPEND="${JAVA_PKG_E_DEPEND} source? ( app-arch/zip )"
48
49 # @ECLASS-VARIABLE: JAVA_PKG_WANT_BOOTCLASSPATH
50 # @DEFAULT_UNSET
51 # @DESCRIPTION:
52 # The version of bootclasspath the package needs to work. Translates to a proper
53 # dependency. The bootclasspath can then be obtained by java-ant_rewrite-bootclasspath
54 if [[ -n "${JAVA_PKG_WANT_BOOTCLASSPATH}" ]]; then
55 if [[ "${JAVA_PKG_WANT_BOOTCLASSPATH}" == "1.5" ]]; then
56 JAVA_PKG_E_DEPEND="${JAVA_PKG_E_DEPEND} >=dev-java/gnu-classpath-0.98-r1:0.98"
57 else
58 eerror "Unknown value of JAVA_PKG_WANT_BOOTCLASSPATH"
59 # since die in global scope doesn't work, this will make repoman fail
60 JAVA_PKG_E_DEPEND="${JAVA_PKG_E_DEPEND} BAD_JAVA_PKG_WANT_BOOTCLASSPATH"
61 fi
62 fi
63
64 # @ECLASS-VARIABLE: JAVA_PKG_ALLOW_VM_CHANGE
65 # @DESCRIPTION:
66 # Allow this eclass to change the active VM?
67 # If your system VM isn't sufficient for the package, the build will fail
68 # instead of trying to switch to another VM.
69 #
70 # Overriding the default can be useful for testing specific VMs locally, but
71 # should not be used in the final ebuild.
72 JAVA_PKG_ALLOW_VM_CHANGE=${JAVA_PKG_ALLOW_VM_CHANGE:="yes"}
73
74 # @ECLASS-VARIABLE: JAVA_PKG_FORCE_VM
75 # @DEFAULT_UNSET
76 # @DESCRIPTION:
77 # Explicitly set a particular VM to use. If its not valid, it'll fall back to
78 # whatever /etc/java-config-2/build/jdk.conf would elect to use.
79 #
80 # Should only be used for testing and debugging.
81 #
82 # Example: use sun-jdk-1.5 to emerge foo:
83 # @CODE
84 # JAVA_PKG_FORCE_VM=sun-jdk-1.5 emerge foo
85 # @CODE
86
87 # @ECLASS-VARIABLE: JAVA_PKG_WANT_BUILD_VM
88 # @DEFAULT_UNSET
89 # @DESCRIPTION:
90 # A list of VM handles to choose a build VM from. If the list contains the
91 # currently active VM use that one, otherwise step through the list till a
92 # usable/installed VM is found.
93 #
94 # This allows to use an explicit list of JDKs in DEPEND instead of a virtual.
95 # Users of this variable must make sure at least one of the listed handles is
96 # covered by DEPEND.
97 # Requires JAVA_PKG_WANT_SOURCE and JAVA_PKG_WANT_TARGET to be set as well.
98
99 # @ECLASS-VARIABLE: JAVA_PKG_WANT_SOURCE
100 # @DEFAULT_UNSET
101 # @DESCRIPTION:
102 # Specify a non-standard Java source version for compilation (via javac -source
103 # parameter or Ant equivalent via build.xml rewriting done by java-ant-2 eclass).
104 # Normally this is determined from the jdk version specified in DEPEND.
105 # See java-pkg_get-source function below.
106 #
107 # Should generally only be used for testing and debugging.
108 #
109 # Use 1.4 source to emerge baz
110 # @CODE
111 # JAVA_PKG_WANT_SOURCE=1.4 emerge baz
112 # @CODE
113
114 # @ECLASS-VARIABLE: JAVA_PKG_WANT_TARGET
115 # @DEFAULT_UNSET
116 # @DESCRIPTION:
117 # Same as JAVA_PKG_WANT_SOURCE (see above) but for javac -target parameter,
118 # which affects the version of generated bytecode.
119 # Normally this is determined from the jre/jdk version specified in RDEPEND.
120 # See java-pkg_get-target function below.
121 #
122 # Should generallyonly be used for testing and debugging.
123 #
124 # emerge bar to be compatible with 1.3
125 # @CODE
126 # JAVA_PKG_WANT_TARGET=1.3 emerge bar
127 # @CODE
128
129 # @VARIABLE: JAVA_PKG_COMPILER_DIR
130 # @INTERNAL
131 # @DESCRIPTION:
132 # Directory where compiler settings are saved, without trailing slash.
133 # You probably shouldn't touch this variable except local testing.
134 JAVA_PKG_COMPILER_DIR=${JAVA_PKG_COMPILER_DIR:="/usr/share/java-config-2/compiler"}
135
136 # @VARIABLE: JAVA_PKG_COMPILERS_CONF
137 # @INTERNAL
138 # @DESCRIPTION:
139 # Path to file containing information about which compiler to use.
140 # Can be overloaded, but it should be overloaded only for local testing.
141 JAVA_PKG_COMPILERS_CONF=${JAVA_PKG_COMPILERS_CONF:="/etc/java-config-2/build/compilers.conf"}
142
143 # @ECLASS-VARIABLE: JAVA_PKG_FORCE_COMPILER
144 # @INTERNAL
145 # @DEFAULT_UNSET
146 # @DESCRIPTION:
147 # Explicitly set a list of compilers to choose from. This is normally read from
148 # JAVA_PKG_COMPILERS_CONF.
149 #
150 # Useful for local testing.
151 #
152 # Use jikes and javac, in that order
153 # @CODE
154 # JAVA_PKG_FORCE_COMPILER="jikes javac"
155 # @CODE
156
157 # @ECLASS-VARIABLE: JAVA_PKG_FORCE_ANT_TASKS
158 # @DEFAULT_UNSET
159 # @DESCRIPTION:
160 # An $IFS separated list of ant tasks. Can be set in environment before calling
161 # emerge/ebuild to override variables set in ebuild, mainly for testing before
162 # putting the resulting (WANT_)ANT_TASKS into ebuild. Affects only ANT_TASKS in
163 # eant() call, not the dependencies specified in WANT_ANT_TASKS.
164 #
165 # @CODE
166 # JAVA_PKG_FORCE_ANT_TASKS="ant-junit ant-trax" \
167 # ebuild foo.ebuild compile
168 # @CODE
169
170 # TODO document me
171 JAVA_PKG_QA_VIOLATIONS=0
172
173 # @FUNCTION: java-pkg_doexamples
174 # @USAGE: [--subdir <subdir>] <file1/dir1> [<file2> ...]
175 # @DESCRIPTION:
176 # Installs given arguments to /usr/share/doc/${PF}/examples
177 # If you give it only one parameter and it is a directory it will install
178 # everything in that directory to the examples directory.
179 #
180 # @CODE
181 # Parameters:
182 # --subdir - If the examples need a certain directory structure
183 # $* - list of files to install
184 #
185 # Examples:
186 # java-pkg_doexamples demo
187 # java-pkg_doexamples demo/* examples/*
188 # @CODE
189 java-pkg_doexamples() {
190 debug-print-function ${FUNCNAME} $*
191
192 [[ ${#} -lt 1 ]] && die "At least one argument needed"
193
194 java-pkg_check-phase install
195 java-pkg_init_paths_
196
197 local dest=/usr/share/doc/${PF}/examples
198 if [[ ${1} == --subdir ]]; then
199 local dest=${dest}/${2}
200 dodir ${dest}
201 shift 2
202 fi
203
204 if [[ ${#} = 1 && -d ${1} ]]; then
205 ( # dont want to pollute calling env
206 insinto "${dest}"
207 doins -r ${1}/*
208 ) || die "Installing examples failed"
209 else
210 ( # dont want to pollute calling env
211 insinto "${dest}"
212 doins -r "$@"
213 ) || die "Installing examples failed"
214 fi
215
216 # Let's make a symlink to the directory we have everything else under
217 dosym "${dest}" "${JAVA_PKG_SHAREPATH}/examples" || die
218 }
219
220 # @FUNCTION: java-pkg_addres
221 # @USAGE: <jar> <dir> [<find arguments> ...]
222 # @DESCRIPTION:
223 # Adds resource files to an existing jar.
224 # It is important that the directory given is actually the root of the
225 # corresponding resource tree. The target directory as well as
226 # sources.lst, MANIFEST.MF, *.class, *.jar, and *.java files are
227 # automatically excluded. Symlinks are always followed. Additional
228 # arguments are passed through to find.
229 #
230 # @CODE
231 # java-pkg_addres ${PN}.jar resources ! -name "*.html"
232 # @CODE
233 #
234 # @param $1 - jar file
235 # @param $2 - resource tree directory
236 # @param $* - arguments to pass to find
237 java-pkg_addres() {
238 debug-print-function ${FUNCNAME} $*
239
240 [[ ${#} -lt 2 ]] && die "at least two arguments needed"
241
242 local jar=$(realpath "$1" || die "realpath $1 failed")
243 local dir="$2"
244 shift 2
245
246 pushd "${dir}" > /dev/null || die "pushd ${dir} failed"
247 find -L -type f ! -path "./target/*" ! -path "./sources.lst" ! -name "MANIFEST.MF" ! -regex ".*\.\(class\|jar\|java\)" "${@}" -print0 | xargs -0 jar uf "${jar}" || die "jar failed"
248 popd > /dev/null || die "popd failed"
249 }
250
251 # @FUNCTION: java-pkg_dojar
252 # @USAGE: <jar1> [<jar2> ...]
253 # @DESCRIPTION:
254 # Installs any number of jars.
255 # Jar's will be installed into /usr/share/${PN}(-${SLOT})/lib/ by default.
256 # You can use java-pkg_jarinto to change this path.
257 # You should never install a jar with a package version in the filename.
258 # Instead, use java-pkg_newjar defined below.
259 #
260 # @CODE
261 # java-pkg_dojar dist/${PN}.jar dist/${PN}-core.jar
262 # @CODE
263 #
264 # @param $* - list of jars to install
265 java-pkg_dojar() {
266 debug-print-function ${FUNCNAME} $*
267
268 [[ ${#} -lt 1 ]] && die "At least one argument needed"
269
270 java-pkg_check-phase install
271 java-pkg_init_paths_
272
273 # Create JARDEST if it doesn't exist
274 dodir ${JAVA_PKG_JARDEST}
275
276 local jar
277 # for each jar
278 for jar in "${@}"; do
279 local jar_basename=$(basename "${jar}")
280
281 java-pkg_check-versioned-jar ${jar_basename}
282
283 # check if it exists
284 if [[ -e "${jar}" ]] ; then
285 # Don't overwrite if jar has already been installed with the same
286 # name
287 local dest="${D}${JAVA_PKG_JARDEST}/${jar_basename}"
288 if [[ -e "${dest}" ]]; then
289 ewarn "Overwriting ${dest}"
290 fi
291
292 # install it into JARDEST if it's a non-symlink
293 if [[ ! -L "${jar}" ]] ; then
294 #but first check class version when in strict mode.
295 is-java-strict && java-pkg_verify-classes "${jar}"
296
297 INSDESTTREE="${JAVA_PKG_JARDEST}" \
298 doins "${jar}" || die "failed to install ${jar}"
299 java-pkg_append_ JAVA_PKG_CLASSPATH "${JAVA_PKG_JARDEST}/${jar_basename}"
300 debug-print "installed ${jar} to ${D}${JAVA_PKG_JARDEST}"
301 # make a symlink to the original jar if it's symlink
302 else
303 # TODO use dosym, once we find something that could use it
304 # -nichoj
305 ln -s "$(readlink "${jar}")" "${D}${JAVA_PKG_JARDEST}/${jar_basename}"
306 debug-print "${jar} is a symlink, linking accordingly"
307 fi
308 else
309 die "${jar} does not exist"
310 fi
311 done
312
313 java-pkg_do_write_
314 }
315
316 # @FUNCTION: java-pkg_regjar
317 # @USAGE: </path/to/installed/jar>
318 # @DESCRIPTION:
319 # Records an already installed (in ${D}) jar in the package.env
320 # This would mostly be used if the package has make or a custom script to
321 # install things.
322 #
323 # WARNING:
324 # if you want to use shell expansion, you have to use ${D}/... as the for in
325 # this function will not be able to expand the path, here's an example:
326 #
327 # @CODE
328 # java-pkg_regjar ${D}/opt/my-java/lib/*.jar
329 # @CODE
330 #
331
332 # TODO should we be making sure the jar is present on ${D} or wherever?
333 java-pkg_regjar() {
334 debug-print-function ${FUNCNAME} $*
335
336 java-pkg_check-phase install
337
338 [[ ${#} -lt 1 ]] && die "at least one argument needed"
339
340 java-pkg_init_paths_
341
342 local jar jar_dir jar_file
343 for jar in "${@}"; do
344 # TODO use java-pkg_check-versioned-jar
345 if [[ -e "${jar}" || -e "${D}${jar}" ]]; then
346 [[ -d "${jar}" || -d "${D}${jar}" ]] \
347 && die "Called ${FUNCNAME} on a directory $*"
348
349 #check that class version correct when in strict mode
350 is-java-strict && java-pkg_verify-classes "${jar}"
351
352 # nelchael: we should strip ${D} in this case too, here's why:
353 # imagine such call:
354 # java-pkg_regjar ${D}/opt/java/*.jar
355 # such call will fall into this case (-e ${jar}) and will
356 # record paths with ${D} in package.env
357 java-pkg_append_ JAVA_PKG_CLASSPATH "${jar#${D}}"
358 else
359 if [[ ${jar} = *\** ]]; then
360 eerror "The argument ${jar} to ${FUNCNAME}"
361 eerror "has * in it. If you want it to glob in"
362 eerror '${D} add ${D} to the argument.'
363 fi
364 debug-print "${jar} or ${D}${jar} not found"
365 die "${jar} does not exist"
366 fi
367 done
368
369 java-pkg_do_write_
370 }
371
372 # @FUNCTION: java-pkg_newjar
373 # @USAGE: <path/to/oldname.jar> [<newname.jar>]
374 # @DESCRIPTION:
375 # Installs a jar with a new name (defaults to $PN.jar)
376 #
377 # For example, installs a versioned jar without the version
378 java-pkg_newjar() {
379 debug-print-function ${FUNCNAME} $*
380
381 local original_jar="${1}"
382 local new_jar="${2:-${PN}.jar}"
383 local new_jar_dest="${T}/${new_jar}"
384
385 [[ -z ${original_jar} ]] && die "Must specify a jar to install"
386 [[ ! -f ${original_jar} ]] \
387 && die "${original_jar} does not exist or is not a file!"
388
389 rm -f "${new_jar_dest}" || die "Failed to remove ${new_jar_dest}"
390 cp "${original_jar}" "${new_jar_dest}" \
391 || die "Failed to copy ${original_jar} to ${new_jar_dest}"
392 java-pkg_dojar "${new_jar_dest}"
393 }
394
395 # @FUNCTION: java-pkg_addcp
396 # @USAGE: <classpath>
397 # @DESCRIPTION:
398 # Add something to the package's classpath. For jars, you should use dojar,
399 # newjar, or regjar. This is typically used to add directories to the classpath.
400 # The parameters of this function are appended to JAVA_PKG_CLASSPATH
401 java-pkg_addcp() {
402 java-pkg_append_ JAVA_PKG_CLASSPATH "${@}"
403 java-pkg_do_write_
404 }
405
406 # @FUNCTION: java-pkg_doso
407 # @USAGE: <path/to/file1.so> [...]
408 # @DESCRIPTION:
409 # Installs any number of JNI libraries
410 # They will be installed into /usr/lib by default, but java-pkg_sointo
411 # can be used change this path
412 #
413 # @CODE
414 # Example:
415 # java-pkg_doso *.so
416 # @CODE
417 java-pkg_doso() {
418 debug-print-function ${FUNCNAME} $*
419
420 java-pkg_check-phase install
421
422 [[ ${#} -lt 1 ]] && die "${FUNCNAME} requires at least one argument"
423
424 java-pkg_init_paths_
425
426 local lib
427 # for each lib
428 for lib in "$@" ; do
429 # if the lib exists...
430 if [[ -e "${lib}" ]] ; then
431 # install if it isn't a symlink
432 if [[ ! -L "${lib}" ]] ; then
433 INSDESTTREE="${JAVA_PKG_LIBDEST}" \
434 INSOPTIONS="-m0755" \
435 doins "${lib}" || die "failed to install ${lib}"
436 java-pkg_append_ JAVA_PKG_LIBRARY "${JAVA_PKG_LIBDEST}"
437 debug-print "Installing ${lib} to ${JAVA_PKG_LIBDEST}"
438 # otherwise make a symlink to the symlink's origin
439 else
440 dosym "$(readlink "${lib}")" "${JAVA_PKG_LIBDEST}/${lib##*/}"
441 debug-print "${lib} is a symlink, linking accordantly"
442 fi
443 # otherwise die
444 else
445 die "${lib} does not exist"
446 fi
447 done
448
449 java-pkg_do_write_
450 }
451
452 # @FUNCTION: java-pkg_regso
453 # @USAGE: <file1.so> [...]
454 # @DESCRIPTION:
455 # Registers an already installed JNI library in package.env.
456 #
457 # @CODE
458 # Parameters:
459 # $@ - JNI libraries to register
460 #
461 # Example:
462 # java-pkg_regso *.so /path/*.so
463 # @CODE
464 java-pkg_regso() {
465 debug-print-function ${FUNCNAME} $*
466
467 java-pkg_check-phase install
468
469 [[ ${#} -lt 1 ]] && die "${FUNCNAME} requires at least one argument"
470
471 java-pkg_init_paths_
472
473 local lib target_dir
474 for lib in "$@" ; do
475 # Check the absolute path of the lib
476 if [[ -e "${lib}" ]] ; then
477 target_dir="$(java-pkg_expand_dir_ ${lib})"
478 java-pkg_append_ JAVA_PKG_LIBRARY "/${target_dir#${D}}"
479 # Check the path of the lib relative to ${D}
480 elif [[ -e "${D}${lib}" ]]; then
481 target_dir="$(java-pkg_expand_dir_ ${D}${lib})"
482 java-pkg_append_ JAVA_PKG_LIBRARY "${target_dir}"
483 else
484 die "${lib} does not exist"
485 fi
486 done
487
488 java-pkg_do_write_
489 }
490
491 # @FUNCTION: java-pkg_jarinto
492 # @USAGE: </path/to/install/jars/into>
493 # @DESCRIPTION:
494 # Changes the path jars are installed into via subsequent java-pkg_dojar calls.
495 java-pkg_jarinto() {
496 debug-print-function ${FUNCNAME} $*
497
498 JAVA_PKG_JARDEST="${1}"
499 }
500
501 # @FUNCTION: java-pkg_sointo
502 # @USAGE: </path/to/install/sofiles/into>
503 # @DESCRIPTION:
504 # Changes the path that JNI libraries are installed into via subsequent
505 # java-pkg_doso calls.
506 java-pkg_sointo() {
507 debug-print-function ${FUNCNAME} $*
508
509 JAVA_PKG_LIBDEST="${1}"
510 }
511
512 # @FUNCTION: java-pkg_dohtml
513 # @USAGE: <path/to/javadoc/documentation> [...]
514 # @DESCRIPTION:
515 # Install Javadoc HTML documentation. Usage of java-pkg_dojavadoc is preferred.
516 #
517 # @CODE
518 # java-pkg_dohtml dist/docs/
519 # @CODE
520 java-pkg_dohtml() {
521 debug-print-function ${FUNCNAME} $*
522
523 [[ ${#} -lt 1 ]] && die "At least one argument required for ${FUNCNAME}"
524
525 # from /usr/lib/portage/bin/dohtml -h
526 # -f Set list of allowed extensionless file names.
527 dohtml -f package-list "$@"
528
529 # this probably shouldn't be here but it provides
530 # a reasonable way to catch # docs for all of the
531 # old ebuilds.
532 java-pkg_recordjavadoc
533 }
534
535 # @FUNCTION: java-pkg_dojavadoc
536 # @USAGE: [--symlink destination] <path/to/javadocs/root>
537 # @DESCRIPTION:
538 # Installs javadoc documentation. This should be controlled by the doc use flag.
539 #
540 # @CODE
541 # Parameters:
542 # $1: optional --symlink creates to symlink like this for html
543 # documentation bundles.
544 # $2: - The javadoc root directory.
545 #
546 # Examples:
547 # java-pkg_dojavadoc docs/api
548 # java-pkg_dojavadoc --symlink apidocs docs/api
549 # @CODE
550 java-pkg_dojavadoc() {
551 debug-print-function ${FUNCNAME} $*
552
553 # For html documentation bundles that link to Javadoc
554 local symlink
555 if [[ ${1} = --symlink ]]; then
556 symlink=${2}
557 shift 2
558 fi
559
560 local dir="$1"
561 local dest=/usr/share/doc/${PF}/html
562
563 # QA checks
564
565 java-pkg_check-phase install
566 java-pkg_init_paths_
567
568 [[ -z "${dir}" ]] && die "Must specify a directory!"
569 [[ ! -d "${dir}" ]] && die "${dir} does not exist, or isn't a directory!"
570 if [[ ! -e "${dir}/index.html" ]]; then
571 local msg="No index.html in javadoc directory"
572 ewarn "${msg}"
573 is-java-strict && die "${msg}"
574 fi
575
576 if [[ -e ${D}/${dest}/api ]]; then
577 eerror "${dest} already exists. Will not overwrite."
578 die "${dest}"
579 fi
580
581 # Renaming to match our directory layout
582
583 local dir_to_install="${dir}"
584 if [[ "$(basename "${dir}")" != "api" ]]; then
585 dir_to_install="${T}/api"
586 # TODO use doins
587 cp -r "${dir}" "${dir_to_install}" || die "cp failed"
588 fi
589
590 # Actual installation
591
592 java-pkg_dohtml -r "${dir_to_install}"
593
594 # Let's make a symlink to the directory we have everything else under
595 dosym ${dest}/api "${JAVA_PKG_SHAREPATH}/api" || die
596
597 if [[ ${symlink} ]]; then
598 debug-print "symlinking ${dest}/{api,${symlink}}"
599 dosym ${dest}/{api,${symlink}} || die
600 fi
601 }
602
603 # @FUNCTION: java-pkg_dosrc
604 # @USAGE: <path/to/sources> [...]
605 # @DESCRIPTION:
606 # Installs a zip containing the source for a package, so it can used in
607 # from IDEs like eclipse and netbeans.
608 # Ebuild needs to DEPEND on app-arch/zip to use this. It also should be controlled by USE=source.
609 #
610 # @CODE
611 # Example:
612 # java-pkg_dosrc src/*
613 # @CODE
614
615 # TODO change so it the arguments it takes are the base directories containing
616 # source -nichoj
617 #
618 # TODO should we be able to handle multiple calls to dosrc? -nichoj
619 #
620 # TODO maybe we can take an existing zip/jar? -nichoj
621 #
622 # FIXME apparently this fails if you give it an empty directories
623 java-pkg_dosrc() {
624 debug-print-function ${FUNCNAME} $*
625
626 [ ${#} -lt 1 ] && die "At least one argument needed"
627
628 java-pkg_check-phase install
629
630 [[ ${#} -lt 1 ]] && die "At least one argument needed"
631
632 if ! [[ ${DEPEND} = *app-arch/zip* ]]; then
633 local msg="${FUNCNAME} called without app-arch/zip in DEPEND"
634 java-pkg_announce-qa-violation ${msg}
635 fi
636
637 java-pkg_init_paths_
638
639 local zip_name="${PN}-src.zip"
640 local zip_path="${T}/${zip_name}"
641 local dir
642 for dir in "${@}"; do
643 local dir_parent=$(dirname "${dir}")
644 local dir_name=$(basename "${dir}")
645 pushd ${dir_parent} > /dev/null || die "problem entering ${dir_parent}"
646 zip -q -r ${zip_path} ${dir_name} -i '*.java'
647 local result=$?
648 # 12 means zip has nothing to do
649 if [[ ${result} != 12 && ${result} != 0 ]]; then
650 die "failed to zip ${dir_name}"
651 fi
652 popd >/dev/null
653 done
654
655 # Install the zip
656 INSDESTTREE=${JAVA_PKG_SOURCESPATH} \
657 doins ${zip_path} || die "Failed to install source"
658
659 JAVA_SOURCES="${JAVA_PKG_SOURCESPATH}/${zip_name}"
660 java-pkg_do_write_
661 }
662
663 # @FUNCTION: java-pkg_dolauncher
664 # @USAGE: <filename> [options]
665 # @DESCRIPTION:
666 # Make a wrapper script to lauch/start this package
667 # If necessary, the wrapper will switch to the appropriate VM.
668 #
669 # Can be called without parameters if the package installs only one jar
670 # that has the Main-class attribute set. The wrapper will be named ${PN}.
671 #
672 # @CODE
673 # Parameters:
674 # $1 - filename of launcher to create
675 # $2 - options, as follows:
676 # --main the.main.class.to.start
677 # --jar /the/jar/too/launch.jar or just <name>.jar
678 # --java_args 'Extra arguments to pass to java'
679 # --pkg_args 'Extra arguments to pass to the package'
680 # --pwd Directory the launcher changes to before executing java
681 # -into Directory to install the launcher to, instead of /usr/bin
682 # -pre Prepend contents of this file to the launcher
683 # @CODE
684 java-pkg_dolauncher() {
685 debug-print-function ${FUNCNAME} $*
686
687 java-pkg_check-phase install
688 java-pkg_init_paths_
689
690 if [[ ${#} = 0 ]]; then
691 local name="${PN}"
692 else
693 local name="${1}"
694 shift
695 fi
696
697 # TODO rename to launcher
698 local target="${T}/${name}"
699 local var_tmp="${T}/launcher_variables_tmp"
700 local target_dir pre
701
702 # Process the other the rest of the arguments
703 while [[ -n "${1}" && -n "${2}" ]]; do
704 local var="${1}" value="${2}"
705 if [[ "${var:0:2}" == "--" ]]; then
706 local var=${var:2}
707 echo "gjl_${var}=\"${value}\"" >> "${var_tmp}"
708 local gjl_${var}="${value}"
709 elif [[ "${var}" == "-into" ]]; then
710 target_dir="${value}"
711 elif [[ "${var}" == "-pre" ]]; then
712 pre="${value}"
713 fi
714 shift 2
715 done
716
717 # Test if no --jar and --main arguments were given and
718 # in that case check if the package only installs one jar
719 # and use that jar.
720 if [[ -z "${gjl_jar}" && -z "${gjl_main}" ]]; then
721 local cp="${JAVA_PKG_CLASSPATH}"
722 if [[ "${cp/:}" = "${cp}" && "${cp%.jar}" != "${cp}" ]]; then
723 echo "gjl_jar=\"${JAVA_PKG_CLASSPATH}\"" >> "${var_tmp}"
724 else
725 local msg="Not enough information to create a launcher given."
726 msg="${msg} Please give --jar or --main argument to ${FUNCNAME}."
727 die "${msg}"
728 fi
729 fi
730
731 # Write the actual script
732 echo "#!/bin/bash" > "${target}"
733 if [[ -n "${pre}" ]]; then
734 if [[ -f "${pre}" ]]; then
735 cat "${pre}" >> "${target}"
736 else
737 die "-pre specified file '${pre}' does not exist"
738 fi
739 fi
740 echo "gjl_package=${JAVA_PKG_NAME}" >> "${target}"
741 cat "${var_tmp}" >> "${target}"
742 rm -f "${var_tmp}"
743 echo "source /usr/share/java-config-2/launcher/launcher.bash" >> "${target}"
744
745 if [[ -n "${target_dir}" ]]; then
746 DESTTREE="${target_dir}" dobin "${target}"
747 local ret=$?
748 return ${ret}
749 else
750 dobin "${target}"
751 fi
752 }
753
754 # @FUNCTION: java-pkg_dowar
755 # @DESCRIPTION:
756 # Install war files.
757 # TODO document
758 java-pkg_dowar() {
759 debug-print-function ${FUNCNAME} $*
760
761 # Check for arguments
762 [[ ${#} -lt 1 ]] && die "At least one argument needed"
763 java-pkg_check-phase install
764
765 java-pkg_init_paths_
766
767 local war
768 for war in $* ; do
769 local warpath
770 # TODO evaluate if we want to handle symlinks differently -nichoj
771 # Check for symlink
772 if [[ -L "${war}" ]] ; then
773 cp "${war}" "${T}"
774 warpath="${T}$(basename "${war}")"
775 # Check for directory
776 # TODO evaluate if we want to handle directories differently -nichoj
777 elif [[ -d "${war}" ]] ; then
778 echo "dowar: warning, skipping directory ${war}"
779 continue
780 else
781 warpath="${war}"
782 fi
783
784 # Install those files like you mean it
785 INSOPTIONS="-m 0644" \
786 INSDESTTREE=${JAVA_PKG_WARDEST} \
787 doins ${warpath}
788 done
789 }
790
791 # @FUNCTION: java-pkg_recordjavadoc
792 # @INTERNAL
793 # @DESCRIPTION:
794 # Scan for JavaDocs, and record their existence in the package.env file
795
796 # TODO make sure this in the proper section
797 java-pkg_recordjavadoc()
798 {
799 debug-print-function ${FUNCNAME} $*
800 # the find statement is important
801 # as some packages include multiple trees of javadoc
802 JAVADOC_PATH="$(find ${D}/usr/share/doc/ -name allclasses-frame.html -printf '%h:')"
803 # remove $D - TODO: check this is ok with all cases of the above
804 JAVADOC_PATH="${JAVADOC_PATH//${D}}"
805 if [[ -n "${JAVADOC_PATH}" ]] ; then
806 debug-print "javadocs found in ${JAVADOC_PATH%:}"
807 java-pkg_do_write_
808 else
809 debug-print "No javadocs found"
810 fi
811 }
812
813
814 # @FUNCTION: java-pkg_jar-from
815 # @USAGE: [--build-only] [--with-dependencies] [--virtual] [--into dir] <package> [<package.jar>] [<destination.jar>]
816 # @DESCRIPTION:
817 # Makes a symlink to a jar from a certain package
818 # A lot of java packages include dependencies in a lib/ directory
819 # You can use this function to replace these bundled dependencies.
820 # The dependency is recorded into package.env DEPEND line, unless "--build-only"
821 # is passed as the very first argument, for jars that have to be present only
822 # at build time and are not needed on runtime (junit testing etc).
823 #
824 # @CODE
825 # Example: get all jars from xerces slot 2
826 # java-pkg_jar-from xerces-2
827 #
828 # Example: get a specific jar from xerces slot 2
829 # java-pkg_jar-from xerces-2 xml-apis.jar
830 #
831 # Example: get a specific jar from xerces slot 2, and name it diffrently
832 # java-pkg_jar-from xerces-2 xml-apis.jar xml.jar
833 #
834 # Example: get junit.jar which is needed only for building
835 # java-pkg_jar-from --build-only junit junit.jar
836 # @CODE
837 #
838 # @CODE
839 # Parameters
840 # --build-only - makes the jar(s) not added into package.env DEPEND line.
841 # (assumed automatically when called inside src_test)
842 # --with-dependencies - get jars also from requested package's dependencies
843 # transitively.
844 # --virtual - Packages passed to this function are to be handled as virtuals
845 # and will not have individual jar dependencies recorded.
846 # --into $dir - symlink jar(s) into $dir (must exist) instead of .
847 # $1 - Package to get jars from, or comma-separated list of packages in
848 # case other parameters are not used.
849 # $2 - jar from package. If not specified, all jars will be used.
850 # $3 - When a single jar is specified, destination filename of the
851 # symlink. Defaults to the name of the jar.
852 # @CODE
853
854 # TODO could probably be cleaned up a little
855 java-pkg_jar-from() {
856 debug-print-function ${FUNCNAME} $*
857
858 local build_only=""
859 local destdir="."
860 local deep=""
861 local virtual=""
862 local record_jar=""
863
864 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="build"
865
866 while [[ "${1}" == --* ]]; do
867 if [[ "${1}" = "--build-only" ]]; then
868 build_only="build"
869 elif [[ "${1}" = "--with-dependencies" ]]; then
870 deep="--with-dependencies"
871 elif [[ "${1}" = "--virtual" ]]; then
872 virtual="true"
873 elif [[ "${1}" = "--into" ]]; then
874 destdir="${2}"
875 shift
876 else
877 die "java-pkg_jar-from called with unknown parameter: ${1}"
878 fi
879 shift
880 done
881
882 local target_pkg="${1}" target_jar="${2}" destjar="${3}"
883
884 [[ -z ${target_pkg} ]] && die "Must specify a package"
885
886 if [[ "${EAPI}" == "1" ]]; then
887 target_pkg="${target_pkg//:/-}"
888 fi
889
890 # default destjar to the target jar
891 [[ -z "${destjar}" ]] && destjar="${target_jar}"
892
893 local error_msg="There was a problem getting the classpath for ${target_pkg}."
894 local classpath
895 classpath="$(java-config ${deep} --classpath=${target_pkg})"
896 [[ $? != 0 ]] && die ${error_msg}
897
898 # When we have commas this functions is called to bring jars from multiple
899 # packages. This affects recording of dependencencies performed later
900 # which expects one package only, so we do it here.
901 if [[ ${target_pkg} = *,* ]]; then
902 for pkg in ${target_pkg//,/ }; do
903 java-pkg_ensure-dep "${build_only}" "${pkg}"
904 [[ -z "${build_only}" ]] && java-pkg_record-jar_ "${pkg}"
905 done
906 # setting this disables further record-jar_ calls later
907 record_jar="true"
908 else
909 java-pkg_ensure-dep "${build_only}" "${target_pkg}"
910 fi
911
912 # Record the entire virtual as a dependency so that
913 # no jars are missed.
914 if [[ -z "${build_only}" && -n "${virtual}" ]]; then
915 java-pkg_record-jar_ "${target_pkg}"
916 # setting this disables further record-jars_ calls later
917 record_jar="true"
918 fi
919
920 pushd ${destdir} > /dev/null \
921 || die "failed to change directory to ${destdir}"
922
923 local jar
924 for jar in ${classpath//:/ }; do
925 local jar_name=$(basename "${jar}")
926 if [[ ! -f "${jar}" ]] ; then
927 debug-print "${jar} from ${target_pkg} does not exist"
928 die "Installation problems with jars in ${target_pkg} - is it installed?"
929 fi
930 # If no specific target jar was indicated, link it
931 if [[ -z "${target_jar}" ]] ; then
932 [[ -f "${target_jar}" ]] && rm "${target_jar}"
933 ln -snf "${jar}" \
934 || die "Failed to make symlink from ${jar} to ${jar_name}"
935 if [[ -z "${record_jar}" ]]; then
936 if [[ -z "${build_only}" ]]; then
937 java-pkg_record-jar_ "${target_pkg}" "${jar}"
938 else
939 java-pkg_record-jar_ --build-only "${target_pkg}" "${jar}"
940 fi
941 fi
942 # otherwise, if the current jar is the target jar, link it
943 elif [[ "${jar_name}" == "${target_jar}" ]] ; then
944 [[ -f "${destjar}" ]] && rm "${destjar}"
945 ln -snf "${jar}" "${destjar}" \
946 || die "Failed to make symlink from ${jar} to ${destjar}"
947 if [[ -z "${record_jar}" ]]; then
948 if [[ -z "${build_only}" ]]; then
949 java-pkg_record-jar_ "${target_pkg}" "${jar}"
950 else
951 java-pkg_record-jar_ --build-only "${target_pkg}" "${jar}"
952 fi
953 fi
954 popd > /dev/null
955 return 0
956 fi
957 done
958 popd > /dev/null
959 # if no target was specified, we're ok
960 if [[ -z "${target_jar}" ]] ; then
961 return 0
962 # otherwise, die bitterly
963 else
964 die "Failed to find ${target_jar:-jar} in ${target_pkg}"
965 fi
966 }
967
968 # @FUNCTION: java-pkg_jarfrom
969 # @DESCRIPTION:
970 # See java-pkg_jar-from
971 java-pkg_jarfrom() {
972 java-pkg_jar-from "$@"
973 }
974
975 # @FUNCTION: java-pkg_getjars
976 # @USAGE: [--build-only] [--with-dependencies] <package1>[,<package2>...]
977 # @DESCRIPTION:
978 # Get the classpath provided by any number of packages
979 # Among other things, this can be passed to 'javac -classpath' or 'ant -lib'.
980 # The providing packages are recorded as dependencies into package.env DEPEND
981 # line, unless "--build-only" is passed as the very first argument, for jars
982 # that have to be present only at build time and are not needed on runtime
983 # (junit testing etc).
984 #
985 # @CODE
986 # Example: Get the classpath for xerces-2 and xalan,
987 # java-pkg_getjars xerces-2,xalan
988 #
989 # Example Return:
990 # /usr/share/xerces-2/lib/xml-apis.jar:/usr/share/xerces-2/lib/xmlParserAPIs.jar:/usr/share/xalan/lib/xalan.jar
991 #
992 #
993 # Parameters:
994 # --build-only - makes the jar(s) not added into package.env DEPEND line.
995 # (assumed automatically when called inside src_test)
996 # --with-dependencies - get jars also from requested package's dependencies
997 # transitively.
998 # $1 - list of packages to get jars from
999 # (passed to java-config --classpath)
1000 # @CODE
1001 java-pkg_getjars() {
1002 debug-print-function ${FUNCNAME} $*
1003
1004 local build_only=""
1005 local deep=""
1006
1007 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="build"
1008
1009 while [[ "${1}" == --* ]]; do
1010 if [[ "${1}" = "--build-only" ]]; then
1011 build_only="build"
1012 elif [[ "${1}" = "--with-dependencies" ]]; then
1013 deep="--with-dependencies"
1014 else
1015 die "java-pkg_jar-from called with unknown parameter: ${1}"
1016 fi
1017 shift
1018 done
1019
1020 [[ ${#} -ne 1 ]] && die "${FUNCNAME} takes only one argument besides --*"
1021
1022
1023 local pkgs="${1}"
1024
1025 if [[ "${EAPI}" == "1" ]]; then
1026 pkgs="${pkgs//:/-}"
1027 fi
1028
1029 jars="$(java-config ${deep} --classpath=${pkgs})"
1030 [[ $? != 0 ]] && die "java-config --classpath=${pkgs} failed"
1031 debug-print "${pkgs}:${jars}"
1032
1033 for pkg in ${pkgs//,/ }; do
1034 java-pkg_ensure-dep "${build_only}" "${pkg}"
1035 done
1036
1037 for pkg in ${pkgs//,/ }; do
1038 if [[ -z "${build_only}" ]]; then
1039 java-pkg_record-jar_ "${pkg}"
1040 else
1041 java-pkg_record-jar_ --build-only "${pkg}"
1042 fi
1043 done
1044
1045 echo "${jars}"
1046 }
1047
1048 # @FUNCTION: java-pkg_getjar
1049 # @USAGE: [--build-only] [--virtual] <package> <jarfile>
1050 # @DESCRIPTION:
1051 # Get the complete path of a single jar from a package
1052 # The providing package is recorded as runtime dependency into package.env
1053 # DEPEND line, unless "--build-only" is passed as the very first argument, for
1054 # jars that have to be present only at build time and are not needed on runtime
1055 # (junit testing etc).
1056 #
1057 # @CODE
1058 # Example:
1059 # java-pkg_getjar xerces-2 xml-apis.jar
1060 # returns
1061 # /usr/share/xerces-2/lib/xml-apis.jar
1062 #
1063 # Parameters:
1064 # --build-only - makes the jar not added into package.env DEPEND line.
1065 # --virtual - Packages passed to this function are to be handled as virtuals
1066 # and will not have individual jar dependencies recorded.
1067 # $1 - package to use
1068 # $2 - jar to get
1069 # @CODE
1070 java-pkg_getjar() {
1071 debug-print-function ${FUNCNAME} $*
1072
1073 local build_only=""
1074 local virtual=""
1075 local record_jar=""
1076
1077 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="build"
1078
1079 while [[ "${1}" == --* ]]; do
1080 if [[ "${1}" = "--build-only" ]]; then
1081 build_only="build"
1082 elif [[ "${1}" == "--virtual" ]]; then
1083 virtual="true"
1084 else
1085 die "java-pkg_getjar called with unknown parameter: ${1}"
1086 fi
1087 shift
1088 done
1089
1090 [[ ${#} -ne 2 ]] && die "${FUNCNAME} takes only two arguments besides --*"
1091
1092 local pkg="${1}" target_jar="${2}" jar
1093
1094 if [[ "${EAPI}" == "1" ]]; then
1095 pkg="${pkg//:/-}"
1096 fi
1097
1098 [[ -z ${pkg} ]] && die "Must specify package to get a jar from"
1099 [[ -z ${target_jar} ]] && die "Must specify jar to get"
1100
1101 local error_msg="Could not find classpath for ${pkg}. Are you sure its installed?"
1102 local classpath
1103 classpath=$(java-config --classpath=${pkg})
1104 [[ $? != 0 ]] && die ${error_msg}
1105
1106 java-pkg_ensure-dep "${build_only}" "${pkg}"
1107
1108 # Record the package(Virtual) as a dependency and then set build_only
1109 # So that individual jars are not recorded.
1110 if [[ -n "${virtual}" ]]; then
1111 if [[ -z "${build_only}" ]]; then
1112 java-pkg_record-jar_ "${pkg}"
1113 else
1114 java-pkg_record-jar_ --build-only "${pkg}"
1115 fi
1116 record_jar="true"
1117 fi
1118
1119 for jar in ${classpath//:/ }; do
1120 if [[ ! -f "${jar}" ]] ; then
1121 die "Installation problem with jar ${jar} in ${pkg} - is it installed?"
1122 fi
1123
1124 if [[ "$(basename ${jar})" == "${target_jar}" ]] ; then
1125 # Only record jars that aren't build-only
1126 if [[ -z "${record_jar}" ]]; then
1127 if [[ -z "${build_only}" ]]; then
1128 java-pkg_record-jar_ "${pkg}" "${jar}"
1129 else
1130 java-pkg_record-jar_ --build-only "${pkg}" "${jar}"
1131 fi
1132 fi
1133 echo "${jar}"
1134 return 0
1135 fi
1136 done
1137
1138 die "Could not find ${target_jar} in ${pkg}"
1139 return 1
1140 }
1141
1142 # @FUNCTION: java-pkg_register-dependency
1143 # @USAGE: <package>[,<package2>...] [<jarfile>]
1144 # @DESCRIPTION:
1145 # Registers runtime dependency on a package, list of packages, or a single jar
1146 # from a package, into package.env DEPEND line. Can only be called in
1147 # src_install phase.
1148 # Intended for binary packages where you don't need to symlink the jars or get
1149 # their classpath during build. As such, the dependencies only need to be
1150 # specified in ebuild's RDEPEND, and should be omitted in DEPEND.
1151 #
1152 # @CODE
1153 # Parameters:
1154 # $1 - comma-separated list of packages, or a single package
1155 # $2 - if param $1 is a single package, optionally specify the jar
1156 # to depend on
1157 #
1158 # Examples:
1159 # Record the dependency on whole xerces-2 and xalan,
1160 # java-pkg_register-dependency xerces-2,xalan
1161 #
1162 # Record the dependency on ant.jar from ant-core
1163 # java-pkg_register-dependency ant-core ant.jar
1164 # @CODE
1165 #
1166 # Note: Passing both list of packages as the first parameter AND specifying the
1167 # jar as the second is not allowed and will cause the function to die. We assume
1168 # that there's more chance one passes such combination as a mistake, than that
1169 # there are more packages providing identically named jar without class
1170 # collisions.
1171 java-pkg_register-dependency() {
1172 debug-print-function ${FUNCNAME} $*
1173
1174 java-pkg_check-phase install
1175
1176 [[ ${#} -gt 2 ]] && die "${FUNCNAME} takes at most two arguments"
1177
1178 local pkgs="${1}"
1179 local jar="${2}"
1180
1181 [[ -z "${pkgs}" ]] && die "${FUNCNAME} called with no package(s) specified"
1182
1183 if [[ "${EAPI}" == "1" ]]; then
1184 pkgs="${pkgs//:/-}"
1185 fi
1186
1187 if [[ -z "${jar}" ]]; then
1188 for pkg in ${pkgs//,/ }; do
1189 java-pkg_ensure-dep runtime "${pkg}"
1190 java-pkg_record-jar_ "${pkg}"
1191 done
1192 else
1193 [[ ${pkgs} == *,* ]] && \
1194 die "${FUNCNAME} called with both package list and jar name"
1195 java-pkg_ensure-dep runtime "${pkgs}"
1196 java-pkg_record-jar_ "${pkgs}" "${jar}"
1197 fi
1198
1199 java-pkg_do_write_
1200 }
1201
1202 # @FUNCTION: java-pkg_register-optional-dependency
1203 # @USAGE: <package>[,<package2>...] [<jarfile>]
1204 # @DESCRIPTION:
1205 # Registers optional runtime dependency on a package, list of packages, or a
1206 # single jar from a package, into package.env OPTIONAL_DEPEND line. Can only be
1207 # called in src_install phase.
1208 # Intended for packages that can use other packages when those are in classpath.
1209 # Will be put on classpath by launcher if they are installed. Typical case is
1210 # JDBC implementations for various databases. It's better than having USE flag
1211 # for each implementation triggering hard dependency.
1212 #
1213 # @CODE
1214 # Parameters:
1215 # $1 - comma-separated list of packages, or a single package
1216 # $2 - if param $1 is a single package, optionally specify the jar to depend on
1217 #
1218 # Example:
1219 # Record the optional dependency on some jdbc providers
1220 # java-pkg_register-optional-dependency jdbc-jaybird,jtds-1.2,jdbc-mysql
1221 # @CODE
1222 #
1223 # Note: Passing both list of packages as the first parameter AND specifying the
1224 # jar as the second is not allowed and will cause the function to die. We assume
1225 # that there's more chance one passes such combination as a mistake, than that
1226 # there are more packages providing identically named jar without class
1227 # collisions.
1228 java-pkg_register-optional-dependency() {
1229 debug-print-function ${FUNCNAME} $*
1230
1231 java-pkg_check-phase install
1232
1233 [[ ${#} -gt 2 ]] && die "${FUNCNAME} takes at most two arguments"
1234
1235 local pkgs="${1}"
1236 local jar="${2}"
1237
1238 [[ -z "${pkgs}" ]] && die "${FUNCNAME} called with no package(s) specified"
1239
1240 if [[ "${EAPI}" == "1" ]]; then
1241 pkgs="${pkgs//:/-}"
1242 fi
1243
1244 if [[ -z "${jar}" ]]; then
1245 for pkg in ${pkgs//,/ }; do
1246 java-pkg_record-jar_ --optional "${pkg}"
1247 done
1248 else
1249 [[ ${pkgs} == *,* ]] && \
1250 die "${FUNCNAME} called with both package list and jar name"
1251 java-pkg_record-jar_ --optional "${pkgs}" "${jar}"
1252 fi
1253
1254 java-pkg_do_write_
1255 }
1256
1257 # @FUNCTION: java-pkg_register-environment-variable
1258 # @USAGE: <name> <value>
1259 # @DESCRIPTION:
1260 # Register an arbitrary environment variable into package.env. The gjl launcher
1261 # for this package or any package depending on this will export it into
1262 # environement before executing java command.
1263 # Must only be called in src_install phase.
1264 JAVA_PKG_EXTRA_ENV="${T}/java-pkg-extra-env"
1265 JAVA_PKG_EXTRA_ENV_VARS=""
1266 java-pkg_register-environment-variable() {
1267 debug-print-function ${FUNCNAME} $*
1268
1269 java-pkg_check-phase install
1270
1271 [[ ${#} != 2 ]] && die "${FUNCNAME} takes two arguments"
1272
1273 echo "${1}=\"${2}\"" >> ${JAVA_PKG_EXTRA_ENV}
1274 JAVA_PKG_EXTRA_ENV_VARS="${JAVA_PKG_EXTRA_ENV_VARS} ${1}"
1275
1276 java-pkg_do_write_
1277 }
1278
1279 # @FUNCTION: java-pkg_get-bootclasspath
1280 # @USAGE: <version>
1281 # @DESCRIPTION:
1282 # Returns classpath of a given bootclasspath-providing package version.
1283 #
1284 # @param $1 - the version of bootclasspath (e.g. 1.5), 'auto' for bootclasspath
1285 # of the current JDK
1286 java-pkg_get-bootclasspath() {
1287 local version="${1}"
1288
1289 local bcp
1290 case "${version}" in
1291 auto)
1292 bcp="$(java-config -g BOOTCLASSPATH)"
1293 ;;
1294 1.5)
1295 bcp="$(java-pkg_getjars --build-only gnu-classpath-0.98)"
1296 ;;
1297 *)
1298 eerror "unknown parameter of java-pkg_get-bootclasspath"
1299 die "unknown parameter of java-pkg_get-bootclasspath"
1300 ;;
1301 esac
1302
1303 echo "${bcp}"
1304 }
1305
1306
1307 # This function reads stdin, and based on that input, figures out how to
1308 # populate jars from the filesystem.
1309 # Need to figure out a good way of making use of this, ie be able to use a
1310 # string that was built instead of stdin
1311 # NOTE: this isn't quite ready for primetime.
1312 #java-pkg_populate-jars() {
1313 # local line
1314 #
1315 # read line
1316 # while [[ -n "${line}" ]]; do
1317 # # Ignore comments
1318 # [[ ${line%%#*} == "" ]] && continue
1319 #
1320 # # get rid of any spaces
1321 # line="${line// /}"
1322 #
1323 # # format: path=jarinfo
1324 # local path=${line%%=*}
1325 # local jarinfo=${line##*=}
1326 #
1327 # # format: jar@package
1328 # local jar=${jarinfo%%@*}.jar
1329 # local package=${jarinfo##*@}
1330 # if [[ -n ${replace_only} ]]; then
1331 # [[ ! -f $path ]] && die "No jar exists at ${path}"
1332 # fi
1333 # if [[ -n ${create_parent} ]]; then
1334 # local parent=$(dirname ${path})
1335 # mkdir -p "${parent}"
1336 # fi
1337 # java-pkg_jar-from "${package}" "${jar}" "${path}"
1338 #
1339 # read line
1340 # done
1341 #}
1342
1343 # @FUNCTION: java-pkg_find-normal-jars
1344 # @USAGE: [<path/to/directory>]
1345 # @DESCRIPTION:
1346 # Find the files with suffix .jar file in the given directory (default: $WORKDIR)
1347 java-pkg_find-normal-jars() {
1348 local dir=$1
1349 [[ "${dir}" ]] || dir="${WORKDIR}"
1350 local found
1351 for jar in $(find "${dir}" -name "*.jar" -type f); do
1352 echo "${jar}"
1353 found="true"
1354 done
1355 [[ "${found}" ]]
1356 return $?
1357 }
1358
1359 # @FUNCTION: java-pkg_ensure-no-bundled-jars
1360 # @DESCRIPTION:
1361 # Try to locate bundled jar files in ${WORKDIR} and die if found.
1362 # This function should be called after WORKDIR has been populated with symlink
1363 # to system jar files or bundled jars removed.
1364 java-pkg_ensure-no-bundled-jars() {
1365 debug-print-function ${FUNCNAME} $*
1366
1367 local bundled_jars=$(java-pkg_find-normal-jars)
1368 if [[ -n ${bundled_jars} ]]; then
1369 echo "Bundled jars found:"
1370 local jar
1371 for jar in ${bundled_jars}; do
1372 echo $(pwd)${jar/./}
1373 done
1374 die "Bundled jars found!"
1375 fi
1376 }
1377
1378 # @FUNCTION: java-pkg_ensure-vm-version-sufficient
1379 # @INTERNAL
1380 # @DESCRIPTION:
1381 # Checks if we have a sufficient VM and dies if we don't.
1382 java-pkg_ensure-vm-version-sufficient() {
1383 debug-print-function ${FUNCNAME} $*
1384
1385 if ! java-pkg_is-vm-version-sufficient; then
1386 debug-print "VM is not suffient"
1387 eerror "Current Java VM cannot build this package"
1388 einfo "Please use java-config -S to set the correct one"
1389 die "Active Java VM cannot build this package"
1390 fi
1391 }
1392
1393 # @FUNCTION: java-pkg_is-vm-version-sufficient
1394 # @INTERNAL
1395 # @DESCRIPTION:
1396 # @RETURN: zero - VM is sufficient; non-zero - VM is not sufficient
1397 java-pkg_is-vm-version-sufficient() {
1398 debug-print-function ${FUNCNAME} $*
1399
1400 depend-java-query --is-sufficient "${DEPEND}" > /dev/null
1401 return $?
1402 }
1403
1404 # @FUNCTION: java-pkg_ensure-vm-version-eq
1405 # @INTERNAL
1406 # @DESCRIPTION:
1407 # Die if the current VM is not equal to the argument passed.
1408 #
1409 # @param $@ - Desired VM version to ensure
1410 java-pkg_ensure-vm-version-eq() {
1411 debug-print-function ${FUNCNAME} $*
1412
1413 if ! java-pkg_is-vm-version-eq $@ ; then
1414 debug-print "VM is not suffient"
1415 eerror "This package requires a Java VM version = $@"
1416 einfo "Please use java-config -S to set the correct one"
1417 die "Active Java VM too old"
1418 fi
1419 }
1420
1421 # @FUNCTION: java-pkg_is-vm-version-eq
1422 # @USAGE: <version>
1423 # @INTERNAL
1424 # @RETURN: zero - VM versions are equal; non-zero - VM version are not equal
1425 java-pkg_is-vm-version-eq() {
1426 debug-print-function ${FUNCNAME} $*
1427
1428 local needed_version="$@"
1429
1430 [[ -z "${needed_version}" ]] && die "need an argument"
1431
1432 local vm_version="$(java-pkg_get-vm-version)"
1433
1434 vm_version="$(get_version_component_range 1-2 "${vm_version}")"
1435 needed_version="$(get_version_component_range 1-2 "${needed_version}")"
1436
1437 if [[ -z "${vm_version}" ]]; then
1438 debug-print "Could not get JDK version from DEPEND"
1439 return 1
1440 else
1441 if [[ "${vm_version}" == "${needed_version}" ]]; then
1442 debug-print "Detected a JDK(${vm_version}) = ${needed_version}"
1443 return 0
1444 else
1445 debug-print "Detected a JDK(${vm_version}) != ${needed_version}"
1446 return 1
1447 fi
1448 fi
1449 }
1450
1451 # @FUNCTION: java-pkg_ensure-vm-version-ge
1452 # @INTERNAL
1453 # @DESCRIPTION:
1454 # Die if the current VM is not greater than the desired version
1455 #
1456 # @param $@ - VM version to compare current to
1457 java-pkg_ensure-vm-version-ge() {
1458 debug-print-function ${FUNCNAME} $*
1459
1460 if ! java-pkg_is-vm-version-ge "$@" ; then
1461 debug-print "vm is not suffient"
1462 eerror "This package requires a Java VM version >= $@"
1463 einfo "Please use java-config -S to set the correct one"
1464 die "Active Java VM too old"
1465 fi
1466 }
1467
1468 # @FUNCTION: java-pkg_is-vm-version-ge
1469 # @INTERNAL
1470 # @DESCRIPTION:
1471 # @CODE
1472 # Parameters:
1473 # $@ - VM version to compare current VM to
1474 # @CODE
1475 # @RETURN: zero - current VM version is greater than checked version;
1476 # non-zero - current VM version is not greater than checked version
1477 java-pkg_is-vm-version-ge() {
1478 debug-print-function ${FUNCNAME} $*
1479
1480 local needed_version=$@
1481 local vm_version=$(java-pkg_get-vm-version)
1482 if [[ -z "${vm_version}" ]]; then
1483 debug-print "Could not get JDK version from DEPEND"
1484 return 1
1485 else
1486 if version_is_at_least "${needed_version}" "${vm_version}"; then
1487 debug-print "Detected a JDK(${vm_version}) >= ${needed_version}"
1488 return 0
1489 else
1490 debug-print "Detected a JDK(${vm_version}) < ${needed_version}"
1491 return 1
1492 fi
1493 fi
1494 }
1495
1496 java-pkg_set-current-vm() {
1497 export GENTOO_VM=${1}
1498 }
1499
1500 java-pkg_get-current-vm() {
1501 echo ${GENTOO_VM}
1502 }
1503
1504 java-pkg_current-vm-matches() {
1505 has $(java-pkg_get-current-vm) ${@}
1506 return $?
1507 }
1508
1509 # @FUNCTION: java-pkg_get-source
1510 # @DESCRIPTION:
1511 # Determines what source version should be used, for passing to -source.
1512 # Unless you want to break things you probably shouldn't set _WANT_SOURCE
1513 #
1514 # @RETURN: string - Either the lowest possible source, or JAVA_PKG_WANT_SOURCE
1515 java-pkg_get-source() {
1516 echo ${JAVA_PKG_WANT_SOURCE:-$(depend-java-query --get-lowest "${DEPEND} ${RDEPEND}")}
1517 }
1518
1519 # @FUNCTION: java-pkg_get-target
1520 # @DESCRIPTION:
1521 # Determines what target version should be used, for passing to -target.
1522 # If you don't care about lower versions, you can set _WANT_TARGET to the
1523 # version of your JDK.
1524 #
1525 # @RETURN: string - Either the lowest possible target, or JAVA_PKG_WANT_TARGET
1526 java-pkg_get-target() {
1527 echo ${JAVA_PKG_WANT_TARGET:-$(depend-java-query --get-lowest "${DEPEND} ${RDEPEND}")}
1528 }
1529
1530 # @FUNCTION: java-pkg_get-javac
1531 # @DESCRIPTION:
1532 # Returns the compiler executable
1533 java-pkg_get-javac() {
1534 debug-print-function ${FUNCNAME} $*
1535
1536
1537 local compiler="${GENTOO_COMPILER}"
1538
1539 local compiler_executable
1540 if [[ "${compiler}" = "javac" ]]; then
1541 # nothing fancy needs to be done for javac
1542 compiler_executable="javac"
1543 else
1544 # for everything else, try to determine from an env file
1545
1546 local compiler_env="/usr/share/java-config-2/compiler/${compiler}"
1547 if [[ -f ${compiler_env} ]]; then
1548 local old_javac=${JAVAC}
1549 unset JAVAC
1550 # try to get value of JAVAC
1551 compiler_executable="$(source ${compiler_env} 1>/dev/null 2>&1; echo ${JAVAC})"
1552 export JAVAC=${old_javac}
1553
1554 if [[ -z ${compiler_executable} ]]; then
1555 echo "JAVAC is empty or undefined in ${compiler_env}"
1556 return 1
1557 fi
1558
1559 # check that it's executable
1560 if [[ ! -x ${compiler_executable} ]]; then
1561 echo "${compiler_executable} doesn't exist, or isn't executable"
1562 return 1
1563 fi
1564 else
1565 echo "Could not find environment file for ${compiler}"
1566 return 1
1567 fi
1568 fi
1569 echo ${compiler_executable}
1570 }
1571
1572 # @FUNCTION: java-pkg_javac-args
1573 # @DESCRIPTION:
1574 # If an ebuild uses javac directly, instead of using ejavac, it should call this
1575 # to know what -source/-target to use.
1576 #
1577 # @RETURN: string - arguments to pass to javac, complete with -target and -source
1578 java-pkg_javac-args() {
1579 debug-print-function ${FUNCNAME} $*
1580
1581 local want_source="$(java-pkg_get-source)"
1582 local want_target="$(java-pkg_get-target)"
1583
1584 local source_str="-source ${want_source}"
1585 local target_str="-target ${want_target}"
1586
1587 debug-print "want source: ${want_source}"
1588 debug-print "want target: ${want_target}"
1589
1590 if [[ -z "${want_source}" || -z "${want_target}" ]]; then
1591 debug-print "could not find valid -source/-target values for javac"
1592 echo "Could not find valid -source/-target values for javac"
1593 return 1
1594 else
1595 echo "${source_str} ${target_str}"
1596 fi
1597 }
1598
1599 # @FUNCTION: java-pkg_get-jni-cflags
1600 # @DESCRIPTION:
1601 # Echos the CFLAGS for JNI compilations
1602 java-pkg_get-jni-cflags() {
1603 local flags="-I${JAVA_HOME}/include"
1604
1605 local platform="linux"
1606 use elibc_FreeBSD && platform="freebsd"
1607
1608 # TODO do a check that the directories are valid
1609 flags="${flags} -I${JAVA_HOME}/include/${platform}"
1610
1611 echo ${flags}
1612 }
1613
1614 java-pkg_ensure-gcj() {
1615 # was enforcing sys-devel/gcc[gcj]
1616 die "${FUNCNAME} was removed. Use use-deps available as of EAPI 2 instead. #261562"
1617 }
1618
1619 java-pkg_ensure-test() {
1620 # was enforcing USE=test if FEATURES=test
1621 die "${FUNCNAME} was removed. Package mangers handle this already. #278965"
1622 }
1623
1624 # @FUNCTION: java-pkg_register-ant-task
1625 # @USAGE: [--version x.y] [<name>]
1626 # @DESCRIPTION:
1627 # Register this package as ant task, so that ant will load it when no specific
1628 # ANT_TASKS are specified. Note that even without this registering, all packages
1629 # specified in ANT_TASKS will be loaded. Mostly used by the actual ant tasks
1630 # packages, but can be also used by other ebuilds that used to symlink their
1631 # .jar into /usr/share/ant-core/lib to get autoloaded, for backwards
1632 # compatibility.
1633 #
1634 # @CODE
1635 # Parameters
1636 # --version x.y Register only for ant version x.y (otherwise for any ant
1637 # version). Used by the ant-* packages to prevent loading of mismatched
1638 # ant-core ant tasks after core was updated, before the tasks are updated,
1639 # without a need for blockers.
1640 # $1 Name to register as. Defaults to JAVA_PKG_NAME ($PN[-$SLOT])
1641 # @CODE
1642 java-pkg_register-ant-task() {
1643 local TASKS_DIR="tasks"
1644
1645 # check for --version x.y parameters
1646 while [[ -n "${1}" && -n "${2}" ]]; do
1647 local var="${1#--}"
1648 local val="${2}"
1649 if [[ "${var}" == "version" ]]; then
1650 TASKS_DIR="tasks-${val}"
1651 else
1652 die "Unknown parameter passed to java-pkg_register-ant-tasks: ${1} ${2}"
1653 fi
1654 shift 2
1655 done
1656
1657 local TASK_NAME="${1:-${JAVA_PKG_NAME}}"
1658
1659 dodir /usr/share/ant/${TASKS_DIR}
1660 touch "${D}/usr/share/ant/${TASKS_DIR}/${TASK_NAME}"
1661 }
1662
1663 # @FUNCTION: java-pkg_ant-tasks-depend
1664 # @INTERNAL
1665 # @DESCRIPTION:
1666 # Translates the WANT_ANT_TASKS variable into valid dependencies.
1667 java-pkg_ant-tasks-depend() {
1668 debug-print-function ${FUNCNAME} ${WANT_ANT_TASKS}
1669
1670 if [[ -n "${WANT_ANT_TASKS}" ]]; then
1671 local DEP=""
1672 for i in ${WANT_ANT_TASKS}
1673 do
1674 if [[ ${i} = ant-* ]]; then
1675 DEP="${DEP}dev-java/${i} "
1676 elif [[ ${i} = */*:* ]]; then
1677 DEP="${DEP}${i} "
1678 else
1679 echo "Invalid atom in WANT_ANT_TASKS: ${i}"
1680 return 1
1681 fi
1682 done
1683 echo ${DEP}
1684 return 0
1685 else
1686 return 0
1687 fi
1688 }
1689
1690
1691 # @FUNCTION: ejunit_
1692 # @INTERNAL
1693 # @DESCRIPTION:
1694 # Internal Junit wrapper function. Makes it easier to run the tests and checks for
1695 # dev-java/junit in DEPEND. Launches the tests using junit.textui.TestRunner.
1696 # @CODE
1697 # Parameters:
1698 # $1 - junit package (junit or junit-4)
1699 # $2 - -cp or -classpath
1700 # $3 - classpath; junit and recorded dependencies get appended
1701 # $@ - the rest of the parameters are passed to java
1702 # @CODE
1703 ejunit_() {
1704 debug-print-function ${FUNCNAME} $*
1705
1706 local pkgs
1707 if [[ -f ${JAVA_PKG_DEPEND_FILE} ]]; then
1708 for atom in $(cat ${JAVA_PKG_DEPEND_FILE} | tr : ' '); do
1709 pkgs=${pkgs},$(echo ${atom} | sed -re "s/^.*@//")
1710 done
1711 fi
1712
1713 local junit=${1}
1714 shift 1
1715
1716 local cp=$(java-pkg_getjars --with-dependencies ${junit}${pkgs})
1717 if [[ ${1} = -cp || ${1} = -classpath ]]; then
1718 cp="${2}:${cp}"
1719 shift 2
1720 else
1721 cp=".:${cp}"
1722 fi
1723
1724 local runner=junit.textui.TestRunner
1725 if [[ "${junit}" == "junit-4" ]] ; then
1726 runner=org.junit.runner.JUnitCore
1727 fi
1728 debug-print "Calling: java -cp \"${cp}\" -Djava.awt.headless=true ${runner} ${@}"
1729 java -cp "${cp}" -Djava.awt.headless=true ${runner} "${@}" || die "Running junit failed"
1730 }
1731
1732 # @FUNCTION: ejunit
1733 # @DESCRIPTION:
1734 # Junit wrapper function. Makes it easier to run the tests and checks for
1735 # dev-java/junit in DEPEND. Launches the tests using org.junit.runner.JUnitCore.
1736 #
1737 # @CODE
1738 # Parameters:
1739 # $1 - -cp or -classpath
1740 # $2 - classpath; junit and recorded dependencies get appended
1741 # $@ - the rest of the parameters are passed to java
1742 #
1743 # Examples:
1744 # ejunit -cp build/classes org.blinkenlights.jid3.test.AllTests
1745 # ejunit org.blinkenlights.jid3.test.AllTests
1746 # ejunit org.blinkenlights.jid3.test.FirstTest org.blinkenlights.jid3.test.SecondTest
1747 # @CODE
1748 ejunit() {
1749 debug-print-function ${FUNCNAME} $*
1750
1751 ejunit_ "junit" "${@}"
1752 }
1753
1754 # @FUNCTION: ejunit4
1755 # @DESCRIPTION:
1756 # Junit4 wrapper function. Makes it easier to run the tests and checks for
1757 # dev-java/junit:4 in DEPEND. Launches the tests using junit.textui.TestRunner.
1758 #
1759 # @CODE
1760 # Parameters:
1761 # $1 - -cp or -classpath
1762 # $2 - classpath; junit and recorded dependencies get appended
1763 # $@ - the rest of the parameters are passed to java
1764 #
1765 # Examples:
1766 # ejunit4 -cp build/classes org.blinkenlights.jid3.test.AllTests
1767 # ejunit4 org.blinkenlights.jid3.test.AllTests
1768 # ejunit4 org.blinkenlights.jid3.test.FirstTest \
1769 # org.blinkenlights.jid3.test.SecondTest
1770 # @CODE
1771 ejunit4() {
1772 debug-print-function ${FUNCNAME} $*
1773
1774 ejunit_ "junit-4" "${@}"
1775 }
1776
1777 # @FUNCTION: java-utils-2_src_prepare
1778 # @DESCRIPTION:
1779 # src_prepare Searches for bundled jars
1780 # Don't call directly, but via java-pkg-2_src_prepare!
1781 java-utils-2_src_prepare() {
1782 [[ ${EBUILD_PHASE} == prepare ]] &&
1783 java-pkg_func-exists java_prepare && java_prepare
1784
1785 # Remember that eant will call this unless called via Portage
1786 if [[ ! -e "${T}/java-utils-2_src_prepare-run" ]] && is-java-strict; then
1787 echo "Searching for bundled jars:"
1788 java-pkg_find-normal-jars || echo "None found."
1789 echo "Searching for bundled classes (no output if none found):"
1790 find "${WORKDIR}" -name "*.class"
1791 echo "Search done."
1792 fi
1793 touch "${T}/java-utils-2_src_prepare-run"
1794 }
1795
1796 # @FUNCTION: java-utils-2_pkg_preinst
1797 # @DESCRIPTION:
1798 # pkg_preinst Searches for missing and unneeded dependencies
1799 # Don't call directly, but via java-pkg-2_pkg_preinst!
1800 java-utils-2_pkg_preinst() {
1801 if is-java-strict; then
1802 if [[ ! -e "${JAVA_PKG_ENV}" ]] || has ant-tasks ${INHERITED}; then
1803 return
1804 fi
1805
1806 if has_version dev-java/java-dep-check; then
1807 local output=$(GENTOO_VM= java-dep-check --image "${D}" "${JAVA_PKG_ENV}")
1808 [[ ${output} ]] && ewarn "${output}"
1809 else
1810 eerror "Install dev-java/java-dep-check for dependency checking"
1811 fi
1812 fi
1813 }
1814
1815 # @FUNCTION: eant
1816 # @USAGE: <ant_build_target(s)>
1817 # @DESCRIPTION:
1818 # Ant wrapper function. Will use the appropriate compiler, based on user-defined
1819 # compiler. Will also set proper ANT_TASKS from the variable ANT_TASKS,
1820 # variables:
1821 #
1822 # @CODE
1823 # Variables:
1824 # EANT_GENTOO_CLASSPATH - calls java-pkg_getjars for the value and adds to the
1825 # gentoo.classpath property. Be sure to call java-ant_rewrite-classpath in src_unpack.
1826 # EANT_NEEDS_TOOLS - add tools.jar to the gentoo.classpath. Should only be used
1827 # for build-time purposes, the dependency is not recorded to
1828 # package.env!
1829 # ANT_TASKS - used to determine ANT_TASKS before calling Ant.
1830 # @CODE
1831 eant() {
1832 debug-print-function ${FUNCNAME} $*
1833
1834 if [[ ${EBUILD_PHASE} = compile ]]; then
1835 java-ant-2_src_configure
1836 java-utils-2_src_prepare
1837 fi
1838
1839 if ! has java-ant-2 ${INHERITED}; then
1840 local msg="You should inherit java-ant-2 when using eant"
1841 java-pkg_announce-qa-violation "${msg}"
1842 fi
1843
1844 local antflags="-Dnoget=true -Dmaven.mode.offline=true -Dbuild.sysclasspath=ignore"
1845
1846 java-pkg_init-compiler_
1847 local compiler="${GENTOO_COMPILER}"
1848
1849 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}"
1850 local build_compiler="$(source ${compiler_env} 1>/dev/null 2>&1; echo ${ANT_BUILD_COMPILER})"
1851 if [[ "${compiler}" != "javac" && -z "${build_compiler}" ]]; then
1852 die "ANT_BUILD_COMPILER undefined in ${compiler_env}"
1853 fi
1854
1855 if [[ ${compiler} != "javac" ]]; then
1856 antflags="${antflags} -Dbuild.compiler=${build_compiler}"
1857 # Figure out any extra stuff to put on the classpath for compilers aside
1858 # from javac
1859 # ANT_BUILD_COMPILER_DEPS should be something that could be passed to
1860 # java-config -p
1861 local build_compiler_deps="$(source ${JAVA_PKG_COMPILER_DIR}/${compiler} 1>/dev/null 2>&1; echo ${ANT_BUILD_COMPILER_DEPS})"
1862 if [[ -n ${build_compiler_deps} ]]; then
1863 antflags="${antflags} -lib $(java-config -p ${build_compiler_deps})"
1864 fi
1865 fi
1866
1867 for arg in "${@}"; do
1868 if [[ ${arg} = -lib ]]; then
1869 if is-java-strict; then
1870 eerror "You should not use the -lib argument to eant because it will fail"
1871 eerror "with JAVA_PKG_STRICT. Please use for example java-pkg_jar-from"
1872 eerror "or ant properties to make dependencies available."
1873 eerror "For ant tasks use WANT_ANT_TASKS or ANT_TASKS from."
1874 eerror "split ant (>=dev-java/ant-core-1.7)."
1875 die "eant -lib is deprecated/forbidden"
1876 else
1877 echo "eant -lib is deprecated. Turn JAVA_PKG_STRICT on for"
1878 echo "more info."
1879 fi
1880 fi
1881 done
1882
1883 # parse WANT_ANT_TASKS for atoms
1884 local want_ant_tasks
1885 for i in ${WANT_ANT_TASKS}; do
1886 if [[ ${i} = */*:* ]]; then
1887 i=${i#*/}
1888 i=${i%:0}
1889 want_ant_tasks+="${i/:/-} "
1890 else
1891 want_ant_tasks+="${i} "
1892 fi
1893 done
1894 # default ANT_TASKS to WANT_ANT_TASKS, if ANT_TASKS is not set explicitly
1895 ANT_TASKS="${ANT_TASKS:-${want_ant_tasks% }}"
1896
1897 # override ANT_TASKS with JAVA_PKG_FORCE_ANT_TASKS if it's set
1898 ANT_TASKS="${JAVA_PKG_FORCE_ANT_TASKS:-${ANT_TASKS}}"
1899
1900 # if ant-tasks is not set by ebuild or forced, use none
1901 ANT_TASKS="${ANT_TASKS:-none}"
1902
1903 # at this point, ANT_TASKS should be "all", "none" or explicit list
1904 if [[ "${ANT_TASKS}" == "all" ]]; then
1905 einfo "Using all available ANT_TASKS"
1906 elif [[ "${ANT_TASKS}" == "none" ]]; then
1907 einfo "Disabling all optional ANT_TASKS"
1908 else
1909 einfo "Using following ANT_TASKS: ${ANT_TASKS}"
1910 fi
1911
1912 export ANT_TASKS
1913
1914 [[ -n ${JAVA_PKG_DEBUG} ]] && antflags="${antflags} --execdebug -debug"
1915 [[ -n ${PORTAGE_QUIET} ]] && antflags="${antflags} -q"
1916
1917 local gcp="${EANT_GENTOO_CLASSPATH}"
1918 local getjarsarg=""
1919
1920 if [[ ${EBUILD_PHASE} = "test" ]]; then
1921 antflags="${antflags} -DJunit.present=true"
1922 getjarsarg="--with-dependencies"
1923
1924 local re="\bant-junit4?([-:]\S+)?\b"
1925 [[ ${ANT_TASKS} =~ ${re} ]] && gcp+=" ${BASH_REMATCH[0]}"
1926 else
1927 antflags="${antflags} -Dmaven.test.skip=true"
1928 fi
1929
1930 local cp
1931
1932 for atom in ${gcp}; do
1933 cp+=":$(java-pkg_getjars ${getjarsarg} ${atom})"
1934 done
1935
1936 [[ ${EANT_NEEDS_TOOLS} ]] && cp+=":$(java-config --tools)"
1937 [[ ${EANT_GENTOO_CLASSPATH_EXTRA} ]] && cp+=":${EANT_GENTOO_CLASSPATH_EXTRA}"
1938
1939 if [[ ${cp#:} ]]; then
1940 # It seems ant does not like single quotes around ${cp}
1941 antflags="${antflags} -Dgentoo.classpath=\"${cp#:}\""
1942 fi
1943
1944 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ant ${antflags} "${@}"
1945 debug-print "Calling ant (GENTOO_VM: ${GENTOO_VM}): ${antflags} ${@}"
1946 ant ${antflags} "${@}" || die "eant failed"
1947 }
1948
1949 # @FUNCTION: ejavac
1950 # @USAGE: <javac_arguments>
1951 # @DESCRIPTION:
1952 # Javac wrapper function. Will use the appropriate compiler, based on
1953 # /etc/java-config/compilers.conf
1954 ejavac() {
1955 debug-print-function ${FUNCNAME} $*
1956
1957 java-pkg_init-compiler_
1958
1959 local compiler_executable
1960 compiler_executable=$(java-pkg_get-javac)
1961 if [[ ${?} != 0 ]]; then
1962 eerror "There was a problem determining compiler: ${compiler_executable}"
1963 die "get-javac failed"
1964 fi
1965
1966 local javac_args
1967 javac_args="$(java-pkg_javac-args)"
1968 if [[ ${?} != 0 ]]; then
1969 eerror "There was a problem determining JAVACFLAGS: ${javac_args}"
1970 die "java-pkg_javac-args failed"
1971 fi
1972
1973 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ${compiler_executable} ${javac_args} "${@}"
1974 ${compiler_executable} ${javac_args} "${@}" || die "ejavac failed"
1975 }
1976
1977 # @FUNCTION: ejavadoc
1978 # @USAGE: <javadoc_arguments>
1979 # @DESCRIPTION:
1980 # javadoc wrapper function. Will set some flags based on the VM version
1981 # due to strict javadoc rules in 1.8.
1982 ejavadoc() {
1983 debug-print-function ${FUNCNAME} $*
1984
1985 local javadoc_args=""
1986
1987 if java-pkg_is-vm-version-ge "1.8" ; then
1988 javadoc_args="-Xdoclint:none"
1989 fi
1990
1991 javadoc ${javadoc_args} "${@}" || die "ejavadoc failed"
1992 }
1993
1994 # @FUNCTION: java-pkg_filter-compiler
1995 # @USAGE: <compiler(s)_to_filter>
1996 # @DESCRIPTION:
1997 # Used to prevent the use of some compilers. Should be used in src_compile.
1998 # Basically, it just appends onto JAVA_PKG_FILTER_COMPILER
1999 java-pkg_filter-compiler() {
2000 JAVA_PKG_FILTER_COMPILER="${JAVA_PKG_FILTER_COMPILER} $@"
2001 }
2002
2003 # @FUNCTION: java-pkg_force-compiler
2004 # @USAGE: <compiler(s)_to_force>
2005 # @DESCRIPTION:
2006 # Used to force the use of particular compilers. Should be used in src_compile.
2007 # A common use of this would be to force ecj-3.1 to be used on amd64, to avoid
2008 # OutOfMemoryErrors that may come up.
2009 java-pkg_force-compiler() {
2010 JAVA_PKG_FORCE_COMPILER="$@"
2011 }
2012
2013 # @FUNCTION: use_doc
2014 # @DESCRIPTION:
2015 #
2016 # Helper function for getting ant to build javadocs. If the user has USE=doc,
2017 # then 'javadoc' or the argument are returned. Otherwise, there is no return.
2018 #
2019 # The output of this should be passed to ant.
2020 # @CODE
2021 # Parameters:
2022 # $@ - Option value to return. Defaults to 'javadoc'
2023 #
2024 # Examples:
2025 # build javadocs by calling 'javadoc' target
2026 # eant $(use_doc)
2027 #
2028 # build javadocs by calling 'apidoc' target
2029 # eant $(use_doc apidoc)
2030 # @CODE
2031 # @RETURN string - Name of the target to create javadocs
2032 use_doc() {
2033 use doc && echo ${@:-javadoc}
2034 }
2035
2036
2037 # @FUNCTION: java-pkg_init
2038 # @INTERNAL
2039 # @DESCRIPTION:
2040 # The purpose of this function, as the name might imply, is to initialize the
2041 # Java environment. It ensures that that there aren't any environment variables
2042 # that'll muss things up. It initializes some variables, which are used
2043 # internally. And most importantly, it'll switch the VM if necessary.
2044 #
2045 # This shouldn't be used directly. Instead, java-pkg and java-pkg-opt will
2046 # call it during each of the phases of the merge process.
2047 java-pkg_init() {
2048 debug-print-function ${FUNCNAME} $*
2049
2050 # Don't set up build environment if installing from binary. #206024 #258423
2051 [[ "${MERGE_TYPE}" == "binary" ]] && return
2052 # Also try Portage's nonstandard EMERGE_FROM for old EAPIs, if it doesn't
2053 # work nothing is lost.
2054 has ${EAPI:-0} 0 1 2 3 && [[ "${EMERGE_FROM}" == "binary" ]] && return
2055
2056 unset JAVAC
2057 unset JAVA_HOME
2058
2059 java-config --help >/dev/null || {
2060 eerror ""
2061 eerror "Can't run java-config --help"
2062 eerror "Have you upgraded python recently but haven't"
2063 eerror "run python-updater yet?"
2064 die "Can't run java-config --help"
2065 }
2066
2067 # People do all kinds of weird things.
2068 # http://forums.gentoo.org/viewtopic-p-3943166.html
2069 local silence="${SILENCE_JAVA_OPTIONS_WARNING}"
2070 local accept="${I_WANT_GLOBAL_JAVA_OPTIONS}"
2071 if [[ -n ${_JAVA_OPTIONS} && -z ${accept} && -z ${silence} ]]; then
2072 ewarn "_JAVA_OPTIONS changes what java -version outputs at least for"
2073 ewarn "sun-jdk vms and and as such break configure scripts that"
2074 ewarn "use it (for example app-office/openoffice) so we filter it out."
2075 ewarn "Use SILENCE_JAVA_OPTIONS_WARNING=true in the environment (use"
2076 ewarn "make.conf for example) to silence this warning or"
2077 ewarn "I_WANT_GLOBAL_JAVA_OPTIONS to not filter it."
2078 fi
2079
2080 if [[ -z ${accept} ]]; then
2081 # export _JAVA_OPTIONS= doesn't work because it will show up in java
2082 # -version output
2083 unset _JAVA_OPTIONS
2084 # phase hooks make this run many times without this
2085 I_WANT_GLOBAL_JAVA_OPTIONS="true"
2086 fi
2087
2088 if java-pkg_func-exists ant_src_unpack; then
2089 java-pkg_announce-qa-violation "Using old ant_src_unpack. Should be src_unpack"
2090 fi
2091
2092 java-pkg_switch-vm
2093 PATH=${JAVA_HOME}/bin:${PATH}
2094
2095 # TODO we will probably want to set JAVAC and JAVACFLAGS
2096
2097 # Do some QA checks
2098 java-pkg_check-jikes
2099
2100 # Can't use unset here because Portage does not save the unset
2101 # see https://bugs.gentoo.org/show_bug.cgi?id=189417#c11
2102
2103 # When users have crazy classpaths some packages can fail to compile.
2104 # and everything should work with empty CLASSPATH.
2105 # This also helps prevent unexpected dependencies on random things
2106 # from the CLASSPATH.
2107 export CLASSPATH=
2108
2109 # Unset external ANT_ stuff
2110 export ANT_TASKS=
2111 export ANT_OPTS=
2112 export ANT_RESPECT_JAVA_HOME=
2113 }
2114
2115 # @FUNCTION: java-pkg-init-compiler_
2116 # @INTERNAL
2117 # @DESCRIPTION:
2118 # This function attempts to figure out what compiler should be used. It does
2119 # this by reading the file at JAVA_PKG_COMPILERS_CONF, and checking the
2120 # COMPILERS variable defined there.
2121 # This can be overridden by a list in JAVA_PKG_FORCE_COMPILER
2122 #
2123 # It will go through the list of compilers, and verify that it supports the
2124 # target and source that are needed. If it is not suitable, then the next
2125 # compiler is checked. When JAVA_PKG_FORCE_COMPILER is defined, this checking
2126 # isn't done.
2127 #
2128 # Once the which compiler to use has been figured out, it is set to
2129 # GENTOO_COMPILER.
2130 #
2131 # If you hadn't guessed, JAVA_PKG_FORCE_COMPILER is for testing only.
2132 #
2133 # If the user doesn't defined anything in JAVA_PKG_COMPILERS_CONF, or no
2134 # suitable compiler was found there, then the default is to use javac provided
2135 # by the current VM.
2136 #
2137 #
2138 # @RETURN name of the compiler to use
2139 java-pkg_init-compiler_() {
2140 debug-print-function ${FUNCNAME} $*
2141
2142 if [[ -n ${GENTOO_COMPILER} ]]; then
2143 debug-print "GENTOO_COMPILER already set"
2144 return
2145 fi
2146
2147 local compilers;
2148 if [[ -z ${JAVA_PKG_FORCE_COMPILER} ]]; then
2149 compilers="$(source ${JAVA_PKG_COMPILERS_CONF} 1>/dev/null 2>&1; echo ${COMPILERS})"
2150 else
2151 compilers=${JAVA_PKG_FORCE_COMPILER}
2152 fi
2153
2154 debug-print "Read \"${compilers}\" from ${JAVA_PKG_COMPILERS_CONF}"
2155
2156 # Figure out if we should announce what compiler we're using
2157 local compiler
2158 for compiler in ${compilers}; do
2159 debug-print "Checking ${compiler}..."
2160 # javac should always be alright
2161 if [[ ${compiler} = "javac" ]]; then
2162 debug-print "Found javac... breaking"
2163 export GENTOO_COMPILER="javac"
2164 break
2165 fi
2166
2167 if has ${compiler} ${JAVA_PKG_FILTER_COMPILER}; then
2168 if [[ -z ${JAVA_PKG_FORCE_COMPILER} ]]; then
2169 einfo "Filtering ${compiler}"
2170 continue
2171 fi
2172 fi
2173
2174 # for non-javac, we need to make sure it supports the right target and
2175 # source
2176 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}"
2177 if [[ -f ${compiler_env} ]]; then
2178 local desired_target="$(java-pkg_get-target)"
2179 local desired_source="$(java-pkg_get-source)"
2180
2181
2182 # Verify that the compiler supports target
2183 local supported_target=$(source ${compiler_env} 1>/dev/null 2>&1; echo ${SUPPORTED_TARGET})
2184 if ! has ${desired_target} ${supported_target}; then
2185 ewarn "${compiler} does not support -target ${desired_target}, skipping"
2186 continue
2187 fi
2188
2189 # Verify that the compiler supports source
2190 local supported_source=$(source ${compiler_env} 1>/dev/null 2>&1; echo ${SUPPORTED_SOURCE})
2191 if ! has ${desired_source} ${supported_source}; then
2192 ewarn "${compiler} does not support -source ${desired_source}, skipping"
2193 continue
2194 fi
2195
2196 # if you get here, then the compiler should be good to go
2197 export GENTOO_COMPILER="${compiler}"
2198 break
2199 else
2200 ewarn "Could not find configuration for ${compiler}, skipping"
2201 ewarn "Perhaps it is not installed?"
2202 continue
2203 fi
2204 done
2205
2206 # If it hasn't been defined already, default to javac
2207 if [[ -z ${GENTOO_COMPILER} ]]; then
2208 if [[ -n ${compilers} ]]; then
2209 einfo "No suitable compiler found: defaulting to JDK default for compilation"
2210 else
2211 # probably don't need to notify users about the default.
2212 :;#einfo "Defaulting to javac for compilation"
2213 fi
2214 if java-config -g GENTOO_COMPILER 2> /dev/null; then
2215 export GENTOO_COMPILER=$(java-config -g GENTOO_COMPILER)
2216 else
2217 export GENTOO_COMPILER=javac
2218 fi
2219 else
2220 einfo "Using ${GENTOO_COMPILER} for compilation"
2221 fi
2222
2223 }
2224
2225 # @FUNCTION: init_paths_
2226 # @INTERNAL
2227 # @DESCRIPTION:
2228 # Initializes some variables that will be used. These variables are mostly used
2229 # to determine where things will eventually get installed.
2230 java-pkg_init_paths_() {
2231 debug-print-function ${FUNCNAME} $*
2232
2233 local pkg_name
2234 if [[ "${SLOT%/*}" == "0" ]] ; then
2235 JAVA_PKG_NAME="${PN}"
2236 else
2237 JAVA_PKG_NAME="${PN}-${SLOT%/*}"
2238 fi
2239
2240 JAVA_PKG_SHAREPATH="${DESTTREE}/share/${JAVA_PKG_NAME}"
2241 JAVA_PKG_SOURCESPATH="${JAVA_PKG_SHAREPATH}/sources/"
2242 JAVA_PKG_ENV="${D}${JAVA_PKG_SHAREPATH}/package.env"
2243 JAVA_PKG_VIRTUALS_PATH="${DESTTREE}/share/java-config-2/virtuals"
2244 JAVA_PKG_VIRTUAL_PROVIDER="${D}/${JAVA_PKG_VIRTUALS_PATH}/${JAVA_PKG_NAME}"
2245
2246 [[ -z "${JAVA_PKG_JARDEST}" ]] && JAVA_PKG_JARDEST="${JAVA_PKG_SHAREPATH}/lib"
2247 [[ -z "${JAVA_PKG_LIBDEST}" ]] && JAVA_PKG_LIBDEST="${DESTTREE}/$(get_libdir)/${JAVA_PKG_NAME}"
2248 [[ -z "${JAVA_PKG_WARDEST}" ]] && JAVA_PKG_WARDEST="${JAVA_PKG_SHAREPATH}/webapps"
2249
2250 # TODO maybe only print once?
2251 debug-print "JAVA_PKG_SHAREPATH: ${JAVA_PKG_SHAREPATH}"
2252 debug-print "JAVA_PKG_ENV: ${JAVA_PKG_ENV}"
2253 debug-print "JAVA_PKG_JARDEST: ${JAVA_PKG_JARDEST}"
2254 debug-print "JAVA_PKG_LIBDEST: ${JAVA_PKG_LIBDEST}"
2255 debug-print "JAVA_PKG_WARDEST: ${JAVA_PKG_WARDEST}"
2256 }
2257
2258 # @FUNCTION: java-pkg_do_write_
2259 # @INTERNAL
2260 # @DESCRIPTION:
2261 # Writes the package.env out to disk.
2262 #
2263 # TODO change to do-write, to match everything else
2264 java-pkg_do_write_() {
2265 debug-print-function ${FUNCNAME} $*
2266 java-pkg_init_paths_
2267 # Create directory for package.env
2268 dodir "${JAVA_PKG_SHAREPATH}"
2269 if [[ -n "${JAVA_PKG_CLASSPATH}" || -n "${JAVA_PKG_LIBRARY}" || -f \
2270 "${JAVA_PKG_DEPEND_FILE}" || -f \
2271 "${JAVA_PKG_OPTIONAL_DEPEND_FILE}" ]]; then
2272 # Create package.env
2273 (
2274 echo "DESCRIPTION=\"${DESCRIPTION}\""
2275 echo "GENERATION=\"2\""
2276 echo "SLOT=\"${SLOT}\""
2277 echo "CATEGORY=\"${CATEGORY}\""
2278 echo "PVR=\"${PVR}\""
2279
2280 [[ -n "${JAVA_PKG_CLASSPATH}" ]] && echo "CLASSPATH=\"${JAVA_PKG_CLASSPATH}\""
2281 [[ -n "${JAVA_PKG_LIBRARY}" ]] && echo "LIBRARY_PATH=\"${JAVA_PKG_LIBRARY}\""
2282 [[ -n "${JAVA_PROVIDE}" ]] && echo "PROVIDES=\"${JAVA_PROVIDE}\""
2283 [[ -f "${JAVA_PKG_DEPEND_FILE}" ]] \
2284 && echo "DEPEND=\"$(sort -u "${JAVA_PKG_DEPEND_FILE}" | tr '\n' ':')\""
2285 [[ -f "${JAVA_PKG_OPTIONAL_DEPEND_FILE}" ]] \
2286 && echo "OPTIONAL_DEPEND=\"$(sort -u "${JAVA_PKG_OPTIONAL_DEPEND_FILE}" | tr '\n' ':')\""
2287 echo "VM=\"$(echo ${RDEPEND} ${DEPEND} | sed -e 's/ /\n/g' | sed -n -e '/virtual\/\(jre\|jdk\)/ { p;q }')\"" # TODO cleanup !
2288 [[ -f "${JAVA_PKG_BUILD_DEPEND_FILE}" ]] \
2289 && echo "BUILD_DEPEND=\"$(sort -u "${JAVA_PKG_BUILD_DEPEND_FILE}" | tr '\n' ':')\""
2290 ) > "${JAVA_PKG_ENV}"
2291
2292 # register target/source
2293 local target="$(java-pkg_get-target)"
2294 local source="$(java-pkg_get-source)"
2295 [[ -n ${target} ]] && echo "TARGET=\"${target}\"" >> "${JAVA_PKG_ENV}"
2296 [[ -n ${source} ]] && echo "SOURCE=\"${source}\"" >> "${JAVA_PKG_ENV}"
2297
2298 # register javadoc info
2299 [[ -n ${JAVADOC_PATH} ]] && echo "JAVADOC_PATH=\"${JAVADOC_PATH}\"" \
2300 >> ${JAVA_PKG_ENV}
2301 # register source archives
2302 [[ -n ${JAVA_SOURCES} ]] && echo "JAVA_SOURCES=\"${JAVA_SOURCES}\"" \
2303 >> ${JAVA_PKG_ENV}
2304
2305
2306 echo "MERGE_VM=\"${GENTOO_VM}\"" >> "${JAVA_PKG_ENV}"
2307 [[ -n ${GENTOO_COMPILER} ]] && echo "MERGE_COMPILER=\"${GENTOO_COMPILER}\"" >> "${JAVA_PKG_ENV}"
2308
2309 # extra env variables
2310 if [[ -n "${JAVA_PKG_EXTRA_ENV_VARS}" ]]; then
2311 cat "${JAVA_PKG_EXTRA_ENV}" >> "${JAVA_PKG_ENV}" || die
2312 # nested echo to remove leading/trailing spaces
2313 echo "ENV_VARS=\"$(echo ${JAVA_PKG_EXTRA_ENV_VARS})\"" \
2314 >> "${JAVA_PKG_ENV}" || die
2315 fi
2316
2317 # Strip unnecessary leading and trailing colons
2318 # TODO try to cleanup if possible
2319 sed -e "s/=\":/=\"/" -e "s/:\"$/\"/" -i "${JAVA_PKG_ENV}" || die "Did you forget to call java_init ?"
2320 else
2321 debug-print "JAVA_PKG_CLASSPATH, JAVA_PKG_LIBRARY, JAVA_PKG_DEPEND_FILE"
2322 debug-print "or JAVA_PKG_OPTIONAL_DEPEND_FILE not defined so can't"
2323 debug-print "write package.env."
2324 fi
2325 }
2326
2327 # @FUNCTION: java-pkg_record-jar_
2328 # @INTERNAL
2329 # @DESCRIPTION:
2330 # Record an (optional) dependency to the package.env
2331 # @CODE
2332 # Parameters:
2333 # --optional - record dependency as optional
2334 # --build - record dependency as build_only
2335 # $1 - package to record
2336 # $2 - (optional) jar of package to record
2337 # @CODE
2338 JAVA_PKG_DEPEND_FILE="${T}/java-pkg-depend"
2339 JAVA_PKG_OPTIONAL_DEPEND_FILE="${T}/java-pkg-optional-depend"
2340 JAVA_PKG_BUILD_DEPEND_FILE="${T}/java-pkg-build-depend"
2341
2342 java-pkg_record-jar_() {
2343 debug-print-function ${FUNCNAME} $*
2344
2345 local depend_file="${JAVA_PKG_DEPEND_FILE}"
2346 case "${1}" in
2347 "--optional") depend_file="${JAVA_PKG_OPTIONAL_DEPEND_FILE}"; shift;;
2348 "--build-only") depend_file="${JAVA_PKG_BUILD_DEPEND_FILE}"; shift;;
2349 esac
2350
2351 local pkg=${1} jar=${2} append
2352 if [[ -z "${jar}" ]]; then
2353 append="${pkg}"
2354 else
2355 append="$(basename ${jar})@${pkg}"
2356 fi
2357
2358 echo "${append}" >> "${depend_file}"
2359 }
2360
2361 # @FUNCTION: java-pkg_append_
2362 # @INTERNAL
2363 # @DESCRIPTION:
2364 # Appends a value to a variable
2365 #
2366 # @CODE
2367 # Parameters:
2368 # $1 variable name to modify
2369 # $2 value to append
2370 #
2371 # Examples:
2372 # java-pkg_append_ CLASSPATH foo.jar
2373 # @CODE
2374 java-pkg_append_() {
2375 debug-print-function ${FUNCNAME} $*
2376
2377 local var="${1}" value="${2}"
2378 if [[ -z "${!var}" ]] ; then
2379 export ${var}="${value}"
2380 else
2381 local oldIFS=${IFS} cur haveit
2382 IFS=':'
2383 for cur in ${!var}; do
2384 if [[ ${cur} == ${value} ]]; then
2385 haveit="yes"
2386 break
2387 fi
2388 done
2389 [[ -z ${haveit} ]] && export ${var}="${!var}:${value}"
2390 IFS=${oldIFS}
2391 fi
2392 }
2393
2394 # @FUNCTION: java-pkg_expand_dir_
2395 # @INTERNAL
2396 # @DESCRIPTION:
2397 # Gets the full path of the file/directory's parent.
2398 # @CODE
2399 # Parameters:
2400 # $1 - file/directory to find parent directory for
2401 # @CODE
2402 # @RETURN: path to $1's parent directory
2403 java-pkg_expand_dir_() {
2404 pushd "$(dirname "${1}")" >/dev/null 2>&1
2405 pwd
2406 popd >/dev/null 2>&1
2407 }
2408
2409 # @FUNCTION: java-pkg_func-exists
2410 # @INTERNAL
2411 # @DESCRIPTION:
2412 # Does the indicated function exist?
2413 # @RETURN: 0 - function is declared, 1 - function is undeclared
2414 java-pkg_func-exists() {
2415 declare -F ${1} > /dev/null
2416 }
2417
2418 # @FUNCTION: java-pkg_setup-vm
2419 # @INTERNAL
2420 # @DESCRIPTION:
2421 # Sets up the environment for a specific VM
2422 java-pkg_setup-vm() {
2423 debug-print-function ${FUNCNAME} $*
2424
2425 local vendor="$(java-pkg_get-vm-vendor)"
2426 if [[ "${vendor}" == "sun" ]] && java-pkg_is-vm-version-ge "1.5" ; then
2427 addpredict "/dev/random"
2428 elif [[ "${vendor}" == "ibm" ]]; then
2429 addpredict "/proc/self/maps"
2430 addpredict "/proc/cpuinfo"
2431 addpredict "/proc/self/coredump_filter"
2432 elif [[ "${vendor}" == "oracle" ]]; then
2433 addpredict "/dev/random"
2434 addpredict "/proc/self/coredump_filter"
2435 elif [[ "${vendor}" == icedtea* ]] && java-pkg_is-vm-version-ge "1.7" ; then
2436 addpredict "/dev/random"
2437 addpredict "/proc/self/coredump_filter"
2438 elif [[ "${vendor}" == "jrockit" ]]; then
2439 addpredict "/proc/cpuinfo"
2440 fi
2441 }
2442
2443 # @FUNCTION: java-pkg_needs-vm
2444 # @INTERNAL
2445 # @DESCRIPTION:
2446 # Does the current package depend on virtual/jdk or does it set
2447 # JAVA_PKG_WANT_BUILD_VM?
2448 #
2449 # @RETURN: 0 - Package depends on virtual/jdk; 1 - Package does not depend on virtual/jdk
2450 java-pkg_needs-vm() {
2451 debug-print-function ${FUNCNAME} $*
2452
2453 if [[ -n "$(echo ${JAVA_PKG_NV_DEPEND:-${DEPEND}} | sed -e '\:virtual/jdk:!d')" ]]; then
2454 return 0
2455 fi
2456
2457 [[ -n "${JAVA_PKG_WANT_BUILD_VM}" ]] && return 0
2458
2459 return 1
2460 }
2461
2462 # @FUNCTION: java-pkg_get-current-vm
2463 # @INTERNAL
2464 # @RETURN - The current VM being used
2465 java-pkg_get-current-vm() {
2466 java-config -f
2467 }
2468
2469 # @FUNCTION: java-pkg_get-vm-vendor
2470 # @INTERNAL
2471 # @RETURN - The vendor of the current VM
2472 java-pkg_get-vm-vendor() {
2473 debug-print-function ${FUNCNAME} $*
2474
2475 local vm="$(java-pkg_get-current-vm)"
2476 vm="${vm/-*/}"
2477 echo "${vm}"
2478 }
2479
2480 # @FUNCTION: java-pkg_get-vm-version
2481 # @INTERNAL
2482 # @RETURN - The version of the current VM
2483 java-pkg_get-vm-version() {
2484 debug-print-function ${FUNCNAME} $*
2485
2486 java-config -g PROVIDES_VERSION
2487 }
2488
2489 # @FUNCTION: java-pkg_build-vm-from-handle
2490 # @INTERNAL
2491 # @DESCRIPTION:
2492 # Selects a build vm from a list of vm handles. First checks for the system-vm
2493 # beeing usable, then steps through the listed handles till a suitable vm is
2494 # found.
2495 #
2496 # @RETURN - VM handle of an available JDK
2497 java-pkg_build-vm-from-handle() {
2498 debug-print-function ${FUNCNAME} "$*"
2499
2500 local vm
2501 vm=$(java-pkg_get-current-vm 2>/dev/null)
2502 if [[ $? -eq 0 ]]; then
2503 if has ${vm} ${JAVA_PKG_WANT_BUILD_VM}; then
2504 echo ${vm}
2505 return 0
2506 fi
2507 fi
2508
2509 for vm in ${JAVA_PKG_WANT_BUILD_VM}; do
2510 if java-config-2 --select-vm=${vm} 2>/dev/null; then
2511 echo ${vm}
2512 return 0
2513 fi
2514 done
2515
2516 eerror "${FUNCNAME}: No vm found for handles: ${JAVA_PKG_WANT_BUILD_VM}"
2517 return 1
2518 }
2519
2520 # @FUNCTION: java-pkg_switch-vm
2521 # @INTERNAL
2522 # @DESCRIPTION:
2523 # Switch VM if we're allowed to (controlled by JAVA_PKG_ALLOW_VM_CHANGE), and
2524 # verify that the current VM is sufficient.
2525 # Setup the environment for the VM being used.
2526 java-pkg_switch-vm() {
2527 debug-print-function ${FUNCNAME} $*
2528
2529 if java-pkg_needs-vm; then
2530 # Use the VM specified by JAVA_PKG_FORCE_VM
2531 if [[ -n "${JAVA_PKG_FORCE_VM}" ]]; then
2532 # If you're forcing the VM, I hope you know what your doing...
2533 debug-print "JAVA_PKG_FORCE_VM used: ${JAVA_PKG_FORCE_VM}"
2534 export GENTOO_VM="${JAVA_PKG_FORCE_VM}"
2535 # if we're allowed to switch the vm...
2536 elif [[ "${JAVA_PKG_ALLOW_VM_CHANGE}" == "yes" ]]; then
2537 # if there is an explicit list of handles to choose from
2538 if [[ -n "${JAVA_PKG_WANT_BUILD_VM}" ]]; then
2539 debug-print "JAVA_PKG_WANT_BUILD_VM used: ${JAVA_PKG_WANT_BUILD_VM}"
2540 GENTOO_VM=$(java-pkg_build-vm-from-handle)
2541 if [[ $? != 0 ]]; then
2542 eerror "${FUNCNAME}: No VM found for handles: ${JAVA_PKG_WANT_BUILD_VM}"
2543 die "${FUNCNAME}: Failed to determine VM for building"
2544 fi
2545 # JAVA_PKG_WANT_SOURCE and JAVA_PKG_WANT_TARGET are required as
2546 # they can't be deduced from handles.
2547 if [[ -z "${JAVA_PKG_WANT_SOURCE}" ]]; then
2548 eerror "JAVA_PKG_WANT_BUILD_VM specified but not JAVA_PKG_WANT_SOURCE"
2549 die "Specify JAVA_PKG_WANT_SOURCE"
2550 fi
2551 if [[ -z "${JAVA_PKG_WANT_TARGET}" ]]; then
2552 eerror "JAVA_PKG_WANT_BUILD_VM specified but not JAVA_PKG_WANT_TARGET"
2553 die "Specify JAVA_PKG_WANT_TARGET"
2554 fi
2555 # otherwise determine a vm from dep string
2556 else
2557 debug-print "depend-java-query: NV_DEPEND: ${JAVA_PKG_NV_DEPEND:-${DEPEND}}"
2558 GENTOO_VM="$(depend-java-query --get-vm "${JAVA_PKG_NV_DEPEND:-${DEPEND}}")"
2559 if [[ -z "${GENTOO_VM}" || "${GENTOO_VM}" == "None" ]]; then
2560 eerror "Unable to determine VM for building from dependencies:"
2561 echo "NV_DEPEND: ${JAVA_PKG_NV_DEPEND:-${DEPEND}}"
2562 die "Failed to determine VM for building."
2563 fi
2564 fi
2565 export GENTOO_VM
2566 # otherwise just make sure the current VM is sufficient
2567 else
2568 java-pkg_ensure-vm-version-sufficient
2569 fi
2570 debug-print "Using: $(java-config -f)"
2571
2572 java-pkg_setup-vm
2573
2574 export JAVA=$(java-config --java)
2575 export JAVAC=$(java-config --javac)
2576 JAVACFLAGS="$(java-pkg_javac-args)"
2577 if [[ ${?} != 0 ]]; then
2578 eerror "There was a problem determining JAVACFLAGS: ${JAVACFLAGS}"
2579 die "java-pkg_javac-args failed"
2580 fi
2581 [[ -n ${JAVACFLAGS_EXTRA} ]] && JAVACFLAGS="${JAVACFLAGS_EXTRA} ${JAVACFLAGS}"
2582 export JAVACFLAGS
2583
2584 export JAVA_HOME="$(java-config -g JAVA_HOME)"
2585 export JDK_HOME=${JAVA_HOME}
2586
2587 #TODO If you know a better solution let us know.
2588 java-pkg_append_ LD_LIBRARY_PATH "$(java-config -g LDPATH)"
2589
2590 local tann="${T}/announced-vm"
2591 # With the hooks we should only get here once from pkg_setup but better safe than sorry
2592 # if people have for example modified eclasses some where
2593 if [[ -n "${JAVA_PKG_DEBUG}" ]] || [[ ! -f "${tann}" ]] ; then
2594 einfo "Using: $(java-config -f)"
2595 [[ ! -f "${tann}" ]] && touch "${tann}"
2596 fi
2597
2598 else
2599 [[ -n "${JAVA_PKG_DEBUG}" ]] && ewarn "!!! This package inherits java-pkg but doesn't depend on a JDK. -bin or broken dependency!!!"
2600 fi
2601 }
2602
2603 # @FUNCTION: java-pkg_die
2604 # @INTERNAL
2605 # @DESCRIPTION:
2606 # Enhanced die for Java packages, which displays some information that may be
2607 # useful for debugging bugs on bugzilla.
2608 #register_die_hook java-pkg_die
2609 if ! has java-pkg_die ${EBUILD_DEATH_HOOKS}; then
2610 EBUILD_DEATH_HOOKS="${EBUILD_DEATH_HOOKS} java-pkg_die"
2611 fi
2612
2613 java-pkg_die() {
2614 echo "!!! When you file a bug report, please include the following information:" >&2
2615 echo "GENTOO_VM=${GENTOO_VM} CLASSPATH=\"${CLASSPATH}\" JAVA_HOME=\"${JAVA_HOME}\"" >&2
2616 echo "JAVACFLAGS=\"${JAVACFLAGS}\" COMPILER=\"${GENTOO_COMPILER}\"" >&2
2617 echo "and of course, the output of emerge --info =${P}" >&2
2618 }
2619
2620
2621 # TODO document
2622 # List jars in the source directory, ${S}
2623 java-pkg_jar-list() {
2624 if [[ -n "${JAVA_PKG_DEBUG}" ]]; then
2625 einfo "Linked Jars"
2626 find "${S}" -type l -name '*.jar' -print0 | xargs -0 -r -n 500 ls -ald | sed -e "s,${WORKDIR},\${WORKDIR},"
2627 einfo "Jars"
2628 find "${S}" -type f -name '*.jar' -print0 | xargs -0 -r -n 500 ls -ald | sed -e "s,${WORKDIR},\${WORKDIR},"
2629 einfo "Classes"
2630 find "${S}" -type f -name '*.class' -print0 | xargs -0 -r -n 500 ls -ald | sed -e "s,${WORKDIR},\${WORKDIR},"
2631 fi
2632 }
2633
2634 # @FUNCTION: java-pkg_verify-classes
2635 # @INTERNAL
2636 # @DESCRIPTION:
2637 # Verify that the classes were compiled for the right source / target. Dies if
2638 # not.
2639 # @CODE
2640 # $1 (optional) - the file to check, otherwise checks whole ${D}
2641 # @CODE
2642 java-pkg_verify-classes() {
2643 #$(find ${D} -type f -name '*.jar' -o -name '*.class')
2644
2645 local version_verify="/usr/bin/class-version-verify.py"
2646
2647 if [[ ! -x "${version_verify}" ]]; then
2648 version_verify="/usr/$(get_libdir)/javatoolkit/bin/class-version-verify.py"
2649 fi
2650
2651 if [[ ! -x "${version_verify}" ]]; then
2652 ewarn "Unable to perform class version checks as"
2653 ewarn "class-version-verify.py is unavailable"
2654 ewarn "Please install dev-java/javatoolkit."
2655 return
2656 fi
2657
2658 local target=$(java-pkg_get-target)
2659 local result
2660 local log="${T}/class-version-verify.log"
2661 if [[ -n "${1}" ]]; then
2662 ${version_verify} -v -t ${target} "${1}" > "${log}"
2663 result=$?
2664 else
2665 ebegin "Verifying java class versions (target: ${target})"
2666 ${version_verify} -v -t ${target} -r "${D}" > "${log}"
2667 result=$?
2668 eend ${result}
2669 fi
2670 [[ -n ${JAVA_PKG_DEBUG} ]] && cat "${log}"
2671 if [[ ${result} != 0 ]]; then
2672 eerror "Incorrect bytecode version found"
2673 [[ -n "${1}" ]] && eerror "in file: ${1}"
2674 eerror "See ${log} for more details."
2675 die "Incorrect bytecode found"
2676 fi
2677 }
2678
2679 # @FUNCTION: java-pkg_ensure-dep
2680 # @INTERNAL
2681 # @DESCRIPTION:
2682 # Check that a package being used in jarfrom, getjars and getjar is contained
2683 # within DEPEND or RDEPEND with the correct SLOT. See this mail for details:
2684 # https://archives.gentoo.org/gentoo-dev/message/dcb644f89520f4bbb61cc7bbe45fdf6e
2685 # @CODE
2686 # Parameters:
2687 # $1 - empty - check both vars; "runtime" or "build" - check only
2688 # RDEPEND, resp. DEPEND
2689 # $2 - Package name and slot.
2690 # @CODE
2691 java-pkg_ensure-dep() {
2692 debug-print-function ${FUNCNAME} $*
2693
2694 local limit_to="${1}"
2695 local target_pkg="${2}"
2696 local dev_error=""
2697
2698 # Transform into a regular expression to look for a matching package
2699 # and SLOT. SLOTs don't have to be numeric so foo-bar could either
2700 # mean foo-bar:0 or foo:bar. So you want to get your head around the
2701 # line below?
2702 #
2703 # * The target package first has any dots escaped, e.g. foo-1.2
2704 # becomes foo-1\.2.
2705 #
2706 # * sed then looks at the component following the last - or :
2707 # character, or the whole string if there is no - or :
2708 # character. It uses this to build a new regexp with two
2709 # significant branches.
2710 #
2711 # * The first checks for the whole target package string, optionally
2712 # followed by a version number, and then :0.
2713 #
2714 # * The second checks for the first part of the target package
2715 # string, optionally followed by a version number, followed by the
2716 # aforementioned component, treating that as a SLOT.
2717 #
2718 local stripped_pkg=/$(sed -r 's/[-:]?([^-:]+)$/(\0(-[^:]+)?:0|(-[^:]+)?:\1)/' <<< "${target_pkg//./\\.}")\\b
2719
2720 debug-print "Matching against: ${stripped_pkg}"
2721
2722 # Uncomment the lines below once we've dealt with more of these
2723 # otherwise we'll be tempted to turn JAVA_PKG_STRICT off while
2724 # getting hit with a wave of bug reports. :(
2725
2726 if [[ ${limit_to} != runtime && ! ( "${DEPEND}" =~ $stripped_pkg ) ]]; then
2727 dev_error="The ebuild is attempting to use ${target_pkg}, which is not "
2728 dev_error+="declared with a SLOT in DEPEND."
2729 # if is-java-strict; then
2730 # die "${dev_error}"
2731 # else
2732 eqawarn "java-pkg_ensure-dep: ${dev_error}"
2733 # eerror "Because you have ${target_pkg} installed,"
2734 # eerror "the package will build without problems, but please"
2735 # eerror "report this to http://bugs.gentoo.org."
2736 # fi
2737 elif [[ ${limit_to} != build && ! ( "${RDEPEND}${PDEPEND}" =~ ${stripped_pkg} ) ]]; then
2738 dev_error="The ebuild is attempting to use ${target_pkg}, which is not "
2739 dev_error+="declared with a SLOT in [RP]DEPEND and --build-only wasn't given."
2740 # if is-java-strict; then
2741 # die "${dev_error}"
2742 # else
2743 eqawarn "java-pkg_ensure-dep: ${dev_error}"
2744 # eerror "The package will build without problems, but may fail to run"
2745 # eerror "if you don't have ${target_pkg} installed,"
2746 # eerror "so please report this to http://bugs.gentoo.org."
2747 # fi
2748 fi
2749 }
2750
2751 java-pkg_check-phase() {
2752 local phase=${1}
2753 local funcname=${FUNCNAME[1]}
2754 if [[ ${EBUILD_PHASE} != ${phase} ]]; then
2755 local msg="${funcname} used outside of src_${phase}"
2756 java-pkg_announce-qa-violation "${msg}"
2757 fi
2758 }
2759
2760 java-pkg_check-versioned-jar() {
2761 local jar=${1}
2762
2763 if [[ ${jar} =~ ${PV} ]]; then
2764 java-pkg_announce-qa-violation "installing versioned jar '${jar}'"
2765 fi
2766 }
2767
2768 java-pkg_check-jikes() {
2769 if has jikes ${IUSE}; then
2770 java-pkg_announce-qa-violation "deprecated USE flag 'jikes' in IUSE"
2771 fi
2772 }
2773
2774 java-pkg_announce-qa-violation() {
2775 local nodie
2776 if [[ ${1} == "--nodie" ]]; then
2777 nodie="true"
2778 shift
2779 fi
2780 echo "Java QA Notice: $@" >&2
2781 increment-qa-violations
2782 [[ -z "${nodie}" ]] && is-java-strict && die "${@}"
2783 }
2784
2785 increment-qa-violations() {
2786 let "JAVA_PKG_QA_VIOLATIONS+=1"
2787 export JAVA_PKG_QA_VIOLATIONS
2788 }
2789
2790 is-java-strict() {
2791 [[ -n ${JAVA_PKG_STRICT} ]]
2792 return $?
2793 }

  ViewVC Help
Powered by ViewVC 1.1.20