/[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.22 Revision 1.55
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.55 2007/01/30 12:50:25 betelgeuse 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
23# 24#
24# ----------------------------------------------------------------------------- 25# -----------------------------------------------------------------------------
25 26
26inherit eutils versionator multilib 27inherit eutils versionator multilib
27 28
29IUSE="elibc_FreeBSD"
30
28# ----------------------------------------------------------------------------- 31# -----------------------------------------------------------------------------
29# @section-begin variables 32# @section-begin variables
30# @section-title Variables 33# @section-title Variables
31# 34#
32# Summary of variables which control the behavior of building Java packges. 35# Summary of variables which control the behavior of building Java packges.
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#
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"
156# -----------------------------------------------------------------------------
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
130# ----------------------------------------------------------------------------- 170# -----------------------------------------------------------------------------
131 171
132# TODO document me 172# TODO document me
133JAVA_PKG_QA_VIOLATIONS=0 173JAVA_PKG_QA_VIOLATIONS=0
134 174
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
232 #but first check class version when in strict mode.
233 is-java-strict && java-pkg_verify-classes "${jar}"
234
185 INSDESTTREE="${JAVA_PKG_JARDEST}" \ 235 INSDESTTREE="${JAVA_PKG_JARDEST}" \
186 doins "${jar}" || die "failed to install ${jar}" 236 doins "${jar}" || die "failed to install ${jar}"
187 java-pkg_append_ JAVA_PKG_CLASSPATH "${JAVA_PKG_JARDEST}/${jar_basename}" 237 java-pkg_append_ JAVA_PKG_CLASSPATH "${JAVA_PKG_JARDEST}/${jar_basename}"
188 debug-print "installed ${jar} to ${D}${JAVA_PKG_JARDEST}" 238 debug-print "installed ${jar} to ${D}${JAVA_PKG_JARDEST}"
189 # make a symlink to the original jar if it's symlink 239 # make a symlink to the original jar if it's symlink
200 250
201 java-pkg_do_write_ 251 java-pkg_do_write_
202} 252}
203 253
204 254
255# ------------------------------------------------------------------------------
256# @internal-function depend-java-query
257#
258# Wrapper for the depend-java-query binary to enable passing USE in env.
259# Using env variables keeps this eclass working with java-config versions that
260# do not handle use flags.
261# ------------------------------------------------------------------------------
262
263depend-java-query() {
264 USE="${USE}" $(which depend-java-query) "${@}"
265}
205 266
206# ------------------------------------------------------------------------------ 267# ------------------------------------------------------------------------------
207# @ebuild-function java-pkg_regjar 268# @ebuild-function java-pkg_regjar
208# 269#
209# Records an already installed jar in the package.env 270# Records an already installed jar in the package.env
240 [[ ${#} -lt 1 ]] && die "at least one argument needed" 301 [[ ${#} -lt 1 ]] && die "at least one argument needed"
241 302
242 java-pkg_init_paths_ 303 java-pkg_init_paths_
243 304
244 local jar jar_dir jar_file 305 local jar jar_dir jar_file
245 for jar in "$@"; do 306 for jar in "${@}"; do
246 # TODO use java-pkg_check-versioned-jar 307 # TODO use java-pkg_check-versioned-jar
247 if [[ -e "${jar}" ]]; then 308 if [[ -e "${jar}" || -e "${D}${jar}" ]]; then
309 [[ -d "${jar}" || -d "${D}${jar}" ]] \
310 && die "Called ${FUNCNAME} on a directory $*"
311
312 #check that class version correct when in strict mode
313 is-java-strict && java-pkg_verify-classes "${jar}"
314
248 # nelchael: we should strip ${D} in this case too, here's why: 315 # nelchael: we should strip ${D} in this case too, here's why:
249 # imagine such call: 316 # imagine such call:
250 # java-pkg_regjar ${D}/opt/java/*.jar 317 # java-pkg_regjar ${D}/opt/java/*.jar
251 # such call will fall into this case (-e ${jar}) and will 318 # such call will fall into this case (-e ${jar}) and will
252 # record paths with ${D} in package.env 319 # record paths with ${D} in package.env
253 java-pkg_append_ JAVA_PKG_CLASSPATH "${jar#${D}}" 320 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 321 else
257 die "${jar} does not exist" 322 die "${jar} does not exist"
258 fi 323 fi
259 done 324 done
260 325
261 java-pkg_do_write_ 326 java-pkg_do_write_
262} 327}
263
264 328
265# ------------------------------------------------------------------------------ 329# ------------------------------------------------------------------------------
266# @ebuild-function java-pkg_newjar 330# @ebuild-function java-pkg_newjar
267# 331#
268# Installs a jar with a new name 332# Installs a jar with a new name
279 local original_jar="${1}" 343 local original_jar="${1}"
280 local new_jar="${2:-${PN}.jar}" 344 local new_jar="${2:-${PN}.jar}"
281 local new_jar_dest="${T}/${new_jar}" 345 local new_jar_dest="${T}/${new_jar}"
282 346
283 [[ -z ${original_jar} ]] && die "Must specify a jar to install" 347 [[ -z ${original_jar} ]] && die "Must specify a jar to install"
284 [[ ! -f ${original_jar} ]] && die "${original_jar} does not exist!" 348 [[ ! -f ${original_jar} ]] \
349 && die "${original_jar} does not exist or is not a file!"
285 350
286 rm -f "${new_jar_dest}" || die "Failed to remove ${new_jar_dest}" 351 rm -f "${new_jar_dest}" || die "Failed to remove ${new_jar_dest}"
287 cp "${original_jar}" "${new_jar_dest}" \ 352 cp "${original_jar}" "${new_jar_dest}" \
288 || die "Failed to copy ${original_jar} to ${new_jar_dest}" 353 || die "Failed to copy ${original_jar} to ${new_jar_dest}"
289 java-pkg_dojar "${new_jar_dest}" 354 java-pkg_dojar "${new_jar_dest}"
290} 355}
291 356
292
293# ------------------------------------------------------------------------------ 357# ------------------------------------------------------------------------------
294# @ebuild-function java-pkg_addcp 358# @ebuild-function java-pkg_addcp
295# 359#
296# Add something to the package's classpath. For jars, you should use dojar, 360# 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. 361# newjar, or regjar. This is typically used to add directories to the classpath.
301# ------------------------------------------------------------------------------ 365# ------------------------------------------------------------------------------
302java-pkg_addcp() { 366java-pkg_addcp() {
303 java-pkg_append_ JAVA_PKG_CLASSPATH "${@}" 367 java-pkg_append_ JAVA_PKG_CLASSPATH "${@}"
304 java-pkg_do_write_ 368 java-pkg_do_write_
305} 369}
306
307 370
308# ------------------------------------------------------------------------------ 371# ------------------------------------------------------------------------------
309# @ebuild-function java-pkg_doso 372# @ebuild-function java-pkg_doso
310# 373#
311# Installs any number of JNI libraries 374# Installs any number of JNI libraries
428# ------------------------------------------------------------------------------ 491# ------------------------------------------------------------------------------
429java-pkg_dohtml() { 492java-pkg_dohtml() {
430 debug-print-function ${FUNCNAME} $* 493 debug-print-function ${FUNCNAME} $*
431 494
432 [[ ${#} -lt 1 ]] && die "At least one argument required for ${FUNCNAME}" 495 [[ ${#} -lt 1 ]] && die "At least one argument required for ${FUNCNAME}"
433 # TODO-nichoj find out what exactly -f package-list does 496
497 # from /usr/lib/portage/bin/dohtml -h
498 # -f Set list of allowed extensionless file names.
434 dohtml -f package-list "$@" 499 dohtml -f package-list "$@"
500
435 # this probably shouldn't be here but it provides 501 # this probably shouldn't be here but it provides
436 # a reasonable way to catch # docs for all of the 502 # a reasonable way to catch # docs for all of the
437 # old ebuilds. 503 # old ebuilds.
438 java-pkg_recordjavadoc 504 java-pkg_recordjavadoc
439} 505}
440 506
441# TODO document 507# ------------------------------------------------------------------------------
508# @ebuild-function java-pkg_dojavadoc
509#
510# Installs javadoc documentation. This should be controlled by the doc use flag.
511#
512# @param $1: - The javadoc root directory.
513#
514# @example:
515# java-pkg_dojavadoc docs/api
516#
517# ------------------------------------------------------------------------------
442java-pkg_dojavadoc() { 518java-pkg_dojavadoc() {
443 local dir="$1" 519 local dir="$1"
444 520
445 java-pkg_check-phase install 521 java-pkg_check-phase install
446 522
491 java-pkg_init_paths_ 567 java-pkg_init_paths_
492 568
493 local zip_name="${PN}-src.zip" 569 local zip_name="${PN}-src.zip"
494 local zip_path="${T}/${zip_name}" 570 local zip_path="${T}/${zip_name}"
495 local dir 571 local dir
496 for dir in ${@}; do 572 for dir in "${@}"; do
497 local dir_parent=$(dirname "${dir}") 573 local dir_parent=$(dirname "${dir}")
498 local dir_name=$(basename "${dir}") 574 local dir_name=$(basename "${dir}")
499 pushd ${dir_parent} > /dev/null || die "problem entering ${dir_parent}" 575 pushd ${dir_parent} > /dev/null || die "problem entering ${dir_parent}"
500 zip -q -r ${zip_path} ${dir_name} -i '*.java' 576 zip -q -r ${zip_path} ${dir_name} -i '*.java'
501 local result=$? 577 local result=$?
518# @ebuild-function java-pkg_dolauncher 594# @ebuild-function java-pkg_dolauncher
519# 595#
520# Make a wrapper script to lauch/start this package 596# Make a wrapper script to lauch/start this package
521# If necessary, the wrapper will switch to the appropriate VM. 597# If necessary, the wrapper will switch to the appropriate VM.
522# 598#
599# Can be called without parameters if the package installs only one jar
600# that has the Main-class attribute set. The wrapper will be named ${PN}.
601#
523# @param $1 - filename of launcher to create 602# @param $1 - filename of launcher to create
524# @param $2 - options, as follows: 603# @param $2 - options, as follows:
525# --main the.main.class.too.start 604# --main the.main.class.too.start
526# --jar /the/jar/too/launch.jar 605# --jar /the/jar/too/launch.jar or just <name>.jar
527# --java_args 'Extra arguments to pass to java' 606# --java_args 'Extra arguments to pass to java'
528# --pkg_args 'Extra arguments too pass to the package' 607# --pkg_args 'Extra arguments to pass to the package'
529# --pwd 608# --pwd Directory the launcher changes to before executing java
530# -into 609# -into Directory to install the launcher to, instead of /usr/bin
531# -pre 610# -pre Prepend contents of this file to the launcher
532# ------------------------------------------------------------------------------ 611# ------------------------------------------------------------------------------
533java-pkg_dolauncher() { 612java-pkg_dolauncher() {
534 debug-print-function ${FUNCNAME} $* 613 debug-print-function ${FUNCNAME} $*
535 614
536 java-pkg_check-phase install 615 java-pkg_check-phase install
537
538 [[ ${#} -lt 1 ]] && die "Need at least one argument"
539
540 java-pkg_init_paths_ 616 java-pkg_init_paths_
541 617
618 if [[ ${#} = 0 ]]; then
619 local name="${PN}"
620 else
542 local name="${1}" 621 local name="${1}"
622 shift
623 fi
624
543 # TODO rename to launcher 625 # TODO rename to launcher
544 local target="${T}/${name}" 626 local target="${T}/${name}"
545 local var_tmp="${T}/launcher_variables_tmp" 627 local var_tmp="${T}/launcher_variables_tmp"
546 local target_dir pre 628 local target_dir pre
547 shift
548 629
549 # Process the other the rest of the arguments 630 # Process the other the rest of the arguments
550 while [[ -n "${1}" && -n "${2}" ]]; do 631 while [[ -n "${1}" && -n "${2}" ]]; do
551 local var=${1} value=${2} 632 local var="${1}" value="${2}"
552 if [[ "${var:0:2}" == "--" ]]; then 633 if [[ "${var:0:2}" == "--" ]]; then
634 local var=${var:2}
553 echo "gjl_${var:2}=\"${value}\"" >> "${var_tmp}" 635 echo "gjl_${var}=\"${value}\"" >> "${var_tmp}"
636 local gjl_${var}="${value}"
554 elif [[ "${var}" == "-into" ]]; then 637 elif [[ "${var}" == "-into" ]]; then
555 target_dir="${value}" 638 target_dir="${value}"
556 elif [[ "${var}" == "-pre" ]]; then 639 elif [[ "${var}" == "-pre" ]]; then
557 pre="${value}" 640 pre="${value}"
558 fi 641 fi
559 shift 2 642 shift 2
560 done 643 done
561 644
645 # Test if no --jar and --main arguments were given and
646 # in that case check if the package only installs one jar
647 # and use that jar.
648 if [[ -z "${gjl_jar}" && -z "${gjl_main}" ]]; then
649 local cp="${JAVA_PKG_CLASSPATH}"
650 if [[ "${cp/:}" = "${cp}" && "${cp%.jar}" != "${cp}" ]]; then
651 echo "gjl_jar=\"${JAVA_PKG_CLASSPATH}\"" >> "${var_tmp}"
652 else
653 local msg="Not enough information to create a launcher given."
654 msg="${msg} Please give --jar or --main argument to ${FUNCNAME}."
655 die "${msg}"
656 fi
657 fi
658
562 # Write the actual script 659 # Write the actual script
563 echo "#!/bin/bash" > "${target}" 660 echo "#!/bin/bash" > "${target}"
564 [[ -n "${pre}" ]] && [[ -f "${pre}" ]] && cat "${pre}" >> "${target}" 661 if [[ -n "${pre}" ]]; then
662 if [[ -f "${pre}" ]]; then
663 cat "${pre}" >> "${target}"
664 else
665 die "-pre specified file '${pre}' does not exist"
666 fi
667 fi
565 echo "gjl_package=${JAVA_PKG_NAME}" >> "${target}" 668 echo "gjl_package=${JAVA_PKG_NAME}" >> "${target}"
566 cat "${var_tmp}" >> "${target}" 669 cat "${var_tmp}" >> "${target}"
567 rm -f "${var_tmp}" 670 rm -f "${var_tmp}"
568 echo "source /usr/share/java-config-2/launcher/launcher.bash" >> "${target}" 671 echo "source /usr/share/java-config-2/launcher/launcher.bash" >> "${target}"
569 672
661# Example: get a specific jar from xerces slot 2, and name it diffrently 764# Example: get a specific jar from xerces slot 2, and name it diffrently
662# java-pkg_jar-from xerces-2 xml-apis.jar xml.jar 765# java-pkg_jar-from xerces-2 xml-apis.jar xml.jar
663# Example: get junit.jar which is needed only for building 766# Example: get junit.jar which is needed only for building
664# java-pkg_jar-from --build-only junit junit.jar 767# java-pkg_jar-from --build-only junit junit.jar
665# 768#
666# @param $1 - (optional) "--build-only" makes the jar(s) not added into 769# @param $opt
667# package.env DEPEND line. 770# --build-only - makes the jar(s) not added into package.env DEPEND line.
771# (assumed automatically when called inside src_test)
772# --with-dependencies - get jars also from requested package's dependencies
773# transitively.
774# --into $dir - symlink jar(s) into $dir (must exist) instead of .
668# @param $1 - Package to get jars from. 775# @param $1 - Package to get jars from.
669# @param $2 - jar from package. If not specified, all jars will be used. 776# @param $2 - jar from package. If not specified, all jars will be used.
670# @param $3 - When a single jar is specified, destination filename of the 777# @param $3 - When a single jar is specified, destination filename of the
671# symlink. Defaults to the name of the jar. 778# symlink. Defaults to the name of the jar.
672# ------------------------------------------------------------------------------ 779# ------------------------------------------------------------------------------
673# TODO could probably be cleaned up a little 780# TODO could probably be cleaned up a little
674java-pkg_jar-from() { 781java-pkg_jar-from() {
675 debug-print-function ${FUNCNAME} $* 782 debug-print-function ${FUNCNAME} $*
676 783
677 local build_only="" 784 local build_only=""
785 local destdir="."
786 local deep=""
787
788 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="true"
678 789
790 while [[ "${1}" == --* ]]; do
679 if [[ "${1}" = "--build-only" ]]; then 791 if [[ "${1}" = "--build-only" ]]; then
680 build_only="true" 792 build_only="true"
793 elif [[ "${1}" = "--with-dependencies" ]]; then
794 deep="--with-dependencies"
795 elif [[ "${1}" = "--into" ]]; then
796 destdir="${2}"
797 shift
798 else
799 die "java-pkg_jar-from called with unknown parameter: ${1}"
800 fi
681 shift 801 shift
682 fi 802 done
683 803
684 local target_pkg="${1}" target_jar="${2}" destjar="${3}" 804 local target_pkg="${1}" target_jar="${2}" destjar="${3}"
685 805
686 [[ -z ${target_pkg} ]] && die "Must specify a package" 806 [[ -z ${target_pkg} ]] && die "Must specify a package"
687 807
688 # default destjar to the target jar 808 # default destjar to the target jar
689 [[ -z "${destjar}" ]] && destjar="${target_jar}" 809 [[ -z "${destjar}" ]] && destjar="${target_jar}"
690 810
691 local error_msg="There was a problem getting the classpath for ${target_pkg}." 811 local error_msg="There was a problem getting the classpath for ${target_pkg}."
692 local classpath 812 local classpath
693 classpath="$(java-config --classpath=${target_pkg})" 813 classpath="$(java-config ${deep} --classpath=${target_pkg})"
694 [[ $? != 0 ]] && die ${error_msg} 814 [[ $? != 0 ]] && die ${error_msg}
695 815
816 pushd ${destdir} > /dev/null \
817 || die "failed to change directory to ${destdir}"
696 local jar 818 local jar
697 for jar in ${classpath//:/ }; do 819 for jar in ${classpath//:/ }; do
698 local jar_name=$(basename "${jar}") 820 local jar_name=$(basename "${jar}")
699 if [[ ! -f "${jar}" ]] ; then 821 if [[ ! -f "${jar}" ]] ; then
700 debug-print "${jar} from ${target_pkg} does not exist" 822 debug-print "${jar} from ${target_pkg} does not exist"
710 elif [[ "${jar_name}" == "${target_jar}" ]] ; then 832 elif [[ "${jar_name}" == "${target_jar}" ]] ; then
711 [[ -f "${destjar}" ]] && rm "${destjar}" 833 [[ -f "${destjar}" ]] && rm "${destjar}"
712 ln -snf "${jar}" "${destjar}" \ 834 ln -snf "${jar}" "${destjar}" \
713 || die "Failed to make symlink from ${jar} to ${destjar}" 835 || die "Failed to make symlink from ${jar} to ${destjar}"
714 [[ -z "${build_only}" ]] && java-pkg_record-jar_ "${target_pkg}" "${jar}" 836 [[ -z "${build_only}" ]] && java-pkg_record-jar_ "${target_pkg}" "${jar}"
837 popd > /dev/null
715 return 0 838 return 0
716 fi 839 fi
717 done 840 done
841 popd > /dev/null
718 # if no target was specified, we're ok 842 # if no target was specified, we're ok
719 if [[ -z "${target_jar}" ]] ; then 843 if [[ -z "${target_jar}" ]] ; then
720 return 0 844 return 0
721 # otherwise, die bitterly 845 # otherwise, die bitterly
722 else 846 else
741# The providing packages are recorded as dependencies into package.env DEPEND 865# The providing packages are recorded as dependencies into package.env DEPEND
742# line, unless "--build-only" is passed as the very first argument, for jars 866# line, unless "--build-only" is passed as the very first argument, for jars
743# that have to be present only at build time and are not needed on runtime 867# that have to be present only at build time and are not needed on runtime
744# (junit testing etc). 868# (junit testing etc).
745# 869#
746# Example: Get the classpath for xerces-2, 870# Example: Get the classpath for xerces-2 and xalan,
747# java-pkg_getjars xerces-2 xalan 871# java-pkg_getjars xerces-2,xalan
748# Example Return: 872# Example Return:
749# /usr/share/xerces-2/lib/xml-apis.jar:/usr/share/xerces-2/lib/xmlParserAPIs.jar:/usr/share/xalan/lib/xalan.jar 873# /usr/share/xerces-2/lib/xml-apis.jar:/usr/share/xerces-2/lib/xmlParserAPIs.jar:/usr/share/xalan/lib/xalan.jar
750# 874#
751# @param $1 - (optional) "--build-only" makes the jar(s) not added into 875# @param $opt
752# package.env DEPEND line. 876# --build-only - makes the jar(s) not added into package.env DEPEND line.
877# (assumed automatically when called inside src_test)
878# --with-dependencies - get jars also from requested package's dependencies
879# transitively.
753# @param $@ - list of packages to get jars from 880# @param $1 - list of packages to get jars from
881# (passed to java-config --classpath)
754# ------------------------------------------------------------------------------ 882# ------------------------------------------------------------------------------
755java-pkg_getjars() { 883java-pkg_getjars() {
756 debug-print-function ${FUNCNAME} $* 884 debug-print-function ${FUNCNAME} $*
757 885
758 local build_only="" 886 local build_only=""
887 local deep=""
888
889 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="true"
759 890
891 while [[ "${1}" == --* ]]; do
760 if [[ "${1}" = "--build-only" ]]; then 892 if [[ "${1}" = "--build-only" ]]; then
761 build_only="true" 893 build_only="true"
894 elif [[ "${1}" = "--with-dependencies" ]]; then
895 deep="--with-dependencies"
896 else
897 die "java-pkg_jar-from called with unknown parameter: ${1}"
898 fi
762 shift 899 shift
763 fi
764
765 [[ ${#} -lt 1 ]] && die "At least one argument needed"
766
767 # NOTE could probably just pass $@ to java-config --classpath. and return it
768 local classpath pkg
769 for pkg in ${@//,/ }; do
770 #for pkg in $(echo "$@" | tr ',' ' '); do
771 jars="$(java-config --classpath=${pkg})"
772 [[ -z "${jars}" ]] && die "java-config --classpath=${pkg} failed"
773 debug-print "${pkg}:${jars}"
774
775 if [[ -z "${classpath}" ]]; then
776 classpath="${jars}"
777 else
778 classpath="${classpath}:${jars}"
779 fi
780 # Only record jars that aren't build-only
781 [[ -z "${build_only}" ]] && java-pkg_record-jar_ "${pkg}"
782 done 900 done
901
902 [[ ${#} -ne 1 ]] && die "${FUNCNAME} takes only one argument besides --*"
903
904 local classpath pkgs="${1}"
905 jars="$(java-config ${deep} --classpath=${pkgs})"
906 [[ -z "${jars}" ]] && die "java-config --classpath=${pkgs} failed"
907 debug-print "${pkgs}:${jars}"
908
909 if [[ -z "${classpath}" ]]; then
910 classpath="${jars}"
911 else
912 classpath="${classpath}:${jars}"
913 fi
914
915 # Only record jars that aren't build-only
916 if [[ -z "${build_only}" ]]; then
917 oldifs="${IFS}"
918 IFS=","
919 for pkg in ${pkgs}; do
920 java-pkg_record-jar_ "${pkg}"
921 done
922 IFS="${oldifs}"
923 fi
924
783 echo "${classpath}" 925 echo "${classpath}"
784} 926}
785 927
786# ------------------------------------------------------------------------------ 928# ------------------------------------------------------------------------------
787# @ebuild-function java-pkg_getjar 929# @ebuild-function java-pkg_getjar
795# @example 937# @example
796# java-pkg_getjar xerces-2 xml-apis.jar 938# java-pkg_getjar xerces-2 xml-apis.jar
797# @example-return 939# @example-return
798# /usr/share/xerces-2/lib/xml-apis.jar 940# /usr/share/xerces-2/lib/xml-apis.jar
799# 941#
800# @param $1 - (optional) "--build-only" makes the jar not added into 942# @param $opt
801# package.env DEPEND line. 943# --build-only - makes the jar not added into package.env DEPEND line.
802# @param $1 - package to use 944# @param $1 - package to use
803# @param $2 - jar to get 945# @param $2 - jar to get
804# ------------------------------------------------------------------------------ 946# ------------------------------------------------------------------------------
805java-pkg_getjar() { 947java-pkg_getjar() {
806 debug-print-function ${FUNCNAME} $* 948 debug-print-function ${FUNCNAME} $*
807 949
808 local build_only="" 950 local build_only=""
951
952 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="true"
809 953
954 while [[ "${1}" == --* ]]; do
810 if [[ "${1}" = "--build-only" ]]; then 955 if [[ "${1}" = "--build-only" ]]; then
811 build_only="true" 956 build_only="true"
957 else
958 die "java-pkg_jar-from called with unknown parameter: ${1}"
959 fi
812 shift 960 shift
813 fi 961 done
962
963 [[ ${#} -ne 2 ]] && die "${FUNCNAME} takes only two arguments besides --*"
814 964
815 local pkg="${1}" target_jar="${2}" jar 965 local pkg="${1}" target_jar="${2}" jar
816 [[ -z ${pkg} ]] && die "Must specify package to get a jar from" 966 [[ -z ${pkg} ]] && die "Must specify package to get a jar from"
817 [[ -z ${target_jar} ]] && die "Must specify jar to get" 967 [[ -z ${target_jar} ]] && die "Must specify jar to get"
818 968
960# 1110#
961# export DEPEND="${DEPEND} ${depstr}" 1111# export DEPEND="${DEPEND} ${depstr}"
962# export RDEPEND="${RDEPEND} ${depstr}" 1112# export RDEPEND="${RDEPEND} ${depstr}"
963#} 1113#}
964 1114
1115# ------------------------------------------------------------------------------
1116# @ebuild-function java-pkg_find-normal-jars
1117#
1118# Find the files with suffix .jar file in the given directory or $WORKDIR
1119#
1120# @param $1 - The directory to search for jar files (default: ${WORKDIR})
1121# ------------------------------------------------------------------------------
1122java-pkg_find-normal-jars() {
1123 local dir=$1
1124 [[ "${dir}" ]] || dir="${WORKDIR}"
1125 local found
1126 for jar in $(find "${dir}" -name "*.jar" -type f); do
1127 echo "${jar}"
1128 found="true"
1129 done
1130 [[ "${found}" ]]
1131 return $?
1132}
1133
1134# ------------------------------------------------------------------------------
1135# @ebuild-function java-pkg_ensure-no-bundled-jars
1136#
1137# Try to locate bundled jar files in ${WORKDIR} and die if found.
965# This should be used after S has been populated with symlinks to jars 1138# This function should be called after WORKDIR has been populated with symlink
966# TODO document 1139# to system jar files or bundled jars removed.
1140# ------------------------------------------------------------------------------
967java-pkg_ensure-no-bundled-jars() { 1141java-pkg_ensure-no-bundled-jars() {
968 debug-print-function ${FUNCNAME} $* 1142 debug-print-function ${FUNCNAME} $*
969 pushd ${WORKDIR} >/dev/null 2>/dev/null
970 1143
971 local bundled_jars=$(find . -name "*.jar" -type f) 1144 local bundled_jars=$(java-pkg_find-normal-jars)
972 if [[ -n ${bundled_jars} ]]; then 1145 if [[ -n ${bundled_jars} ]]; then
973 echo "Bundled jars found:" 1146 echo "Bundled jars found:"
974 local jar 1147 local jar
975 for jar in ${bundled_jars}; do 1148 for jar in ${bundled_jars}; do
976 echo $(pwd)${jar/./} 1149 echo $(pwd)${jar/./}
977 done 1150 done
978 die "Bundled jars found!" 1151 die "Bundled jars found!"
979
980 fi 1152 fi
981 popd >/dev/null 2>/dev/null
982} 1153}
983 1154
984# ------------------------------------------------------------------------------ 1155# ------------------------------------------------------------------------------
985# @internal-function java-pkg_ensure-vm-version-sufficient 1156# @internal-function java-pkg_ensure-vm-version-sufficient
986# 1157#
1135# @ebuild-function java-pkg_get-target 1306# @ebuild-function java-pkg_get-target
1136# 1307#
1137# Determines what target version should be used, for passing to -target. 1308# Determines what target version should be used, for passing to -target.
1138# If you don't care about lower versions, you can set _WANT_TARGET to the 1309# If you don't care about lower versions, you can set _WANT_TARGET to the
1139# version of your JDK. 1310# version of your JDK.
1140# Remember doing this will mostly like cause things to break.
1141# Doesn't allow it to be lower then the one in depend.
1142# Doesn't allow it to be higher then the active vm.
1143# 1311#
1144# @return string - Either the lowest possible target, or JAVA_PKG_WANT_TARGET 1312# @return string - Either the lowest possible target, or JAVA_PKG_WANT_TARGET
1145# ------------------------------------------------------------------------------ 1313# ------------------------------------------------------------------------------
1146java-pkg_get-target() { 1314java-pkg_get-target() {
1147 local min=$(depend-java-query --get-lowest "${DEPEND} ${RDEPEND}")
1148 if [[ -n "${JAVA_PKG_WANT_TARGET}" ]]; then
1149 local max="$(java-config --select-vm "${GENTOO_VM}" -g PROVIDES_VERSION)"
1150 if version_is_at_least "${min}" "${JAVA_PKG_WANT_TARGET}" && version_is_at_least "${JAVA_PKG_WANT_TARGET}" "${max}"; then
1151 echo ${JAVA_PKG_WANT_TARGET}
1152 else
1153 echo ${min}
1154 fi
1155 else
1156 echo ${min}
1157 fi
1158
1159 #echo ${JAVA_PKG_WANT_TARGET:-$(depend-java-query --get-lowest "${DEPEND}")} 1315 echo ${JAVA_PKG_WANT_TARGET:-$(depend-java-query --get-lowest "${DEPEND} ${RDEPEND}")}
1160} 1316}
1161 1317
1162java-pkg_get-javac() { 1318java-pkg_get-javac() {
1163 debug-print-function ${FUNCNAME} $* 1319 debug-print-function ${FUNCNAME} $*
1164 1320
1165 java-pkg_init-compiler_ 1321
1166 local compiler="${GENTOO_COMPILER}" 1322 local compiler="${GENTOO_COMPILER}"
1167 1323
1168 local compiler_executable 1324 local compiler_executable
1169 if [[ "${compiler}" = "javac" ]]; then 1325 if [[ "${compiler}" = "javac" ]]; then
1170 # nothing fancy needs to be done for javac 1326 # nothing fancy needs to be done for javac
1178 unset JAVAC 1334 unset JAVAC
1179 # try to get value of JAVAC 1335 # try to get value of JAVAC
1180 compiler_executable="$(source ${compiler_env} 1>/dev/null 2>&1; echo ${JAVAC})" 1336 compiler_executable="$(source ${compiler_env} 1>/dev/null 2>&1; echo ${JAVAC})"
1181 export JAVAC=${old_javac} 1337 export JAVAC=${old_javac}
1182 1338
1183 [[ -z ${compiler_executable} ]] && die "JAVAC is empty or undefined in ${compiler_env}" 1339 if [[ -z ${compiler_executable} ]]; then
1340 echo "JAVAC is empty or undefined in ${compiler_env}"
1341 return 1
1342 fi
1184 1343
1185 # check that it's executable 1344 # check that it's executable
1186 if [[ ! -x ${compiler_executable} ]]; then 1345 if [[ ! -x ${compiler_executable} ]]; then
1187 eerror "Could not find ${compiler_executable}!"
1188 die "${compiler_executable} doesn't exist, or isn't executable" 1346 echo "${compiler_executable} doesn't exist, or isn't executable"
1347 return 1
1189 fi 1348 fi
1190 else 1349 else
1191 eerror "Could not find environment file for ${compiler}" 1350 echo "Could not find environment file for ${compiler}"
1192 die "Could not find ${compiler_env}" 1351 return 1
1193 fi 1352 fi
1194 fi 1353 fi
1195 echo ${compiler_executable} 1354 echo ${compiler_executable}
1196} 1355}
1197 1356
1214 1373
1215 debug-print "want source: ${want_source}" 1374 debug-print "want source: ${want_source}"
1216 debug-print "want target: ${want_target}" 1375 debug-print "want target: ${want_target}"
1217 1376
1218 if [[ -z "${want_source}" || -z "${want_target}" ]]; then 1377 if [[ -z "${want_source}" || -z "${want_target}" ]]; then
1219 debug-print "could not find valid -source/-target values" 1378 debug-print "could not find valid -source/-target values for javac"
1220 die "Could not find valid -source/-target values" 1379 echo "Could not find valid -source/-target values for javac"
1380 return 1
1221 else 1381 else
1222 if java-pkg_is-vm-version-ge "1.4"; then 1382 if java-pkg_is-vm-version-ge "1.4"; then
1223 echo "${source_str} ${target_str}" 1383 echo "${source_str} ${target_str}"
1224 else 1384 else
1225 echo "${target_str}" 1385 echo "${target_str}"
1229 1389
1230# TODO document 1390# TODO document
1231java-pkg_get-jni-cflags() { 1391java-pkg_get-jni-cflags() {
1232 local flags="-I${JAVA_HOME}/include" 1392 local flags="-I${JAVA_HOME}/include"
1233 1393
1394 local platform="linux"
1395 use elibc_FreeBSD && platform="freebsd"
1396
1234 # TODO do a check that the directories are valid 1397 # TODO do a check that the directories are valid
1235 # TODO figure out how to cope with other things than linux...
1236 flags="${flags} -I${JAVA_HOME}/include/linux" 1398 flags="${flags} -I${JAVA_HOME}/include/${platform}"
1237 1399
1238 echo ${flags} 1400 echo ${flags}
1239} 1401}
1240 1402
1241java-pkg_ensure-gcj() { 1403java-pkg_ensure-gcj() {
1247 die "No GCJ support found!" 1409 die "No GCJ support found!"
1248 fi 1410 fi
1249} 1411}
1250 1412
1251java-pkg_ensure-test() { 1413java-pkg_ensure-test() {
1252 if hasq test ${FEATURES} && ! hasq -test ${FEATURES} && ! use test; then 1414 if hasq test ${FEATURES} && ! hasq -test ${FEATURES} \
1415 && hasq test ${IUSE} && ! use test;
1416 then
1253 eerror "You specified FEATURES=test, but USE=test is needed" 1417 eerror "You specified FEATURES=test, but USE=test is needed"
1254 eerror "to pull in the additional dependencies for testing" 1418 eerror "to pull in the additional dependencies for testing"
1255 die "Need USE=test enabled" 1419 die "Need USE=test enabled"
1256 fi 1420 fi
1257} 1421}
1258 1422
1259# ------------------------------------------------------------------------------ 1423# ------------------------------------------------------------------------------
1424# @ebuild-function java-pkg_register-ant-task
1425#
1426# Register this package as ant task, so that ant will load it when no specific
1427# ANT_TASKS are specified. Note that even without this registering, all packages
1428# specified in ANT_TASKS will be loaded. Mostly used by the actual ant tasks
1429# packages, but can be also used by other ebuilds that used to symlink their
1430# .jar into /usr/share/ant-core/lib to get autoloaded, for backwards
1431# compatibility.
1432#
1433# @param --version x.y Register only for ant version x.y (otherwise for any ant
1434# version). Used by the ant-* packages to prevent loading of mismatched
1435# ant-core ant tasks after core was updated, before the tasks are updated,
1436# without a need for blockers.
1437# @param $1 Name to register as. Defaults to JAVA_PKG_NAME ($PN[-$SLOT])
1438# ------------------------------------------------------------------------------
1439java-pkg_register-ant-task() {
1440 local TASKS_DIR="tasks"
1441
1442 # check for --version x.y parameters
1443 while [[ -n "${1}" && -n "${2}" ]]; do
1444 local var="${1#--}"
1445 local val="${2}"
1446 if [[ "${var}" == "version" ]]; then
1447 TASKS_DIR="tasks-${val}"
1448 else
1449 die "Unknown parameter passed to java-pkg_register-ant-tasks: ${1} ${2}"
1450 fi
1451 shift 2
1452 done
1453
1454 local TASK_NAME="${1:-${JAVA_PKG_NAME}}"
1455
1456 dodir /usr/share/ant/${TASKS_DIR}
1457 touch "${D}/usr/share/ant/${TASKS_DIR}/${TASK_NAME}"
1458}
1459
1460# ------------------------------------------------------------------------------
1461# @internal-function java-pkg_ant-tasks-from-deps
1462#
1463# Function to determine ANT_TASKS from DEPEND variable for backwards
1464# compatibility with ebuilds that don't set ANT_TASKS before calling eant() or
1465# WANT_ANT_TASKS before inheriting java-pkg-2. If the DEPEND string contains
1466# "dev-java/ant" or "dev-java/ant-tasks", then it returns "all", otherwise
1467# "none". It's not smart enough to cope with USE flag depends but that shouldn't
1468# be a problem, the worst it can do is activace all tasks when not needed.
1469# Note that this is called only with JAVA_PKG_STRICT=1, to find ebuilds with
1470# insufficient dependencies, otherwise all available tasks are used for
1471# backwards compatilbility.
1472#
1473# @return "all" or "none"
1474# ------------------------------------------------------------------------------
1475java-pkg_ant-tasks-from-deps() {
1476 local found_ant found_ant_tasks
1477
1478 for dep in ${DEPEND}
1479 do
1480 local ant="$(awk '/(dev-java\/ant)/ { if (match($1, "(dev-java/ant)((-[0-9])+|$)", m)) print m[1] }' <<< ${dep})"
1481 [[ "${ant}" == "dev-java/ant" ]] && found_ant=true
1482 [[ "${dep}" == *"ant-tasks"* ]] && found_ant_tasks=true
1483 done
1484
1485 if [[ -n "${found_ant}" || -n "${found_ant_tasks}" ]]; then
1486 java-pkg_announce-qa-violation "The ebuild DEPENDS on deprecated ant or ant-tasks"
1487 echo "all"
1488 else
1489 # ebuild doesn't set ANT_TASKS and doesn't depend on ant-tasks or ant
1490 # so we deactivate all tasks that may be installed
1491 echo "none"
1492 fi
1493}
1494
1495# ------------------------------------------------------------------------------
1496# @internal-function java-pkg_ant-tasks-depend
1497#
1498# Translates the WANT_ANT_TASKS variable into valid dependencies.
1499# ------------------------------------------------------------------------------
1500java-pkg_ant-tasks-depend() {
1501 debug-print-function ${FUNCNAME} ${WANT_ANT_TASKS}
1502
1503 if [[ -n "${WANT_ANT_TASKS}" ]]; then
1504 local DEP=""
1505 for i in ${WANT_ANT_TASKS}
1506 do
1507 if [[ ${i} != ant-* ]]; then
1508 echo "Invalid atom in WANT_ANT_TASKS: ${i}"
1509 return 1
1510 fi
1511 DEP="${DEP}dev-java/${i} "
1512 done
1513 echo ${DEP}
1514 return 0
1515 else
1516 return 0
1517 fi
1518}
1519
1520# ------------------------------------------------------------------------------
1260# @section-end helper 1521# @section-end helper
1261# ------------------------------------------------------------------------------ 1522# ------------------------------------------------------------------------------
1262 1523
1263# ------------------------------------------------------------------------------ 1524# ------------------------------------------------------------------------------
1264# @section-begin build 1525# @section-begin build
1270 1531
1271# ------------------------------------------------------------------------------ 1532# ------------------------------------------------------------------------------
1272# @ebuild-function eant 1533# @ebuild-function eant
1273# 1534#
1274# Ant wrapper function. Will use the appropriate compiler, based on user-defined 1535# Ant wrapper function. Will use the appropriate compiler, based on user-defined
1275# compiler. 1536# compiler. Will also set proper ANT_TASKS from the variable ANT_TASKS,
1276# 1537# variables:
1538# EANT_GENTOO_CLASSPATH - calls java-pkg_getjars for the value and adds to the
1539# gentoo.classpath property. Be sure to call
1540# java-ant_rewrite-classpath in src_unpack.
1541# *ANT_TASKS - used to determine ANT_TASKS before calling Ant.
1277# ------------------------------------------------------------------------------ 1542# ------------------------------------------------------------------------------
1278eant() { 1543eant() {
1279 debug-print-function ${FUNCNAME} $* 1544 debug-print-function ${FUNCNAME} $*
1280 1545
1281 # FIXME get this working 1546 # FIXME get this working
1282# if is-java-strict && [[ ! ${DEPEND} =~ "dev-java/ant" ]]; then 1547# if is-java-strict && [[ ! ${DEPEND} =~ "dev-java/ant" ]]; then
1283# java-pkg_announce-qa-violation \ 1548# java-pkg_announce-qa-violation \
1284# "Using eant, but not depending on dev-java/ant or dev-java/ant-core" 1549# "Using eant, but not depending on dev-java/ant or dev-java/ant-core"
1285# fi 1550# fi
1286 1551
1287 local antflags 1552 if ! hasq java-ant-2 ${INHERITED} && is-java-strict; then
1553 local msg="You should inherit java-ant-2 when using eant"
1554 java-pkg_announce-qa-violation ${msg}
1555 die ${msg}
1556 fi
1557
1558 local antflags="-Dnoget=true -Dmaven.mode.offline=true"
1288 java-pkg_init-compiler_ 1559 java-pkg_init-compiler_
1289 local compiler="${GENTOO_COMPILER}" 1560 local compiler="${GENTOO_COMPILER}"
1290 1561
1291 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}" 1562 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}"
1292 1563
1294 if [[ "${compiler}" != "javac" && -z "${build_compiler}" ]]; then 1565 if [[ "${compiler}" != "javac" && -z "${build_compiler}" ]]; then
1295 die "ANT_BUILD_COMPILER undefined in ${compiler_env}" 1566 die "ANT_BUILD_COMPILER undefined in ${compiler_env}"
1296 fi 1567 fi
1297 1568
1298 if [[ ${compiler} != "javac" ]]; then 1569 if [[ ${compiler} != "javac" ]]; then
1299 antflags="-Dbuild.compiler=${build_compiler}" 1570 antflags="${antflags} -Dbuild.compiler=${build_compiler}"
1300 # Figure out any extra stuff to put on the classpath for compilers aside 1571 # Figure out any extra stuff to put on the classpath for compilers aside
1301 # from javac 1572 # from javac
1302 # ANT_BUILD_COMPILER_DEPS should be something that could be passed to 1573 # ANT_BUILD_COMPILER_DEPS should be something that could be passed to
1303 # java-config -p 1574 # java-config -p
1304 local build_compiler_deps="$(source ${JAVA_PKG_COMPILER_DIR}/${compiler} 1>/dev/null 2>&1; echo ${ANT_BUILD_COMPILER_DEPS})" 1575 local build_compiler_deps="$(source ${JAVA_PKG_COMPILER_DIR}/${compiler} 1>/dev/null 2>&1; echo ${ANT_BUILD_COMPILER_DEPS})"
1310 if is-java-strict; then 1581 if is-java-strict; then
1311 einfo "Disabling system classpath for ant" 1582 einfo "Disabling system classpath for ant"
1312 antflags="${antflags} -Dbuild.sysclasspath=ignore" 1583 antflags="${antflags} -Dbuild.sysclasspath=ignore"
1313 fi 1584 fi
1314 1585
1315 if [[ -n ${JAVA_PKG_DEBUG} ]]; then 1586 for arg in "${@}"; do
1316 antflags="${antflags} -debug" 1587 if [[ ${arg} = -lib ]]; then
1588 if is-java-strict; then
1589 eerror "You should not use the -lib argument to eant because it will fail"
1590 eerror "with JAVA_PKG_STRICT. Please use for example java-pkg_jar-from"
1591 eerror "or ant properties to make dependencies available."
1592 eerror "For ant tasks use WANT_ANT_TASKS or ANT_TASKS from."
1593 eerror "split ant (>=dev-java/ant-core-1.7)."
1594 die "eant -lib is deprecated/forbidden"
1595 else
1596 echo "eant -lib is deprecated. Turn JAVA_PKG_STRICT on for"
1597 echo "more info."
1598 fi
1599 fi
1600 done
1601
1602 if has_version ">=dev-java/ant-core-1.7.0"; then
1603 # default ANT_TASKS to WANT_ANT_TASKS, if ANT_TASKS is not set explicitly
1604 ANT_TASKS="${ANT_TASKS:-${WANT_ANT_TASKS}}"
1605
1606 # override ANT_TASKS with JAVA_PKG_FORCE_ANT_TASKS if it's set
1607 ANT_TASKS="${JAVA_PKG_FORCE_ANT_TASKS:-${ANT_TASKS}}"
1608
1609 if is-java-strict; then
1610 # if ant-tasks were not set by ebuild or forced, try to determine them from depends
1611 if [[ -z "${ANT_TASKS}" ]]; then
1612 ANT_TASKS="$(java-pkg_ant-tasks-from-deps)"
1613 fi
1614 else
1615 # if ant-tasks is not set by ebuild or forced, activate all of them
1616 ANT_TASKS="${ANT_TASKS:-all}"
1617 fi
1618
1619 # at this point, ANT_TASKS should be "all", "none" or explicit list
1620 if [[ "${ANT_TASKS}" == "all" ]]; then
1621 einfo "Using all available ANT_TASKS"
1622 elif [[ "${ANT_TASKS}" == "none" ]]; then
1623 einfo "Disabling all optional ANT_TASKS"
1624 else
1625 einfo "Using following ANT_TASKS: ${ANT_TASKS}"
1626 fi
1627
1628 export ANT_TASKS
1629 fi
1630
1631 [[ -n ${JAVA_PKG_DEBUG} ]] && antflags="${antflags} --execdebug -debug"
1632 [[ -n ${PORTAGE_QUIET} ]] && antflags="${antflags} -q"
1633
1634 local gcp="${EANT_GENTOO_CLASSPATH}"
1635
1636 if [[ "${gcp}" ]]; then
1637 local cp="$(java-pkg_getjars ${gcp})"
1638 # It seems ant does not like single quotes around ${cp}
1639 antflags="${antflags} -Dgentoo.classpath=\"${cp}\""
1317 fi 1640 fi
1318 1641
1319 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ant ${antflags} "${@}" 1642 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ant ${antflags} "${@}"
1643 debug-print "Calling ant: ${antflags} ${@}"
1320 ant ${antflags} "${@}" || die "eant failed" 1644 ant ${antflags} "${@}" || die "eant failed"
1321 1645
1322} 1646}
1323 1647
1324# ------------------------------------------------------------------------------ 1648# ------------------------------------------------------------------------------
1330# @param $@ - Arguments to be passed to the compiler 1654# @param $@ - Arguments to be passed to the compiler
1331# ------------------------------------------------------------------------------ 1655# ------------------------------------------------------------------------------
1332ejavac() { 1656ejavac() {
1333 debug-print-function ${FUNCNAME} $* 1657 debug-print-function ${FUNCNAME} $*
1334 1658
1335 # FIXME using get-javac ends up printing stuff with einfo 1659 java-pkg_init-compiler_
1660
1661 local compiler_executable
1336# local compiler_executable=$(java-pkg_get-javac) 1662 compiler_executable=$(java-pkg_get-javac)
1337 local compiler_executable="javac" 1663 if [[ ${?} != 0 ]]; then
1664 eerror "There was a problem determining compiler: ${compiler_executable}"
1665 die "get-javac failed"
1666 fi
1338 1667
1668 local javac_args
1669 javac_args="$(java-pkg_javac-args)"
1670 if [[ ${?} != 0 ]]; then
1671 eerror "There was a problem determining JAVACFLAGS: ${javac_args}"
1672 die "java-pkg_javac-args failed"
1673 fi
1674
1339 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ${compiler_executable} $(java-pkg_javac-args) "${@}" 1675 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ${compiler_executable} ${javac_args} "${@}"
1340 ${compiler_executable} $(java-pkg_javac-args) "${@}" || die "ejavac failed" 1676 ${compiler_executable} ${javac_args} "${@}" || die "ejavac failed"
1341} 1677}
1342 1678
1343# ------------------------------------------------------------------------------ 1679# ------------------------------------------------------------------------------
1344# @ebuild-function java-pkg_filter-compiler 1680# @ebuild-function java-pkg_filter-compiler
1345# 1681#
1382# @return string - Name of the target to create javadocs 1718# @return string - Name of the target to create javadocs
1383# ------------------------------------------------------------------------------ 1719# ------------------------------------------------------------------------------
1384use_doc() { 1720use_doc() {
1385 use doc && echo ${@:-javadoc} 1721 use doc && echo ${@:-javadoc}
1386} 1722}
1723
1387 1724
1388# ------------------------------------------------------------------------------ 1725# ------------------------------------------------------------------------------
1389# @section-end build 1726# @section-end build
1390# ------------------------------------------------------------------------------ 1727# ------------------------------------------------------------------------------
1391 1728
1424 # When users have crazy classpaths some packages can fail to compile. 1761 # When users have crazy classpaths some packages can fail to compile.
1425 # and everything should work with empty CLASSPATH. 1762 # and everything should work with empty CLASSPATH.
1426 # This also helps prevent unexpected dependencies on random things 1763 # This also helps prevent unexpected dependencies on random things
1427 # from the CLASSPATH. 1764 # from the CLASSPATH.
1428 unset CLASSPATH 1765 unset CLASSPATH
1766
1767 # Unset external ANT_ stuff
1768 unset ANT_TASKS
1769 unset ANT_OPTS
1429} 1770}
1430 1771
1431# ------------------------------------------------------------------------------ 1772# ------------------------------------------------------------------------------
1432# @function-internal java-pkg-init-compiler_ 1773# @function-internal java-pkg-init-compiler_
1433# 1774#
1577# Writes the package.env out to disk. 1918# Writes the package.env out to disk.
1578# 1919#
1579# ------------------------------------------------------------------------------ 1920# ------------------------------------------------------------------------------
1580# TODO change to do-write, to match everything else 1921# TODO change to do-write, to match everything else
1581java-pkg_do_write_() { 1922java-pkg_do_write_() {
1923 java-pkg_init_paths_
1582 # Create directory for package.env 1924 # Create directory for package.env
1583 dodir "${JAVA_PKG_SHAREPATH}" 1925 dodir "${JAVA_PKG_SHAREPATH}"
1584 if [[ -n "${JAVA_PKG_CLASSPATH}" || -n "${JAVA_PKG_LIBRARY}" || -f "${JAVA_PKG_DEPEND}" ]]; then 1926 if [[ -n "${JAVA_PKG_CLASSPATH}" || -n "${JAVA_PKG_LIBRARY}" || -f "${JAVA_PKG_DEPEND}" ]]; then
1585 # Create package.env 1927 # Create package.env
1586 ( 1928 (
1614 # Strip unnecessary leading and trailing colons 1956 # Strip unnecessary leading and trailing colons
1615 # TODO try to cleanup if possible 1957 # TODO try to cleanup if possible
1616 sed -e "s/=\":/=\"/" -e "s/:\"$/\"/" -i "${JAVA_PKG_ENV}" || die "Did you forget to call java_init ?" 1958 sed -e "s/=\":/=\"/" -e "s/:\"$/\"/" -i "${JAVA_PKG_ENV}" || die "Did you forget to call java_init ?"
1617 fi 1959 fi
1618} 1960}
1619
1620 1961
1621# ------------------------------------------------------------------------------ 1962# ------------------------------------------------------------------------------
1622# @internal-function java-pkg_record-jar_ 1963# @internal-function java-pkg_record-jar_
1623# 1964#
1624# Record a dependency to the package.env 1965# Record a dependency to the package.env
1705# ------------------------------------------------------------------------------ 2046# ------------------------------------------------------------------------------
1706java-pkg_setup-vm() { 2047java-pkg_setup-vm() {
1707 debug-print-function ${FUNCNAME} $* 2048 debug-print-function ${FUNCNAME} $*
1708 2049
1709 local vendor="$(java-pkg_get-vm-vendor)" 2050 local vendor="$(java-pkg_get-vm-vendor)"
1710 if [[ "${vendor}" == "sun" ]] && java-pkg_is-vm-version-ge 1 5; then 2051 if [[ "${vendor}" == "sun" ]] && java-pkg_is-vm-version-ge "1.5" ; then
1711 addpredict "/dev/random" 2052 addpredict "/dev/random"
1712 elif [[ "${vendor}" == "ibm" ]]; then 2053 elif [[ "${vendor}" == "ibm" ]]; then
1713 addpredict "/proc/self/maps" 2054 addpredict "/proc/self/maps"
1714 addpredict "/proc/cpuinfo" 2055 addpredict "/proc/cpuinfo"
1715 export LANG="C" LC_ALL="C" 2056 export LANG="C" LC_ALL="C"
1775# Switch VM if we're allowed to (controlled by JAVA_PKG_ALLOW_VM_CHANGE), and 2116# Switch VM if we're allowed to (controlled by JAVA_PKG_ALLOW_VM_CHANGE), and
1776# verify that the current VM is sufficient. 2117# verify that the current VM is sufficient.
1777# Setup the environment for the VM being used. 2118# Setup the environment for the VM being used.
1778# ------------------------------------------------------------------------------ 2119# ------------------------------------------------------------------------------
1779java-pkg_switch-vm() { 2120java-pkg_switch-vm() {
2121 debug-print-function ${FUNCNAME} $*
2122
1780 if java-pkg_needs-vm; then 2123 if java-pkg_needs-vm; then
1781 # Use the VM specified by JAVA_PKG_FORCE_VM 2124 # Use the VM specified by JAVA_PKG_FORCE_VM
1782 if [[ -n ${JAVA_PKG_FORCE_VM} ]]; then 2125 if [[ -n "${JAVA_PKG_FORCE_VM}" ]]; then
1783 # If you're forcing the VM, I hope you know what your doing... 2126 # If you're forcing the VM, I hope you know what your doing...
2127 debug-print "JAVA_PKG_FORCE_VM used: ${JAVA_PKG_FORCE_VM}"
1784 export GENTOO_VM="${JAVA_PKG_FORCE_VM}" 2128 export GENTOO_VM="${JAVA_PKG_FORCE_VM}"
1785 # if we're allowed to switch the vm... 2129 # if we're allowed to switch the vm...
1786 elif [[ "${JAVA_PKG_ALLOW_VM_CHANGE}" == "yes" ]]; then 2130 elif [[ "${JAVA_PKG_ALLOW_VM_CHANGE}" == "yes" ]]; then
1787 debug-print "depend-java-query: NV_DEPEND: ${JAVA_PKG_NV_DEPEND:-${DEPEND}} VNEED: ${JAVA_PKG_VNEED}" 2131 debug-print "depend-java-query: NV_DEPEND: ${JAVA_PKG_NV_DEPEND:-${DEPEND}} VNEED: ${JAVA_PKG_VNEED}"
1788 if [[ -n ${JAVA_PKG_VNEED} ]]; then 2132 if [[ -n ${JAVA_PKG_VNEED} ]]; then
1789 export GENTOO_VM="$(depend-java-query --need-virtual "${JAVA_PKG_VNEED}" --get-vm "${JAVA_PKG_NV_DEPEND:-${DEPEND}}")" 2133 GENTOO_VM="$(depend-java-query --need-virtual "${JAVA_PKG_VNEED}" --get-vm "${JAVA_PKG_NV_DEPEND:-${DEPEND}}")"
1790 else 2134 else
1791 export GENTOO_VM="$(depend-java-query --get-vm "${JAVA_PKG_NV_DEPEND:-${DEPEND}}")" 2135 GENTOO_VM="$(depend-java-query --get-vm "${JAVA_PKG_NV_DEPEND:-${DEPEND}}")"
2136 fi
2137 if [[ -z "${GENTOO_VM}" || "${GENTOO_VM}" == "None" ]]; then
2138 eerror "Unable to determine VM for building from dependencies:"
2139 echo "NV_DEPEND: ${JAVA_PKG_NV_DEPEND:-${DEPEND}}"
2140 echo "VNEED: ${JAVA_PKG_VNEED}"
2141 die "Failed to determine VM for building."
2142 else
2143 export GENTOO_VM
1792 fi 2144 fi
1793 # otherwise just make sure the current VM is sufficient 2145 # otherwise just make sure the current VM is sufficient
1794 else 2146 else
1795 java-pkg_ensure-vm-version-sufficient 2147 java-pkg_ensure-vm-version-sufficient
1796 fi 2148 fi
1798 2150
1799 java-pkg_setup-vm 2151 java-pkg_setup-vm
1800 2152
1801 export JAVA=$(java-config --java) 2153 export JAVA=$(java-config --java)
1802 export JAVAC=$(java-config --javac) 2154 export JAVAC=$(java-config --javac)
1803 export JAVACFLAGS="$(java-pkg_javac-args)" 2155 JAVACFLAGS="$(java-pkg_javac-args)"
2156 if [[ ${?} != 0 ]]; then
2157 eerror "There was a problem determining JAVACFLAGS: ${JAVACFLAGS}"
2158 die "java-pkg_javac-args failed"
2159 fi
1804 [[ -n ${JAVACFLAGS_EXTRA} ]] && export JAVACFLAGS="${JAVACFLAGS_EXTRA} ${JAVACFLAGS}" 2160 [[ -n ${JAVACFLAGS_EXTRA} ]] && JAVACFLAGS="${JAVACFLAGS_EXTRA} ${JAVACFLAGS}"
2161 export JAVACFLAGS
1805 2162
1806 export JAVA_HOME="$(java-config -g JAVA_HOME)" 2163 export JAVA_HOME="$(java-config -g JAVA_HOME)"
1807 export JDK_HOME=${JAVA_HOME} 2164 export JDK_HOME=${JAVA_HOME}
1808 2165
1809 #TODO If you know a better solution let us know. 2166 #TODO If you know a better solution let us know.
1857 fi 2214 fi
1858} 2215}
1859 2216
1860# TODO document 2217# TODO document
1861# Verify that the classes were compiled for the right source / target 2218# Verify that the classes were compiled for the right source / target
2219# If $1 is present will check that file otherwise the ${D} directory
2220# recursively.
1862java-pkg_verify-classes() { 2221java-pkg_verify-classes() {
1863 ebegin "Verifying java class versions"
1864 #$(find ${D} -type f -name '*.jar' -o -name '*.class') 2222 #$(find ${D} -type f -name '*.jar' -o -name '*.class')
2223 local target=$(java-pkg_get-target)
2224 ebegin "Verifying java class versions (target: ${target})"
2225 if [[ -n "${1}" ]]; then
2226 class-version-verify.py -t ${target} "${1}"
2227 else
1865 class-version-verify.py -t $(java-pkg_get-target) -r ${D} 2228 class-version-verify.py -t ${target} -r "${D}"
2229 fi
1866 result=$? 2230 result=$?
1867 eend ${result} 2231 eend ${result}
1868 if [[ ${result} == 0 ]]; then 2232 if [[ ${result} != 0 ]]; then
1869 einfo "All good"
1870 else
1871 ewarn "Possible problem" 2233 ewarn "Possible problem"
1872 die "Bad class files found" 2234 die "Bad class files found"
1873 fi 2235 fi
1874} 2236}
1875
1876 2237
1877# ------------------------------------------------------------------------------ 2238# ------------------------------------------------------------------------------
1878# @section-end internal 2239# @section-end internal
1879# ------------------------------------------------------------------------------ 2240# ------------------------------------------------------------------------------
1880 2241

Legend:
Removed from v.1.22  
changed lines
  Added in v.1.55

  ViewVC Help
Powered by ViewVC 1.1.20