/[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 - (hide annotations) (download)
Sun Jun 28 13:33:48 2015 UTC (3 years, 8 months 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 nichoj 1.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 chewi 1.158 # Copyright (c) 2004-2015, Gentoo Foundation
6 nichoj 1.1 #
7     # Licensed under the GNU General Public License, v2
8     #
9 chewi 1.165 # $Header: /var/cvsroot/gentoo-x86/eclass/java-utils-2.eclass,v 1.164 2015/06/19 14:11:24 chewi Exp $
10 nichoj 1.1
11 caster 1.155 # @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 chewi 1.157 # Ant-based packages.
25 nichoj 1.1 inherit eutils versionator multilib
26    
27 flameeyes 1.33 IUSE="elibc_FreeBSD"
28    
29 nichoj 1.1 # Make sure we use java-config-2
30     export WANT_JAVA_CONFIG="2"
31    
32 caster 1.155 # @VARIABLE: JAVA_PKG_PORTAGE_DEP
33     # @INTERNAL
34     # @DESCRIPTION:
35 betelgeuse 1.92 # 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 betelgeuse 1.121 # saving. For EAPI 2 we have new enough stuff so let's have cleaner deps.
38 ssuominen 1.141 has "${EAPI}" 0 1 && JAVA_PKG_PORTAGE_DEP=">=sys-apps/portage-2.1.2.7"
39 nichoj 1.7
40 caster 1.155 # @VARIABLE: JAVA_PKG_E_DEPEND
41     # @INTERNAL
42     # @DESCRIPTION:
43 nichoj 1.1 # This is a convience variable to be used from the other java eclasses. This is
44 betelgeuse 1.91 # 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 chewi 1.161 JAVA_PKG_E_DEPEND=">=dev-java/java-config-2.2.0 ${JAVA_PKG_PORTAGE_DEP}"
47 ssuominen 1.141 has source ${JAVA_PKG_IUSE} && JAVA_PKG_E_DEPEND="${JAVA_PKG_E_DEPEND} source? ( app-arch/zip )"
48 nichoj 1.1
49 caster 1.155 # @ECLASS-VARIABLE: JAVA_PKG_WANT_BOOTCLASSPATH
50     # @DEFAULT_UNSET
51     # @DESCRIPTION:
52 caster 1.130 # The version of bootclasspath the package needs to work. Translates to a proper
53 caster 1.155 # dependency. The bootclasspath can then be obtained by java-ant_rewrite-bootclasspath
54 caster 1.130 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 caster 1.155 # @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 nichoj 1.1 #
70 caster 1.155 # Overriding the default can be useful for testing specific VMs locally, but
71     # should not be used in the final ebuild.
72 nichoj 1.1 JAVA_PKG_ALLOW_VM_CHANGE=${JAVA_PKG_ALLOW_VM_CHANGE:="yes"}
73    
74 caster 1.155 # @ECLASS-VARIABLE: JAVA_PKG_FORCE_VM
75     # @DEFAULT_UNSET
76     # @DESCRIPTION:
77 nichoj 1.1 # 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 caster 1.155 # Example: use sun-jdk-1.5 to emerge foo:
83     # @CODE
84 nichoj 1.1 # JAVA_PKG_FORCE_VM=sun-jdk-1.5 emerge foo
85 caster 1.155 # @CODE
86 nichoj 1.1
87 caster 1.155 # @ECLASS-VARIABLE: JAVA_PKG_WANT_BUILD_VM
88     # @DEFAULT_UNSET
89     # @DESCRIPTION:
90 sera 1.150 # 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 caster 1.155 # Requires JAVA_PKG_WANT_SOURCE and JAVA_PKG_WANT_TARGET to be set as well.
98 sera 1.150
99 caster 1.155 # @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 nichoj 1.1 # See java-pkg_get-source function below.
106     #
107 caster 1.155 # Should generally only be used for testing and debugging.
108 nichoj 1.1 #
109 caster 1.155 # Use 1.4 source to emerge baz
110     # @CODE
111 nichoj 1.1 # JAVA_PKG_WANT_SOURCE=1.4 emerge baz
112 caster 1.155 # @CODE
113 nichoj 1.1
114 caster 1.155 # @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 nichoj 1.1 # See java-pkg_get-target function below.
121     #
122 caster 1.155 # Should generallyonly be used for testing and debugging.
123 nichoj 1.1 #
124 caster 1.155 # emerge bar to be compatible with 1.3
125     # @CODE
126 nichoj 1.1 # JAVA_PKG_WANT_TARGET=1.3 emerge bar
127 caster 1.155 # @CODE
128 nichoj 1.1
129 caster 1.155 # @VARIABLE: JAVA_PKG_COMPILER_DIR
130     # @INTERNAL
131     # @DESCRIPTION:
132 nichoj 1.1 # Directory where compiler settings are saved, without trailing slash.
133 caster 1.155 # You probably shouldn't touch this variable except local testing.
134 nichoj 1.1 JAVA_PKG_COMPILER_DIR=${JAVA_PKG_COMPILER_DIR:="/usr/share/java-config-2/compiler"}
135    
136 caster 1.155 # @VARIABLE: JAVA_PKG_COMPILERS_CONF
137     # @INTERNAL
138     # @DESCRIPTION:
139 nichoj 1.1 # Path to file containing information about which compiler to use.
140 caster 1.155 # Can be overloaded, but it should be overloaded only for local testing.
141 nichoj 1.1 JAVA_PKG_COMPILERS_CONF=${JAVA_PKG_COMPILERS_CONF:="/etc/java-config-2/build/compilers.conf"}
142    
143 caster 1.155 # @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 nichoj 1.1 #
150 caster 1.155 # Useful for local testing.
151 nichoj 1.1 #
152 caster 1.155 # Use jikes and javac, in that order
153     # @CODE
154 nichoj 1.1 # JAVA_PKG_FORCE_COMPILER="jikes javac"
155 caster 1.155 # @CODE
156 nichoj 1.1
157 caster 1.155 # @ECLASS-VARIABLE: JAVA_PKG_FORCE_ANT_TASKS
158     # @DEFAULT_UNSET
159     # @DESCRIPTION:
160 caster 1.46 # 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 caster 1.155 # @CODE
166     # JAVA_PKG_FORCE_ANT_TASKS="ant-junit ant-trax" \
167 caster 1.46 # ebuild foo.ebuild compile
168 caster 1.155 # @CODE
169 caster 1.46
170 nichoj 1.1 # TODO document me
171     JAVA_PKG_QA_VIOLATIONS=0
172    
173 caster 1.155 # @FUNCTION: java-pkg_doexamples
174     # @USAGE: [--subdir <subdir>] <file1/dir1> [<file2> ...]
175     # @DESCRIPTION:
176 betelgeuse 1.63 # 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 caster 1.155 # @CODE
181     # Parameters:
182     # --subdir - If the examples need a certain directory structure
183     # $* - list of files to install
184     #
185     # Examples:
186 betelgeuse 1.63 # java-pkg_doexamples demo
187     # java-pkg_doexamples demo/* examples/*
188 caster 1.155 # @CODE
189 betelgeuse 1.63 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 radhermit 1.156 java-pkg_init_paths_
196 betelgeuse 1.63
197     local dest=/usr/share/doc/${PF}/examples
198 betelgeuse 1.93 if [[ ${1} == --subdir ]]; then
199     local dest=${dest}/${2}
200     dodir ${dest}
201     shift 2
202     fi
203    
204 betelgeuse 1.63 if [[ ${#} = 1 && -d ${1} ]]; then
205 vapier 1.69 ( # dont want to pollute calling env
206     insinto "${dest}"
207     doins -r ${1}/*
208     ) || die "Installing examples failed"
209 betelgeuse 1.63 else
210 vapier 1.69 ( # dont want to pollute calling env
211     insinto "${dest}"
212     doins -r "$@"
213     ) || die "Installing examples failed"
214 betelgeuse 1.63 fi
215 serkan 1.138
216     # Let's make a symlink to the directory we have everything else under
217     dosym "${dest}" "${JAVA_PKG_SHAREPATH}/examples" || die
218 betelgeuse 1.63 }
219 nichoj 1.1
220 chewi 1.163 # @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 caster 1.155 # @FUNCTION: java-pkg_dojar
252     # @USAGE: <jar1> [<jar2> ...]
253     # @DESCRIPTION:
254 nichoj 1.1 # 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 betelgeuse 1.19 # You should never install a jar with a package version in the filename.
258 nichoj 1.1 # Instead, use java-pkg_newjar defined below.
259     #
260 caster 1.155 # @CODE
261 nichoj 1.1 # java-pkg_dojar dist/${PN}.jar dist/${PN}-core.jar
262 caster 1.155 # @CODE
263 nichoj 1.1 #
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 caster 1.50 for jar in "${@}"; do
279 nichoj 1.1 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 betelgeuse 1.43 # 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 nichoj 1.1 # install it into JARDEST if it's a non-symlink
293     if [[ ! -L "${jar}" ]] ; then
294 betelgeuse 1.55 #but first check class version when in strict mode.
295     is-java-strict && java-pkg_verify-classes "${jar}"
296    
297 nichoj 1.1 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 caster 1.155 # @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 nichoj 1.1 # This would mostly be used if the package has make or a custom script to
321     # install things.
322     #
323 nelchael 1.5 # WARNING:
324 caster 1.155 # 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 nelchael 1.5 #
327 caster 1.155 # @CODE
328 nelchael 1.5 # java-pkg_regjar ${D}/opt/my-java/lib/*.jar
329 caster 1.155 # @CODE
330 nichoj 1.1 #
331 caster 1.155
332 nichoj 1.10 # TODO should we be making sure the jar is present on ${D} or wherever?
333 nichoj 1.1 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 caster 1.50 for jar in "${@}"; do
344 nichoj 1.1 # TODO use java-pkg_check-versioned-jar
345 betelgeuse 1.38 if [[ -e "${jar}" || -e "${D}${jar}" ]]; then
346     [[ -d "${jar}" || -d "${D}${jar}" ]] \
347     && die "Called ${FUNCNAME} on a directory $*"
348 betelgeuse 1.55
349     #check that class version correct when in strict mode
350     is-java-strict && java-pkg_verify-classes "${jar}"
351    
352 nelchael 1.5 # 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 nichoj 1.1 else
359 betelgeuse 1.68 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 betelgeuse 1.126 debug-print "${jar} or ${D}${jar} not found"
365 nichoj 1.1 die "${jar} does not exist"
366     fi
367     done
368    
369     java-pkg_do_write_
370     }
371    
372 caster 1.155 # @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 nichoj 1.1 #
377 caster 1.155 # For example, installs a versioned jar without the version
378 nichoj 1.1 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 betelgeuse 1.44 [[ ! -f ${original_jar} ]] \
387     && die "${original_jar} does not exist or is not a file!"
388 nichoj 1.1
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 caster 1.155 # @FUNCTION: java-pkg_addcp
396     # @USAGE: <classpath>
397     # @DESCRIPTION:
398 nichoj 1.1 # 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 caster 1.155 # The parameters of this function are appended to JAVA_PKG_CLASSPATH
401 nichoj 1.1 java-pkg_addcp() {
402     java-pkg_append_ JAVA_PKG_CLASSPATH "${@}"
403     java-pkg_do_write_
404     }
405    
406 caster 1.155 # @FUNCTION: java-pkg_doso
407     # @USAGE: <path/to/file1.so> [...]
408     # @DESCRIPTION:
409 nichoj 1.1 # 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 caster 1.155 # @CODE
414 nichoj 1.1 # Example:
415     # java-pkg_doso *.so
416 caster 1.155 # @CODE
417 nichoj 1.1 java-pkg_doso() {
418     debug-print-function ${FUNCNAME} $*
419    
420     java-pkg_check-phase install
421    
422 caster 1.127 [[ ${#} -lt 1 ]] && die "${FUNCNAME} requires at least one argument"
423 nichoj 1.1
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 chewi 1.160 INSOPTIONS="-m0755" \
435 tove 1.111 doins "${lib}" || die "failed to install ${lib}"
436 nichoj 1.1 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 caster 1.127 dosym "$(readlink "${lib}")" "${JAVA_PKG_LIBDEST}/${lib##*/}"
441     debug-print "${lib} is a symlink, linking accordantly"
442 nichoj 1.1 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 caster 1.155 # @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 nichoj 1.1 #
461     # Example:
462     # java-pkg_regso *.so /path/*.so
463 caster 1.155 # @CODE
464 nichoj 1.1 java-pkg_regso() {
465     debug-print-function ${FUNCNAME} $*
466    
467     java-pkg_check-phase install
468    
469 caster 1.127 [[ ${#} -lt 1 ]] && die "${FUNCNAME} requires at least one argument"
470 nichoj 1.1
471     java-pkg_init_paths_
472 betelgeuse 1.19
473 nichoj 1.1 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 caster 1.155 # @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 nichoj 1.1 java-pkg_jarinto() {
496     debug-print-function ${FUNCNAME} $*
497    
498     JAVA_PKG_JARDEST="${1}"
499     }
500    
501 caster 1.155 # @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 nichoj 1.1 java-pkg_sointo() {
507     debug-print-function ${FUNCNAME} $*
508    
509     JAVA_PKG_LIBDEST="${1}"
510     }
511    
512 caster 1.155 # @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 nichoj 1.1 #
517 caster 1.155 # @CODE
518 nichoj 1.1 # java-pkg_dohtml dist/docs/
519 caster 1.155 # @CODE
520 nichoj 1.1 java-pkg_dohtml() {
521     debug-print-function ${FUNCNAME} $*
522    
523     [[ ${#} -lt 1 ]] && die "At least one argument required for ${FUNCNAME}"
524 betelgeuse 1.27
525 betelgeuse 1.31 # from /usr/lib/portage/bin/dohtml -h
526     # -f Set list of allowed extensionless file names.
527 nichoj 1.1 dohtml -f package-list "$@"
528 betelgeuse 1.31
529 nichoj 1.1 # 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 caster 1.155 # @FUNCTION: java-pkg_dojavadoc
536     # @USAGE: [--symlink destination] <path/to/javadocs/root>
537     # @DESCRIPTION:
538 betelgeuse 1.30 # Installs javadoc documentation. This should be controlled by the doc use flag.
539     #
540 caster 1.155 # @CODE
541     # Parameters:
542     # $1: optional --symlink creates to symlink like this for html
543 betelgeuse 1.99 # documentation bundles.
544 caster 1.155 # $2: - The javadoc root directory.
545 betelgeuse 1.30 #
546 caster 1.155 # Examples:
547 betelgeuse 1.30 # java-pkg_dojavadoc docs/api
548 caster 1.155 # java-pkg_dojavadoc --symlink apidocs docs/api
549     # @CODE
550 nichoj 1.1 java-pkg_dojavadoc() {
551 betelgeuse 1.74 debug-print-function ${FUNCNAME} $*
552 betelgeuse 1.99
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 nichoj 1.1 local dir="$1"
561 betelgeuse 1.99 local dest=/usr/share/doc/${PF}/html
562 nichoj 1.1
563 betelgeuse 1.74 # QA checks
564    
565 nichoj 1.1 java-pkg_check-phase install
566 radhermit 1.156 java-pkg_init_paths_
567 nichoj 1.1
568     [[ -z "${dir}" ]] && die "Must specify a directory!"
569     [[ ! -d "${dir}" ]] && die "${dir} does not exist, or isn't a directory!"
570 betelgeuse 1.74 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 betelgeuse 1.99 if [[ -e ${D}/${dest}/api ]]; then
577     eerror "${dest} already exists. Will not overwrite."
578     die "${dest}"
579     fi
580    
581 betelgeuse 1.74 # Renaming to match our directory layout
582 nichoj 1.1
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 betelgeuse 1.74 # Actual installation
591    
592 betelgeuse 1.99 java-pkg_dohtml -r "${dir_to_install}"
593    
594     # Let's make a symlink to the directory we have everything else under
595 betelgeuse 1.100 dosym ${dest}/api "${JAVA_PKG_SHAREPATH}/api" || die
596 betelgeuse 1.99
597     if [[ ${symlink} ]]; then
598 betelgeuse 1.106 debug-print "symlinking ${dest}/{api,${symlink}}"
599 betelgeuse 1.99 dosym ${dest}/{api,${symlink}} || die
600     fi
601 nichoj 1.1 }
602    
603 caster 1.155 # @FUNCTION: java-pkg_dosrc
604     # @USAGE: <path/to/sources> [...]
605     # @DESCRIPTION:
606 betelgeuse 1.19 # Installs a zip containing the source for a package, so it can used in
607 nichoj 1.1 # from IDEs like eclipse and netbeans.
608 caster 1.155 # Ebuild needs to DEPEND on app-arch/zip to use this. It also should be controlled by USE=source.
609 nichoj 1.1 #
610 caster 1.155 # @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 nichoj 1.1 #
618 caster 1.155 # TODO should we be able to handle multiple calls to dosrc? -nichoj
619 nichoj 1.1 #
620 caster 1.155 # TODO maybe we can take an existing zip/jar? -nichoj
621 nichoj 1.1 #
622     # FIXME apparently this fails if you give it an empty directories
623     java-pkg_dosrc() {
624     debug-print-function ${FUNCNAME} $*
625    
626 betelgeuse 1.19 [ ${#} -lt 1 ] && die "At least one argument needed"
627 nichoj 1.1
628     java-pkg_check-phase install
629    
630 betelgeuse 1.19 [[ ${#} -lt 1 ]] && die "At least one argument needed"
631 nichoj 1.1
632 betelgeuse 1.66 if ! [[ ${DEPEND} = *app-arch/zip* ]]; then
633     local msg="${FUNCNAME} called without app-arch/zip in DEPEND"
634 betelgeuse 1.104 java-pkg_announce-qa-violation ${msg}
635 betelgeuse 1.66 fi
636    
637 nichoj 1.1 java-pkg_init_paths_
638    
639     local zip_name="${PN}-src.zip"
640     local zip_path="${T}/${zip_name}"
641     local dir
642 caster 1.50 for dir in "${@}"; do
643 nichoj 1.1 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 caster 1.155 # @FUNCTION: java-pkg_dolauncher
664     # @USAGE: <filename> [options]
665     # @DESCRIPTION:
666 nichoj 1.1 # Make a wrapper script to lauch/start this package
667     # If necessary, the wrapper will switch to the appropriate VM.
668     #
669 betelgeuse 1.25 # 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 caster 1.155 # @CODE
673     # Parameters:
674     # $1 - filename of launcher to create
675     # $2 - options, as follows:
676     # --main the.main.class.to.start
677 betelgeuse 1.25 # --jar /the/jar/too/launch.jar or just <name>.jar
678 betelgeuse 1.20 # --java_args 'Extra arguments to pass to java'
679 caster 1.42 # --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 caster 1.155 # @CODE
684 nichoj 1.1 java-pkg_dolauncher() {
685     debug-print-function ${FUNCNAME} $*
686    
687     java-pkg_check-phase install
688 betelgeuse 1.25 java-pkg_init_paths_
689 nichoj 1.1
690 betelgeuse 1.25 if [[ ${#} = 0 ]]; then
691     local name="${PN}"
692     else
693     local name="${1}"
694     shift
695     fi
696 nichoj 1.1
697     # TODO rename to launcher
698     local target="${T}/${name}"
699 betelgeuse 1.20 local var_tmp="${T}/launcher_variables_tmp"
700 nichoj 1.1 local target_dir pre
701    
702 betelgeuse 1.20 # Process the other the rest of the arguments
703 nichoj 1.1 while [[ -n "${1}" && -n "${2}" ]]; do
704 betelgeuse 1.38 local var="${1}" value="${2}"
705 betelgeuse 1.19 if [[ "${var:0:2}" == "--" ]]; then
706 betelgeuse 1.25 local var=${var:2}
707     echo "gjl_${var}=\"${value}\"" >> "${var_tmp}"
708 betelgeuse 1.26 local gjl_${var}="${value}"
709 nichoj 1.1 elif [[ "${var}" == "-into" ]]; then
710     target_dir="${value}"
711     elif [[ "${var}" == "-pre" ]]; then
712     pre="${value}"
713     fi
714     shift 2
715     done
716 betelgeuse 1.20
717 betelgeuse 1.25 # 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 betelgeuse 1.20 # Write the actual script
732     echo "#!/bin/bash" > "${target}"
733 caster 1.42 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 nichoj 1.1 echo "gjl_package=${JAVA_PKG_NAME}" >> "${target}"
741 betelgeuse 1.20 cat "${var_tmp}" >> "${target}"
742 caster 1.21 rm -f "${var_tmp}"
743 nichoj 1.1 echo "source /usr/share/java-config-2/launcher/launcher.bash" >> "${target}"
744 betelgeuse 1.19
745 nichoj 1.17 if [[ -n "${target_dir}" ]]; then
746 nichoj 1.1 DESTTREE="${target_dir}" dobin "${target}"
747     local ret=$?
748     return ${ret}
749     else
750     dobin "${target}"
751     fi
752     }
753    
754 caster 1.155 # @FUNCTION: java-pkg_dowar
755     # @DESCRIPTION:
756 nichoj 1.1 # 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 betelgeuse 1.18
784 nichoj 1.1 # Install those files like you mean it
785     INSOPTIONS="-m 0644" \
786     INSDESTTREE=${JAVA_PKG_WARDEST} \
787     doins ${warpath}
788     done
789     }
790    
791 caster 1.155 # @FUNCTION: java-pkg_recordjavadoc
792     # @INTERNAL
793     # @DESCRIPTION:
794 nichoj 1.1 # Scan for JavaDocs, and record their existence in the package.env file
795 caster 1.155
796 nichoj 1.1 # 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 caster 1.155 # @FUNCTION: java-pkg_jar-from
815     # @USAGE: [--build-only] [--with-dependencies] [--virtual] [--into dir] <package> [<package.jar>] [<destination.jar>]
816     # @DESCRIPTION:
817 nichoj 1.1 # 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 nichoj 1.16 # 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 nichoj 1.1 #
824 caster 1.155 # @CODE
825 nichoj 1.1 # Example: get all jars from xerces slot 2
826     # java-pkg_jar-from xerces-2
827 caster 1.155 #
828 nichoj 1.1 # Example: get a specific jar from xerces slot 2
829     # java-pkg_jar-from xerces-2 xml-apis.jar
830 caster 1.155 #
831 nichoj 1.16 # Example: get a specific jar from xerces slot 2, and name it diffrently
832 nichoj 1.1 # java-pkg_jar-from xerces-2 xml-apis.jar xml.jar
833 caster 1.155 #
834 nichoj 1.16 # Example: get junit.jar which is needed only for building
835     # java-pkg_jar-from --build-only junit junit.jar
836 caster 1.155 # @CODE
837 nichoj 1.1 #
838 caster 1.155 # @CODE
839     # Parameters
840 caster 1.49 # --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 ali_bush 1.94 # --virtual - Packages passed to this function are to be handled as virtuals
845     # and will not have individual jar dependencies recorded.
846 caster 1.49 # --into $dir - symlink jar(s) into $dir (must exist) instead of .
847 caster 1.155 # $1 - Package to get jars from, or comma-separated list of packages in
848 caster 1.79 # case other parameters are not used.
849 caster 1.155 # $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 nichoj 1.1 # symlink. Defaults to the name of the jar.
852 caster 1.155 # @CODE
853    
854 nichoj 1.1 # TODO could probably be cleaned up a little
855     java-pkg_jar-from() {
856     debug-print-function ${FUNCNAME} $*
857    
858 nichoj 1.16 local build_only=""
859 caster 1.49 local destdir="."
860     local deep=""
861 ali_bush 1.94 local virtual=""
862 ali_bush 1.129 local record_jar=""
863 betelgeuse 1.59
864 caster 1.78 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="build"
865 nichoj 1.16
866 caster 1.49 while [[ "${1}" == --* ]]; do
867     if [[ "${1}" = "--build-only" ]]; then
868 caster 1.77 build_only="build"
869 caster 1.49 elif [[ "${1}" = "--with-dependencies" ]]; then
870     deep="--with-dependencies"
871 ali_bush 1.94 elif [[ "${1}" = "--virtual" ]]; then
872     virtual="true"
873 caster 1.49 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 nichoj 1.16 shift
880 caster 1.49 done
881 betelgeuse 1.43
882 betelgeuse 1.18 local target_pkg="${1}" target_jar="${2}" destjar="${3}"
883    
884 nichoj 1.1 [[ -z ${target_pkg} ]] && die "Must specify a package"
885    
886 ali_bush 1.105 if [[ "${EAPI}" == "1" ]]; then
887     target_pkg="${target_pkg//:/-}"
888     fi
889    
890 nichoj 1.1 # default destjar to the target jar
891     [[ -z "${destjar}" ]] && destjar="${target_jar}"
892    
893 betelgeuse 1.18 local error_msg="There was a problem getting the classpath for ${target_pkg}."
894     local classpath
895 betelgeuse 1.43 classpath="$(java-config ${deep} --classpath=${target_pkg})"
896 betelgeuse 1.18 [[ $? != 0 ]] && die ${error_msg}
897 nichoj 1.1
898 betelgeuse 1.60 # When we have commas this functions is called to bring jars from multiple
899 caster 1.79 # packages. This affects recording of dependencencies performed later
900     # which expects one package only, so we do it here.
901 betelgeuse 1.60 if [[ ${target_pkg} = *,* ]]; then
902 caster 1.79 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 ali_bush 1.129 record_jar="true"
908 caster 1.79 else
909     java-pkg_ensure-dep "${build_only}" "${target_pkg}"
910 betelgeuse 1.60 fi
911    
912 ali_bush 1.94 # 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 ali_bush 1.129 record_jar="true"
918 ali_bush 1.94 fi
919    
920 caster 1.79 pushd ${destdir} > /dev/null \
921     || die "failed to change directory to ${destdir}"
922    
923 nichoj 1.1 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 ali_bush 1.129 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 chewi 1.159 # otherwise, if the current jar is the target jar, link it
943 nichoj 1.1 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 ali_bush 1.129 if [[ -z "${record_jar}" ]]; then
948     if [[ -z "${build_only}" ]]; then
949     java-pkg_record-jar_ "${target_pkg}" "${jar}"
950     else
951 chewi 1.159 java-pkg_record-jar_ --build-only "${target_pkg}" "${jar}"
952 ali_bush 1.129 fi
953     fi
954 betelgeuse 1.54 popd > /dev/null
955 nichoj 1.1 return 0
956     fi
957     done
958 caster 1.49 popd > /dev/null
959 nichoj 1.1 # 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 caster 1.155 # @FUNCTION: java-pkg_jarfrom
969     # @DESCRIPTION:
970 nichoj 1.1 # See java-pkg_jar-from
971     java-pkg_jarfrom() {
972     java-pkg_jar-from "$@"
973     }
974    
975 caster 1.155 # @FUNCTION: java-pkg_getjars
976     # @USAGE: [--build-only] [--with-dependencies] <package1>[,<package2>...]
977     # @DESCRIPTION:
978 nichoj 1.1 # Get the classpath provided by any number of packages
979     # Among other things, this can be passed to 'javac -classpath' or 'ant -lib'.
980 nichoj 1.16 # 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 betelgeuse 1.19 #
985 caster 1.155 # @CODE
986 betelgeuse 1.30 # Example: Get the classpath for xerces-2 and xalan,
987     # java-pkg_getjars xerces-2,xalan
988 caster 1.155 #
989 nichoj 1.1 # 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 betelgeuse 1.19 #
992 caster 1.155 #
993     # Parameters:
994 caster 1.49 # --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 caster 1.155 # $1 - list of packages to get jars from
999 betelgeuse 1.30 # (passed to java-config --classpath)
1000 caster 1.155 # @CODE
1001 nichoj 1.1 java-pkg_getjars() {
1002     debug-print-function ${FUNCNAME} $*
1003    
1004 caster 1.49 local build_only=""
1005     local deep=""
1006 betelgeuse 1.59
1007 caster 1.78 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="build"
1008 nichoj 1.16
1009 caster 1.49 while [[ "${1}" == --* ]]; do
1010     if [[ "${1}" = "--build-only" ]]; then
1011 caster 1.77 build_only="build"
1012 caster 1.49 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 betelgeuse 1.43 shift
1018 caster 1.49 done
1019 betelgeuse 1.43
1020 caster 1.49 [[ ${#} -ne 1 ]] && die "${FUNCNAME} takes only one argument besides --*"
1021 betelgeuse 1.38
1022 ali_bush 1.70
1023 betelgeuse 1.106 local pkgs="${1}"
1024 ali_bush 1.105
1025     if [[ "${EAPI}" == "1" ]]; then
1026     pkgs="${pkgs//:/-}"
1027     fi
1028    
1029 betelgeuse 1.43 jars="$(java-config ${deep} --classpath=${pkgs})"
1030 betelgeuse 1.106 [[ $? != 0 ]] && die "java-config --classpath=${pkgs} failed"
1031 betelgeuse 1.30 debug-print "${pkgs}:${jars}"
1032    
1033 betelgeuse 1.73 for pkg in ${pkgs//,/ }; do
1034 ali_bush 1.70 java-pkg_ensure-dep "${build_only}" "${pkg}"
1035     done
1036    
1037 ali_bush 1.129 for pkg in ${pkgs//,/ }; do
1038     if [[ -z "${build_only}" ]]; then
1039 betelgeuse 1.30 java-pkg_record-jar_ "${pkg}"
1040 ali_bush 1.129 else
1041     java-pkg_record-jar_ --build-only "${pkg}"
1042     fi
1043     done
1044 betelgeuse 1.18
1045 betelgeuse 1.106 echo "${jars}"
1046 nichoj 1.1 }
1047    
1048 caster 1.155 # @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 nichoj 1.16 # 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 nichoj 1.1 #
1057 caster 1.155 # @CODE
1058     # Example:
1059 nichoj 1.1 # java-pkg_getjar xerces-2 xml-apis.jar
1060 caster 1.155 # returns
1061 nichoj 1.1 # /usr/share/xerces-2/lib/xml-apis.jar
1062 betelgeuse 1.19 #
1063 caster 1.155 # Parameters:
1064 caster 1.49 # --build-only - makes the jar not added into package.env DEPEND line.
1065 ali_bush 1.94 # --virtual - Packages passed to this function are to be handled as virtuals
1066     # and will not have individual jar dependencies recorded.
1067 caster 1.155 # $1 - package to use
1068     # $2 - jar to get
1069     # @CODE
1070 nichoj 1.1 java-pkg_getjar() {
1071     debug-print-function ${FUNCNAME} $*
1072    
1073 nichoj 1.16 local build_only=""
1074 ali_bush 1.94 local virtual=""
1075 ali_bush 1.129 local record_jar=""
1076 betelgeuse 1.59
1077 caster 1.78 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="build"
1078 nichoj 1.16
1079 caster 1.49 while [[ "${1}" == --* ]]; do
1080     if [[ "${1}" = "--build-only" ]]; then
1081 caster 1.77 build_only="build"
1082 caster 1.101 elif [[ "${1}" == "--virtual" ]]; then
1083 ali_bush 1.94 virtual="true"
1084 caster 1.49 else
1085 caster 1.102 die "java-pkg_getjar called with unknown parameter: ${1}"
1086 caster 1.49 fi
1087 nichoj 1.16 shift
1088 caster 1.49 done
1089    
1090     [[ ${#} -ne 2 ]] && die "${FUNCNAME} takes only two arguments besides --*"
1091 nichoj 1.16
1092 nichoj 1.1 local pkg="${1}" target_jar="${2}" jar
1093 ali_bush 1.105
1094     if [[ "${EAPI}" == "1" ]]; then
1095     pkg="${pkg//:/-}"
1096     fi
1097    
1098 nichoj 1.1 [[ -z ${pkg} ]] && die "Must specify package to get a jar from"
1099     [[ -z ${target_jar} ]] && die "Must specify jar to get"
1100    
1101 betelgeuse 1.18 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 ali_bush 1.70 java-pkg_ensure-dep "${build_only}" "${pkg}"
1107    
1108 ali_bush 1.94 # 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 ali_bush 1.129 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 ali_bush 1.94 fi
1118    
1119 nichoj 1.1 for jar in ${classpath//:/ }; do
1120     if [[ ! -f "${jar}" ]] ; then
1121 nichoj 1.16 die "Installation problem with jar ${jar} in ${pkg} - is it installed?"
1122 nichoj 1.1 fi
1123    
1124     if [[ "$(basename ${jar})" == "${target_jar}" ]] ; then
1125 nichoj 1.16 # Only record jars that aren't build-only
1126 ali_bush 1.129 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 nichoj 1.1 echo "${jar}"
1134     return 0
1135     fi
1136     done
1137 betelgeuse 1.19
1138 nichoj 1.1 die "Could not find ${target_jar} in ${pkg}"
1139     return 1
1140     }
1141    
1142 caster 1.155 # @FUNCTION: java-pkg_register-dependency
1143     # @USAGE: <package>[,<package2>...] [<jarfile>]
1144     # @DESCRIPTION:
1145 caster 1.77 # 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 caster 1.155 # @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 caster 1.77 # to depend on
1157     #
1158 caster 1.155 # Examples:
1159     # Record the dependency on whole xerces-2 and xalan,
1160 caster 1.77 # java-pkg_register-dependency xerces-2,xalan
1161 caster 1.155 #
1162     # Record the dependency on ant.jar from ant-core
1163 caster 1.77 # java-pkg_register-dependency ant-core ant.jar
1164 caster 1.155 # @CODE
1165 caster 1.77 #
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 ali_bush 1.105 if [[ "${EAPI}" == "1" ]]; then
1184     pkgs="${pkgs//:/-}"
1185     fi
1186    
1187 caster 1.77 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 caster 1.85 java-pkg_do_write_
1200     }
1201    
1202 caster 1.155 # @FUNCTION: java-pkg_register-optional-dependency
1203     # @USAGE: <package>[,<package2>...] [<jarfile>]
1204     # @DESCRIPTION:
1205 caster 1.88 # 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 caster 1.155 # @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 caster 1.88 #
1218 caster 1.155 # Example:
1219     # Record the optional dependency on some jdbc providers
1220 caster 1.88 # java-pkg_register-optional-dependency jdbc-jaybird,jtds-1.2,jdbc-mysql
1221 caster 1.155 # @CODE
1222 caster 1.88 #
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 ali_bush 1.105 if [[ "${EAPI}" == "1" ]]; then
1241     pkgs="${pkgs//:/-}"
1242     fi
1243    
1244 caster 1.88 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 caster 1.155 # @FUNCTION: java-pkg_register-environment-variable
1258     # @USAGE: <name> <value>
1259     # @DESCRIPTION:
1260 caster 1.85 # 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 caster 1.77 }
1278    
1279 caster 1.155 # @FUNCTION: java-pkg_get-bootclasspath
1280     # @USAGE: <version>
1281     # @DESCRIPTION:
1282 caster 1.132 # 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 vapier 1.142 case "${version}" in
1291 caster 1.132 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 nichoj 1.1 # 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 betelgeuse 1.19 #
1327 nichoj 1.1 # # 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 caster 1.155 # @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 betelgeuse 1.40 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 caster 1.155 # @FUNCTION: java-pkg_ensure-no-bundled-jars
1360     # @DESCRIPTION:
1361 betelgeuse 1.40 # 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 nichoj 1.1 java-pkg_ensure-no-bundled-jars() {
1365     debug-print-function ${FUNCNAME} $*
1366    
1367 betelgeuse 1.40 local bundled_jars=$(java-pkg_find-normal-jars)
1368 nichoj 1.1 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 caster 1.155 # @FUNCTION: java-pkg_ensure-vm-version-sufficient
1379     # @INTERNAL
1380     # @DESCRIPTION:
1381 nichoj 1.1 # 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 caster 1.155 # @FUNCTION: java-pkg_is-vm-version-sufficient
1394     # @INTERNAL
1395     # @DESCRIPTION:
1396     # @RETURN: zero - VM is sufficient; non-zero - VM is not sufficient
1397 nichoj 1.1 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 caster 1.155 # @FUNCTION: java-pkg_ensure-vm-version-eq
1405     # @INTERNAL
1406     # @DESCRIPTION:
1407 nichoj 1.1 # 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 caster 1.155 # @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 nichoj 1.1 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 caster 1.155 # @FUNCTION: java-pkg_ensure-vm-version-ge
1452     # @INTERNAL
1453     # @DESCRIPTION:
1454 nichoj 1.1 # 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 betelgeuse 1.19
1460 nichoj 1.1 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 caster 1.155 # @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 nichoj 1.1 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 nichoj 1.12 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 ssuominen 1.141 has $(java-pkg_get-current-vm) ${@}
1506 nichoj 1.12 return $?
1507     }
1508    
1509 caster 1.155 # @FUNCTION: java-pkg_get-source
1510     # @DESCRIPTION:
1511 nichoj 1.1 # 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 caster 1.155 # @RETURN: string - Either the lowest possible source, or JAVA_PKG_WANT_SOURCE
1515 nichoj 1.1 java-pkg_get-source() {
1516     echo ${JAVA_PKG_WANT_SOURCE:-$(depend-java-query --get-lowest "${DEPEND} ${RDEPEND}")}
1517     }
1518    
1519 caster 1.155 # @FUNCTION: java-pkg_get-target
1520     # @DESCRIPTION:
1521 nichoj 1.1 # 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 betelgeuse 1.19 # version of your JDK.
1524 nichoj 1.1 #
1525 caster 1.155 # @RETURN: string - Either the lowest possible target, or JAVA_PKG_WANT_TARGET
1526 nichoj 1.1 java-pkg_get-target() {
1527 caster 1.37 echo ${JAVA_PKG_WANT_TARGET:-$(depend-java-query --get-lowest "${DEPEND} ${RDEPEND}")}
1528 nichoj 1.1 }
1529    
1530 caster 1.155 # @FUNCTION: java-pkg_get-javac
1531     # @DESCRIPTION:
1532     # Returns the compiler executable
1533 nichoj 1.1 java-pkg_get-javac() {
1534     debug-print-function ${FUNCNAME} $*
1535    
1536 caster 1.24
1537 nichoj 1.1 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 caster 1.24 if [[ -z ${compiler_executable} ]]; then
1555     echo "JAVAC is empty or undefined in ${compiler_env}"
1556     return 1
1557     fi
1558 betelgeuse 1.19
1559 nichoj 1.1 # check that it's executable
1560     if [[ ! -x ${compiler_executable} ]]; then
1561 caster 1.24 echo "${compiler_executable} doesn't exist, or isn't executable"
1562     return 1
1563 nichoj 1.1 fi
1564     else
1565 caster 1.24 echo "Could not find environment file for ${compiler}"
1566     return 1
1567 nichoj 1.1 fi
1568     fi
1569     echo ${compiler_executable}
1570     }
1571    
1572 caster 1.155 # @FUNCTION: java-pkg_javac-args
1573     # @DESCRIPTION:
1574 nichoj 1.1 # If an ebuild uses javac directly, instead of using ejavac, it should call this
1575     # to know what -source/-target to use.
1576     #
1577 caster 1.155 # @RETURN: string - arguments to pass to javac, complete with -target and -source
1578 nichoj 1.1 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 betelgeuse 1.19 local source_str="-source ${want_source}"
1585 nichoj 1.1 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 caster 1.24 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 nichoj 1.1 else
1595 chewi 1.165 echo "${source_str} ${target_str}"
1596 nichoj 1.1 fi
1597     }
1598    
1599 caster 1.155 # @FUNCTION: java-pkg_get-jni-cflags
1600     # @DESCRIPTION:
1601     # Echos the CFLAGS for JNI compilations
1602 nichoj 1.1 java-pkg_get-jni-cflags() {
1603     local flags="-I${JAVA_HOME}/include"
1604    
1605 flameeyes 1.33 local platform="linux"
1606     use elibc_FreeBSD && platform="freebsd"
1607    
1608 nichoj 1.10 # TODO do a check that the directories are valid
1609 flameeyes 1.33 flags="${flags} -I${JAVA_HOME}/include/${platform}"
1610 nichoj 1.1
1611     echo ${flags}
1612     }
1613    
1614 nichoj 1.10 java-pkg_ensure-gcj() {
1615 sera 1.151 # was enforcing sys-devel/gcc[gcj]
1616     die "${FUNCNAME} was removed. Use use-deps available as of EAPI 2 instead. #261562"
1617 nichoj 1.10 }
1618    
1619 nichoj 1.13 java-pkg_ensure-test() {
1620 sera 1.151 # was enforcing USE=test if FEATURES=test
1621     die "${FUNCNAME} was removed. Package mangers handle this already. #278965"
1622 nichoj 1.13 }
1623    
1624 caster 1.155 # @FUNCTION: java-pkg_register-ant-task
1625     # @USAGE: [--version x.y] [<name>]
1626     # @DESCRIPTION:
1627 caster 1.46 # 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 caster 1.155 # @CODE
1635     # Parameters
1636     # --version x.y Register only for ant version x.y (otherwise for any ant
1637 caster 1.46 # 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 caster 1.155 # $1 Name to register as. Defaults to JAVA_PKG_NAME ($PN[-$SLOT])
1641     # @CODE
1642 caster 1.46 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 caster 1.155 # @FUNCTION: java-pkg_ant-tasks-depend
1664     # @INTERNAL
1665     # @DESCRIPTION:
1666 caster 1.46 # 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 betelgeuse 1.110 if [[ ${i} = ant-* ]]; then
1675     DEP="${DEP}dev-java/${i} "
1676     elif [[ ${i} = */*:* ]]; then
1677     DEP="${DEP}${i} "
1678     else
1679 caster 1.46 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 serkan 1.136
1691 caster 1.155 # @FUNCTION: ejunit_
1692     # @INTERNAL
1693     # @DESCRIPTION:
1694 serkan 1.136 # Internal Junit wrapper function. Makes it easier to run the tests and checks for
1695 betelgeuse 1.84 # dev-java/junit in DEPEND. Launches the tests using junit.textui.TestRunner.
1696 caster 1.155 # @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 serkan 1.136 ejunit_() {
1704 betelgeuse 1.84 debug-print-function ${FUNCNAME} $*
1705    
1706 betelgeuse 1.87 local pkgs
1707 betelgeuse 1.106 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 betelgeuse 1.87
1713 serkan 1.136 local junit=${1}
1714     shift 1
1715    
1716     local cp=$(java-pkg_getjars --with-dependencies ${junit}${pkgs})
1717 betelgeuse 1.84 if [[ ${1} = -cp || ${1} = -classpath ]]; then
1718 betelgeuse 1.87 cp="${2}:${cp}"
1719 betelgeuse 1.84 shift 2
1720     else
1721 betelgeuse 1.87 cp=".:${cp}"
1722 betelgeuse 1.84 fi
1723    
1724     local runner=junit.textui.TestRunner
1725 serkan 1.138 if [[ "${junit}" == "junit-4" ]] ; then
1726     runner=org.junit.runner.JUnitCore
1727     fi
1728 betelgeuse 1.84 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 caster 1.155 # @FUNCTION: ejunit
1733     # @DESCRIPTION:
1734 serkan 1.136 # Junit wrapper function. Makes it easier to run the tests and checks for
1735 serkan 1.139 # dev-java/junit in DEPEND. Launches the tests using org.junit.runner.JUnitCore.
1736 serkan 1.136 #
1737 caster 1.155 # @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 serkan 1.136 # Examples:
1744     # ejunit -cp build/classes org.blinkenlights.jid3.test.AllTests
1745     # ejunit org.blinkenlights.jid3.test.AllTests
1746 caster 1.155 # ejunit org.blinkenlights.jid3.test.FirstTest org.blinkenlights.jid3.test.SecondTest
1747     # @CODE
1748 serkan 1.136 ejunit() {
1749     debug-print-function ${FUNCNAME} $*
1750    
1751     ejunit_ "junit" "${@}"
1752     }
1753    
1754 caster 1.155 # @FUNCTION: ejunit4
1755     # @DESCRIPTION:
1756 serkan 1.136 # 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 caster 1.155 # @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 serkan 1.136 # Examples:
1766 serkan 1.137 # ejunit4 -cp build/classes org.blinkenlights.jid3.test.AllTests
1767     # ejunit4 org.blinkenlights.jid3.test.AllTests
1768 serkan 1.138 # ejunit4 org.blinkenlights.jid3.test.FirstTest \
1769     # org.blinkenlights.jid3.test.SecondTest
1770 caster 1.155 # @CODE
1771 serkan 1.136 ejunit4() {
1772     debug-print-function ${FUNCNAME} $*
1773    
1774     ejunit_ "junit-4" "${@}"
1775     }
1776    
1777 caster 1.155 # @FUNCTION: java-utils-2_src_prepare
1778     # @DESCRIPTION:
1779 betelgeuse 1.113 # src_prepare Searches for bundled jars
1780 caster 1.117 # Don't call directly, but via java-pkg-2_src_prepare!
1781 betelgeuse 1.113 java-utils-2_src_prepare() {
1782 betelgeuse 1.125 [[ ${EBUILD_PHASE} == prepare ]] &&
1783     java-pkg_func-exists java_prepare && java_prepare
1784    
1785 betelgeuse 1.113 # 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 caster 1.155 # @FUNCTION: java-utils-2_pkg_preinst
1797     # @DESCRIPTION:
1798 serkan 1.122 # 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 chewi 1.159 if [[ ! -e "${JAVA_PKG_ENV}" ]] || has ant-tasks ${INHERITED}; then
1803     return
1804     fi
1805    
1806 serkan 1.122 if has_version dev-java/java-dep-check; then
1807     local output=$(GENTOO_VM= java-dep-check --image "${D}" "${JAVA_PKG_ENV}")
1808 chewi 1.159 [[ ${output} ]] && ewarn "${output}"
1809 serkan 1.122 else
1810     eerror "Install dev-java/java-dep-check for dependency checking"
1811     fi
1812     fi
1813     }
1814    
1815 caster 1.155 # @FUNCTION: eant
1816     # @USAGE: <ant_build_target(s)>
1817     # @DESCRIPTION:
1818 nichoj 1.1 # Ant wrapper function. Will use the appropriate compiler, based on user-defined
1819 caster 1.46 # compiler. Will also set proper ANT_TASKS from the variable ANT_TASKS,
1820 betelgeuse 1.41 # variables:
1821 chewi 1.157 #
1822 caster 1.155 # @CODE
1823     # Variables:
1824 betelgeuse 1.41 # EANT_GENTOO_CLASSPATH - calls java-pkg_getjars for the value and adds to the
1825 caster 1.155 # gentoo.classpath property. Be sure to call java-ant_rewrite-classpath in src_unpack.
1826 caster 1.120 # EANT_NEEDS_TOOLS - add tools.jar to the gentoo.classpath. Should only be used
1827 caster 1.155 # 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 nichoj 1.1 eant() {
1832     debug-print-function ${FUNCNAME} $*
1833    
1834 betelgeuse 1.92 if [[ ${EBUILD_PHASE} = compile ]]; then
1835 betelgeuse 1.113 java-ant-2_src_configure
1836     java-utils-2_src_prepare
1837 betelgeuse 1.92 fi
1838    
1839 ssuominen 1.141 if ! has java-ant-2 ${INHERITED}; then
1840 betelgeuse 1.52 local msg="You should inherit java-ant-2 when using eant"
1841 caster 1.82 java-pkg_announce-qa-violation "${msg}"
1842 betelgeuse 1.51 fi
1843    
1844 caster 1.96 local antflags="-Dnoget=true -Dmaven.mode.offline=true -Dbuild.sysclasspath=ignore"
1845 betelgeuse 1.57
1846 nichoj 1.1 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 caster 1.36 antflags="${antflags} -Dbuild.compiler=${build_compiler}"
1857 nichoj 1.1 # 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 nichoj 1.9
1867 betelgeuse 1.52 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 betelgeuse 1.53 eerror "with JAVA_PKG_STRICT. Please use for example java-pkg_jar-from"
1872 betelgeuse 1.52 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 betelgeuse 1.110 # 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 caster 1.103 # default ANT_TASKS to WANT_ANT_TASKS, if ANT_TASKS is not set explicitly
1895 betelgeuse 1.110 ANT_TASKS="${ANT_TASKS:-${want_ant_tasks% }}"
1896 caster 1.46
1897 caster 1.103 # override ANT_TASKS with JAVA_PKG_FORCE_ANT_TASKS if it's set
1898     ANT_TASKS="${JAVA_PKG_FORCE_ANT_TASKS:-${ANT_TASKS}}"
1899 caster 1.46
1900 caster 1.103 # if ant-tasks is not set by ebuild or forced, use none
1901     ANT_TASKS="${ANT_TASKS:-none}"
1902 betelgeuse 1.52
1903 caster 1.103 # 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 caster 1.46 fi
1911    
1912 caster 1.103 export ANT_TASKS
1913    
1914 caster 1.46 [[ -n ${JAVA_PKG_DEBUG} ]] && antflags="${antflags} --execdebug -debug"
1915 betelgeuse 1.45 [[ -n ${PORTAGE_QUIET} ]] && antflags="${antflags} -q"
1916 betelgeuse 1.19
1917 betelgeuse 1.41 local gcp="${EANT_GENTOO_CLASSPATH}"
1918 caster 1.76 local getjarsarg=""
1919 betelgeuse 1.41
1920 betelgeuse 1.57 if [[ ${EBUILD_PHASE} = "test" ]]; then
1921     antflags="${antflags} -DJunit.present=true"
1922 caster 1.76 getjarsarg="--with-dependencies"
1923 chewi 1.159
1924     local re="\bant-junit4?([-:]\S+)?\b"
1925     [[ ${ANT_TASKS} =~ ${re} ]] && gcp+=" ${BASH_REMATCH[0]}"
1926 caster 1.147 else
1927     antflags="${antflags} -Dmaven.test.skip=true"
1928 betelgeuse 1.57 fi
1929    
1930     local cp
1931    
1932     for atom in ${gcp}; do
1933 chewi 1.164 cp+=":$(java-pkg_getjars ${getjarsarg} ${atom})"
1934 betelgeuse 1.57 done
1935    
1936 chewi 1.164 [[ ${EANT_NEEDS_TOOLS} ]] && cp+=":$(java-config --tools)"
1937     [[ ${EANT_GENTOO_CLASSPATH_EXTRA} ]] && cp+=":${EANT_GENTOO_CLASSPATH_EXTRA}"
1938 caster 1.120
1939 chewi 1.164 if [[ ${cp#:} ]]; then
1940 betelgeuse 1.41 # It seems ant does not like single quotes around ${cp}
1941 chewi 1.164 antflags="${antflags} -Dgentoo.classpath=\"${cp#:}\""
1942 betelgeuse 1.41 fi
1943    
1944 nichoj 1.1 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ant ${antflags} "${@}"
1945 betelgeuse 1.75 debug-print "Calling ant (GENTOO_VM: ${GENTOO_VM}): ${antflags} ${@}"
1946 nichoj 1.1 ant ${antflags} "${@}" || die "eant failed"
1947     }
1948    
1949 caster 1.155 # @FUNCTION: ejavac
1950     # @USAGE: <javac_arguments>
1951     # @DESCRIPTION:
1952 betelgeuse 1.19 # Javac wrapper function. Will use the appropriate compiler, based on
1953 nichoj 1.1 # /etc/java-config/compilers.conf
1954     ejavac() {
1955     debug-print-function ${FUNCNAME} $*
1956    
1957 caster 1.24 java-pkg_init-compiler_
1958 nichoj 1.1
1959 caster 1.24 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 nichoj 1.1 }
1976    
1977 chewi 1.157 # @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 caster 1.155 # @FUNCTION: java-pkg_filter-compiler
1995     # @USAGE: <compiler(s)_to_filter>
1996     # @DESCRIPTION:
1997 nichoj 1.1 # 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 caster 1.155 # @FUNCTION: java-pkg_force-compiler
2004     # @USAGE: <compiler(s)_to_force>
2005     # @DESCRIPTION:
2006 nichoj 1.8 # 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 caster 1.155 # @FUNCTION: use_doc
2014     # @DESCRIPTION:
2015 nichoj 1.1 #
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 betelgeuse 1.19 #
2019 nichoj 1.1 # The output of this should be passed to ant.
2020 caster 1.155 # @CODE
2021     # Parameters:
2022     # $@ - Option value to return. Defaults to 'javadoc'
2023 nichoj 1.1 #
2024 caster 1.155 # Examples:
2025     # build javadocs by calling 'javadoc' target
2026 nichoj 1.1 # eant $(use_doc)
2027 caster 1.155 #
2028     # build javadocs by calling 'apidoc' target
2029 nichoj 1.1 # eant $(use_doc apidoc)
2030 caster 1.155 # @CODE
2031     # @RETURN string - Name of the target to create javadocs
2032 nichoj 1.1 use_doc() {
2033     use doc && echo ${@:-javadoc}
2034     }
2035    
2036 betelgeuse 1.38
2037 caster 1.155 # @FUNCTION: java-pkg_init
2038     # @INTERNAL
2039     # @DESCRIPTION:
2040 nichoj 1.1 # 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 betelgeuse 1.97 debug-print-function ${FUNCNAME} $*
2049 sera 1.148
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 nichoj 1.1 unset JAVAC
2057     unset JAVA_HOME
2058 betelgeuse 1.64
2059 betelgeuse 1.116 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 betelgeuse 1.64 # People do all kinds of weird things.
2068     # http://forums.gentoo.org/viewtopic-p-3943166.html
2069 betelgeuse 1.65 local silence="${SILENCE_JAVA_OPTIONS_WARNING}"
2070 betelgeuse 1.64 local accept="${I_WANT_GLOBAL_JAVA_OPTIONS}"
2071 betelgeuse 1.65 if [[ -n ${_JAVA_OPTIONS} && -z ${accept} && -z ${silence} ]]; then
2072 betelgeuse 1.64 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 betelgeuse 1.98 # export _JAVA_OPTIONS= doesn't work because it will show up in java
2082     # -version output
2083     unset _JAVA_OPTIONS
2084 betelgeuse 1.64 # phase hooks make this run many times without this
2085     I_WANT_GLOBAL_JAVA_OPTIONS="true"
2086     fi
2087    
2088 betelgeuse 1.92 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 nichoj 1.1 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 betelgeuse 1.97 # 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 betelgeuse 1.19 # When users have crazy classpaths some packages can fail to compile.
2104 nichoj 1.1 # and everything should work with empty CLASSPATH.
2105     # This also helps prevent unexpected dependencies on random things
2106     # from the CLASSPATH.
2107 betelgeuse 1.97 export CLASSPATH=
2108 betelgeuse 1.59
2109 caster 1.46 # Unset external ANT_ stuff
2110 betelgeuse 1.97 export ANT_TASKS=
2111     export ANT_OPTS=
2112 caster 1.118 export ANT_RESPECT_JAVA_HOME=
2113 nichoj 1.1 }
2114    
2115 caster 1.155 # @FUNCTION: java-pkg-init-compiler_
2116     # @INTERNAL
2117     # @DESCRIPTION:
2118 nichoj 1.1 # This function attempts to figure out what compiler should be used. It does
2119 betelgeuse 1.19 # this by reading the file at JAVA_PKG_COMPILERS_CONF, and checking the
2120 nichoj 1.1 # COMPILERS variable defined there.
2121     # This can be overridden by a list in JAVA_PKG_FORCE_COMPILER
2122 betelgeuse 1.19 #
2123 nichoj 1.1 # 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 caster 1.155 # @RETURN name of the compiler to use
2139 nichoj 1.1 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 nichoj 1.3 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 betelgeuse 1.19
2154 nichoj 1.1 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 betelgeuse 1.19
2167 nichoj 1.1 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 betelgeuse 1.19
2174 nichoj 1.1 # 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 chewi 1.165 # 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 nichoj 1.1 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 betelgeuse 1.104 einfo "No suitable compiler found: defaulting to JDK default for compilation"
2210 nichoj 1.1 else
2211     # probably don't need to notify users about the default.
2212     :;#einfo "Defaulting to javac for compilation"
2213     fi
2214 betelgeuse 1.104 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 nichoj 1.1 else
2220     einfo "Using ${GENTOO_COMPILER} for compilation"
2221     fi
2222    
2223     }
2224    
2225 caster 1.155 # @FUNCTION: init_paths_
2226     # @INTERNAL
2227     # @DESCRIPTION:
2228 nichoj 1.1 # 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 radhermit 1.154 if [[ "${SLOT%/*}" == "0" ]] ; then
2235 nichoj 1.1 JAVA_PKG_NAME="${PN}"
2236     else
2237 radhermit 1.154 JAVA_PKG_NAME="${PN}-${SLOT%/*}"
2238 nichoj 1.1 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 ali_bush 1.94 JAVA_PKG_VIRTUALS_PATH="${DESTTREE}/share/java-config-2/virtuals"
2244     JAVA_PKG_VIRTUAL_PROVIDER="${D}/${JAVA_PKG_VIRTUALS_PATH}/${JAVA_PKG_NAME}"
2245 nichoj 1.1
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 caster 1.155 # @FUNCTION: java-pkg_do_write_
2259     # @INTERNAL
2260     # @DESCRIPTION:
2261 nichoj 1.1 # Writes the package.env out to disk.
2262     #
2263     # TODO change to do-write, to match everything else
2264     java-pkg_do_write_() {
2265 betelgeuse 1.87 debug-print-function ${FUNCNAME} $*
2266 betelgeuse 1.28 java-pkg_init_paths_
2267 nichoj 1.1 # Create directory for package.env
2268     dodir "${JAVA_PKG_SHAREPATH}"
2269 betelgeuse 1.87 if [[ -n "${JAVA_PKG_CLASSPATH}" || -n "${JAVA_PKG_LIBRARY}" || -f \
2270 caster 1.88 "${JAVA_PKG_DEPEND_FILE}" || -f \
2271     "${JAVA_PKG_OPTIONAL_DEPEND_FILE}" ]]; then
2272 nichoj 1.1 # Create package.env
2273     (
2274     echo "DESCRIPTION=\"${DESCRIPTION}\""
2275     echo "GENERATION=\"2\""
2276 betelgeuse 1.104 echo "SLOT=\"${SLOT}\""
2277 ali_bush 1.129 echo "CATEGORY=\"${CATEGORY}\""
2278     echo "PVR=\"${PVR}\""
2279 nichoj 1.1
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 betelgeuse 1.87 [[ -f "${JAVA_PKG_DEPEND_FILE}" ]] \
2284 betelgeuse 1.133 && echo "DEPEND=\"$(sort -u "${JAVA_PKG_DEPEND_FILE}" | tr '\n' ':')\""
2285 caster 1.88 [[ -f "${JAVA_PKG_OPTIONAL_DEPEND_FILE}" ]] \
2286 betelgeuse 1.133 && echo "OPTIONAL_DEPEND=\"$(sort -u "${JAVA_PKG_OPTIONAL_DEPEND_FILE}" | tr '\n' ':')\""
2287 nichoj 1.1 echo "VM=\"$(echo ${RDEPEND} ${DEPEND} | sed -e 's/ /\n/g' | sed -n -e '/virtual\/\(jre\|jdk\)/ { p;q }')\"" # TODO cleanup !
2288 ali_bush 1.129 [[ -f "${JAVA_PKG_BUILD_DEPEND_FILE}" ]] \
2289 betelgeuse 1.133 && echo "BUILD_DEPEND=\"$(sort -u "${JAVA_PKG_BUILD_DEPEND_FILE}" | tr '\n' ':')\""
2290 nichoj 1.1 ) > "${JAVA_PKG_ENV}"
2291 betelgeuse 1.19
2292 nichoj 1.1 # 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 caster 1.85 # 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 nichoj 1.1 # 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 betelgeuse 1.87 else
2321 caster 1.88 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 betelgeuse 1.87 debug-print "write package.env."
2324 nichoj 1.1 fi
2325     }
2326    
2327 caster 1.155 # @FUNCTION: java-pkg_record-jar_
2328     # @INTERNAL
2329     # @DESCRIPTION:
2330 caster 1.88 # Record an (optional) dependency to the package.env
2331 caster 1.155 # @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 betelgeuse 1.87 JAVA_PKG_DEPEND_FILE="${T}/java-pkg-depend"
2339 caster 1.88 JAVA_PKG_OPTIONAL_DEPEND_FILE="${T}/java-pkg-optional-depend"
2340 ali_bush 1.129 JAVA_PKG_BUILD_DEPEND_FILE="${T}/java-pkg-build-depend"
2341 nichoj 1.1
2342     java-pkg_record-jar_() {
2343     debug-print-function ${FUNCNAME} $*
2344    
2345 caster 1.88 local depend_file="${JAVA_PKG_DEPEND_FILE}"
2346 ali_bush 1.129 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 caster 1.88
2351 nichoj 1.1 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 caster 1.88 echo "${append}" >> "${depend_file}"
2359 nichoj 1.1 }
2360    
2361 caster 1.155 # @FUNCTION: java-pkg_append_
2362     # @INTERNAL
2363     # @DESCRIPTION:
2364     # Appends a value to a variable
2365 nichoj 1.1 #
2366 caster 1.155 # @CODE
2367     # Parameters:
2368     # $1 variable name to modify
2369     # $2 value to append
2370 nichoj 1.1 #
2371 caster 1.155 # Examples:
2372     # java-pkg_append_ CLASSPATH foo.jar
2373     # @CODE
2374 nichoj 1.1 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 caster 1.155 # @FUNCTION: java-pkg_expand_dir_
2395     # @INTERNAL
2396     # @DESCRIPTION:
2397 nichoj 1.1 # Gets the full path of the file/directory's parent.
2398 caster 1.155 # @CODE
2399     # Parameters:
2400     # $1 - file/directory to find parent directory for
2401     # @CODE
2402     # @RETURN: path to $1's parent directory
2403 nichoj 1.1 java-pkg_expand_dir_() {
2404     pushd "$(dirname "${1}")" >/dev/null 2>&1
2405     pwd
2406     popd >/dev/null 2>&1
2407     }
2408    
2409 caster 1.155 # @FUNCTION: java-pkg_func-exists
2410     # @INTERNAL
2411     # @DESCRIPTION:
2412 nichoj 1.1 # Does the indicated function exist?
2413 caster 1.155 # @RETURN: 0 - function is declared, 1 - function is undeclared
2414 nichoj 1.1 java-pkg_func-exists() {
2415 betelgeuse 1.126 declare -F ${1} > /dev/null
2416 nichoj 1.1 }
2417    
2418 caster 1.155 # @FUNCTION: java-pkg_setup-vm
2419     # @INTERNAL
2420     # @DESCRIPTION:
2421 nichoj 1.1 # 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 caster 1.23 if [[ "${vendor}" == "sun" ]] && java-pkg_is-vm-version-ge "1.5" ; then
2427 nichoj 1.1 addpredict "/dev/random"
2428     elif [[ "${vendor}" == "ibm" ]]; then
2429     addpredict "/proc/self/maps"
2430     addpredict "/proc/cpuinfo"
2431 serkan 1.143 addpredict "/proc/self/coredump_filter"
2432     elif [[ "${vendor}" == "oracle" ]]; then
2433     addpredict "/dev/random"
2434     addpredict "/proc/self/coredump_filter"
2435 serkan 1.145 elif [[ "${vendor}" == icedtea* ]] && java-pkg_is-vm-version-ge "1.7" ; then
2436 serkan 1.144 addpredict "/dev/random"
2437     addpredict "/proc/self/coredump_filter"
2438 nichoj 1.1 elif [[ "${vendor}" == "jrockit" ]]; then
2439     addpredict "/proc/cpuinfo"
2440     fi
2441     }
2442    
2443 caster 1.155 # @FUNCTION: java-pkg_needs-vm
2444     # @INTERNAL
2445     # @DESCRIPTION:
2446 sera 1.150 # Does the current package depend on virtual/jdk or does it set
2447     # JAVA_PKG_WANT_BUILD_VM?
2448 nichoj 1.1 #
2449 caster 1.155 # @RETURN: 0 - Package depends on virtual/jdk; 1 - Package does not depend on virtual/jdk
2450 nichoj 1.1 java-pkg_needs-vm() {
2451     debug-print-function ${FUNCNAME} $*
2452    
2453 caster 1.134 if [[ -n "$(echo ${JAVA_PKG_NV_DEPEND:-${DEPEND}} | sed -e '\:virtual/jdk:!d')" ]]; then
2454 nichoj 1.1 return 0
2455     fi
2456    
2457 sera 1.150 [[ -n "${JAVA_PKG_WANT_BUILD_VM}" ]] && return 0
2458    
2459 nichoj 1.1 return 1
2460     }
2461    
2462 caster 1.155 # @FUNCTION: java-pkg_get-current-vm
2463     # @INTERNAL
2464     # @RETURN - The current VM being used
2465 nichoj 1.1 java-pkg_get-current-vm() {
2466     java-config -f
2467     }
2468    
2469 caster 1.155 # @FUNCTION: java-pkg_get-vm-vendor
2470     # @INTERNAL
2471     # @RETURN - The vendor of the current VM
2472 nichoj 1.1 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 caster 1.155 # @FUNCTION: java-pkg_get-vm-version
2481     # @INTERNAL
2482     # @RETURN - The version of the current VM
2483 nichoj 1.1 java-pkg_get-vm-version() {
2484     debug-print-function ${FUNCNAME} $*
2485    
2486 caster 1.22 java-config -g PROVIDES_VERSION
2487 nichoj 1.1 }
2488    
2489 caster 1.155 # @FUNCTION: java-pkg_build-vm-from-handle
2490     # @INTERNAL
2491     # @DESCRIPTION:
2492 sera 1.150 # 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 caster 1.155 # @RETURN - VM handle of an available JDK
2497 sera 1.150 java-pkg_build-vm-from-handle() {
2498     debug-print-function ${FUNCNAME} "$*"
2499    
2500     local vm
2501 sera 1.152 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 sera 1.150 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 caster 1.155 # @FUNCTION: java-pkg_switch-vm
2521     # @INTERNAL
2522     # @DESCRIPTION:
2523 betelgeuse 1.19 # Switch VM if we're allowed to (controlled by JAVA_PKG_ALLOW_VM_CHANGE), and
2524 nichoj 1.1 # verify that the current VM is sufficient.
2525     # Setup the environment for the VM being used.
2526     java-pkg_switch-vm() {
2527 betelgeuse 1.38 debug-print-function ${FUNCNAME} $*
2528    
2529 nichoj 1.1 if java-pkg_needs-vm; then
2530     # Use the VM specified by JAVA_PKG_FORCE_VM
2531 betelgeuse 1.38 if [[ -n "${JAVA_PKG_FORCE_VM}" ]]; then
2532 nichoj 1.1 # If you're forcing the VM, I hope you know what your doing...
2533 betelgeuse 1.38 debug-print "JAVA_PKG_FORCE_VM used: ${JAVA_PKG_FORCE_VM}"
2534 nichoj 1.1 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 sera 1.150 # 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 caster 1.24 else
2557 sera 1.150 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 nichoj 1.1 fi
2565 sera 1.150 export GENTOO_VM
2566 nichoj 1.1 # 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 betelgeuse 1.19
2572 nichoj 1.1 java-pkg_setup-vm
2573    
2574 nichoj 1.4 export JAVA=$(java-config --java)
2575     export JAVAC=$(java-config --javac)
2576 caster 1.24 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 nichoj 1.1
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 betelgeuse 1.19
2590 nichoj 1.1 local tann="${T}/announced-vm"
2591 betelgeuse 1.92 # 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 nichoj 1.1 if [[ -n "${JAVA_PKG_DEBUG}" ]] || [[ ! -f "${tann}" ]] ; then
2594 betelgeuse 1.92 einfo "Using: $(java-config -f)"
2595     [[ ! -f "${tann}" ]] && touch "${tann}"
2596 nichoj 1.1 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 caster 1.155 # @FUNCTION: java-pkg_die
2604     # @INTERNAL
2605     # @DESCRIPTION:
2606 nichoj 1.1 # 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 ssuominen 1.141 if ! has java-pkg_die ${EBUILD_DEATH_HOOKS}; then
2610 nichoj 1.1 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 sera 1.153 echo "and of course, the output of emerge --info =${P}" >&2
2618 nichoj 1.1 }
2619    
2620 nichoj 1.7
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 caster 1.155 # @FUNCTION: java-pkg_verify-classes
2635     # @INTERNAL
2636     # @DESCRIPTION:
2637 caster 1.56 # Verify that the classes were compiled for the right source / target. Dies if
2638     # not.
2639 caster 1.155 # @CODE
2640     # $1 (optional) - the file to check, otherwise checks whole ${D}
2641     # @CODE
2642 nichoj 1.7 java-pkg_verify-classes() {
2643     #$(find ${D} -type f -name '*.jar' -o -name '*.class')
2644 ali_bush 1.108
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 betelgeuse 1.55 local target=$(java-pkg_get-target)
2659 caster 1.56 local result
2660     local log="${T}/class-version-verify.log"
2661 betelgeuse 1.55 if [[ -n "${1}" ]]; then
2662 ali_bush 1.108 ${version_verify} -v -t ${target} "${1}" > "${log}"
2663 caster 1.56 result=$?
2664 betelgeuse 1.55 else
2665 caster 1.56 ebegin "Verifying java class versions (target: ${target})"
2666 ali_bush 1.108 ${version_verify} -v -t ${target} -r "${D}" > "${log}"
2667 caster 1.56 result=$?
2668     eend ${result}
2669 betelgeuse 1.55 fi
2670 caster 1.56 [[ -n ${JAVA_PKG_DEBUG} ]] && cat "${log}"
2671 betelgeuse 1.55 if [[ ${result} != 0 ]]; then
2672 caster 1.56 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 nichoj 1.7 fi
2677     }
2678    
2679 caster 1.155 # @FUNCTION: java-pkg_ensure-dep
2680     # @INTERNAL
2681     # @DESCRIPTION:
2682 ali_bush 1.70 # Check that a package being used in jarfrom, getjars and getjar is contained
2683 chewi 1.159 # within DEPEND or RDEPEND with the correct SLOT. See this mail for details:
2684     # https://archives.gentoo.org/gentoo-dev/message/dcb644f89520f4bbb61cc7bbe45fdf6e
2685 caster 1.155 # @CODE
2686     # Parameters:
2687     # $1 - empty - check both vars; "runtime" or "build" - check only
2688 caster 1.77 # RDEPEND, resp. DEPEND
2689 caster 1.155 # $2 - Package name and slot.
2690     # @CODE
2691 ali_bush 1.70 java-pkg_ensure-dep() {
2692     debug-print-function ${FUNCNAME} $*
2693    
2694 caster 1.77 local limit_to="${1}"
2695 ali_bush 1.70 local target_pkg="${2}"
2696     local dev_error=""
2697    
2698 chewi 1.158 # 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 chewi 1.159 # * 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 chewi 1.158 #
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 chewi 1.159 local stripped_pkg=/$(sed -r 's/[-:]?([^-:]+)$/(\0(-[^:]+)?:0|(-[^:]+)?:\1)/' <<< "${target_pkg//./\\.}")\\b
2719 ali_bush 1.70
2720 betelgeuse 1.87 debug-print "Matching against: ${stripped_pkg}"
2721    
2722 chewi 1.159 # 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 chewi 1.158 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 chewi 1.159 # if is-java-strict; then
2730     # die "${dev_error}"
2731     # else
2732     eqawarn "java-pkg_ensure-dep: ${dev_error}"
2733 chewi 1.158 # 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 chewi 1.159 # fi
2737 chewi 1.158 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 chewi 1.159 # if is-java-strict; then
2741     # die "${dev_error}"
2742     # else
2743     eqawarn "java-pkg_ensure-dep: ${dev_error}"
2744 chewi 1.158 # 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 chewi 1.159 # fi
2748 ali_bush 1.70 fi
2749     }
2750    
2751 nichoj 1.1 java-pkg_check-phase() {
2752     local phase=${1}
2753 caster 1.82 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 nichoj 1.1 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 ssuominen 1.141 if has jikes ${IUSE}; then
2770 nichoj 1.1 java-pkg_announce-qa-violation "deprecated USE flag 'jikes' in IUSE"
2771     fi
2772     }
2773    
2774     java-pkg_announce-qa-violation() {
2775 caster 1.82 local nodie
2776     if [[ ${1} == "--nodie" ]]; then
2777     nodie="true"
2778     shift
2779 nichoj 1.1 fi
2780 caster 1.82 echo "Java QA Notice: $@" >&2
2781     increment-qa-violations
2782     [[ -z "${nodie}" ]] && is-java-strict && die "${@}"
2783 nichoj 1.1 }
2784    
2785     increment-qa-violations() {
2786     let "JAVA_PKG_QA_VIOLATIONS+=1"
2787     export JAVA_PKG_QA_VIOLATIONS
2788     }
2789    
2790 nichoj 1.9 is-java-strict() {
2791 nichoj 1.14 [[ -n ${JAVA_PKG_STRICT} ]]
2792 nichoj 1.9 return $?
2793     }

  ViewVC Help
Powered by ViewVC 1.1.20