/[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.10 Revision 1.50
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-2005, 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.50 2007/01/26 20:24:23 caster Exp $
9 10
10 11
11# ----------------------------------------------------------------------------- 12# -----------------------------------------------------------------------------
12# @eclass-begin 13# @eclass-begin
13# @eclass-shortdesc Java Utility eclass 14# @eclass-shortdesc Java Utility eclass
14# @eclass-maintainer java@gentoo.org 15# @eclass-maintainer java@gentoo.org
15# 16#
16# This eclass provides functionality which is used by 17# This eclass provides functionality which is used by
17# java-pkg.eclass and java-pkg-opt.eclass as well as from ebuilds. 18# java-pkg.eclass and java-pkg-opt.eclass as well as from ebuilds.
18# 19#
19# @warning 20# @warning
20# You probably don't want to inherit this directly from an ebuild. Instead, 21# You probably don't want to inherit this directly from an ebuild. Instead,
21# you should inherit java-ant for Ant-based Java packages, java-pkg for other 22# you should inherit java-ant for Ant-based Java packages, java-pkg for other
22# Java packages, or java-pkg-opt for packages that have optional Java support. 23# Java packages, or java-pkg-opt for packages that have optional Java support.
23# 24#
24# ----------------------------------------------------------------------------- 25# -----------------------------------------------------------------------------
25 26
26inherit eutils versionator multilib 27inherit eutils versionator multilib
28
29IUSE="elibc_FreeBSD"
27 30
28# ----------------------------------------------------------------------------- 31# -----------------------------------------------------------------------------
29# @section-begin variables 32# @section-begin variables
30# @section-title Variables 33# @section-title Variables
31# 34#
33# ----------------------------------------------------------------------------- 36# -----------------------------------------------------------------------------
34 37
35# Make sure we use java-config-2 38# Make sure we use java-config-2
36export WANT_JAVA_CONFIG="2" 39export WANT_JAVA_CONFIG="2"
37 40
38# TODO document 41# -----------------------------------------------------------------------------
42# @variable-external WANT_ANT_TASKS
43# @variable-default ""
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# @variable-internal JAVA_PKG_PORTAGE_DEP
61#
62# The version of portage we need to function properly. At this moment it's
63# portage with phase hooks support.
64# -----------------------------------------------------------------------------
39JAVA_PKG_PORTAGE_DEP=">=sys-apps/portage-2.1_pre1" 65JAVA_PKG_PORTAGE_DEP=">=sys-apps/portage-2.1_pre1"
40 66
41# ----------------------------------------------------------------------------- 67# -----------------------------------------------------------------------------
42# @variable-internal JAVA_PKG_E_DEPEND 68# @variable-internal JAVA_PKG_E_DEPEND
43# 69#
44# This is a convience variable to be used from the other java eclasses. This is 70# This is a convience variable to be used from the other java eclasses. This is
45# the version of java-config we want to use. We also need a recent version 71# the version of java-config we want to use. We also need a recent version
46# portage, that includes phase hooks. 72# portage, that includes phase hooks.
47# ----------------------------------------------------------------------------- 73# -----------------------------------------------------------------------------
48JAVA_PKG_E_DEPEND=">=dev-java/java-config-2.0.19-r1 ${JAVA_PKG_PORTAGE_DEP}" 74JAVA_PKG_E_DEPEND=">=dev-java/java-config-2.0.19-r1 ${JAVA_PKG_PORTAGE_DEP}"
49 75
50# ----------------------------------------------------------------------------- 76# -----------------------------------------------------------------------------
100# ----------------------------------------------------------------------------- 126# -----------------------------------------------------------------------------
101 127
102# ----------------------------------------------------------------------------- 128# -----------------------------------------------------------------------------
103# @variable-internal JAVA_PKG_COMPILER_DIR 129# @variable-internal JAVA_PKG_COMPILER_DIR
104# @default /usr/share/java-config-2/compiler 130# @default /usr/share/java-config-2/compiler
105# 131#
106# Directory where compiler settings are saved, without trailing slash. 132# Directory where compiler settings are saved, without trailing slash.
107# Probably shouldn't touch this variable. 133# Probably shouldn't touch this variable.
108# ----------------------------------------------------------------------------- 134# -----------------------------------------------------------------------------
109JAVA_PKG_COMPILER_DIR=${JAVA_PKG_COMPILER_DIR:="/usr/share/java-config-2/compiler"} 135JAVA_PKG_COMPILER_DIR=${JAVA_PKG_COMPILER_DIR:="/usr/share/java-config-2/compiler"}
110 136
120 146
121# ----------------------------------------------------------------------------- 147# -----------------------------------------------------------------------------
122# @variable-external JAVA_PKG_FORCE_COMPILER 148# @variable-external JAVA_PKG_FORCE_COMPILER
123# 149#
124# Explicitly set a list of compilers to use. This is normally read from 150# Explicitly set a list of compilers to use. This is normally read from
125# JAVA_PKG_COMPILERS_CONF. 151# JAVA_PKG_COMPILERS_CONF.
126# 152#
127# @note This should only be used internally or for testing. 153# @note This should only be used internally or for testing.
128# @example Use jikes and javac, in that order 154# @example Use jikes and javac, in that order
129# JAVA_PKG_FORCE_COMPILER="jikes javac" 155# JAVA_PKG_FORCE_COMPILER="jikes javac"
130# ----------------------------------------------------------------------------- 156# -----------------------------------------------------------------------------
131 157
158# -----------------------------------------------------------------------------
159# @variable-external JAVA_PKG_FORCE_ANT_TASKS
160#
161# An $IFS separated list of ant tasks. Can be set in environment before calling
162# emerge/ebuild to override variables set in ebuild, mainly for testing before
163# putting the resulting (WANT_)ANT_TASKS into ebuild. Affects only ANT_TASKS in
164# eant() call, not the dependencies specified in WANT_ANT_TASKS.
165#
166# @example JAVA_PKG_FORCE_ANT_TASKS="ant-junit ant-trax" \
167# ebuild foo.ebuild compile
168#
169# @seealso WANT_ANT_TASKS
170# -----------------------------------------------------------------------------
171
132# TODO document me 172# TODO document me
133JAVA_PKG_QA_VIOLATIONS=0 173JAVA_PKG_QA_VIOLATIONS=0
134 174
135# ----------------------------------------------------------------------------- 175# -----------------------------------------------------------------------------
136# @section-end variables 176# @section-end variables
150# @ebuild-function java-pkg_dojar 190# @ebuild-function java-pkg_dojar
151# 191#
152# Installs any number of jars. 192# Installs any number of jars.
153# Jar's will be installed into /usr/share/${PN}(-${SLOT})/lib/ by default. 193# Jar's will be installed into /usr/share/${PN}(-${SLOT})/lib/ by default.
154# You can use java-pkg_jarinto to change this path. 194# You can use java-pkg_jarinto to change this path.
155# You should never install a jar with a package version in the filename. 195# You should never install a jar with a package version in the filename.
156# Instead, use java-pkg_newjar defined below. 196# Instead, use java-pkg_newjar defined below.
157# 197#
158# @example 198# @example
159# java-pkg_dojar dist/${PN}.jar dist/${PN}-core.jar 199# java-pkg_dojar dist/${PN}.jar dist/${PN}-core.jar
160# 200#
171 # Create JARDEST if it doesn't exist 211 # Create JARDEST if it doesn't exist
172 dodir ${JAVA_PKG_JARDEST} 212 dodir ${JAVA_PKG_JARDEST}
173 213
174 local jar 214 local jar
175 # for each jar 215 # for each jar
176 for jar in "$@"; do 216 for jar in "${@}"; do
177 local jar_basename=$(basename "${jar}") 217 local jar_basename=$(basename "${jar}")
178 218
179 java-pkg_check-versioned-jar ${jar_basename} 219 java-pkg_check-versioned-jar ${jar_basename}
180 220
181 # check if it exists 221 # check if it exists
182 if [[ -e "${jar}" ]] ; then 222 if [[ -e "${jar}" ]] ; then
223 # Don't overwrite if jar has already been installed with the same
224 # name
225 local dest="${D}${JAVA_PKG_JARDEST}/${jar_basename}"
226 if [[ -e "${dest}" ]]; then
227 ewarn "Overwriting ${dest}"
228 fi
229
183 # install it into JARDEST if it's a non-symlink 230 # install it into JARDEST if it's a non-symlink
184 if [[ ! -L "${jar}" ]] ; then 231 if [[ ! -L "${jar}" ]] ; then
185 INSDESTTREE="${JAVA_PKG_JARDEST}" \ 232 INSDESTTREE="${JAVA_PKG_JARDEST}" \
186 doins "${jar}" || die "failed to install ${jar}" 233 doins "${jar}" || die "failed to install ${jar}"
187 java-pkg_append_ JAVA_PKG_CLASSPATH "${JAVA_PKG_JARDEST}/${jar_basename}" 234 java-pkg_append_ JAVA_PKG_CLASSPATH "${JAVA_PKG_JARDEST}/${jar_basename}"
200 247
201 java-pkg_do_write_ 248 java-pkg_do_write_
202} 249}
203 250
204 251
252# ------------------------------------------------------------------------------
253# @internal-function depend-java-query
254#
255# Wrapper for the depend-java-query binary to enable passing USE in env.
256# Using env variables keeps this eclass working with java-config versions that
257# do not handle use flags.
258# ------------------------------------------------------------------------------
259
260depend-java-query() {
261 USE="${USE}" $(which depend-java-query) "${@}"
262}
205 263
206# ------------------------------------------------------------------------------ 264# ------------------------------------------------------------------------------
207# @ebuild-function java-pkg_regjar 265# @ebuild-function java-pkg_regjar
208# 266#
209# Records an already installed jar in the package.env 267# Records an already installed jar in the package.env
222# will not work, because: 280# will not work, because:
223# * the `for jar in "$@"` can't expand the path to jar file names, as they 281# * the `for jar in "$@"` can't expand the path to jar file names, as they
224# don't exist yet 282# don't exist yet
225# * all `if ...` inside for will fail - the file '/opt/my-java/lib/*.jar' 283# * all `if ...` inside for will fail - the file '/opt/my-java/lib/*.jar'
226# doesn't exist 284# doesn't exist
227# 285#
228# you have to use it as: 286# you have to use it as:
229# 287#
230# java-pkg_regjar ${D}/opt/my-java/lib/*.jar 288# java-pkg_regjar ${D}/opt/my-java/lib/*.jar
231# 289#
232# @param $@ - jars to record 290# @param $@ - jars to record
240 [[ ${#} -lt 1 ]] && die "at least one argument needed" 298 [[ ${#} -lt 1 ]] && die "at least one argument needed"
241 299
242 java-pkg_init_paths_ 300 java-pkg_init_paths_
243 301
244 local jar jar_dir jar_file 302 local jar jar_dir jar_file
245 for jar in "$@"; do 303 for jar in "${@}"; do
246 # TODO use java-pkg_check-versioned-jar 304 # TODO use java-pkg_check-versioned-jar
247 if [[ -e "${jar}" ]]; then 305 if [[ -e "${jar}" || -e "${D}${jar}" ]]; then
306 [[ -d "${jar}" || -d "${D}${jar}" ]] \
307 && die "Called ${FUNCNAME} on a directory $*"
248 # nelchael: we should strip ${D} in this case too, here's why: 308 # nelchael: we should strip ${D} in this case too, here's why:
249 # imagine such call: 309 # imagine such call:
250 # java-pkg_regjar ${D}/opt/java/*.jar 310 # java-pkg_regjar ${D}/opt/java/*.jar
251 # such call will fall into this case (-e ${jar}) and will 311 # such call will fall into this case (-e ${jar}) and will
252 # record paths with ${D} in package.env 312 # record paths with ${D} in package.env
253 java-pkg_append_ JAVA_PKG_CLASSPATH "${jar#${D}}" 313 java-pkg_append_ JAVA_PKG_CLASSPATH "${jar#${D}}"
254 elif [[ -e "${D}${jar}" ]]; then
255 java-pkg_append_ JAVA_PKG_CLASSPATH "${jar#${D}}"
256 else 314 else
257 die "${jar} does not exist" 315 die "${jar} does not exist"
258 fi 316 fi
259 done 317 done
260 318
261 java-pkg_do_write_ 319 java-pkg_do_write_
262} 320}
263
264 321
265# ------------------------------------------------------------------------------ 322# ------------------------------------------------------------------------------
266# @ebuild-function java-pkg_newjar 323# @ebuild-function java-pkg_newjar
267# 324#
268# Installs a jar with a new name 325# Installs a jar with a new name
279 local original_jar="${1}" 336 local original_jar="${1}"
280 local new_jar="${2:-${PN}.jar}" 337 local new_jar="${2:-${PN}.jar}"
281 local new_jar_dest="${T}/${new_jar}" 338 local new_jar_dest="${T}/${new_jar}"
282 339
283 [[ -z ${original_jar} ]] && die "Must specify a jar to install" 340 [[ -z ${original_jar} ]] && die "Must specify a jar to install"
284 [[ ! -f ${original_jar} ]] && die "${original_jar} does not exist!" 341 [[ ! -f ${original_jar} ]] \
342 && die "${original_jar} does not exist or is not a file!"
285 343
286 rm -f "${new_jar_dest}" || die "Failed to remove ${new_jar_dest}" 344 rm -f "${new_jar_dest}" || die "Failed to remove ${new_jar_dest}"
287 cp "${original_jar}" "${new_jar_dest}" \ 345 cp "${original_jar}" "${new_jar_dest}" \
288 || die "Failed to copy ${original_jar} to ${new_jar_dest}" 346 || die "Failed to copy ${original_jar} to ${new_jar_dest}"
289 java-pkg_dojar "${new_jar_dest}" 347 java-pkg_dojar "${new_jar_dest}"
290} 348}
291 349
292
293# ------------------------------------------------------------------------------ 350# ------------------------------------------------------------------------------
294# @ebuild-function java-pkg_addcp 351# @ebuild-function java-pkg_addcp
295# 352#
296# Add something to the package's classpath. For jars, you should use dojar, 353# Add something to the package's classpath. For jars, you should use dojar,
297# newjar, or regjar. This is typically used to add directories to the classpath. 354# newjar, or regjar. This is typically used to add directories to the classpath.
302java-pkg_addcp() { 359java-pkg_addcp() {
303 java-pkg_append_ JAVA_PKG_CLASSPATH "${@}" 360 java-pkg_append_ JAVA_PKG_CLASSPATH "${@}"
304 java-pkg_do_write_ 361 java-pkg_do_write_
305} 362}
306 363
307
308# ------------------------------------------------------------------------------ 364# ------------------------------------------------------------------------------
309# @ebuild-function java-pkg_doso 365# @ebuild-function java-pkg_doso
310# 366#
311# Installs any number of JNI libraries 367# Installs any number of JNI libraries
312# They will be installed into /usr/lib by default, but java-pkg_sointo 368# They will be installed into /usr/lib by default, but java-pkg_sointo
313# can be used change this path 369# can be used change this path
314# 370#
315# Example: 371# Example:
370 java-pkg_check-phase install 426 java-pkg_check-phase install
371 427
372 [[ ${#} -lt 1 ]] && "at least one argument needed" 428 [[ ${#} -lt 1 ]] && "at least one argument needed"
373 429
374 java-pkg_init_paths_ 430 java-pkg_init_paths_
375 431
376 local lib target_dir 432 local lib target_dir
377 for lib in "$@" ; do 433 for lib in "$@" ; do
378 # Check the absolute path of the lib 434 # Check the absolute path of the lib
379 if [[ -e "${lib}" ]] ; then 435 if [[ -e "${lib}" ]] ; then
380 target_dir="$(java-pkg_expand_dir_ ${lib})" 436 target_dir="$(java-pkg_expand_dir_ ${lib})"
428# ------------------------------------------------------------------------------ 484# ------------------------------------------------------------------------------
429java-pkg_dohtml() { 485java-pkg_dohtml() {
430 debug-print-function ${FUNCNAME} $* 486 debug-print-function ${FUNCNAME} $*
431 487
432 [[ ${#} -lt 1 ]] && die "At least one argument required for ${FUNCNAME}" 488 [[ ${#} -lt 1 ]] && die "At least one argument required for ${FUNCNAME}"
433 # TODO-nichoj find out what exactly -f package-list does 489
490 # from /usr/lib/portage/bin/dohtml -h
491 # -f Set list of allowed extensionless file names.
434 dohtml -f package-list "$@" 492 dohtml -f package-list "$@"
493
435 # this probably shouldn't be here but it provides 494 # this probably shouldn't be here but it provides
436 # a reasonable way to catch # docs for all of the 495 # a reasonable way to catch # docs for all of the
437 # old ebuilds. 496 # old ebuilds.
438 java-pkg_recordjavadoc 497 java-pkg_recordjavadoc
439} 498}
440 499
441# TODO document 500# ------------------------------------------------------------------------------
501# @ebuild-function java-pkg_dojavadoc
502#
503# Installs javadoc documentation. This should be controlled by the doc use flag.
504#
505# @param $1: - The javadoc root directory.
506#
507# @example:
508# java-pkg_dojavadoc docs/api
509#
510# ------------------------------------------------------------------------------
442java-pkg_dojavadoc() { 511java-pkg_dojavadoc() {
443 local dir="$1" 512 local dir="$1"
444 513
445 java-pkg_check-phase install 514 java-pkg_check-phase install
446 515
458} 527}
459 528
460# ------------------------------------------------------------------------------ 529# ------------------------------------------------------------------------------
461# @ebuild-function java-pkg_dosrc 530# @ebuild-function java-pkg_dosrc
462# 531#
463# Installs a zip containing the source for a package, so it can used in 532# Installs a zip containing the source for a package, so it can used in
464# from IDEs like eclipse and netbeans. 533# from IDEs like eclipse and netbeans.
465# 534#
466# Ebuild needs to DEPEND on app-arch/zip to use this. 535# Ebuild needs to DEPEND on app-arch/zip to use this.
467# 536#
468# It also should be controlled by USE=source. 537# It also should be controlled by USE=source.
469# 538#
470# @example: 539# @example:
471# java-pkg_dosrc src/* 540# java-pkg_dosrc src/*
472# 541#
473# ------------------------------------------------------------------------------ 542# ------------------------------------------------------------------------------
474# TODO change so it the arguments it takes are the base directories containing 543# TODO change so it the arguments it takes are the base directories containing
475# source -nichoj 544# source -nichoj
476# TODO should we be able to handle multiple calls to dosrc? -nichoj 545# TODO should we be able to handle multiple calls to dosrc? -nichoj
477# TODO maybe we can take an existing zip/jar? -nichoj 546# TODO maybe we can take an existing zip/jar? -nichoj
478# FIXME apparently this fails if you give it an empty directories 547# FIXME apparently this fails if you give it an empty directories
479java-pkg_dosrc() { 548java-pkg_dosrc() {
480 debug-print-function ${FUNCNAME} $* 549 debug-print-function ${FUNCNAME} $*
481 550
482 [ ${#} -lt 1 ] && die "At least one argument needed" 551 [ ${#} -lt 1 ] && die "At least one argument needed"
483 if ! hasq source ${IUSE}; then 552 if ! hasq source ${IUSE}; then
484 echo "Java QA Notice: ${FUNCNAME} called without source in IUSE" 553 echo "Java QA Notice: ${FUNCNAME} called without source in IUSE"
485 fi 554 fi
486 555
487 java-pkg_check-phase install 556 java-pkg_check-phase install
488 557
489 [[ ${#} -lt 1 ]] && die "At least one argument needed" 558 [[ ${#} -lt 1 ]] && die "At least one argument needed"
490 559
491 java-pkg_init_paths_ 560 java-pkg_init_paths_
492 561
493 local zip_name="${PN}-src.zip" 562 local zip_name="${PN}-src.zip"
494 local zip_path="${T}/${zip_name}" 563 local zip_path="${T}/${zip_name}"
495 local dir 564 local dir
496 for dir in ${@}; do 565 for dir in "${@}"; do
497 local dir_parent=$(dirname "${dir}") 566 local dir_parent=$(dirname "${dir}")
498 local dir_name=$(basename "${dir}") 567 local dir_name=$(basename "${dir}")
499 pushd ${dir_parent} > /dev/null || die "problem entering ${dir_parent}" 568 pushd ${dir_parent} > /dev/null || die "problem entering ${dir_parent}"
500 zip -q -r ${zip_path} ${dir_name} -i '*.java' 569 zip -q -r ${zip_path} ${dir_name} -i '*.java'
501 local result=$? 570 local result=$?
518# @ebuild-function java-pkg_dolauncher 587# @ebuild-function java-pkg_dolauncher
519# 588#
520# Make a wrapper script to lauch/start this package 589# Make a wrapper script to lauch/start this package
521# If necessary, the wrapper will switch to the appropriate VM. 590# If necessary, the wrapper will switch to the appropriate VM.
522# 591#
592# Can be called without parameters if the package installs only one jar
593# that has the Main-class attribute set. The wrapper will be named ${PN}.
594#
523# @param $1 - filename of launcher to create 595# @param $1 - filename of launcher to create
524# @param $2 - options, as follows: 596# @param $2 - options, as follows:
525# --main the.main.class.too.start 597# --main the.main.class.too.start
526# --jar /the/jar/too/launch.jar 598# --jar /the/jar/too/launch.jar or just <name>.jar
527# --java_args 'Extra arguments to pass too jave' 599# --java_args 'Extra arguments to pass to java'
528# --pkg_args 'extra arguments too pass too the package' 600# --pkg_args 'Extra arguments to pass to the package'
529# --pwd 601# --pwd Directory the launcher changes to before executing java
530# -into 602# -into Directory to install the launcher to, instead of /usr/bin
531# -pre 603# -pre Prepend contents of this file to the launcher
532# ------------------------------------------------------------------------------ 604# ------------------------------------------------------------------------------
533java-pkg_dolauncher() { 605java-pkg_dolauncher() {
534 debug-print-function ${FUNCNAME} $* 606 debug-print-function ${FUNCNAME} $*
535 607
536 java-pkg_check-phase install 608 java-pkg_check-phase install
537
538 [[ ${#} -lt 1 ]] && die "Need at least one argument"
539
540 java-pkg_init_paths_ 609 java-pkg_init_paths_
541 610
611 if [[ ${#} = 0 ]]; then
612 local name="${PN}"
613 else
542 local name="${1}" 614 local name="${1}"
615 shift
616 fi
617
543 # TODO rename to launcher 618 # TODO rename to launcher
544 local target="${T}/${name}" 619 local target="${T}/${name}"
620 local var_tmp="${T}/launcher_variables_tmp"
545 local target_dir pre 621 local target_dir pre
546 shift
547 622
548 echo "#!/bin/bash" > "${target}" 623 # Process the other the rest of the arguments
549 while [[ -n "${1}" && -n "${2}" ]]; do 624 while [[ -n "${1}" && -n "${2}" ]]; do
550 local var=${1} value=${2} 625 local var="${1}" value="${2}"
551 if [[ "${var:0:2}" == "--" ]]; then 626 if [[ "${var:0:2}" == "--" ]]; then
627 local var=${var:2}
552 echo "gjl_${var:2}=\"${value}\"" >> "${target}" 628 echo "gjl_${var}=\"${value}\"" >> "${var_tmp}"
629 local gjl_${var}="${value}"
553 elif [[ "${var}" == "-into" ]]; then 630 elif [[ "${var}" == "-into" ]]; then
554 target_dir="${value}" 631 target_dir="${value}"
555 elif [[ "${var}" == "-pre" ]]; then 632 elif [[ "${var}" == "-pre" ]]; then
556 pre="${value}" 633 pre="${value}"
557 fi 634 fi
558 shift 2 635 shift 2
559 done 636 done
637
638 # Test if no --jar and --main arguments were given and
639 # in that case check if the package only installs one jar
640 # and use that jar.
641 if [[ -z "${gjl_jar}" && -z "${gjl_main}" ]]; then
642 local cp="${JAVA_PKG_CLASSPATH}"
643 if [[ "${cp/:}" = "${cp}" && "${cp%.jar}" != "${cp}" ]]; then
644 echo "gjl_jar=\"${JAVA_PKG_CLASSPATH}\"" >> "${var_tmp}"
645 else
646 local msg="Not enough information to create a launcher given."
647 msg="${msg} Please give --jar or --main argument to ${FUNCNAME}."
648 die "${msg}"
649 fi
650 fi
651
652 # Write the actual script
653 echo "#!/bin/bash" > "${target}"
654 if [[ -n "${pre}" ]]; then
655 if [[ -f "${pre}" ]]; then
656 cat "${pre}" >> "${target}"
657 else
658 die "-pre specified file '${pre}' does not exist"
659 fi
660 fi
560 echo "gjl_package=${JAVA_PKG_NAME}" >> "${target}" 661 echo "gjl_package=${JAVA_PKG_NAME}" >> "${target}"
561 [[ -n "${pre}" ]] && [[ -f "${pre}" ]] && cat "${pre}" >> "${target}" 662 cat "${var_tmp}" >> "${target}"
663 rm -f "${var_tmp}"
562 echo "source /usr/share/java-config-2/launcher/launcher.bash" >> "${target}" 664 echo "source /usr/share/java-config-2/launcher/launcher.bash" >> "${target}"
563 665
564 if [[ -n "${into}" ]]; then 666 if [[ -n "${target_dir}" ]]; then
565 DESTTREE="${target_dir}" dobin "${target}" 667 DESTTREE="${target_dir}" dobin "${target}"
566 local ret=$? 668 local ret=$?
567 return ${ret} 669 return ${ret}
568 else 670 else
569 dobin "${target}" 671 dobin "${target}"
597 echo "dowar: warning, skipping directory ${war}" 699 echo "dowar: warning, skipping directory ${war}"
598 continue 700 continue
599 else 701 else
600 warpath="${war}" 702 warpath="${war}"
601 fi 703 fi
602 704
603 # Install those files like you mean it 705 # Install those files like you mean it
604 INSOPTIONS="-m 0644" \ 706 INSOPTIONS="-m 0644" \
605 INSDESTTREE=${JAVA_PKG_WARDEST} \ 707 INSDESTTREE=${JAVA_PKG_WARDEST} \
606 doins ${warpath} 708 doins ${warpath}
607 done 709 done
642# @ebuild-function java-pkg_jar-from 744# @ebuild-function java-pkg_jar-from
643# 745#
644# Makes a symlink to a jar from a certain package 746# Makes a symlink to a jar from a certain package
645# A lot of java packages include dependencies in a lib/ directory 747# A lot of java packages include dependencies in a lib/ directory
646# You can use this function to replace these bundled dependencies. 748# You can use this function to replace these bundled dependencies.
749# The dependency is recorded into package.env DEPEND line, unless "--build-only"
750# is passed as the very first argument, for jars that have to be present only
751# at build time and are not needed on runtime (junit testing etc).
647# 752#
648# Example: get all jars from xerces slot 2 753# Example: get all jars from xerces slot 2
649# java-pkg_jar-from xerces-2 754# java-pkg_jar-from xerces-2
650# Example: get a specific jar from xerces slot 2 755# Example: get a specific jar from xerces slot 2
651# java-pkg_jar-from xerces-2 xml-apis.jar 756# java-pkg_jar-from xerces-2 xml-apis.jar
652# Example get a specific jar from xerces slot 2, and name it diffrently 757# Example: get a specific jar from xerces slot 2, and name it diffrently
653# java-pkg_jar-from xerces-2 xml-apis.jar xml.jar 758# java-pkg_jar-from xerces-2 xml-apis.jar xml.jar
759# Example: get junit.jar which is needed only for building
760# java-pkg_jar-from --build-only junit junit.jar
654# 761#
762# @param $opt
763# --build-only - makes the jar(s) not added into package.env DEPEND line.
764# (assumed automatically when called inside src_test)
765# --with-dependencies - get jars also from requested package's dependencies
766# transitively.
767# --into $dir - symlink jar(s) into $dir (must exist) instead of .
655# @param $1 - Package to get jars from. 768# @param $1 - Package to get jars from.
656# @param $2 - jar from package. If not specified, all jars will be used. 769# @param $2 - jar from package. If not specified, all jars will be used.
657# @param $3 - When a single jar is specified, destination filename of the 770# @param $3 - When a single jar is specified, destination filename of the
658# symlink. Defaults to the name of the jar. 771# symlink. Defaults to the name of the jar.
659# ------------------------------------------------------------------------------ 772# ------------------------------------------------------------------------------
660# TODO could probably be cleaned up a little 773# TODO could probably be cleaned up a little
661java-pkg_jar-from() { 774java-pkg_jar-from() {
662 debug-print-function ${FUNCNAME} $* 775 debug-print-function ${FUNCNAME} $*
663 776
664 local target_pkg="${1}" target_jar="${2}" destjar="${3}" 777 local build_only=""
778 local destdir="."
779 local deep=""
665 780
781 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="true"
782
783 while [[ "${1}" == --* ]]; do
784 if [[ "${1}" = "--build-only" ]]; then
785 build_only="true"
786 elif [[ "${1}" = "--with-dependencies" ]]; then
787 deep="--with-dependencies"
788 elif [[ "${1}" = "--into" ]]; then
789 destdir="${2}"
790 shift
791 else
792 die "java-pkg_jar-from called with unknown parameter: ${1}"
793 fi
794 shift
795 done
796
797 local target_pkg="${1}" target_jar="${2}" destjar="${3}"
798
666 [[ -z ${target_pkg} ]] && die "Must specify a package" 799 [[ -z ${target_pkg} ]] && die "Must specify a package"
667 800
668 # default destjar to the target jar 801 # default destjar to the target jar
669 [[ -z "${destjar}" ]] && destjar="${target_jar}" 802 [[ -z "${destjar}" ]] && destjar="${target_jar}"
670 803
804 local error_msg="There was a problem getting the classpath for ${target_pkg}."
805 local classpath
671 local classpath="$(java-config --classpath=${target_pkg})" 806 classpath="$(java-config ${deep} --classpath=${target_pkg})"
672 [[ $? != 0 ]] && die "There was a problem getting the classpath for ${target_pkg}" 807 [[ $? != 0 ]] && die ${error_msg}
673 808
809 pushd ${destdir} > /dev/null \
810 || die "failed to change directory to ${destdir}"
674 local jar 811 local jar
675 for jar in ${classpath//:/ }; do 812 for jar in ${classpath//:/ }; do
676 local jar_name=$(basename "${jar}") 813 local jar_name=$(basename "${jar}")
677 if [[ ! -f "${jar}" ]] ; then 814 if [[ ! -f "${jar}" ]] ; then
678 debug-print "${jar} from ${target_pkg} does not exist" 815 debug-print "${jar} from ${target_pkg} does not exist"
681 # If no specific target jar was indicated, link it 818 # If no specific target jar was indicated, link it
682 if [[ -z "${target_jar}" ]] ; then 819 if [[ -z "${target_jar}" ]] ; then
683 [[ -f "${target_jar}" ]] && rm "${target_jar}" 820 [[ -f "${target_jar}" ]] && rm "${target_jar}"
684 ln -snf "${jar}" \ 821 ln -snf "${jar}" \
685 || die "Failed to make symlink from ${jar} to ${jar_name}" 822 || die "Failed to make symlink from ${jar} to ${jar_name}"
686 java-pkg_record-jar_ "${target_pkg}" "${jar}" 823 [[ -z "${build_only}" ]] && java-pkg_record-jar_ "${target_pkg}" "${jar}"
687 # otherwise, if the current jar is the target jar, link it 824 # otherwise, if the current jar is the target jar, link it
688 elif [[ "${jar_name}" == "${target_jar}" ]] ; then 825 elif [[ "${jar_name}" == "${target_jar}" ]] ; then
689 [[ -f "${destjar}" ]] && rm "${destjar}" 826 [[ -f "${destjar}" ]] && rm "${destjar}"
690 ln -snf "${jar}" "${destjar}" \ 827 ln -snf "${jar}" "${destjar}" \
691 || die "Failed to make symlink from ${jar} to ${destjar}" 828 || die "Failed to make symlink from ${jar} to ${destjar}"
692 java-pkg_record-jar_ "${target_pkg}" "${jar}" 829 [[ -z "${build_only}" ]] && java-pkg_record-jar_ "${target_pkg}" "${jar}"
693 return 0 830 return 0
694 fi 831 fi
695 done 832 done
833 popd > /dev/null
696 # if no target was specified, we're ok 834 # if no target was specified, we're ok
697 if [[ -z "${target_jar}" ]] ; then 835 if [[ -z "${target_jar}" ]] ; then
698 return 0 836 return 0
699 # otherwise, die bitterly 837 # otherwise, die bitterly
700 else 838 else
714# ------------------------------------------------------------------------------ 852# ------------------------------------------------------------------------------
715# @ebuild-function java-pkg_getjars 853# @ebuild-function java-pkg_getjars
716# 854#
717# Get the classpath provided by any number of packages 855# Get the classpath provided by any number of packages
718# Among other things, this can be passed to 'javac -classpath' or 'ant -lib'. 856# Among other things, this can be passed to 'javac -classpath' or 'ant -lib'.
857# The providing packages are recorded as dependencies into package.env DEPEND
858# line, unless "--build-only" is passed as the very first argument, for jars
859# that have to be present only at build time and are not needed on runtime
860# (junit testing etc).
719# 861#
720# Example: Get the classpath for xerces-2, 862# Example: Get the classpath for xerces-2 and xalan,
721# java-pkg_getjars xerces-2 xalan 863# java-pkg_getjars xerces-2,xalan
722# Example Return: 864# Example Return:
723# /usr/share/xerces-2/lib/xml-apis.jar:/usr/share/xerces-2/lib/xmlParserAPIs.jar:/usr/share/xalan/lib/xalan.jar 865# /usr/share/xerces-2/lib/xml-apis.jar:/usr/share/xerces-2/lib/xmlParserAPIs.jar:/usr/share/xalan/lib/xalan.jar
724# 866#
867# @param $opt
868# --build-only - makes the jar(s) not added into package.env DEPEND line.
869# (assumed automatically when called inside src_test)
870# --with-dependencies - get jars also from requested package's dependencies
871# transitively.
725# @param $@ - list of packages to get jars from 872# @param $1 - list of packages to get jars from
873# (passed to java-config --classpath)
726# ------------------------------------------------------------------------------ 874# ------------------------------------------------------------------------------
727java-pkg_getjars() { 875java-pkg_getjars() {
728 debug-print-function ${FUNCNAME} $* 876 debug-print-function ${FUNCNAME} $*
729 877
730 [[ ${#} -lt 1 ]] && die "At least one argument needed" 878 local build_only=""
879 local deep=""
880
881 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="true"
731 882
732 # NOTE could probably just pass $@ to java-config --classpath. and return it 883 while [[ "${1}" == --* ]]; do
733 local classpath pkg 884 if [[ "${1}" = "--build-only" ]]; then
734 for pkg in ${@//,/ }; do 885 build_only="true"
735 #for pkg in $(echo "$@" | tr ',' ' '); do 886 elif [[ "${1}" = "--with-dependencies" ]]; then
736 jars="$(java-config --classpath=${pkg})" 887 deep="--with-dependencies"
737 debug-print "${pkg}:${jars}"
738 # TODO should we ensure jars exist?
739 if [[ -z "${classpath}" ]]; then
740 classpath="${jars}"
741 else 888 else
742 classpath="${classpath}:${jars}" 889 die "java-pkg_jar-from called with unknown parameter: ${1}"
743 fi 890 fi
744 java-pkg_record-jar_ "${pkg}" 891 shift
745 done 892 done
893
894 [[ ${#} -ne 1 ]] && die "${FUNCNAME} takes only one argument besides --*"
895
896 local classpath pkgs="${1}"
897 jars="$(java-config ${deep} --classpath=${pkgs})"
898 [[ -z "${jars}" ]] && die "java-config --classpath=${pkgs} failed"
899 debug-print "${pkgs}:${jars}"
900
901 if [[ -z "${classpath}" ]]; then
902 classpath="${jars}"
903 else
904 classpath="${classpath}:${jars}"
905 fi
906
907 # Only record jars that aren't build-only
908 if [[ -z "${build_only}" ]]; then
909 oldifs="${IFS}"
910 IFS=","
911 for pkg in ${pkgs}; do
912 java-pkg_record-jar_ "${pkg}"
913 done
914 IFS="${oldifs}"
915 fi
916
746 echo "${classpath}" 917 echo "${classpath}"
747} 918}
748 919
749# ------------------------------------------------------------------------------ 920# ------------------------------------------------------------------------------
750# @ebuild-function java-pkg_getjar 921# @ebuild-function java-pkg_getjar
751# 922#
752# Get the filename of a single jar from a package 923# Get the filename of a single jar from a package
924# The providing package is recorded as runtime dependency into package.env
925# DEPEND line, unless "--build-only" is passed as the very first argument, for
926# jars that have to be present only at build time and are not needed on runtime
927# (junit testing etc).
753# 928#
754# @example 929# @example
755# java-pkg_getjar xerces-2 xml-apis.jar 930# java-pkg_getjar xerces-2 xml-apis.jar
756# @example-return 931# @example-return
757# /usr/share/xerces-2/lib/xml-apis.jar 932# /usr/share/xerces-2/lib/xml-apis.jar
758# 933#
934# @param $opt
935# --build-only - makes the jar not added into package.env DEPEND line.
759# @param $1 - package to use 936# @param $1 - package to use
760# @param $2 - jar to get 937# @param $2 - jar to get
761# ------------------------------------------------------------------------------ 938# ------------------------------------------------------------------------------
762java-pkg_getjar() { 939java-pkg_getjar() {
763 debug-print-function ${FUNCNAME} $* 940 debug-print-function ${FUNCNAME} $*
941
942 local build_only=""
943
944 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="true"
945
946 while [[ "${1}" == --* ]]; do
947 if [[ "${1}" = "--build-only" ]]; then
948 build_only="true"
949 else
950 die "java-pkg_jar-from called with unknown parameter: ${1}"
951 fi
952 shift
953 done
954
955 [[ ${#} -ne 2 ]] && die "${FUNCNAME} takes only two arguments besides --*"
764 956
765 local pkg="${1}" target_jar="${2}" jar 957 local pkg="${1}" target_jar="${2}" jar
766 [[ -z ${pkg} ]] && die "Must specify package to get a jar from" 958 [[ -z ${pkg} ]] && die "Must specify package to get a jar from"
767 [[ -z ${target_jar} ]] && die "Must specify jar to get" 959 [[ -z ${target_jar} ]] && die "Must specify jar to get"
768 960
769 # TODO check that package is actually installed 961 local error_msg="Could not find classpath for ${pkg}. Are you sure its installed?"
962 local classpath
770 local classpath=$(java-config --classpath=${pkg}) 963 classpath=$(java-config --classpath=${pkg})
771 [[ $? != 0 ]] && die "There could not find classpath for ${pkg}. Are you sure its installed?" 964 [[ $? != 0 ]] && die ${error_msg}
965
772 for jar in ${classpath//:/ }; do 966 for jar in ${classpath//:/ }; do
773 if [[ ! -f "${jar}" ]] ; then 967 if [[ ! -f "${jar}" ]] ; then
774 die "Installation problems with jars in ${pkg} - is it installed?" 968 die "Installation problem with jar ${jar} in ${pkg} - is it installed?"
775 fi 969 fi
776 970
777 if [[ "$(basename ${jar})" == "${target_jar}" ]] ; then 971 if [[ "$(basename ${jar})" == "${target_jar}" ]] ; then
778 java-pkg_record-jar_ "${pkg}" "${jar}" 972 # Only record jars that aren't build-only
973 [[ -z "${build_only}" ]] && java-pkg_record-jar_ "${pkg}" "${jar}"
779 echo "${jar}" 974 echo "${jar}"
780 return 0 975 return 0
781 fi 976 fi
782 done 977 done
783 978
784 die "Could not find ${target_jar} in ${pkg}" 979 die "Could not find ${target_jar} in ${pkg}"
785 return 1 980 return 1
786} 981}
787 982
788# This function reads stdin, and based on that input, figures out how to 983# This function reads stdin, and based on that input, figures out how to
802# line="${line// /}" 997# line="${line// /}"
803# 998#
804# # format: path=jarinfo 999# # format: path=jarinfo
805# local path=${line%%=*} 1000# local path=${line%%=*}
806# local jarinfo=${line##*=} 1001# local jarinfo=${line##*=}
807# 1002#
808# # format: jar@package 1003# # format: jar@package
809# local jar=${jarinfo%%@*}.jar 1004# local jar=${jarinfo%%@*}.jar
810# local package=${jarinfo##*@} 1005# local package=${jarinfo##*@}
811# if [[ -n ${replace_only} ]]; then 1006# if [[ -n ${replace_only} ]]; then
812# [[ ! -f $path ]] && die "No jar exists at ${path}" 1007# [[ ! -f $path ]] && die "No jar exists at ${path}"
825# @section-end query 1020# @section-end query
826# ------------------------------------------------------------------------------ 1021# ------------------------------------------------------------------------------
827 1022
828# ------------------------------------------------------------------------------ 1023# ------------------------------------------------------------------------------
829# @section-begin helper 1024# @section-begin helper
830# @section-summary Helper functions 1025# @section-summary Helper functions
831# 1026#
832# Various other functions to use from an ebuild 1027# Various other functions to use from an ebuild
833# ------------------------------------------------------------------------------ 1028# ------------------------------------------------------------------------------
834 1029
835# ------------------------------------------------------------------------------ 1030# ------------------------------------------------------------------------------
841# jdbc-stdext 1036# jdbc-stdext
842# jaf 1037# jaf
843# jdbc-rowset 1038# jdbc-rowset
844# jms 1039# jms
845# 1040#
846# @param $1 - Optionally indicate that the dependencies are controlled by 1041# @param $1 - Optionally indicate that the dependencies are controlled by
847# a use flag by specifying '--use' Requires $2. 1042# a use flag by specifying '--use' Requires $2.
848# @param $2 - USE flag which will enable the dependencies. 1043# @param $2 - USE flag which will enable the dependencies.
849# @param $@ - virtual packages to add depenedencies for 1044# @param $@ - virtual packages to add depenedencies for
850# ------------------------------------------------------------------------------ 1045# ------------------------------------------------------------------------------
851# TODO rewrite to parse a line based declaration file instead -- karltk 1046# TODO rewrite to parse a line based declaration file instead -- karltk
907# 1102#
908# export DEPEND="${DEPEND} ${depstr}" 1103# export DEPEND="${DEPEND} ${depstr}"
909# export RDEPEND="${RDEPEND} ${depstr}" 1104# export RDEPEND="${RDEPEND} ${depstr}"
910#} 1105#}
911 1106
1107# ------------------------------------------------------------------------------
1108# @ebuild-function java-pkg_find-normal-jars
1109#
1110# Find the files with suffix .jar file in the given directory or $WORKDIR
1111#
1112# @param $1 - The directory to search for jar files (default: ${WORKDIR})
1113# ------------------------------------------------------------------------------
1114java-pkg_find-normal-jars() {
1115 local dir=$1
1116 [[ "${dir}" ]] || dir="${WORKDIR}"
1117 local found
1118 for jar in $(find "${dir}" -name "*.jar" -type f); do
1119 echo "${jar}"
1120 found="true"
1121 done
1122 [[ "${found}" ]]
1123 return $?
1124}
1125
1126# ------------------------------------------------------------------------------
1127# @ebuild-function java-pkg_ensure-no-bundled-jars
1128#
1129# Try to locate bundled jar files in ${WORKDIR} and die if found.
912# This should be used after S has been populated with symlinks to jars 1130# This function should be called after WORKDIR has been populated with symlink
913# TODO document 1131# to system jar files or bundled jars removed.
1132# ------------------------------------------------------------------------------
914java-pkg_ensure-no-bundled-jars() { 1133java-pkg_ensure-no-bundled-jars() {
915 debug-print-function ${FUNCNAME} $* 1134 debug-print-function ${FUNCNAME} $*
916 pushd ${WORKDIR} >/dev/null 2>/dev/null
917 1135
918 local bundled_jars=$(find . -name "*.jar" -type f) 1136 local bundled_jars=$(java-pkg_find-normal-jars)
919 if [[ -n ${bundled_jars} ]]; then 1137 if [[ -n ${bundled_jars} ]]; then
920 echo "Bundled jars found:" 1138 echo "Bundled jars found:"
921 local jar 1139 local jar
922 for jar in ${bundled_jars}; do 1140 for jar in ${bundled_jars}; do
923 echo $(pwd)${jar/./} 1141 echo $(pwd)${jar/./}
924 done 1142 done
925 die "Bundled jars found!" 1143 die "Bundled jars found!"
926
927 fi 1144 fi
928 popd >/dev/null 2>/dev/null
929} 1145}
930 1146
931# ------------------------------------------------------------------------------ 1147# ------------------------------------------------------------------------------
932# @internal-function java-pkg_ensure-vm-version-sufficient 1148# @internal-function java-pkg_ensure-vm-version-sufficient
933# 1149#
945 fi 1161 fi
946} 1162}
947 1163
948# ------------------------------------------------------------------------------ 1164# ------------------------------------------------------------------------------
949# @internal-function java-pkg_is-vm-version-sufficient 1165# @internal-function java-pkg_is-vm-version-sufficient
950# 1166#
951# @return zero - VM is sufficient 1167# @return zero - VM is sufficient
952# @return non-zero - VM is not sufficient 1168# @return non-zero - VM is not sufficient
953# ------------------------------------------------------------------------------ 1169# ------------------------------------------------------------------------------
954java-pkg_is-vm-version-sufficient() { 1170java-pkg_is-vm-version-sufficient() {
955 debug-print-function ${FUNCNAME} $* 1171 debug-print-function ${FUNCNAME} $*
975 die "Active Java VM too old" 1191 die "Active Java VM too old"
976 fi 1192 fi
977} 1193}
978 1194
979# ------------------------------------------------------------------------------ 1195# ------------------------------------------------------------------------------
980# @internal-function java-pkg_is-vm-version-eq 1196# @internal-function java-pkg_is-vm-version-eq
981# 1197#
982# @param $@ - VM version to compare current VM to 1198# @param $@ - VM version to compare current VM to
983# @return zero - VM versions are equal 1199# @return zero - VM versions are equal
984# @return non-zero - VM version are not equal 1200# @return non-zero - VM version are not equal
985# ------------------------------------------------------------------------------ 1201# ------------------------------------------------------------------------------
986java-pkg_is-vm-version-eq() { 1202java-pkg_is-vm-version-eq() {
1016# 1232#
1017# @param $@ - VM version to compare current to 1233# @param $@ - VM version to compare current to
1018# ------------------------------------------------------------------------------ 1234# ------------------------------------------------------------------------------
1019java-pkg_ensure-vm-version-ge() { 1235java-pkg_ensure-vm-version-ge() {
1020 debug-print-function ${FUNCNAME} $* 1236 debug-print-function ${FUNCNAME} $*
1021 1237
1022 if ! java-pkg_is-vm-version-ge "$@" ; then 1238 if ! java-pkg_is-vm-version-ge "$@" ; then
1023 debug-print "vm is not suffient" 1239 debug-print "vm is not suffient"
1024 eerror "This package requires a Java VM version >= $@" 1240 eerror "This package requires a Java VM version >= $@"
1025 einfo "Please use java-config -S to set the correct one" 1241 einfo "Please use java-config -S to set the correct one"
1026 die "Active Java VM too old" 1242 die "Active Java VM too old"
1027 fi 1243 fi
1028} 1244}
1029 1245
1030# ------------------------------------------------------------------------------ 1246# ------------------------------------------------------------------------------
1031# @internal-function java-pkg_is-vm-version-ge 1247# @internal-function java-pkg_is-vm-version-ge
1032# 1248#
1033# @param $@ - VM version to compare current VM to 1249# @param $@ - VM version to compare current VM to
1034# @return zero - current VM version is greater than checked version 1250# @return zero - current VM version is greater than checked version
1035# @return non-zero - current VM version is not greater than checked version 1251# @return non-zero - current VM version is not greater than checked version
1036# ------------------------------------------------------------------------------ 1252# ------------------------------------------------------------------------------
1037java-pkg_is-vm-version-ge() { 1253java-pkg_is-vm-version-ge() {
1051 return 1 1267 return 1
1052 fi 1268 fi
1053 fi 1269 fi
1054} 1270}
1055 1271
1272java-pkg_set-current-vm() {
1273 export GENTOO_VM=${1}
1274}
1275
1276java-pkg_get-current-vm() {
1277 echo ${GENTOO_VM}
1278}
1279
1280java-pkg_current-vm-matches() {
1281 hasq $(java-pkg_get-current-vm) ${@}
1282 return $?
1283}
1284
1056# ------------------------------------------------------------------------------ 1285# ------------------------------------------------------------------------------
1057# @ebuild-function java-pkg_get-source 1286# @ebuild-function java-pkg_get-source
1058# 1287#
1059# Determines what source version should be used, for passing to -source. 1288# Determines what source version should be used, for passing to -source.
1060# Unless you want to break things you probably shouldn't set _WANT_SOURCE 1289# Unless you want to break things you probably shouldn't set _WANT_SOURCE
1061# 1290#
1062# @return string - Either the lowest possible source, or JAVA_PKG_WANT_SOURCE 1291# @return string - Either the lowest possible source, or JAVA_PKG_WANT_SOURCE
1063# ------------------------------------------------------------------------------ 1292# ------------------------------------------------------------------------------
1068# ------------------------------------------------------------------------------ 1297# ------------------------------------------------------------------------------
1069# @ebuild-function java-pkg_get-target 1298# @ebuild-function java-pkg_get-target
1070# 1299#
1071# Determines what target version should be used, for passing to -target. 1300# Determines what target version should be used, for passing to -target.
1072# If you don't care about lower versions, you can set _WANT_TARGET to the 1301# If you don't care about lower versions, you can set _WANT_TARGET to the
1073# version of your JDK. 1302# version of your JDK.
1074# Remember doing this will mostly like cause things to break.
1075# Doesn't allow it to be lower then the one in depend.
1076# Doesn't allow it to be higher then the active vm.
1077# 1303#
1078# @return string - Either the lowest possible target, or JAVA_PKG_WANT_TARGET 1304# @return string - Either the lowest possible target, or JAVA_PKG_WANT_TARGET
1079# ------------------------------------------------------------------------------ 1305# ------------------------------------------------------------------------------
1080java-pkg_get-target() { 1306java-pkg_get-target() {
1081 local min=$(depend-java-query --get-lowest "${DEPEND} ${RDEPEND}")
1082 if [[ -n "${JAVA_PKG_WANT_TARGET}" ]]; then
1083 local max="$(java-config --select-vm "${GENTOO_VM}" -g PROVIDES_VERSION)"
1084 if version_is_at_least "${min}" "${JAVA_PKG_WANT_TARGET}" && version_is_at_least "${JAVA_PKG_WANT_TARGET}" "${max}"; then
1085 echo ${JAVA_PKG_WANT_TARGET}
1086 else
1087 echo ${min}
1088 fi
1089 else
1090 echo ${min}
1091 fi
1092
1093 #echo ${JAVA_PKG_WANT_TARGET:-$(depend-java-query --get-lowest "${DEPEND}")} 1307 echo ${JAVA_PKG_WANT_TARGET:-$(depend-java-query --get-lowest "${DEPEND} ${RDEPEND}")}
1094} 1308}
1095 1309
1096java-pkg_get-javac() { 1310java-pkg_get-javac() {
1097 debug-print-function ${FUNCNAME} $* 1311 debug-print-function ${FUNCNAME} $*
1098 1312
1099 java-pkg_init-compiler_ 1313
1100 local compiler="${GENTOO_COMPILER}" 1314 local compiler="${GENTOO_COMPILER}"
1101 1315
1102 local compiler_executable 1316 local compiler_executable
1103 if [[ "${compiler}" = "javac" ]]; then 1317 if [[ "${compiler}" = "javac" ]]; then
1104 # nothing fancy needs to be done for javac 1318 # nothing fancy needs to be done for javac
1112 unset JAVAC 1326 unset JAVAC
1113 # try to get value of JAVAC 1327 # try to get value of JAVAC
1114 compiler_executable="$(source ${compiler_env} 1>/dev/null 2>&1; echo ${JAVAC})" 1328 compiler_executable="$(source ${compiler_env} 1>/dev/null 2>&1; echo ${JAVAC})"
1115 export JAVAC=${old_javac} 1329 export JAVAC=${old_javac}
1116 1330
1117 [[ -z ${compiler_executable} ]] && die "JAVAC is empty or undefined in ${compiler_env}" 1331 if [[ -z ${compiler_executable} ]]; then
1118 1332 echo "JAVAC is empty or undefined in ${compiler_env}"
1333 return 1
1334 fi
1335
1119 # check that it's executable 1336 # check that it's executable
1120 if [[ ! -x ${compiler_executable} ]]; then 1337 if [[ ! -x ${compiler_executable} ]]; then
1121 eerror "Could not find ${compiler_executable}!"
1122 die "${compiler_executable} doesn't exist, or isn't executable" 1338 echo "${compiler_executable} doesn't exist, or isn't executable"
1339 return 1
1123 fi 1340 fi
1124 else 1341 else
1125 eerror "Could not find environment file for ${compiler}" 1342 echo "Could not find environment file for ${compiler}"
1126 die "Could not find ${compiler_env}" 1343 return 1
1127 fi 1344 fi
1128 fi 1345 fi
1129 echo ${compiler_executable} 1346 echo ${compiler_executable}
1130} 1347}
1131 1348
1132# ------------------------------------------------------------------------------ 1349# ------------------------------------------------------------------------------
1133# @ebuild-function java-pkg_javac-args 1350# @ebuild-function java-pkg_javac-args
1134# 1351#
1135# If an ebuild uses javac directly, instead of using ejavac, it should call this 1352# If an ebuild uses javac directly, instead of using ejavac, it should call this
1136# to know what -source/-target to use. 1353# to know what -source/-target to use.
1137# 1354#
1138# @return string - arguments to pass to javac, complete with -target and -source 1355# @return string - arguments to pass to javac, complete with -target and -source
1141 debug-print-function ${FUNCNAME} $* 1358 debug-print-function ${FUNCNAME} $*
1142 1359
1143 local want_source="$(java-pkg_get-source)" 1360 local want_source="$(java-pkg_get-source)"
1144 local want_target="$(java-pkg_get-target)" 1361 local want_target="$(java-pkg_get-target)"
1145 1362
1146 local source_str="-source ${want_source}" 1363 local source_str="-source ${want_source}"
1147 local target_str="-target ${want_target}" 1364 local target_str="-target ${want_target}"
1148 1365
1149 debug-print "want source: ${want_source}" 1366 debug-print "want source: ${want_source}"
1150 debug-print "want target: ${want_target}" 1367 debug-print "want target: ${want_target}"
1151 1368
1152 if [[ -z "${want_source}" || -z "${want_target}" ]]; then 1369 if [[ -z "${want_source}" || -z "${want_target}" ]]; then
1153 debug-print "could not find valid -source/-target values" 1370 debug-print "could not find valid -source/-target values for javac"
1154 die "Could not find valid -source/-target values" 1371 echo "Could not find valid -source/-target values for javac"
1372 return 1
1155 else 1373 else
1156 if java-pkg_is-vm-version-ge "1.4"; then 1374 if java-pkg_is-vm-version-ge "1.4"; then
1157 echo "${source_str} ${target_str}" 1375 echo "${source_str} ${target_str}"
1158 else 1376 else
1159 echo "${target_str}" 1377 echo "${target_str}"
1163 1381
1164# TODO document 1382# TODO document
1165java-pkg_get-jni-cflags() { 1383java-pkg_get-jni-cflags() {
1166 local flags="-I${JAVA_HOME}/include" 1384 local flags="-I${JAVA_HOME}/include"
1167 1385
1386 local platform="linux"
1387 use elibc_FreeBSD && platform="freebsd"
1388
1168 # TODO do a check that the directories are valid 1389 # TODO do a check that the directories are valid
1169 # TODO figure out how to cope with other things than linux...
1170 flags="${flags} -I${JAVA_HOME}/include/linux" 1390 flags="${flags} -I${JAVA_HOME}/include/${platform}"
1171 1391
1172 echo ${flags} 1392 echo ${flags}
1173} 1393}
1174 1394
1175java-pkg_ensure-gcj() { 1395java-pkg_ensure-gcj() {
1180 ebeep 5 1400 ebeep 5
1181 die "No GCJ support found!" 1401 die "No GCJ support found!"
1182 fi 1402 fi
1183} 1403}
1184 1404
1405java-pkg_ensure-test() {
1406 if hasq test ${FEATURES} && ! hasq -test ${FEATURES} \
1407 && hasq test ${IUSE} && ! use test;
1408 then
1409 eerror "You specified FEATURES=test, but USE=test is needed"
1410 eerror "to pull in the additional dependencies for testing"
1411 die "Need USE=test enabled"
1412 fi
1413}
1414
1415# ------------------------------------------------------------------------------
1416# @ebuild-function java-pkg_register-ant-task
1417#
1418# Register this package as ant task, so that ant will load it when no specific
1419# ANT_TASKS are specified. Note that even without this registering, all packages
1420# specified in ANT_TASKS will be loaded. Mostly used by the actual ant tasks
1421# packages, but can be also used by other ebuilds that used to symlink their
1422# .jar into /usr/share/ant-core/lib to get autoloaded, for backwards
1423# compatibility.
1424#
1425# @param --version x.y Register only for ant version x.y (otherwise for any ant
1426# version). Used by the ant-* packages to prevent loading of mismatched
1427# ant-core ant tasks after core was updated, before the tasks are updated,
1428# without a need for blockers.
1429# @param $1 Name to register as. Defaults to JAVA_PKG_NAME ($PN[-$SLOT])
1430# ------------------------------------------------------------------------------
1431java-pkg_register-ant-task() {
1432 local TASKS_DIR="tasks"
1433
1434 # check for --version x.y parameters
1435 while [[ -n "${1}" && -n "${2}" ]]; do
1436 local var="${1#--}"
1437 local val="${2}"
1438 if [[ "${var}" == "version" ]]; then
1439 TASKS_DIR="tasks-${val}"
1440 else
1441 die "Unknown parameter passed to java-pkg_register-ant-tasks: ${1} ${2}"
1442 fi
1443 shift 2
1444 done
1445
1446 local TASK_NAME="${1:-${JAVA_PKG_NAME}}"
1447
1448 dodir /usr/share/ant/${TASKS_DIR}
1449 touch "${D}/usr/share/ant/${TASKS_DIR}/${TASK_NAME}"
1450}
1451
1452# ------------------------------------------------------------------------------
1453# @internal-function java-pkg_ant-tasks-from-deps
1454#
1455# Function to determine ANT_TASKS from DEPEND variable for backwards
1456# compatibility with ebuilds that don't set ANT_TASKS before calling eant() or
1457# WANT_ANT_TASKS before inheriting java-pkg-2. If the DEPEND string contains
1458# "dev-java/ant" or "dev-java/ant-tasks", then it returns "all", otherwise
1459# "none". It's not smart enough to cope with USE flag depends but that shouldn't
1460# be a problem, the worst it can do is activace all tasks when not needed.
1461# Note that this is called only with JAVA_PKG_STRICT=1, to find ebuilds with
1462# insufficient dependencies, otherwise all available tasks are used for
1463# backwards compatilbility.
1464#
1465# @return "all" or "none"
1466# ------------------------------------------------------------------------------
1467java-pkg_ant-tasks-from-deps() {
1468 local found_ant found_ant_tasks
1469
1470 for dep in ${DEPEND}
1471 do
1472 local ant="$(awk '/(dev-java\/ant)/ { if (match($1, "(dev-java/ant)((-[0-9])+|$)", m)) print m[1] }' <<< ${dep})"
1473 [[ "${ant}" == "dev-java/ant" ]] && found_ant=true
1474 [[ "${dep}" == *"ant-tasks"* ]] && found_ant_tasks=true
1475 done
1476
1477 if [[ -n "${found_ant}" || -n "${found_ant_tasks}" ]]; then
1478 java-pkg_announce-qa-violation "The ebuild DEPENDS on deprecated ant or ant-tasks"
1479 echo "all"
1480 else
1481 # ebuild doesn't set ANT_TASKS and doesn't depend on ant-tasks or ant
1482 # so we deactivate all tasks that may be installed
1483 echo "none"
1484 fi
1485}
1486
1487# ------------------------------------------------------------------------------
1488# @internal-function java-pkg_ant-tasks-depend
1489#
1490# Translates the WANT_ANT_TASKS variable into valid dependencies.
1491# ------------------------------------------------------------------------------
1492java-pkg_ant-tasks-depend() {
1493 debug-print-function ${FUNCNAME} ${WANT_ANT_TASKS}
1494
1495 if [[ -n "${WANT_ANT_TASKS}" ]]; then
1496 local DEP=""
1497 for i in ${WANT_ANT_TASKS}
1498 do
1499 if [[ ${i} != ant-* ]]; then
1500 echo "Invalid atom in WANT_ANT_TASKS: ${i}"
1501 return 1
1502 fi
1503 DEP="${DEP}dev-java/${i} "
1504 done
1505 echo ${DEP}
1506 return 0
1507 else
1508 return 0
1509 fi
1510}
1511
1185# ------------------------------------------------------------------------------ 1512# ------------------------------------------------------------------------------
1186# @section-end helper 1513# @section-end helper
1187# ------------------------------------------------------------------------------ 1514# ------------------------------------------------------------------------------
1188 1515
1189# ------------------------------------------------------------------------------ 1516# ------------------------------------------------------------------------------
1196 1523
1197# ------------------------------------------------------------------------------ 1524# ------------------------------------------------------------------------------
1198# @ebuild-function eant 1525# @ebuild-function eant
1199# 1526#
1200# Ant wrapper function. Will use the appropriate compiler, based on user-defined 1527# Ant wrapper function. Will use the appropriate compiler, based on user-defined
1201# compiler. 1528# compiler. Will also set proper ANT_TASKS from the variable ANT_TASKS,
1202# 1529# variables:
1530# EANT_GENTOO_CLASSPATH - calls java-pkg_getjars for the value and adds to the
1531# gentoo.classpath property. Be sure to call
1532# java-ant_rewrite-classpath in src_unpack.
1533# *ANT_TASKS - used to determine ANT_TASKS before calling Ant.
1203# ------------------------------------------------------------------------------ 1534# ------------------------------------------------------------------------------
1204eant() { 1535eant() {
1205 debug-print-function ${FUNCNAME} $* 1536 debug-print-function ${FUNCNAME} $*
1206 1537
1207 local antflags 1538 # FIXME get this working
1539# if is-java-strict && [[ ! ${DEPEND} =~ "dev-java/ant" ]]; then
1540# java-pkg_announce-qa-violation \
1541# "Using eant, but not depending on dev-java/ant or dev-java/ant-core"
1542# fi
1543
1544 local antflags="-Dnoget=true -Dmaven.mode.offline=true"
1208 java-pkg_init-compiler_ 1545 java-pkg_init-compiler_
1209 local compiler="${GENTOO_COMPILER}" 1546 local compiler="${GENTOO_COMPILER}"
1210 1547
1211 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}" 1548 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}"
1212 1549
1214 if [[ "${compiler}" != "javac" && -z "${build_compiler}" ]]; then 1551 if [[ "${compiler}" != "javac" && -z "${build_compiler}" ]]; then
1215 die "ANT_BUILD_COMPILER undefined in ${compiler_env}" 1552 die "ANT_BUILD_COMPILER undefined in ${compiler_env}"
1216 fi 1553 fi
1217 1554
1218 if [[ ${compiler} != "javac" ]]; then 1555 if [[ ${compiler} != "javac" ]]; then
1219 antflags="-Dbuild.compiler=${build_compiler}" 1556 antflags="${antflags} -Dbuild.compiler=${build_compiler}"
1220 # Figure out any extra stuff to put on the classpath for compilers aside 1557 # Figure out any extra stuff to put on the classpath for compilers aside
1221 # from javac 1558 # from javac
1222 # ANT_BUILD_COMPILER_DEPS should be something that could be passed to 1559 # ANT_BUILD_COMPILER_DEPS should be something that could be passed to
1223 # java-config -p 1560 # java-config -p
1224 local build_compiler_deps="$(source ${JAVA_PKG_COMPILER_DIR}/${compiler} 1>/dev/null 2>&1; echo ${ANT_BUILD_COMPILER_DEPS})" 1561 local build_compiler_deps="$(source ${JAVA_PKG_COMPILER_DIR}/${compiler} 1>/dev/null 2>&1; echo ${ANT_BUILD_COMPILER_DEPS})"
1229 1566
1230 if is-java-strict; then 1567 if is-java-strict; then
1231 einfo "Disabling system classpath for ant" 1568 einfo "Disabling system classpath for ant"
1232 antflags="${antflags} -Dbuild.sysclasspath=ignore" 1569 antflags="${antflags} -Dbuild.sysclasspath=ignore"
1233 fi 1570 fi
1234 1571
1235 if [[ -n ${JAVA_PKG_DEBUG} ]]; then 1572 if has_version ">=dev-java/ant-core-1.7.0"; then
1236 antflags="${antflags} -debug" 1573 # default ANT_TASKS to WANT_ANT_TASKS, if ANT_TASKS is not set explicitly
1574 ANT_TASKS="${ANT_TASKS:-${WANT_ANT_TASKS}}"
1575
1576 # override ANT_TASKS with JAVA_PKG_FORCE_ANT_TASKS if it's set
1577 ANT_TASKS="${JAVA_PKG_FORCE_ANT_TASKS:-${ANT_TASKS}}"
1578
1579 if is-java-strict; then
1580 # if ant-tasks were not set by ebuild or forced, try to determine them from depends
1581 if [[ -z "${ANT_TASKS}" ]]; then
1582 ANT_TASKS="$(java-pkg_ant-tasks-from-deps)"
1583 fi
1584 else
1585 # if ant-tasks is not set by ebuild or forced, activate all of them
1586 ANT_TASKS="${ANT_TASKS:-all}"
1237 fi 1587 fi
1238 1588
1589 # at this point, ANT_TASKS should be "all", "none" or explicit list
1590 if [[ "${ANT_TASKS}" == "all" ]]; then
1591 einfo "Using all available ANT_TASKS"
1592 elif [[ "${ANT_TASKS}" == "none" ]]; then
1593 einfo "Disabling all optional ANT_TASKS"
1594 else
1595 einfo "Using following ANT_TASKS: ${ANT_TASKS}"
1596 fi
1597
1598 export ANT_TASKS
1599 fi
1600
1601 [[ -n ${JAVA_PKG_DEBUG} ]] && antflags="${antflags} --execdebug -debug"
1602 [[ -n ${PORTAGE_QUIET} ]] && antflags="${antflags} -q"
1603
1604 local gcp="${EANT_GENTOO_CLASSPATH}"
1605
1606 if [[ "${gcp}" ]]; then
1607 local cp="$(java-pkg_getjars ${gcp})"
1608 # It seems ant does not like single quotes around ${cp}
1609 antflags="${antflags} -Dgentoo.classpath=\"${cp}\""
1610 fi
1611
1239 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ant ${antflags} "${@}" 1612 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ant ${antflags} "${@}"
1613 debug-print "Calling ant: ${antflags} ${@}"
1240 ant ${antflags} "${@}" || die "eant failed" 1614 ant ${antflags} "${@}" || die "eant failed"
1241 1615
1242} 1616}
1243 1617
1244# ------------------------------------------------------------------------------ 1618# ------------------------------------------------------------------------------
1245# @ebuild-function ejavac 1619# @ebuild-function ejavac
1246# 1620#
1247# Javac wrapper function. Will use the appropriate compiler, based on 1621# Javac wrapper function. Will use the appropriate compiler, based on
1248# /etc/java-config/compilers.conf 1622# /etc/java-config/compilers.conf
1249# 1623#
1250# @param $@ - Arguments to be passed to the compiler 1624# @param $@ - Arguments to be passed to the compiler
1251# ------------------------------------------------------------------------------ 1625# ------------------------------------------------------------------------------
1252ejavac() { 1626ejavac() {
1253 debug-print-function ${FUNCNAME} $* 1627 debug-print-function ${FUNCNAME} $*
1254 1628
1255 # FIXME using get-javac ends up printing stuff with einfo 1629 java-pkg_init-compiler_
1630
1631 local compiler_executable
1256# local compiler_executable=$(java-pkg_get-javac) 1632 compiler_executable=$(java-pkg_get-javac)
1257 local compiler_executable="javac" 1633 if [[ ${?} != 0 ]]; then
1634 eerror "There was a problem determining compiler: ${compiler_executable}"
1635 die "get-javac failed"
1636 fi
1258 1637
1638 local javac_args
1639 javac_args="$(java-pkg_javac-args)"
1640 if [[ ${?} != 0 ]]; then
1641 eerror "There was a problem determining JAVACFLAGS: ${javac_args}"
1642 die "java-pkg_javac-args failed"
1643 fi
1644
1259 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ${compiler_executable} $(java-pkg_javac-args) "${@}" 1645 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ${compiler_executable} ${javac_args} "${@}"
1260 ${compiler_executable} $(java-pkg_javac-args) "${@}" || die "ejavac failed" 1646 ${compiler_executable} ${javac_args} "${@}" || die "ejavac failed"
1261} 1647}
1262 1648
1263# ------------------------------------------------------------------------------ 1649# ------------------------------------------------------------------------------
1264# @ebuild-function java-pkg_filter-compiler 1650# @ebuild-function java-pkg_filter-compiler
1265# 1651#
1266# Used to prevent the use of some compilers. Should be used in src_compile. 1652# Used to prevent the use of some compilers. Should be used in src_compile.
1267# Basically, it just appends onto JAVA_PKG_FILTER_COMPILER 1653# Basically, it just appends onto JAVA_PKG_FILTER_COMPILER
1268# 1654#
1269# @param $@ - compilers to filter 1655# @param $@ - compilers to filter
1270# ------------------------------------------------------------------------------ 1656# ------------------------------------------------------------------------------
1288# ------------------------------------------------------------------------------ 1674# ------------------------------------------------------------------------------
1289# @ebuild-function use_doc 1675# @ebuild-function use_doc
1290# 1676#
1291# Helper function for getting ant to build javadocs. If the user has USE=doc, 1677# Helper function for getting ant to build javadocs. If the user has USE=doc,
1292# then 'javadoc' or the argument are returned. Otherwise, there is no return. 1678# then 'javadoc' or the argument are returned. Otherwise, there is no return.
1293# 1679#
1294# The output of this should be passed to ant. 1680# The output of this should be passed to ant.
1295# 1681#
1296# Example: build javadocs by calling 'javadoc' target 1682# Example: build javadocs by calling 'javadoc' target
1297# eant $(use_doc) 1683# eant $(use_doc)
1298# Example: build javadocs by calling 'apidoc' target 1684# Example: build javadocs by calling 'apidoc' target
1303# ------------------------------------------------------------------------------ 1689# ------------------------------------------------------------------------------
1304use_doc() { 1690use_doc() {
1305 use doc && echo ${@:-javadoc} 1691 use doc && echo ${@:-javadoc}
1306} 1692}
1307 1693
1694
1308# ------------------------------------------------------------------------------ 1695# ------------------------------------------------------------------------------
1309# @section-end build 1696# @section-end build
1310# ------------------------------------------------------------------------------ 1697# ------------------------------------------------------------------------------
1311 1698
1312# ------------------------------------------------------------------------------ 1699# ------------------------------------------------------------------------------
1313# @section-begin internal 1700# @section-begin internal
1314# @section-summary Internal functions 1701# @section-summary Internal functions
1315# 1702#
1316# Do __NOT__ use any of these from an ebuild! These are only to be used from 1703# Do __NOT__ use any of these from an ebuild! These are only to be used from
1317# within the java eclasses. 1704# within the java eclasses.
1318# ------------------------------------------------------------------------------ 1705# ------------------------------------------------------------------------------
1319 1706
1320# ----------------------------------------------------------------------------- 1707# -----------------------------------------------------------------------------
1321# @function-internal java-pkg_init 1708# @function-internal java-pkg_init
1322# 1709#
1323# The purpose of this function, as the name might imply, is to initialize the 1710# The purpose of this function, as the name might imply, is to initialize the
1324# Java environment. It ensures that that there aren't any environment variables 1711# Java environment. It ensures that that there aren't any environment variables
1325# that'll muss things up. It initializes some variables, which are used 1712# that'll muss things up. It initializes some variables, which are used
1326# internally. And most importantly, it'll switch the VM if necessary. 1713# internally. And most importantly, it'll switch the VM if necessary.
1327# 1714#
1339 # TODO we will probably want to set JAVAC and JAVACFLAGS 1726 # TODO we will probably want to set JAVAC and JAVACFLAGS
1340 1727
1341 # Do some QA checks 1728 # Do some QA checks
1342 java-pkg_check-jikes 1729 java-pkg_check-jikes
1343 1730
1344 # When users have crazy classpaths some packages can fail to compile. 1731 # When users have crazy classpaths some packages can fail to compile.
1345 # and everything should work with empty CLASSPATH. 1732 # and everything should work with empty CLASSPATH.
1346 # This also helps prevent unexpected dependencies on random things 1733 # This also helps prevent unexpected dependencies on random things
1347 # from the CLASSPATH. 1734 # from the CLASSPATH.
1348 unset CLASSPATH 1735 unset CLASSPATH
1736
1737 # Unset external ANT_ stuff
1738 unset ANT_TASKS
1739 unset ANT_OPTS
1349} 1740}
1350 1741
1351# ------------------------------------------------------------------------------ 1742# ------------------------------------------------------------------------------
1352# @function-internal java-pkg-init-compiler_ 1743# @function-internal java-pkg-init-compiler_
1353# 1744#
1354# This function attempts to figure out what compiler should be used. It does 1745# This function attempts to figure out what compiler should be used. It does
1355# this by reading the file at JAVA_PKG_COMPILERS_CONF, and checking the 1746# this by reading the file at JAVA_PKG_COMPILERS_CONF, and checking the
1356# COMPILERS variable defined there. 1747# COMPILERS variable defined there.
1357# This can be overridden by a list in JAVA_PKG_FORCE_COMPILER 1748# This can be overridden by a list in JAVA_PKG_FORCE_COMPILER
1358# 1749#
1359# It will go through the list of compilers, and verify that it supports the 1750# It will go through the list of compilers, and verify that it supports the
1360# target and source that are needed. If it is not suitable, then the next 1751# target and source that are needed. If it is not suitable, then the next
1361# compiler is checked. When JAVA_PKG_FORCE_COMPILER is defined, this checking 1752# compiler is checked. When JAVA_PKG_FORCE_COMPILER is defined, this checking
1362# isn't done. 1753# isn't done.
1363# 1754#
1385 if [[ -z ${JAVA_PKG_FORCE_COMPILER} ]]; then 1776 if [[ -z ${JAVA_PKG_FORCE_COMPILER} ]]; then
1386 compilers="$(source ${JAVA_PKG_COMPILERS_CONF} 1>/dev/null 2>&1; echo ${COMPILERS})" 1777 compilers="$(source ${JAVA_PKG_COMPILERS_CONF} 1>/dev/null 2>&1; echo ${COMPILERS})"
1387 else 1778 else
1388 compilers=${JAVA_PKG_FORCE_COMPILER} 1779 compilers=${JAVA_PKG_FORCE_COMPILER}
1389 fi 1780 fi
1390 1781
1391 debug-print "Read \"${compilers}\" from ${JAVA_PKG_COMPILERS_CONF}" 1782 debug-print "Read \"${compilers}\" from ${JAVA_PKG_COMPILERS_CONF}"
1392 1783
1393 # Figure out if we should announce what compiler we're using 1784 # Figure out if we should announce what compiler we're using
1394 local compiler 1785 local compiler
1395 for compiler in ${compilers}; do 1786 for compiler in ${compilers}; do
1398 if [[ ${compiler} = "javac" ]]; then 1789 if [[ ${compiler} = "javac" ]]; then
1399 debug-print "Found javac... breaking" 1790 debug-print "Found javac... breaking"
1400 export GENTOO_COMPILER="javac" 1791 export GENTOO_COMPILER="javac"
1401 break 1792 break
1402 fi 1793 fi
1403 1794
1404 if has ${compiler} ${JAVA_PKG_FILTER_COMPILER}; then 1795 if has ${compiler} ${JAVA_PKG_FILTER_COMPILER}; then
1405 if [[ -z ${JAVA_PKG_FORCE_COMPILER} ]]; then 1796 if [[ -z ${JAVA_PKG_FORCE_COMPILER} ]]; then
1406 einfo "Filtering ${compiler}" 1797 einfo "Filtering ${compiler}"
1407 continue 1798 continue
1408 fi 1799 fi
1409 fi 1800 fi
1410 1801
1411 # for non-javac, we need to make sure it supports the right target and 1802 # for non-javac, we need to make sure it supports the right target and
1412 # source 1803 # source
1413 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}" 1804 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}"
1414 if [[ -f ${compiler_env} ]]; then 1805 if [[ -f ${compiler_env} ]]; then
1415 local desired_target="$(java-pkg_get-target)" 1806 local desired_target="$(java-pkg_get-target)"
1497# Writes the package.env out to disk. 1888# Writes the package.env out to disk.
1498# 1889#
1499# ------------------------------------------------------------------------------ 1890# ------------------------------------------------------------------------------
1500# TODO change to do-write, to match everything else 1891# TODO change to do-write, to match everything else
1501java-pkg_do_write_() { 1892java-pkg_do_write_() {
1893 java-pkg_init_paths_
1502 # Create directory for package.env 1894 # Create directory for package.env
1503 dodir "${JAVA_PKG_SHAREPATH}" 1895 dodir "${JAVA_PKG_SHAREPATH}"
1504 if [[ -n "${JAVA_PKG_CLASSPATH}" || -n "${JAVA_PKG_LIBRARY}" || -f "${JAVA_PKG_DEPEND}" ]]; then 1896 if [[ -n "${JAVA_PKG_CLASSPATH}" || -n "${JAVA_PKG_LIBRARY}" || -f "${JAVA_PKG_DEPEND}" ]]; then
1505 # Create package.env 1897 # Create package.env
1506 ( 1898 (
1511 [[ -n "${JAVA_PKG_LIBRARY}" ]] && echo "LIBRARY_PATH=\"${JAVA_PKG_LIBRARY}\"" 1903 [[ -n "${JAVA_PKG_LIBRARY}" ]] && echo "LIBRARY_PATH=\"${JAVA_PKG_LIBRARY}\""
1512 [[ -n "${JAVA_PROVIDE}" ]] && echo "PROVIDES=\"${JAVA_PROVIDE}\"" 1904 [[ -n "${JAVA_PROVIDE}" ]] && echo "PROVIDES=\"${JAVA_PROVIDE}\""
1513 [[ -f "${JAVA_PKG_DEPEND}" ]] && echo "DEPEND=\"$(cat ${JAVA_PKG_DEPEND} | uniq | tr '\n' ':')\"" 1905 [[ -f "${JAVA_PKG_DEPEND}" ]] && echo "DEPEND=\"$(cat ${JAVA_PKG_DEPEND} | uniq | tr '\n' ':')\""
1514 echo "VM=\"$(echo ${RDEPEND} ${DEPEND} | sed -e 's/ /\n/g' | sed -n -e '/virtual\/\(jre\|jdk\)/ { p;q }')\"" # TODO cleanup ! 1906 echo "VM=\"$(echo ${RDEPEND} ${DEPEND} | sed -e 's/ /\n/g' | sed -n -e '/virtual\/\(jre\|jdk\)/ { p;q }')\"" # TODO cleanup !
1515 ) > "${JAVA_PKG_ENV}" 1907 ) > "${JAVA_PKG_ENV}"
1516 1908
1517 # register target/source 1909 # register target/source
1518 local target="$(java-pkg_get-target)" 1910 local target="$(java-pkg_get-target)"
1519 local source="$(java-pkg_get-source)" 1911 local source="$(java-pkg_get-source)"
1520 [[ -n ${target} ]] && echo "TARGET=\"${target}\"" >> "${JAVA_PKG_ENV}" 1912 [[ -n ${target} ]] && echo "TARGET=\"${target}\"" >> "${JAVA_PKG_ENV}"
1521 [[ -n ${source} ]] && echo "SOURCE=\"${source}\"" >> "${JAVA_PKG_ENV}" 1913 [[ -n ${source} ]] && echo "SOURCE=\"${source}\"" >> "${JAVA_PKG_ENV}"
1534 # Strip unnecessary leading and trailing colons 1926 # Strip unnecessary leading and trailing colons
1535 # TODO try to cleanup if possible 1927 # TODO try to cleanup if possible
1536 sed -e "s/=\":/=\"/" -e "s/:\"$/\"/" -i "${JAVA_PKG_ENV}" || die "Did you forget to call java_init ?" 1928 sed -e "s/=\":/=\"/" -e "s/:\"$/\"/" -i "${JAVA_PKG_ENV}" || die "Did you forget to call java_init ?"
1537 fi 1929 fi
1538} 1930}
1539
1540 1931
1541# ------------------------------------------------------------------------------ 1932# ------------------------------------------------------------------------------
1542# @internal-function java-pkg_record-jar_ 1933# @internal-function java-pkg_record-jar_
1543# 1934#
1544# Record a dependency to the package.env 1935# Record a dependency to the package.env
1588 fi 1979 fi
1589} 1980}
1590 1981
1591# ------------------------------------------------------------------------------ 1982# ------------------------------------------------------------------------------
1592# @internal-function java-pkg_expand_dir_ 1983# @internal-function java-pkg_expand_dir_
1593# 1984#
1594# Gets the full path of the file/directory's parent. 1985# Gets the full path of the file/directory's parent.
1595# @param $1 - file/directory to find parent directory for 1986# @param $1 - file/directory to find parent directory for
1596# @return - path to $1's parent directory 1987# @return - path to $1's parent directory
1597# ------------------------------------------------------------------------------ 1988# ------------------------------------------------------------------------------
1598java-pkg_expand_dir_() { 1989java-pkg_expand_dir_() {
1625# ------------------------------------------------------------------------------ 2016# ------------------------------------------------------------------------------
1626java-pkg_setup-vm() { 2017java-pkg_setup-vm() {
1627 debug-print-function ${FUNCNAME} $* 2018 debug-print-function ${FUNCNAME} $*
1628 2019
1629 local vendor="$(java-pkg_get-vm-vendor)" 2020 local vendor="$(java-pkg_get-vm-vendor)"
1630 if [[ "${vendor}" == "sun" ]] && java-pkg_is-vm-version-ge 1 5; then 2021 if [[ "${vendor}" == "sun" ]] && java-pkg_is-vm-version-ge "1.5" ; then
1631 addpredict "/dev/random" 2022 addpredict "/dev/random"
1632 elif [[ "${vendor}" == "ibm" ]]; then 2023 elif [[ "${vendor}" == "ibm" ]]; then
1633 addpredict "/proc/self/maps" 2024 addpredict "/proc/self/maps"
1634 addpredict "/proc/cpuinfo" 2025 addpredict "/proc/cpuinfo"
1635 export LANG="C" LC_ALL="C" 2026 export LANG="C" LC_ALL="C"
1684# @return - The version of the current VM 2075# @return - The version of the current VM
1685# ------------------------------------------------------------------------------ 2076# ------------------------------------------------------------------------------
1686java-pkg_get-vm-version() { 2077java-pkg_get-vm-version() {
1687 debug-print-function ${FUNCNAME} $* 2078 debug-print-function ${FUNCNAME} $*
1688 2079
1689 java-pkg_get-current-vm | sed -e "s/.*-\([0-9.]\+\).*/\1/" 2080 java-config -g PROVIDES_VERSION
1690} 2081}
1691 2082
1692# ------------------------------------------------------------------------------ 2083# ------------------------------------------------------------------------------
1693# @internal-function java-pkg_switch-vm 2084# @internal-function java-pkg_switch-vm
1694# 2085#
1695# Switch VM if we're allowed to (controlled by JAVA_PKG_ALLOW_VM_CHANGE), and 2086# Switch VM if we're allowed to (controlled by JAVA_PKG_ALLOW_VM_CHANGE), and
1696# verify that the current VM is sufficient. 2087# verify that the current VM is sufficient.
1697# Setup the environment for the VM being used. 2088# Setup the environment for the VM being used.
1698# ------------------------------------------------------------------------------ 2089# ------------------------------------------------------------------------------
1699java-pkg_switch-vm() { 2090java-pkg_switch-vm() {
2091 debug-print-function ${FUNCNAME} $*
2092
1700 if java-pkg_needs-vm; then 2093 if java-pkg_needs-vm; then
1701 # Use the VM specified by JAVA_PKG_FORCE_VM 2094 # Use the VM specified by JAVA_PKG_FORCE_VM
1702 if [[ -n ${JAVA_PKG_FORCE_VM} ]]; then 2095 if [[ -n "${JAVA_PKG_FORCE_VM}" ]]; then
1703 # If you're forcing the VM, I hope you know what your doing... 2096 # If you're forcing the VM, I hope you know what your doing...
2097 debug-print "JAVA_PKG_FORCE_VM used: ${JAVA_PKG_FORCE_VM}"
1704 export GENTOO_VM="${JAVA_PKG_FORCE_VM}" 2098 export GENTOO_VM="${JAVA_PKG_FORCE_VM}"
1705 # if we're allowed to switch the vm... 2099 # if we're allowed to switch the vm...
1706 elif [[ "${JAVA_PKG_ALLOW_VM_CHANGE}" == "yes" ]]; then 2100 elif [[ "${JAVA_PKG_ALLOW_VM_CHANGE}" == "yes" ]]; then
1707 debug-print "depend-java-query: NV_DEPEND: ${JAVA_PKG_NV_DEPEND:-${DEPEND}} VNEED: ${JAVA_PKG_VNEED}" 2101 debug-print "depend-java-query: NV_DEPEND: ${JAVA_PKG_NV_DEPEND:-${DEPEND}} VNEED: ${JAVA_PKG_VNEED}"
1708 if [[ -n ${JAVA_PKG_VNEED} ]]; then 2102 if [[ -n ${JAVA_PKG_VNEED} ]]; then
1709 export GENTOO_VM="$(depend-java-query --need-virtual "${JAVA_PKG_VNEED}" --get-vm "${JAVA_PKG_NV_DEPEND:-${DEPEND}}")" 2103 GENTOO_VM="$(depend-java-query --need-virtual "${JAVA_PKG_VNEED}" --get-vm "${JAVA_PKG_NV_DEPEND:-${DEPEND}}")"
1710 else 2104 else
1711 export GENTOO_VM="$(depend-java-query --get-vm "${JAVA_PKG_NV_DEPEND:-${DEPEND}}")" 2105 GENTOO_VM="$(depend-java-query --get-vm "${JAVA_PKG_NV_DEPEND:-${DEPEND}}")"
2106 fi
2107 if [[ -z "${GENTOO_VM}" || "${GENTOO_VM}" == "None" ]]; then
2108 eerror "Unable to determine VM for building from dependencies:"
2109 echo "NV_DEPEND: ${JAVA_PKG_NV_DEPEND:-${DEPEND}}"
2110 echo "VNEED: ${JAVA_PKG_VNEED}"
2111 die "Failed to determine VM for building."
2112 else
2113 export GENTOO_VM
1712 fi 2114 fi
1713 # otherwise just make sure the current VM is sufficient 2115 # otherwise just make sure the current VM is sufficient
1714 else 2116 else
1715 java-pkg_ensure-vm-version-sufficient 2117 java-pkg_ensure-vm-version-sufficient
1716 fi 2118 fi
1717 debug-print "Using: $(java-config -f)" 2119 debug-print "Using: $(java-config -f)"
1718 2120
1719 java-pkg_setup-vm 2121 java-pkg_setup-vm
1720 2122
1721 export JAVA=$(java-config --java) 2123 export JAVA=$(java-config --java)
1722 export JAVAC=$(java-config --javac) 2124 export JAVAC=$(java-config --javac)
1723 export JAVACFLAGS="$(java-pkg_javac-args)" 2125 JAVACFLAGS="$(java-pkg_javac-args)"
2126 if [[ ${?} != 0 ]]; then
2127 eerror "There was a problem determining JAVACFLAGS: ${JAVACFLAGS}"
2128 die "java-pkg_javac-args failed"
2129 fi
1724 [[ -n ${JAVACFLAGS_EXTRA} ]] && export JAVACFLAGS="${JAVACFLAGS_EXTRA} ${JAVACFLAGS}" 2130 [[ -n ${JAVACFLAGS_EXTRA} ]] && JAVACFLAGS="${JAVACFLAGS_EXTRA} ${JAVACFLAGS}"
2131 export JAVACFLAGS
1725 2132
1726 export JAVA_HOME="$(java-config -g JAVA_HOME)" 2133 export JAVA_HOME="$(java-config -g JAVA_HOME)"
1727 export JDK_HOME=${JAVA_HOME} 2134 export JDK_HOME=${JAVA_HOME}
1728 2135
1729 #TODO If you know a better solution let us know. 2136 #TODO If you know a better solution let us know.
1730 java-pkg_append_ LD_LIBRARY_PATH "$(java-config -g LDPATH)" 2137 java-pkg_append_ LD_LIBRARY_PATH "$(java-config -g LDPATH)"
1731 2138
1732 local tann="${T}/announced-vm" 2139 local tann="${T}/announced-vm"
1733 if [[ -n "${JAVA_PKG_DEBUG}" ]] || [[ ! -f "${tann}" ]] ; then 2140 if [[ -n "${JAVA_PKG_DEBUG}" ]] || [[ ! -f "${tann}" ]] ; then
1734 # Add a check for setup/preinst phase... to avoid duplicate outputs 2141 # Add a check for setup/preinst phase... to avoid duplicate outputs
1735 # for when FEATURES=buildpkg 2142 # for when FEATURES=buildpkg
1736 if [[ ${EBUILD_PHASE} != "setup" && ${EBUILD_PHASE} != "preinst" && ${EBUILD_PHASE} != "postinst" ]]; 2143 if [[ ${EBUILD_PHASE} != "setup" && ${EBUILD_PHASE} != "preinst" && ${EBUILD_PHASE} != "postinst" ]];
1780# TODO document 2187# TODO document
1781# Verify that the classes were compiled for the right source / target 2188# Verify that the classes were compiled for the right source / target
1782java-pkg_verify-classes() { 2189java-pkg_verify-classes() {
1783 ebegin "Verifying java class versions" 2190 ebegin "Verifying java class versions"
1784 #$(find ${D} -type f -name '*.jar' -o -name '*.class') 2191 #$(find ${D} -type f -name '*.jar' -o -name '*.class')
1785 class-version-verify.py -t $(java-pkg_get-target) -r ${D} 2192 class-version-verify.py -t $(java-pkg_get-target) -r ${D}
1786 result=$? 2193 result=$?
1787 eend ${result} 2194 eend ${result}
1788 if [[ ${result} == 0 ]]; then 2195 if [[ ${result} == 0 ]]; then
1789 einfo "All good" 2196 einfo "All good"
1790 else 2197 else
1791 ewarn "Possible problem" 2198 ewarn "Possible problem"
1792 die "Bad class files found" 2199 die "Bad class files found"
1793 fi 2200 fi
1794} 2201}
1795 2202
1796
1797# ------------------------------------------------------------------------------ 2203# ------------------------------------------------------------------------------
1798# @section-end internal 2204# @section-end internal
1799# ------------------------------------------------------------------------------ 2205# ------------------------------------------------------------------------------
1800 2206
1801java-pkg_check-phase() { 2207java-pkg_check-phase() {
1832 let "JAVA_PKG_QA_VIOLATIONS+=1" 2238 let "JAVA_PKG_QA_VIOLATIONS+=1"
1833 export JAVA_PKG_QA_VIOLATIONS 2239 export JAVA_PKG_QA_VIOLATIONS
1834} 2240}
1835 2241
1836is-java-strict() { 2242is-java-strict() {
1837 hasq java-strict ${FEATURES}; 2243 [[ -n ${JAVA_PKG_STRICT} ]]
1838 return $? 2244 return $?
1839} 2245}
1840 2246
1841# ------------------------------------------------------------------------------ 2247# ------------------------------------------------------------------------------
1842# @eclass-end 2248# @eclass-end

Legend:
Removed from v.1.10  
changed lines
  Added in v.1.50

  ViewVC Help
Powered by ViewVC 1.1.20