/[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.36
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.36 2006/12/20 22:45:18 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#
40 43
41# ----------------------------------------------------------------------------- 44# -----------------------------------------------------------------------------
42# @variable-internal JAVA_PKG_E_DEPEND 45# @variable-internal JAVA_PKG_E_DEPEND
43# 46#
44# This is a convience variable to be used from the other java eclasses. This is 47# 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 48# the version of java-config we want to use. We also need a recent version
46# portage, that includes phase hooks. 49# portage, that includes phase hooks.
47# ----------------------------------------------------------------------------- 50# -----------------------------------------------------------------------------
48JAVA_PKG_E_DEPEND=">=dev-java/java-config-2.0.19-r1 ${JAVA_PKG_PORTAGE_DEP}" 51JAVA_PKG_E_DEPEND=">=dev-java/java-config-2.0.19-r1 ${JAVA_PKG_PORTAGE_DEP}"
49 52
50# ----------------------------------------------------------------------------- 53# -----------------------------------------------------------------------------
100# ----------------------------------------------------------------------------- 103# -----------------------------------------------------------------------------
101 104
102# ----------------------------------------------------------------------------- 105# -----------------------------------------------------------------------------
103# @variable-internal JAVA_PKG_COMPILER_DIR 106# @variable-internal JAVA_PKG_COMPILER_DIR
104# @default /usr/share/java-config-2/compiler 107# @default /usr/share/java-config-2/compiler
105# 108#
106# Directory where compiler settings are saved, without trailing slash. 109# Directory where compiler settings are saved, without trailing slash.
107# Probably shouldn't touch this variable. 110# Probably shouldn't touch this variable.
108# ----------------------------------------------------------------------------- 111# -----------------------------------------------------------------------------
109JAVA_PKG_COMPILER_DIR=${JAVA_PKG_COMPILER_DIR:="/usr/share/java-config-2/compiler"} 112JAVA_PKG_COMPILER_DIR=${JAVA_PKG_COMPILER_DIR:="/usr/share/java-config-2/compiler"}
110 113
120 123
121# ----------------------------------------------------------------------------- 124# -----------------------------------------------------------------------------
122# @variable-external JAVA_PKG_FORCE_COMPILER 125# @variable-external JAVA_PKG_FORCE_COMPILER
123# 126#
124# Explicitly set a list of compilers to use. This is normally read from 127# Explicitly set a list of compilers to use. This is normally read from
125# JAVA_PKG_COMPILERS_CONF. 128# JAVA_PKG_COMPILERS_CONF.
126# 129#
127# @note This should only be used internally or for testing. 130# @note This should only be used internally or for testing.
128# @example Use jikes and javac, in that order 131# @example Use jikes and javac, in that order
129# JAVA_PKG_FORCE_COMPILER="jikes javac" 132# JAVA_PKG_FORCE_COMPILER="jikes javac"
130# ----------------------------------------------------------------------------- 133# -----------------------------------------------------------------------------
150# @ebuild-function java-pkg_dojar 153# @ebuild-function java-pkg_dojar
151# 154#
152# Installs any number of jars. 155# Installs any number of jars.
153# Jar's will be installed into /usr/share/${PN}(-${SLOT})/lib/ by default. 156# Jar's will be installed into /usr/share/${PN}(-${SLOT})/lib/ by default.
154# You can use java-pkg_jarinto to change this path. 157# You can use java-pkg_jarinto to change this path.
155# You should never install a jar with a package version in the filename. 158# You should never install a jar with a package version in the filename.
156# Instead, use java-pkg_newjar defined below. 159# Instead, use java-pkg_newjar defined below.
157# 160#
158# @example 161# @example
159# java-pkg_dojar dist/${PN}.jar dist/${PN}-core.jar 162# java-pkg_dojar dist/${PN}.jar dist/${PN}-core.jar
160# 163#
200 203
201 java-pkg_do_write_ 204 java-pkg_do_write_
202} 205}
203 206
204 207
208# ------------------------------------------------------------------------------
209# @internal-function depend-java-query
210#
211# Wrapper for the depend-java-query binary to enable passing USE in env.
212# Using env variables keeps this eclass working with java-config versions that
213# do not handle use flags.
214# ------------------------------------------------------------------------------
215
216depend-java-query() {
217 USE="${USE}" $(which depend-java-query) "${@}"
218}
205 219
206# ------------------------------------------------------------------------------ 220# ------------------------------------------------------------------------------
207# @ebuild-function java-pkg_regjar 221# @ebuild-function java-pkg_regjar
208# 222#
209# Records an already installed jar in the package.env 223# Records an already installed jar in the package.env
222# will not work, because: 236# will not work, because:
223# * the `for jar in "$@"` can't expand the path to jar file names, as they 237# * the `for jar in "$@"` can't expand the path to jar file names, as they
224# don't exist yet 238# don't exist yet
225# * all `if ...` inside for will fail - the file '/opt/my-java/lib/*.jar' 239# * all `if ...` inside for will fail - the file '/opt/my-java/lib/*.jar'
226# doesn't exist 240# doesn't exist
227# 241#
228# you have to use it as: 242# you have to use it as:
229# 243#
230# java-pkg_regjar ${D}/opt/my-java/lib/*.jar 244# java-pkg_regjar ${D}/opt/my-java/lib/*.jar
231# 245#
232# @param $@ - jars to record 246# @param $@ - jars to record
259 done 273 done
260 274
261 java-pkg_do_write_ 275 java-pkg_do_write_
262} 276}
263 277
264
265# ------------------------------------------------------------------------------ 278# ------------------------------------------------------------------------------
266# @ebuild-function java-pkg_newjar 279# @ebuild-function java-pkg_newjar
267# 280#
268# Installs a jar with a new name 281# Installs a jar with a new name
269# 282#
287 cp "${original_jar}" "${new_jar_dest}" \ 300 cp "${original_jar}" "${new_jar_dest}" \
288 || die "Failed to copy ${original_jar} to ${new_jar_dest}" 301 || die "Failed to copy ${original_jar} to ${new_jar_dest}"
289 java-pkg_dojar "${new_jar_dest}" 302 java-pkg_dojar "${new_jar_dest}"
290} 303}
291 304
292
293# ------------------------------------------------------------------------------ 305# ------------------------------------------------------------------------------
294# @ebuild-function java-pkg_addcp 306# @ebuild-function java-pkg_addcp
295# 307#
296# Add something to the package's classpath. For jars, you should use dojar, 308# 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. 309# newjar, or regjar. This is typically used to add directories to the classpath.
302java-pkg_addcp() { 314java-pkg_addcp() {
303 java-pkg_append_ JAVA_PKG_CLASSPATH "${@}" 315 java-pkg_append_ JAVA_PKG_CLASSPATH "${@}"
304 java-pkg_do_write_ 316 java-pkg_do_write_
305} 317}
306 318
307
308# ------------------------------------------------------------------------------ 319# ------------------------------------------------------------------------------
309# @ebuild-function java-pkg_doso 320# @ebuild-function java-pkg_doso
310# 321#
311# Installs any number of JNI libraries 322# Installs any number of JNI libraries
312# They will be installed into /usr/lib by default, but java-pkg_sointo 323# They will be installed into /usr/lib by default, but java-pkg_sointo
313# can be used change this path 324# can be used change this path
314# 325#
315# Example: 326# Example:
370 java-pkg_check-phase install 381 java-pkg_check-phase install
371 382
372 [[ ${#} -lt 1 ]] && "at least one argument needed" 383 [[ ${#} -lt 1 ]] && "at least one argument needed"
373 384
374 java-pkg_init_paths_ 385 java-pkg_init_paths_
375 386
376 local lib target_dir 387 local lib target_dir
377 for lib in "$@" ; do 388 for lib in "$@" ; do
378 # Check the absolute path of the lib 389 # Check the absolute path of the lib
379 if [[ -e "${lib}" ]] ; then 390 if [[ -e "${lib}" ]] ; then
380 target_dir="$(java-pkg_expand_dir_ ${lib})" 391 target_dir="$(java-pkg_expand_dir_ ${lib})"
428# ------------------------------------------------------------------------------ 439# ------------------------------------------------------------------------------
429java-pkg_dohtml() { 440java-pkg_dohtml() {
430 debug-print-function ${FUNCNAME} $* 441 debug-print-function ${FUNCNAME} $*
431 442
432 [[ ${#} -lt 1 ]] && die "At least one argument required for ${FUNCNAME}" 443 [[ ${#} -lt 1 ]] && die "At least one argument required for ${FUNCNAME}"
433 # TODO-nichoj find out what exactly -f package-list does 444
445 # from /usr/lib/portage/bin/dohtml -h
446 # -f Set list of allowed extensionless file names.
434 dohtml -f package-list "$@" 447 dohtml -f package-list "$@"
448
435 # this probably shouldn't be here but it provides 449 # this probably shouldn't be here but it provides
436 # a reasonable way to catch # docs for all of the 450 # a reasonable way to catch # docs for all of the
437 # old ebuilds. 451 # old ebuilds.
438 java-pkg_recordjavadoc 452 java-pkg_recordjavadoc
439} 453}
440 454
441# TODO document 455# ------------------------------------------------------------------------------
456# @ebuild-function java-pkg_dojavadoc
457#
458# Installs javadoc documentation. This should be controlled by the doc use flag.
459#
460# @param $1: - The javadoc root directory.
461#
462# @example:
463# java-pkg_dojavadoc docs/api
464#
465# ------------------------------------------------------------------------------
442java-pkg_dojavadoc() { 466java-pkg_dojavadoc() {
443 local dir="$1" 467 local dir="$1"
444 468
445 java-pkg_check-phase install 469 java-pkg_check-phase install
446 470
458} 482}
459 483
460# ------------------------------------------------------------------------------ 484# ------------------------------------------------------------------------------
461# @ebuild-function java-pkg_dosrc 485# @ebuild-function java-pkg_dosrc
462# 486#
463# Installs a zip containing the source for a package, so it can used in 487# Installs a zip containing the source for a package, so it can used in
464# from IDEs like eclipse and netbeans. 488# from IDEs like eclipse and netbeans.
465# 489#
466# Ebuild needs to DEPEND on app-arch/zip to use this. 490# Ebuild needs to DEPEND on app-arch/zip to use this.
467# 491#
468# It also should be controlled by USE=source. 492# It also should be controlled by USE=source.
469# 493#
470# @example: 494# @example:
471# java-pkg_dosrc src/* 495# java-pkg_dosrc src/*
472# 496#
473# ------------------------------------------------------------------------------ 497# ------------------------------------------------------------------------------
474# TODO change so it the arguments it takes are the base directories containing 498# TODO change so it the arguments it takes are the base directories containing
475# source -nichoj 499# source -nichoj
476# TODO should we be able to handle multiple calls to dosrc? -nichoj 500# TODO should we be able to handle multiple calls to dosrc? -nichoj
477# TODO maybe we can take an existing zip/jar? -nichoj 501# TODO maybe we can take an existing zip/jar? -nichoj
478# FIXME apparently this fails if you give it an empty directories 502# FIXME apparently this fails if you give it an empty directories
479java-pkg_dosrc() { 503java-pkg_dosrc() {
480 debug-print-function ${FUNCNAME} $* 504 debug-print-function ${FUNCNAME} $*
481 505
482 [ ${#} -lt 1 ] && die "At least one argument needed" 506 [ ${#} -lt 1 ] && die "At least one argument needed"
483 if ! hasq source ${IUSE}; then 507 if ! hasq source ${IUSE}; then
484 echo "Java QA Notice: ${FUNCNAME} called without source in IUSE" 508 echo "Java QA Notice: ${FUNCNAME} called without source in IUSE"
485 fi 509 fi
486 510
487 java-pkg_check-phase install 511 java-pkg_check-phase install
488 512
489 [[ ${#} -lt 1 ]] && die "At least one argument needed" 513 [[ ${#} -lt 1 ]] && die "At least one argument needed"
490 514
491 java-pkg_init_paths_ 515 java-pkg_init_paths_
492 516
493 local zip_name="${PN}-src.zip" 517 local zip_name="${PN}-src.zip"
494 local zip_path="${T}/${zip_name}" 518 local zip_path="${T}/${zip_name}"
518# @ebuild-function java-pkg_dolauncher 542# @ebuild-function java-pkg_dolauncher
519# 543#
520# Make a wrapper script to lauch/start this package 544# Make a wrapper script to lauch/start this package
521# If necessary, the wrapper will switch to the appropriate VM. 545# If necessary, the wrapper will switch to the appropriate VM.
522# 546#
547# Can be called without parameters if the package installs only one jar
548# that has the Main-class attribute set. The wrapper will be named ${PN}.
549#
523# @param $1 - filename of launcher to create 550# @param $1 - filename of launcher to create
524# @param $2 - options, as follows: 551# @param $2 - options, as follows:
525# --main the.main.class.too.start 552# --main the.main.class.too.start
526# --jar /the/jar/too/launch.jar 553# --jar /the/jar/too/launch.jar or just <name>.jar
527# --java_args 'Extra arguments to pass too jave' 554# --java_args 'Extra arguments to pass to java'
528# --pkg_args 'extra arguments too pass too the package' 555# --pkg_args 'Extra arguments too pass to the package'
529# --pwd 556# --pwd
530# -into 557# -into
531# -pre 558# -pre
532# ------------------------------------------------------------------------------ 559# ------------------------------------------------------------------------------
533java-pkg_dolauncher() { 560java-pkg_dolauncher() {
534 debug-print-function ${FUNCNAME} $* 561 debug-print-function ${FUNCNAME} $*
535 562
536 java-pkg_check-phase install 563 java-pkg_check-phase install
537
538 [[ ${#} -lt 1 ]] && die "Need at least one argument"
539
540 java-pkg_init_paths_ 564 java-pkg_init_paths_
541 565
566 if [[ ${#} = 0 ]]; then
567 local name="${PN}"
568 else
542 local name="${1}" 569 local name="${1}"
570 shift
571 fi
572
543 # TODO rename to launcher 573 # TODO rename to launcher
544 local target="${T}/${name}" 574 local target="${T}/${name}"
575 local var_tmp="${T}/launcher_variables_tmp"
545 local target_dir pre 576 local target_dir pre
546 shift
547 577
548 echo "#!/bin/bash" > "${target}" 578 # Process the other the rest of the arguments
549 while [[ -n "${1}" && -n "${2}" ]]; do 579 while [[ -n "${1}" && -n "${2}" ]]; do
550 local var=${1} value=${2} 580 local var=${1} value=${2}
551 if [[ "${var:0:2}" == "--" ]]; then 581 if [[ "${var:0:2}" == "--" ]]; then
582 local var=${var:2}
552 echo "gjl_${var:2}=\"${value}\"" >> "${target}" 583 echo "gjl_${var}=\"${value}\"" >> "${var_tmp}"
584 local gjl_${var}="${value}"
553 elif [[ "${var}" == "-into" ]]; then 585 elif [[ "${var}" == "-into" ]]; then
554 target_dir="${value}" 586 target_dir="${value}"
555 elif [[ "${var}" == "-pre" ]]; then 587 elif [[ "${var}" == "-pre" ]]; then
556 pre="${value}" 588 pre="${value}"
557 fi 589 fi
558 shift 2 590 shift 2
559 done 591 done
592
593 # Test if no --jar and --main arguments were given and
594 # in that case check if the package only installs one jar
595 # and use that jar.
596 if [[ -z "${gjl_jar}" && -z "${gjl_main}" ]]; then
597 local cp="${JAVA_PKG_CLASSPATH}"
598 if [[ "${cp/:}" = "${cp}" && "${cp%.jar}" != "${cp}" ]]; then
599 echo "gjl_jar=\"${JAVA_PKG_CLASSPATH}\"" >> "${var_tmp}"
600 else
601 local msg="Not enough information to create a launcher given."
602 msg="${msg} Please give --jar or --main argument to ${FUNCNAME}."
603 die "${msg}"
604 fi
605 fi
606
607 # Write the actual script
608 echo "#!/bin/bash" > "${target}"
609 [[ -n "${pre}" ]] && [[ -f "${pre}" ]] && cat "${pre}" >> "${target}"
560 echo "gjl_package=${JAVA_PKG_NAME}" >> "${target}" 610 echo "gjl_package=${JAVA_PKG_NAME}" >> "${target}"
561 [[ -n "${pre}" ]] && [[ -f "${pre}" ]] && cat "${pre}" >> "${target}" 611 cat "${var_tmp}" >> "${target}"
612 rm -f "${var_tmp}"
562 echo "source /usr/share/java-config-2/launcher/launcher.bash" >> "${target}" 613 echo "source /usr/share/java-config-2/launcher/launcher.bash" >> "${target}"
563 614
564 if [[ -n "${into}" ]]; then 615 if [[ -n "${target_dir}" ]]; then
565 DESTTREE="${target_dir}" dobin "${target}" 616 DESTTREE="${target_dir}" dobin "${target}"
566 local ret=$? 617 local ret=$?
567 return ${ret} 618 return ${ret}
568 else 619 else
569 dobin "${target}" 620 dobin "${target}"
597 echo "dowar: warning, skipping directory ${war}" 648 echo "dowar: warning, skipping directory ${war}"
598 continue 649 continue
599 else 650 else
600 warpath="${war}" 651 warpath="${war}"
601 fi 652 fi
602 653
603 # Install those files like you mean it 654 # Install those files like you mean it
604 INSOPTIONS="-m 0644" \ 655 INSOPTIONS="-m 0644" \
605 INSDESTTREE=${JAVA_PKG_WARDEST} \ 656 INSDESTTREE=${JAVA_PKG_WARDEST} \
606 doins ${warpath} 657 doins ${warpath}
607 done 658 done
642# @ebuild-function java-pkg_jar-from 693# @ebuild-function java-pkg_jar-from
643# 694#
644# Makes a symlink to a jar from a certain package 695# Makes a symlink to a jar from a certain package
645# A lot of java packages include dependencies in a lib/ directory 696# A lot of java packages include dependencies in a lib/ directory
646# You can use this function to replace these bundled dependencies. 697# You can use this function to replace these bundled dependencies.
698# The dependency is recorded into package.env DEPEND line, unless "--build-only"
699# is passed as the very first argument, for jars that have to be present only
700# at build time and are not needed on runtime (junit testing etc).
647# 701#
648# Example: get all jars from xerces slot 2 702# Example: get all jars from xerces slot 2
649# java-pkg_jar-from xerces-2 703# java-pkg_jar-from xerces-2
650# Example: get a specific jar from xerces slot 2 704# Example: get a specific jar from xerces slot 2
651# java-pkg_jar-from xerces-2 xml-apis.jar 705# java-pkg_jar-from xerces-2 xml-apis.jar
652# Example get a specific jar from xerces slot 2, and name it diffrently 706# 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 707# java-pkg_jar-from xerces-2 xml-apis.jar xml.jar
708# Example: get junit.jar which is needed only for building
709# java-pkg_jar-from --build-only junit junit.jar
654# 710#
711# @param $1 - (optional) "--build-only" makes the jar(s) not added into
712# package.env DEPEND line.
655# @param $1 - Package to get jars from. 713# @param $1 - Package to get jars from.
656# @param $2 - jar from package. If not specified, all jars will be used. 714# @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 715# @param $3 - When a single jar is specified, destination filename of the
658# symlink. Defaults to the name of the jar. 716# symlink. Defaults to the name of the jar.
659# ------------------------------------------------------------------------------ 717# ------------------------------------------------------------------------------
660# TODO could probably be cleaned up a little 718# TODO could probably be cleaned up a little
661java-pkg_jar-from() { 719java-pkg_jar-from() {
662 debug-print-function ${FUNCNAME} $* 720 debug-print-function ${FUNCNAME} $*
663 721
722 local build_only=""
723
724 if [[ "${1}" = "--build-only" ]]; then
725 build_only="true"
726 shift
727 fi
728
664 local target_pkg="${1}" target_jar="${2}" destjar="${3}" 729 local target_pkg="${1}" target_jar="${2}" destjar="${3}"
665 730
666 [[ -z ${target_pkg} ]] && die "Must specify a package" 731 [[ -z ${target_pkg} ]] && die "Must specify a package"
667 732
668 # default destjar to the target jar 733 # default destjar to the target jar
669 [[ -z "${destjar}" ]] && destjar="${target_jar}" 734 [[ -z "${destjar}" ]] && destjar="${target_jar}"
670 735
736 local error_msg="There was a problem getting the classpath for ${target_pkg}."
737 local classpath
671 local classpath="$(java-config --classpath=${target_pkg})" 738 classpath="$(java-config --classpath=${target_pkg})"
672 [[ $? != 0 ]] && die "There was a problem getting the classpath for ${target_pkg}" 739 [[ $? != 0 ]] && die ${error_msg}
673 740
674 local jar 741 local jar
675 for jar in ${classpath//:/ }; do 742 for jar in ${classpath//:/ }; do
676 local jar_name=$(basename "${jar}") 743 local jar_name=$(basename "${jar}")
677 if [[ ! -f "${jar}" ]] ; then 744 if [[ ! -f "${jar}" ]] ; then
681 # If no specific target jar was indicated, link it 748 # If no specific target jar was indicated, link it
682 if [[ -z "${target_jar}" ]] ; then 749 if [[ -z "${target_jar}" ]] ; then
683 [[ -f "${target_jar}" ]] && rm "${target_jar}" 750 [[ -f "${target_jar}" ]] && rm "${target_jar}"
684 ln -snf "${jar}" \ 751 ln -snf "${jar}" \
685 || die "Failed to make symlink from ${jar} to ${jar_name}" 752 || die "Failed to make symlink from ${jar} to ${jar_name}"
686 java-pkg_record-jar_ "${target_pkg}" "${jar}" 753 [[ -z "${build_only}" ]] && java-pkg_record-jar_ "${target_pkg}" "${jar}"
687 # otherwise, if the current jar is the target jar, link it 754 # otherwise, if the current jar is the target jar, link it
688 elif [[ "${jar_name}" == "${target_jar}" ]] ; then 755 elif [[ "${jar_name}" == "${target_jar}" ]] ; then
689 [[ -f "${destjar}" ]] && rm "${destjar}" 756 [[ -f "${destjar}" ]] && rm "${destjar}"
690 ln -snf "${jar}" "${destjar}" \ 757 ln -snf "${jar}" "${destjar}" \
691 || die "Failed to make symlink from ${jar} to ${destjar}" 758 || die "Failed to make symlink from ${jar} to ${destjar}"
692 java-pkg_record-jar_ "${target_pkg}" "${jar}" 759 [[ -z "${build_only}" ]] && java-pkg_record-jar_ "${target_pkg}" "${jar}"
693 return 0 760 return 0
694 fi 761 fi
695 done 762 done
696 # if no target was specified, we're ok 763 # if no target was specified, we're ok
697 if [[ -z "${target_jar}" ]] ; then 764 if [[ -z "${target_jar}" ]] ; then
714# ------------------------------------------------------------------------------ 781# ------------------------------------------------------------------------------
715# @ebuild-function java-pkg_getjars 782# @ebuild-function java-pkg_getjars
716# 783#
717# Get the classpath provided by any number of packages 784# Get the classpath provided by any number of packages
718# Among other things, this can be passed to 'javac -classpath' or 'ant -lib'. 785# Among other things, this can be passed to 'javac -classpath' or 'ant -lib'.
786# The providing packages are recorded as dependencies into package.env DEPEND
787# line, unless "--build-only" is passed as the very first argument, for jars
788# that have to be present only at build time and are not needed on runtime
789# (junit testing etc).
719# 790#
720# Example: Get the classpath for xerces-2, 791# Example: Get the classpath for xerces-2 and xalan,
721# java-pkg_getjars xerces-2 xalan 792# java-pkg_getjars xerces-2,xalan
722# Example Return: 793# Example Return:
723# /usr/share/xerces-2/lib/xml-apis.jar:/usr/share/xerces-2/lib/xmlParserAPIs.jar:/usr/share/xalan/lib/xalan.jar 794# /usr/share/xerces-2/lib/xml-apis.jar:/usr/share/xerces-2/lib/xmlParserAPIs.jar:/usr/share/xalan/lib/xalan.jar
724# 795#
796# @param $1 - (optional) "--build-only" makes the jar(s) not added into
797# package.env DEPEND line.
725# @param $@ - list of packages to get jars from 798# @param $2 - list of packages to get jars from
799# (passed to java-config --classpath)
726# ------------------------------------------------------------------------------ 800# ------------------------------------------------------------------------------
727java-pkg_getjars() { 801java-pkg_getjars() {
728 debug-print-function ${FUNCNAME} $* 802 debug-print-function ${FUNCNAME} $*
729 803
730 [[ ${#} -lt 1 ]] && die "At least one argument needed" 804 [[ ${#} -lt 1 || ${#} -gt 2 ]] && die "${FUNCNAME} takes only one or two arguments"
731 805
732 # NOTE could probably just pass $@ to java-config --classpath. and return it 806 if [[ "${1}" = "--build-only" ]]; then
807 local build_only="true"
808 shift
809 fi
810
733 local classpath pkg 811 local classpath pkgs="${1}"
734 for pkg in ${@//,/ }; do
735 #for pkg in $(echo "$@" | tr ',' ' '); do
736 jars="$(java-config --classpath=${pkg})" 812 jars="$(java-config --classpath=${pkgs})"
813 [[ -z "${jars}" ]] && die "java-config --classpath=${pkgs} failed"
737 debug-print "${pkg}:${jars}" 814 debug-print "${pkgs}:${jars}"
738 # TODO should we ensure jars exist? 815
739 if [[ -z "${classpath}" ]]; then 816 if [[ -z "${classpath}" ]]; then
740 classpath="${jars}" 817 classpath="${jars}"
741 else 818 else
742 classpath="${classpath}:${jars}" 819 classpath="${classpath}:${jars}"
743 fi 820 fi
821
822 # Only record jars that aren't build-only
823 if [[ -z "${build_only}" ]]; then
824 oldifs="${IFS}"
825 IFS=","
826 for pkg in ${pkgs}; do
744 java-pkg_record-jar_ "${pkg}" 827 java-pkg_record-jar_ "${pkg}"
745 done 828 done
829 IFS="${oldifs}"
830 fi
831
746 echo "${classpath}" 832 echo "${classpath}"
747} 833}
748 834
749# ------------------------------------------------------------------------------ 835# ------------------------------------------------------------------------------
750# @ebuild-function java-pkg_getjar 836# @ebuild-function java-pkg_getjar
751# 837#
752# Get the filename of a single jar from a package 838# Get the filename of a single jar from a package
839# The providing package is recorded as runtime dependency into package.env
840# DEPEND line, unless "--build-only" is passed as the very first argument, for
841# jars that have to be present only at build time and are not needed on runtime
842# (junit testing etc).
753# 843#
754# @example 844# @example
755# java-pkg_getjar xerces-2 xml-apis.jar 845# java-pkg_getjar xerces-2 xml-apis.jar
756# @example-return 846# @example-return
757# /usr/share/xerces-2/lib/xml-apis.jar 847# /usr/share/xerces-2/lib/xml-apis.jar
758# 848#
849# @param $1 - (optional) "--build-only" makes the jar not added into
850# package.env DEPEND line.
759# @param $1 - package to use 851# @param $1 - package to use
760# @param $2 - jar to get 852# @param $2 - jar to get
761# ------------------------------------------------------------------------------ 853# ------------------------------------------------------------------------------
762java-pkg_getjar() { 854java-pkg_getjar() {
763 debug-print-function ${FUNCNAME} $* 855 debug-print-function ${FUNCNAME} $*
856
857 local build_only=""
858
859 if [[ "${1}" = "--build-only" ]]; then
860 build_only="true"
861 shift
862 fi
764 863
765 local pkg="${1}" target_jar="${2}" jar 864 local pkg="${1}" target_jar="${2}" jar
766 [[ -z ${pkg} ]] && die "Must specify package to get a jar from" 865 [[ -z ${pkg} ]] && die "Must specify package to get a jar from"
767 [[ -z ${target_jar} ]] && die "Must specify jar to get" 866 [[ -z ${target_jar} ]] && die "Must specify jar to get"
768 867
769 # TODO check that package is actually installed 868 local error_msg="Could not find classpath for ${pkg}. Are you sure its installed?"
869 local classpath
770 local classpath=$(java-config --classpath=${pkg}) 870 classpath=$(java-config --classpath=${pkg})
771 [[ $? != 0 ]] && die "There could not find classpath for ${pkg}. Are you sure its installed?" 871 [[ $? != 0 ]] && die ${error_msg}
872
772 for jar in ${classpath//:/ }; do 873 for jar in ${classpath//:/ }; do
773 if [[ ! -f "${jar}" ]] ; then 874 if [[ ! -f "${jar}" ]] ; then
774 die "Installation problems with jars in ${pkg} - is it installed?" 875 die "Installation problem with jar ${jar} in ${pkg} - is it installed?"
775 fi 876 fi
776 877
777 if [[ "$(basename ${jar})" == "${target_jar}" ]] ; then 878 if [[ "$(basename ${jar})" == "${target_jar}" ]] ; then
778 java-pkg_record-jar_ "${pkg}" "${jar}" 879 # Only record jars that aren't build-only
880 [[ -z "${build_only}" ]] && java-pkg_record-jar_ "${pkg}" "${jar}"
779 echo "${jar}" 881 echo "${jar}"
780 return 0 882 return 0
781 fi 883 fi
782 done 884 done
783 885
784 die "Could not find ${target_jar} in ${pkg}" 886 die "Could not find ${target_jar} in ${pkg}"
785 return 1 887 return 1
786} 888}
787 889
788# This function reads stdin, and based on that input, figures out how to 890# This function reads stdin, and based on that input, figures out how to
802# line="${line// /}" 904# line="${line// /}"
803# 905#
804# # format: path=jarinfo 906# # format: path=jarinfo
805# local path=${line%%=*} 907# local path=${line%%=*}
806# local jarinfo=${line##*=} 908# local jarinfo=${line##*=}
807# 909#
808# # format: jar@package 910# # format: jar@package
809# local jar=${jarinfo%%@*}.jar 911# local jar=${jarinfo%%@*}.jar
810# local package=${jarinfo##*@} 912# local package=${jarinfo##*@}
811# if [[ -n ${replace_only} ]]; then 913# if [[ -n ${replace_only} ]]; then
812# [[ ! -f $path ]] && die "No jar exists at ${path}" 914# [[ ! -f $path ]] && die "No jar exists at ${path}"
825# @section-end query 927# @section-end query
826# ------------------------------------------------------------------------------ 928# ------------------------------------------------------------------------------
827 929
828# ------------------------------------------------------------------------------ 930# ------------------------------------------------------------------------------
829# @section-begin helper 931# @section-begin helper
830# @section-summary Helper functions 932# @section-summary Helper functions
831# 933#
832# Various other functions to use from an ebuild 934# Various other functions to use from an ebuild
833# ------------------------------------------------------------------------------ 935# ------------------------------------------------------------------------------
834 936
835# ------------------------------------------------------------------------------ 937# ------------------------------------------------------------------------------
841# jdbc-stdext 943# jdbc-stdext
842# jaf 944# jaf
843# jdbc-rowset 945# jdbc-rowset
844# jms 946# jms
845# 947#
846# @param $1 - Optionally indicate that the dependencies are controlled by 948# @param $1 - Optionally indicate that the dependencies are controlled by
847# a use flag by specifying '--use' Requires $2. 949# a use flag by specifying '--use' Requires $2.
848# @param $2 - USE flag which will enable the dependencies. 950# @param $2 - USE flag which will enable the dependencies.
849# @param $@ - virtual packages to add depenedencies for 951# @param $@ - virtual packages to add depenedencies for
850# ------------------------------------------------------------------------------ 952# ------------------------------------------------------------------------------
851# TODO rewrite to parse a line based declaration file instead -- karltk 953# TODO rewrite to parse a line based declaration file instead -- karltk
945 fi 1047 fi
946} 1048}
947 1049
948# ------------------------------------------------------------------------------ 1050# ------------------------------------------------------------------------------
949# @internal-function java-pkg_is-vm-version-sufficient 1051# @internal-function java-pkg_is-vm-version-sufficient
950# 1052#
951# @return zero - VM is sufficient 1053# @return zero - VM is sufficient
952# @return non-zero - VM is not sufficient 1054# @return non-zero - VM is not sufficient
953# ------------------------------------------------------------------------------ 1055# ------------------------------------------------------------------------------
954java-pkg_is-vm-version-sufficient() { 1056java-pkg_is-vm-version-sufficient() {
955 debug-print-function ${FUNCNAME} $* 1057 debug-print-function ${FUNCNAME} $*
975 die "Active Java VM too old" 1077 die "Active Java VM too old"
976 fi 1078 fi
977} 1079}
978 1080
979# ------------------------------------------------------------------------------ 1081# ------------------------------------------------------------------------------
980# @internal-function java-pkg_is-vm-version-eq 1082# @internal-function java-pkg_is-vm-version-eq
981# 1083#
982# @param $@ - VM version to compare current VM to 1084# @param $@ - VM version to compare current VM to
983# @return zero - VM versions are equal 1085# @return zero - VM versions are equal
984# @return non-zero - VM version are not equal 1086# @return non-zero - VM version are not equal
985# ------------------------------------------------------------------------------ 1087# ------------------------------------------------------------------------------
986java-pkg_is-vm-version-eq() { 1088java-pkg_is-vm-version-eq() {
1016# 1118#
1017# @param $@ - VM version to compare current to 1119# @param $@ - VM version to compare current to
1018# ------------------------------------------------------------------------------ 1120# ------------------------------------------------------------------------------
1019java-pkg_ensure-vm-version-ge() { 1121java-pkg_ensure-vm-version-ge() {
1020 debug-print-function ${FUNCNAME} $* 1122 debug-print-function ${FUNCNAME} $*
1021 1123
1022 if ! java-pkg_is-vm-version-ge "$@" ; then 1124 if ! java-pkg_is-vm-version-ge "$@" ; then
1023 debug-print "vm is not suffient" 1125 debug-print "vm is not suffient"
1024 eerror "This package requires a Java VM version >= $@" 1126 eerror "This package requires a Java VM version >= $@"
1025 einfo "Please use java-config -S to set the correct one" 1127 einfo "Please use java-config -S to set the correct one"
1026 die "Active Java VM too old" 1128 die "Active Java VM too old"
1027 fi 1129 fi
1028} 1130}
1029 1131
1030# ------------------------------------------------------------------------------ 1132# ------------------------------------------------------------------------------
1031# @internal-function java-pkg_is-vm-version-ge 1133# @internal-function java-pkg_is-vm-version-ge
1032# 1134#
1033# @param $@ - VM version to compare current VM to 1135# @param $@ - VM version to compare current VM to
1034# @return zero - current VM version is greater than checked version 1136# @return zero - current VM version is greater than checked version
1035# @return non-zero - current VM version is not greater than checked version 1137# @return non-zero - current VM version is not greater than checked version
1036# ------------------------------------------------------------------------------ 1138# ------------------------------------------------------------------------------
1037java-pkg_is-vm-version-ge() { 1139java-pkg_is-vm-version-ge() {
1051 return 1 1153 return 1
1052 fi 1154 fi
1053 fi 1155 fi
1054} 1156}
1055 1157
1158java-pkg_set-current-vm() {
1159 export GENTOO_VM=${1}
1160}
1161
1162java-pkg_get-current-vm() {
1163 echo ${GENTOO_VM}
1164}
1165
1166java-pkg_current-vm-matches() {
1167 hasq $(java-pkg_get-current-vm) ${@}
1168 return $?
1169}
1170
1056# ------------------------------------------------------------------------------ 1171# ------------------------------------------------------------------------------
1057# @ebuild-function java-pkg_get-source 1172# @ebuild-function java-pkg_get-source
1058# 1173#
1059# Determines what source version should be used, for passing to -source. 1174# 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 1175# Unless you want to break things you probably shouldn't set _WANT_SOURCE
1061# 1176#
1062# @return string - Either the lowest possible source, or JAVA_PKG_WANT_SOURCE 1177# @return string - Either the lowest possible source, or JAVA_PKG_WANT_SOURCE
1063# ------------------------------------------------------------------------------ 1178# ------------------------------------------------------------------------------
1068# ------------------------------------------------------------------------------ 1183# ------------------------------------------------------------------------------
1069# @ebuild-function java-pkg_get-target 1184# @ebuild-function java-pkg_get-target
1070# 1185#
1071# Determines what target version should be used, for passing to -target. 1186# 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 1187# If you don't care about lower versions, you can set _WANT_TARGET to the
1073# version of your JDK. 1188# version of your JDK.
1074# Remember doing this will mostly like cause things to break. 1189# Remember doing this will mostly like cause things to break.
1075# Doesn't allow it to be lower then the one in depend. 1190# Doesn't allow it to be lower then the one in depend.
1076# Doesn't allow it to be higher then the active vm. 1191# Doesn't allow it to be higher then the active vm.
1077# 1192#
1078# @return string - Either the lowest possible target, or JAVA_PKG_WANT_TARGET 1193# @return string - Either the lowest possible target, or JAVA_PKG_WANT_TARGET
1079# ------------------------------------------------------------------------------ 1194# ------------------------------------------------------------------------------
1080java-pkg_get-target() { 1195java-pkg_get-target() {
1081 local min=$(depend-java-query --get-lowest "${DEPEND} ${RDEPEND}") 1196 local min=$(depend-java-query --get-lowest "${DEPEND} ${RDEPEND}")
1082 if [[ -n "${JAVA_PKG_WANT_TARGET}" ]]; then 1197 if [[ -n "${JAVA_PKG_WANT_TARGET}" ]]; then
1083 local max="$(java-config --select-vm "${GENTOO_VM}" -g PROVIDES_VERSION)" 1198 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 1199 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} 1200 echo ${JAVA_PKG_WANT_TARGET}
1086 else 1201 else
1094} 1209}
1095 1210
1096java-pkg_get-javac() { 1211java-pkg_get-javac() {
1097 debug-print-function ${FUNCNAME} $* 1212 debug-print-function ${FUNCNAME} $*
1098 1213
1099 java-pkg_init-compiler_ 1214
1100 local compiler="${GENTOO_COMPILER}" 1215 local compiler="${GENTOO_COMPILER}"
1101 1216
1102 local compiler_executable 1217 local compiler_executable
1103 if [[ "${compiler}" = "javac" ]]; then 1218 if [[ "${compiler}" = "javac" ]]; then
1104 # nothing fancy needs to be done for javac 1219 # nothing fancy needs to be done for javac
1112 unset JAVAC 1227 unset JAVAC
1113 # try to get value of JAVAC 1228 # try to get value of JAVAC
1114 compiler_executable="$(source ${compiler_env} 1>/dev/null 2>&1; echo ${JAVAC})" 1229 compiler_executable="$(source ${compiler_env} 1>/dev/null 2>&1; echo ${JAVAC})"
1115 export JAVAC=${old_javac} 1230 export JAVAC=${old_javac}
1116 1231
1117 [[ -z ${compiler_executable} ]] && die "JAVAC is empty or undefined in ${compiler_env}" 1232 if [[ -z ${compiler_executable} ]]; then
1118 1233 echo "JAVAC is empty or undefined in ${compiler_env}"
1234 return 1
1235 fi
1236
1119 # check that it's executable 1237 # check that it's executable
1120 if [[ ! -x ${compiler_executable} ]]; then 1238 if [[ ! -x ${compiler_executable} ]]; then
1121 eerror "Could not find ${compiler_executable}!"
1122 die "${compiler_executable} doesn't exist, or isn't executable" 1239 echo "${compiler_executable} doesn't exist, or isn't executable"
1240 return 1
1123 fi 1241 fi
1124 else 1242 else
1125 eerror "Could not find environment file for ${compiler}" 1243 echo "Could not find environment file for ${compiler}"
1126 die "Could not find ${compiler_env}" 1244 return 1
1127 fi 1245 fi
1128 fi 1246 fi
1129 echo ${compiler_executable} 1247 echo ${compiler_executable}
1130} 1248}
1131 1249
1132# ------------------------------------------------------------------------------ 1250# ------------------------------------------------------------------------------
1133# @ebuild-function java-pkg_javac-args 1251# @ebuild-function java-pkg_javac-args
1134# 1252#
1135# If an ebuild uses javac directly, instead of using ejavac, it should call this 1253# If an ebuild uses javac directly, instead of using ejavac, it should call this
1136# to know what -source/-target to use. 1254# to know what -source/-target to use.
1137# 1255#
1138# @return string - arguments to pass to javac, complete with -target and -source 1256# @return string - arguments to pass to javac, complete with -target and -source
1141 debug-print-function ${FUNCNAME} $* 1259 debug-print-function ${FUNCNAME} $*
1142 1260
1143 local want_source="$(java-pkg_get-source)" 1261 local want_source="$(java-pkg_get-source)"
1144 local want_target="$(java-pkg_get-target)" 1262 local want_target="$(java-pkg_get-target)"
1145 1263
1146 local source_str="-source ${want_source}" 1264 local source_str="-source ${want_source}"
1147 local target_str="-target ${want_target}" 1265 local target_str="-target ${want_target}"
1148 1266
1149 debug-print "want source: ${want_source}" 1267 debug-print "want source: ${want_source}"
1150 debug-print "want target: ${want_target}" 1268 debug-print "want target: ${want_target}"
1151 1269
1152 if [[ -z "${want_source}" || -z "${want_target}" ]]; then 1270 if [[ -z "${want_source}" || -z "${want_target}" ]]; then
1153 debug-print "could not find valid -source/-target values" 1271 debug-print "could not find valid -source/-target values for javac"
1154 die "Could not find valid -source/-target values" 1272 echo "Could not find valid -source/-target values for javac"
1273 return 1
1155 else 1274 else
1156 if java-pkg_is-vm-version-ge "1.4"; then 1275 if java-pkg_is-vm-version-ge "1.4"; then
1157 echo "${source_str} ${target_str}" 1276 echo "${source_str} ${target_str}"
1158 else 1277 else
1159 echo "${target_str}" 1278 echo "${target_str}"
1163 1282
1164# TODO document 1283# TODO document
1165java-pkg_get-jni-cflags() { 1284java-pkg_get-jni-cflags() {
1166 local flags="-I${JAVA_HOME}/include" 1285 local flags="-I${JAVA_HOME}/include"
1167 1286
1287 local platform="linux"
1288 use elibc_FreeBSD && platform="freebsd"
1289
1168 # TODO do a check that the directories are valid 1290 # 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" 1291 flags="${flags} -I${JAVA_HOME}/include/${platform}"
1171 1292
1172 echo ${flags} 1293 echo ${flags}
1173} 1294}
1174 1295
1175java-pkg_ensure-gcj() { 1296java-pkg_ensure-gcj() {
1180 ebeep 5 1301 ebeep 5
1181 die "No GCJ support found!" 1302 die "No GCJ support found!"
1182 fi 1303 fi
1183} 1304}
1184 1305
1306java-pkg_ensure-test() {
1307 if hasq test ${FEATURES} && ! hasq -test ${FEATURES} \
1308 && hasq test ${IUSE} && ! use test;
1309 then
1310 eerror "You specified FEATURES=test, but USE=test is needed"
1311 eerror "to pull in the additional dependencies for testing"
1312 die "Need USE=test enabled"
1313 fi
1314}
1315
1185# ------------------------------------------------------------------------------ 1316# ------------------------------------------------------------------------------
1186# @section-end helper 1317# @section-end helper
1187# ------------------------------------------------------------------------------ 1318# ------------------------------------------------------------------------------
1188 1319
1189# ------------------------------------------------------------------------------ 1320# ------------------------------------------------------------------------------
1202# 1333#
1203# ------------------------------------------------------------------------------ 1334# ------------------------------------------------------------------------------
1204eant() { 1335eant() {
1205 debug-print-function ${FUNCNAME} $* 1336 debug-print-function ${FUNCNAME} $*
1206 1337
1207 local antflags 1338 # FIXME get this working
1339# if is-java-strict && [[ ! ${DEPEND} =~ "dev-java/ant" ]]; then
1340# java-pkg_announce-qa-violation \
1341# "Using eant, but not depending on dev-java/ant or dev-java/ant-core"
1342# fi
1343
1344 local antflags="-Dnoget=true"
1208 java-pkg_init-compiler_ 1345 java-pkg_init-compiler_
1209 local compiler="${GENTOO_COMPILER}" 1346 local compiler="${GENTOO_COMPILER}"
1210 1347
1211 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}" 1348 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}"
1212 1349
1214 if [[ "${compiler}" != "javac" && -z "${build_compiler}" ]]; then 1351 if [[ "${compiler}" != "javac" && -z "${build_compiler}" ]]; then
1215 die "ANT_BUILD_COMPILER undefined in ${compiler_env}" 1352 die "ANT_BUILD_COMPILER undefined in ${compiler_env}"
1216 fi 1353 fi
1217 1354
1218 if [[ ${compiler} != "javac" ]]; then 1355 if [[ ${compiler} != "javac" ]]; then
1219 antflags="-Dbuild.compiler=${build_compiler}" 1356 antflags="${antflags} -Dbuild.compiler=${build_compiler}"
1220 # Figure out any extra stuff to put on the classpath for compilers aside 1357 # Figure out any extra stuff to put on the classpath for compilers aside
1221 # from javac 1358 # from javac
1222 # ANT_BUILD_COMPILER_DEPS should be something that could be passed to 1359 # ANT_BUILD_COMPILER_DEPS should be something that could be passed to
1223 # java-config -p 1360 # java-config -p
1224 local build_compiler_deps="$(source ${JAVA_PKG_COMPILER_DIR}/${compiler} 1>/dev/null 2>&1; echo ${ANT_BUILD_COMPILER_DEPS})" 1361 local build_compiler_deps="$(source ${JAVA_PKG_COMPILER_DIR}/${compiler} 1>/dev/null 2>&1; echo ${ANT_BUILD_COMPILER_DEPS})"
1229 1366
1230 if is-java-strict; then 1367 if is-java-strict; then
1231 einfo "Disabling system classpath for ant" 1368 einfo "Disabling system classpath for ant"
1232 antflags="${antflags} -Dbuild.sysclasspath=ignore" 1369 antflags="${antflags} -Dbuild.sysclasspath=ignore"
1233 fi 1370 fi
1234 1371
1235 if [[ -n ${JAVA_PKG_DEBUG} ]]; then 1372 if [[ -n ${JAVA_PKG_DEBUG} ]]; then
1236 antflags="${antflags} -debug" 1373 antflags="${antflags} -debug"
1237 fi 1374 fi
1238 1375
1239 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ant ${antflags} "${@}" 1376 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ant ${antflags} "${@}"
1240 ant ${antflags} "${@}" || die "eant failed" 1377 ant ${antflags} "${@}" || die "eant failed"
1241 1378
1242} 1379}
1243 1380
1244# ------------------------------------------------------------------------------ 1381# ------------------------------------------------------------------------------
1245# @ebuild-function ejavac 1382# @ebuild-function ejavac
1246# 1383#
1247# Javac wrapper function. Will use the appropriate compiler, based on 1384# Javac wrapper function. Will use the appropriate compiler, based on
1248# /etc/java-config/compilers.conf 1385# /etc/java-config/compilers.conf
1249# 1386#
1250# @param $@ - Arguments to be passed to the compiler 1387# @param $@ - Arguments to be passed to the compiler
1251# ------------------------------------------------------------------------------ 1388# ------------------------------------------------------------------------------
1252ejavac() { 1389ejavac() {
1253 debug-print-function ${FUNCNAME} $* 1390 debug-print-function ${FUNCNAME} $*
1254 1391
1255 # FIXME using get-javac ends up printing stuff with einfo 1392 java-pkg_init-compiler_
1393
1394 local compiler_executable
1256# local compiler_executable=$(java-pkg_get-javac) 1395 compiler_executable=$(java-pkg_get-javac)
1257 local compiler_executable="javac" 1396 if [[ ${?} != 0 ]]; then
1397 eerror "There was a problem determining compiler: ${compiler_executable}"
1398 die "get-javac failed"
1399 fi
1258 1400
1401 local javac_args
1402 javac_args="$(java-pkg_javac-args)"
1403 if [[ ${?} != 0 ]]; then
1404 eerror "There was a problem determining JAVACFLAGS: ${javac_args}"
1405 die "java-pkg_javac-args failed"
1406 fi
1407
1259 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ${compiler_executable} $(java-pkg_javac-args) "${@}" 1408 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ${compiler_executable} ${javac_args} "${@}"
1260 ${compiler_executable} $(java-pkg_javac-args) "${@}" || die "ejavac failed" 1409 ${compiler_executable} ${javac_args} "${@}" || die "ejavac failed"
1261} 1410}
1262 1411
1263# ------------------------------------------------------------------------------ 1412# ------------------------------------------------------------------------------
1264# @ebuild-function java-pkg_filter-compiler 1413# @ebuild-function java-pkg_filter-compiler
1265# 1414#
1266# Used to prevent the use of some compilers. Should be used in src_compile. 1415# Used to prevent the use of some compilers. Should be used in src_compile.
1267# Basically, it just appends onto JAVA_PKG_FILTER_COMPILER 1416# Basically, it just appends onto JAVA_PKG_FILTER_COMPILER
1268# 1417#
1269# @param $@ - compilers to filter 1418# @param $@ - compilers to filter
1270# ------------------------------------------------------------------------------ 1419# ------------------------------------------------------------------------------
1288# ------------------------------------------------------------------------------ 1437# ------------------------------------------------------------------------------
1289# @ebuild-function use_doc 1438# @ebuild-function use_doc
1290# 1439#
1291# Helper function for getting ant to build javadocs. If the user has USE=doc, 1440# 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. 1441# then 'javadoc' or the argument are returned. Otherwise, there is no return.
1293# 1442#
1294# The output of this should be passed to ant. 1443# The output of this should be passed to ant.
1295# 1444#
1296# Example: build javadocs by calling 'javadoc' target 1445# Example: build javadocs by calling 'javadoc' target
1297# eant $(use_doc) 1446# eant $(use_doc)
1298# Example: build javadocs by calling 'apidoc' target 1447# Example: build javadocs by calling 'apidoc' target
1306} 1455}
1307 1456
1308# ------------------------------------------------------------------------------ 1457# ------------------------------------------------------------------------------
1309# @section-end build 1458# @section-end build
1310# ------------------------------------------------------------------------------ 1459# ------------------------------------------------------------------------------
1311 1460
1312# ------------------------------------------------------------------------------ 1461# ------------------------------------------------------------------------------
1313# @section-begin internal 1462# @section-begin internal
1314# @section-summary Internal functions 1463# @section-summary Internal functions
1315# 1464#
1316# Do __NOT__ use any of these from an ebuild! These are only to be used from 1465# Do __NOT__ use any of these from an ebuild! These are only to be used from
1317# within the java eclasses. 1466# within the java eclasses.
1318# ------------------------------------------------------------------------------ 1467# ------------------------------------------------------------------------------
1319 1468
1320# ----------------------------------------------------------------------------- 1469# -----------------------------------------------------------------------------
1321# @function-internal java-pkg_init 1470# @function-internal java-pkg_init
1322# 1471#
1323# The purpose of this function, as the name might imply, is to initialize the 1472# 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 1473# 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 1474# that'll muss things up. It initializes some variables, which are used
1326# internally. And most importantly, it'll switch the VM if necessary. 1475# internally. And most importantly, it'll switch the VM if necessary.
1327# 1476#
1339 # TODO we will probably want to set JAVAC and JAVACFLAGS 1488 # TODO we will probably want to set JAVAC and JAVACFLAGS
1340 1489
1341 # Do some QA checks 1490 # Do some QA checks
1342 java-pkg_check-jikes 1491 java-pkg_check-jikes
1343 1492
1344 # When users have crazy classpaths some packages can fail to compile. 1493 # When users have crazy classpaths some packages can fail to compile.
1345 # and everything should work with empty CLASSPATH. 1494 # and everything should work with empty CLASSPATH.
1346 # This also helps prevent unexpected dependencies on random things 1495 # This also helps prevent unexpected dependencies on random things
1347 # from the CLASSPATH. 1496 # from the CLASSPATH.
1348 unset CLASSPATH 1497 unset CLASSPATH
1349} 1498}
1350 1499
1351# ------------------------------------------------------------------------------ 1500# ------------------------------------------------------------------------------
1352# @function-internal java-pkg-init-compiler_ 1501# @function-internal java-pkg-init-compiler_
1353# 1502#
1354# This function attempts to figure out what compiler should be used. It does 1503# 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 1504# this by reading the file at JAVA_PKG_COMPILERS_CONF, and checking the
1356# COMPILERS variable defined there. 1505# COMPILERS variable defined there.
1357# This can be overridden by a list in JAVA_PKG_FORCE_COMPILER 1506# This can be overridden by a list in JAVA_PKG_FORCE_COMPILER
1358# 1507#
1359# It will go through the list of compilers, and verify that it supports the 1508# 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 1509# 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 1510# compiler is checked. When JAVA_PKG_FORCE_COMPILER is defined, this checking
1362# isn't done. 1511# isn't done.
1363# 1512#
1385 if [[ -z ${JAVA_PKG_FORCE_COMPILER} ]]; then 1534 if [[ -z ${JAVA_PKG_FORCE_COMPILER} ]]; then
1386 compilers="$(source ${JAVA_PKG_COMPILERS_CONF} 1>/dev/null 2>&1; echo ${COMPILERS})" 1535 compilers="$(source ${JAVA_PKG_COMPILERS_CONF} 1>/dev/null 2>&1; echo ${COMPILERS})"
1387 else 1536 else
1388 compilers=${JAVA_PKG_FORCE_COMPILER} 1537 compilers=${JAVA_PKG_FORCE_COMPILER}
1389 fi 1538 fi
1390 1539
1391 debug-print "Read \"${compilers}\" from ${JAVA_PKG_COMPILERS_CONF}" 1540 debug-print "Read \"${compilers}\" from ${JAVA_PKG_COMPILERS_CONF}"
1392 1541
1393 # Figure out if we should announce what compiler we're using 1542 # Figure out if we should announce what compiler we're using
1394 local compiler 1543 local compiler
1395 for compiler in ${compilers}; do 1544 for compiler in ${compilers}; do
1398 if [[ ${compiler} = "javac" ]]; then 1547 if [[ ${compiler} = "javac" ]]; then
1399 debug-print "Found javac... breaking" 1548 debug-print "Found javac... breaking"
1400 export GENTOO_COMPILER="javac" 1549 export GENTOO_COMPILER="javac"
1401 break 1550 break
1402 fi 1551 fi
1403 1552
1404 if has ${compiler} ${JAVA_PKG_FILTER_COMPILER}; then 1553 if has ${compiler} ${JAVA_PKG_FILTER_COMPILER}; then
1405 if [[ -z ${JAVA_PKG_FORCE_COMPILER} ]]; then 1554 if [[ -z ${JAVA_PKG_FORCE_COMPILER} ]]; then
1406 einfo "Filtering ${compiler}" 1555 einfo "Filtering ${compiler}"
1407 continue 1556 continue
1408 fi 1557 fi
1409 fi 1558 fi
1410 1559
1411 # for non-javac, we need to make sure it supports the right target and 1560 # for non-javac, we need to make sure it supports the right target and
1412 # source 1561 # source
1413 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}" 1562 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}"
1414 if [[ -f ${compiler_env} ]]; then 1563 if [[ -f ${compiler_env} ]]; then
1415 local desired_target="$(java-pkg_get-target)" 1564 local desired_target="$(java-pkg_get-target)"
1497# Writes the package.env out to disk. 1646# Writes the package.env out to disk.
1498# 1647#
1499# ------------------------------------------------------------------------------ 1648# ------------------------------------------------------------------------------
1500# TODO change to do-write, to match everything else 1649# TODO change to do-write, to match everything else
1501java-pkg_do_write_() { 1650java-pkg_do_write_() {
1651 java-pkg_init_paths_
1502 # Create directory for package.env 1652 # Create directory for package.env
1503 dodir "${JAVA_PKG_SHAREPATH}" 1653 dodir "${JAVA_PKG_SHAREPATH}"
1504 if [[ -n "${JAVA_PKG_CLASSPATH}" || -n "${JAVA_PKG_LIBRARY}" || -f "${JAVA_PKG_DEPEND}" ]]; then 1654 if [[ -n "${JAVA_PKG_CLASSPATH}" || -n "${JAVA_PKG_LIBRARY}" || -f "${JAVA_PKG_DEPEND}" ]]; then
1505 # Create package.env 1655 # Create package.env
1506 ( 1656 (
1511 [[ -n "${JAVA_PKG_LIBRARY}" ]] && echo "LIBRARY_PATH=\"${JAVA_PKG_LIBRARY}\"" 1661 [[ -n "${JAVA_PKG_LIBRARY}" ]] && echo "LIBRARY_PATH=\"${JAVA_PKG_LIBRARY}\""
1512 [[ -n "${JAVA_PROVIDE}" ]] && echo "PROVIDES=\"${JAVA_PROVIDE}\"" 1662 [[ -n "${JAVA_PROVIDE}" ]] && echo "PROVIDES=\"${JAVA_PROVIDE}\""
1513 [[ -f "${JAVA_PKG_DEPEND}" ]] && echo "DEPEND=\"$(cat ${JAVA_PKG_DEPEND} | uniq | tr '\n' ':')\"" 1663 [[ -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 ! 1664 echo "VM=\"$(echo ${RDEPEND} ${DEPEND} | sed -e 's/ /\n/g' | sed -n -e '/virtual\/\(jre\|jdk\)/ { p;q }')\"" # TODO cleanup !
1515 ) > "${JAVA_PKG_ENV}" 1665 ) > "${JAVA_PKG_ENV}"
1516 1666
1517 # register target/source 1667 # register target/source
1518 local target="$(java-pkg_get-target)" 1668 local target="$(java-pkg_get-target)"
1519 local source="$(java-pkg_get-source)" 1669 local source="$(java-pkg_get-source)"
1520 [[ -n ${target} ]] && echo "TARGET=\"${target}\"" >> "${JAVA_PKG_ENV}" 1670 [[ -n ${target} ]] && echo "TARGET=\"${target}\"" >> "${JAVA_PKG_ENV}"
1521 [[ -n ${source} ]] && echo "SOURCE=\"${source}\"" >> "${JAVA_PKG_ENV}" 1671 [[ -n ${source} ]] && echo "SOURCE=\"${source}\"" >> "${JAVA_PKG_ENV}"
1534 # Strip unnecessary leading and trailing colons 1684 # Strip unnecessary leading and trailing colons
1535 # TODO try to cleanup if possible 1685 # TODO try to cleanup if possible
1536 sed -e "s/=\":/=\"/" -e "s/:\"$/\"/" -i "${JAVA_PKG_ENV}" || die "Did you forget to call java_init ?" 1686 sed -e "s/=\":/=\"/" -e "s/:\"$/\"/" -i "${JAVA_PKG_ENV}" || die "Did you forget to call java_init ?"
1537 fi 1687 fi
1538} 1688}
1539
1540 1689
1541# ------------------------------------------------------------------------------ 1690# ------------------------------------------------------------------------------
1542# @internal-function java-pkg_record-jar_ 1691# @internal-function java-pkg_record-jar_
1543# 1692#
1544# Record a dependency to the package.env 1693# Record a dependency to the package.env
1588 fi 1737 fi
1589} 1738}
1590 1739
1591# ------------------------------------------------------------------------------ 1740# ------------------------------------------------------------------------------
1592# @internal-function java-pkg_expand_dir_ 1741# @internal-function java-pkg_expand_dir_
1593# 1742#
1594# Gets the full path of the file/directory's parent. 1743# Gets the full path of the file/directory's parent.
1595# @param $1 - file/directory to find parent directory for 1744# @param $1 - file/directory to find parent directory for
1596# @return - path to $1's parent directory 1745# @return - path to $1's parent directory
1597# ------------------------------------------------------------------------------ 1746# ------------------------------------------------------------------------------
1598java-pkg_expand_dir_() { 1747java-pkg_expand_dir_() {
1625# ------------------------------------------------------------------------------ 1774# ------------------------------------------------------------------------------
1626java-pkg_setup-vm() { 1775java-pkg_setup-vm() {
1627 debug-print-function ${FUNCNAME} $* 1776 debug-print-function ${FUNCNAME} $*
1628 1777
1629 local vendor="$(java-pkg_get-vm-vendor)" 1778 local vendor="$(java-pkg_get-vm-vendor)"
1630 if [[ "${vendor}" == "sun" ]] && java-pkg_is-vm-version-ge 1 5; then 1779 if [[ "${vendor}" == "sun" ]] && java-pkg_is-vm-version-ge "1.5" ; then
1631 addpredict "/dev/random" 1780 addpredict "/dev/random"
1632 elif [[ "${vendor}" == "ibm" ]]; then 1781 elif [[ "${vendor}" == "ibm" ]]; then
1633 addpredict "/proc/self/maps" 1782 addpredict "/proc/self/maps"
1634 addpredict "/proc/cpuinfo" 1783 addpredict "/proc/cpuinfo"
1635 export LANG="C" LC_ALL="C" 1784 export LANG="C" LC_ALL="C"
1684# @return - The version of the current VM 1833# @return - The version of the current VM
1685# ------------------------------------------------------------------------------ 1834# ------------------------------------------------------------------------------
1686java-pkg_get-vm-version() { 1835java-pkg_get-vm-version() {
1687 debug-print-function ${FUNCNAME} $* 1836 debug-print-function ${FUNCNAME} $*
1688 1837
1689 java-pkg_get-current-vm | sed -e "s/.*-\([0-9.]\+\).*/\1/" 1838 java-config -g PROVIDES_VERSION
1690} 1839}
1691 1840
1692# ------------------------------------------------------------------------------ 1841# ------------------------------------------------------------------------------
1693# @internal-function java-pkg_switch-vm 1842# @internal-function java-pkg_switch-vm
1694# 1843#
1695# Switch VM if we're allowed to (controlled by JAVA_PKG_ALLOW_VM_CHANGE), and 1844# Switch VM if we're allowed to (controlled by JAVA_PKG_ALLOW_VM_CHANGE), and
1696# verify that the current VM is sufficient. 1845# verify that the current VM is sufficient.
1697# Setup the environment for the VM being used. 1846# Setup the environment for the VM being used.
1698# ------------------------------------------------------------------------------ 1847# ------------------------------------------------------------------------------
1699java-pkg_switch-vm() { 1848java-pkg_switch-vm() {
1700 if java-pkg_needs-vm; then 1849 if java-pkg_needs-vm; then
1704 export GENTOO_VM="${JAVA_PKG_FORCE_VM}" 1853 export GENTOO_VM="${JAVA_PKG_FORCE_VM}"
1705 # if we're allowed to switch the vm... 1854 # if we're allowed to switch the vm...
1706 elif [[ "${JAVA_PKG_ALLOW_VM_CHANGE}" == "yes" ]]; then 1855 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}" 1856 debug-print "depend-java-query: NV_DEPEND: ${JAVA_PKG_NV_DEPEND:-${DEPEND}} VNEED: ${JAVA_PKG_VNEED}"
1708 if [[ -n ${JAVA_PKG_VNEED} ]]; then 1857 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}}")" 1858 GENTOO_VM="$(depend-java-query --need-virtual "${JAVA_PKG_VNEED}" --get-vm "${JAVA_PKG_NV_DEPEND:-${DEPEND}}")"
1710 else 1859 else
1711 export GENTOO_VM="$(depend-java-query --get-vm "${JAVA_PKG_NV_DEPEND:-${DEPEND}}")" 1860 GENTOO_VM="$(depend-java-query --get-vm "${JAVA_PKG_NV_DEPEND:-${DEPEND}}")"
1861 fi
1862 if [[ -z "${GENTOO_VM}" || "${GENTOO_VM}" == "None" ]]; then
1863 eerror "Unable to determine VM for building from dependencies:"
1864 echo "NV_DEPEND: ${JAVA_PKG_NV_DEPEND:-${DEPEND}}"
1865 echo "VNEED: ${JAVA_PKG_VNEED}"
1866 die "Failed to determine VM for building."
1867 else
1868 export GENTOO_VM
1712 fi 1869 fi
1713 # otherwise just make sure the current VM is sufficient 1870 # otherwise just make sure the current VM is sufficient
1714 else 1871 else
1715 java-pkg_ensure-vm-version-sufficient 1872 java-pkg_ensure-vm-version-sufficient
1716 fi 1873 fi
1717 debug-print "Using: $(java-config -f)" 1874 debug-print "Using: $(java-config -f)"
1718 1875
1719 java-pkg_setup-vm 1876 java-pkg_setup-vm
1720 1877
1721 export JAVA=$(java-config --java) 1878 export JAVA=$(java-config --java)
1722 export JAVAC=$(java-config --javac) 1879 export JAVAC=$(java-config --javac)
1723 export JAVACFLAGS="$(java-pkg_javac-args)" 1880 JAVACFLAGS="$(java-pkg_javac-args)"
1881 if [[ ${?} != 0 ]]; then
1882 eerror "There was a problem determining JAVACFLAGS: ${JAVACFLAGS}"
1883 die "java-pkg_javac-args failed"
1884 fi
1724 [[ -n ${JAVACFLAGS_EXTRA} ]] && export JAVACFLAGS="${JAVACFLAGS_EXTRA} ${JAVACFLAGS}" 1885 [[ -n ${JAVACFLAGS_EXTRA} ]] && JAVACFLAGS="${JAVACFLAGS_EXTRA} ${JAVACFLAGS}"
1886 export JAVACFLAGS
1725 1887
1726 export JAVA_HOME="$(java-config -g JAVA_HOME)" 1888 export JAVA_HOME="$(java-config -g JAVA_HOME)"
1727 export JDK_HOME=${JAVA_HOME} 1889 export JDK_HOME=${JAVA_HOME}
1728 1890
1729 #TODO If you know a better solution let us know. 1891 #TODO If you know a better solution let us know.
1730 java-pkg_append_ LD_LIBRARY_PATH "$(java-config -g LDPATH)" 1892 java-pkg_append_ LD_LIBRARY_PATH "$(java-config -g LDPATH)"
1731 1893
1732 local tann="${T}/announced-vm" 1894 local tann="${T}/announced-vm"
1733 if [[ -n "${JAVA_PKG_DEBUG}" ]] || [[ ! -f "${tann}" ]] ; then 1895 if [[ -n "${JAVA_PKG_DEBUG}" ]] || [[ ! -f "${tann}" ]] ; then
1734 # Add a check for setup/preinst phase... to avoid duplicate outputs 1896 # Add a check for setup/preinst phase... to avoid duplicate outputs
1735 # for when FEATURES=buildpkg 1897 # for when FEATURES=buildpkg
1736 if [[ ${EBUILD_PHASE} != "setup" && ${EBUILD_PHASE} != "preinst" && ${EBUILD_PHASE} != "postinst" ]]; 1898 if [[ ${EBUILD_PHASE} != "setup" && ${EBUILD_PHASE} != "preinst" && ${EBUILD_PHASE} != "postinst" ]];
1780# TODO document 1942# TODO document
1781# Verify that the classes were compiled for the right source / target 1943# Verify that the classes were compiled for the right source / target
1782java-pkg_verify-classes() { 1944java-pkg_verify-classes() {
1783 ebegin "Verifying java class versions" 1945 ebegin "Verifying java class versions"
1784 #$(find ${D} -type f -name '*.jar' -o -name '*.class') 1946 #$(find ${D} -type f -name '*.jar' -o -name '*.class')
1785 class-version-verify.py -t $(java-pkg_get-target) -r ${D} 1947 class-version-verify.py -t $(java-pkg_get-target) -r ${D}
1786 result=$? 1948 result=$?
1787 eend ${result} 1949 eend ${result}
1788 if [[ ${result} == 0 ]]; then 1950 if [[ ${result} == 0 ]]; then
1789 einfo "All good" 1951 einfo "All good"
1790 else 1952 else
1791 ewarn "Possible problem" 1953 ewarn "Possible problem"
1792 die "Bad class files found" 1954 die "Bad class files found"
1793 fi 1955 fi
1794} 1956}
1795 1957
1796
1797# ------------------------------------------------------------------------------ 1958# ------------------------------------------------------------------------------
1798# @section-end internal 1959# @section-end internal
1799# ------------------------------------------------------------------------------ 1960# ------------------------------------------------------------------------------
1800 1961
1801java-pkg_check-phase() { 1962java-pkg_check-phase() {
1832 let "JAVA_PKG_QA_VIOLATIONS+=1" 1993 let "JAVA_PKG_QA_VIOLATIONS+=1"
1833 export JAVA_PKG_QA_VIOLATIONS 1994 export JAVA_PKG_QA_VIOLATIONS
1834} 1995}
1835 1996
1836is-java-strict() { 1997is-java-strict() {
1837 hasq java-strict ${FEATURES}; 1998 [[ -n ${JAVA_PKG_STRICT} ]]
1838 return $? 1999 return $?
1839} 2000}
1840 2001
1841# ------------------------------------------------------------------------------ 2002# ------------------------------------------------------------------------------
1842# @eclass-end 2003# @eclass-end

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

  ViewVC Help
Powered by ViewVC 1.1.20