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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

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

Legend:
Removed from v.1.82  
changed lines
  Added in v.1.157

  ViewVC Help
Powered by ViewVC 1.1.20