/[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.27
11# ----------------------------------------------------------------------------- 11# -----------------------------------------------------------------------------
12# @eclass-begin 12# @eclass-begin
13# @eclass-shortdesc Java Utility eclass 13# @eclass-shortdesc Java Utility eclass
14# @eclass-maintainer java@gentoo.org 14# @eclass-maintainer java@gentoo.org
15# 15#
16# This eclass provides functionality which is used by 16# This eclass provides functionality which is used by
17# java-pkg.eclass and java-pkg-opt.eclass as well as from ebuilds. 17# java-pkg.eclass and java-pkg-opt.eclass as well as from ebuilds.
18# 18#
19# @warning 19# @warning
20# You probably don't want to inherit this directly from an ebuild. Instead, 20# 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 21# 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. 22# Java packages, or java-pkg-opt for packages that have optional Java support.
23# 23#
24# ----------------------------------------------------------------------------- 24# -----------------------------------------------------------------------------
25 25
26inherit eutils versionator multilib 26inherit eutils versionator multilib
40 40
41# ----------------------------------------------------------------------------- 41# -----------------------------------------------------------------------------
42# @variable-internal JAVA_PKG_E_DEPEND 42# @variable-internal JAVA_PKG_E_DEPEND
43# 43#
44# This is a convience variable to be used from the other java eclasses. This is 44# 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 45# the version of java-config we want to use. We also need a recent version
46# portage, that includes phase hooks. 46# portage, that includes phase hooks.
47# ----------------------------------------------------------------------------- 47# -----------------------------------------------------------------------------
48JAVA_PKG_E_DEPEND=">=dev-java/java-config-2.0.19-r1 ${JAVA_PKG_PORTAGE_DEP}" 48JAVA_PKG_E_DEPEND=">=dev-java/java-config-2.0.19-r1 ${JAVA_PKG_PORTAGE_DEP}"
49 49
50# ----------------------------------------------------------------------------- 50# -----------------------------------------------------------------------------
100# ----------------------------------------------------------------------------- 100# -----------------------------------------------------------------------------
101 101
102# ----------------------------------------------------------------------------- 102# -----------------------------------------------------------------------------
103# @variable-internal JAVA_PKG_COMPILER_DIR 103# @variable-internal JAVA_PKG_COMPILER_DIR
104# @default /usr/share/java-config-2/compiler 104# @default /usr/share/java-config-2/compiler
105# 105#
106# Directory where compiler settings are saved, without trailing slash. 106# Directory where compiler settings are saved, without trailing slash.
107# Probably shouldn't touch this variable. 107# Probably shouldn't touch this variable.
108# ----------------------------------------------------------------------------- 108# -----------------------------------------------------------------------------
109JAVA_PKG_COMPILER_DIR=${JAVA_PKG_COMPILER_DIR:="/usr/share/java-config-2/compiler"} 109JAVA_PKG_COMPILER_DIR=${JAVA_PKG_COMPILER_DIR:="/usr/share/java-config-2/compiler"}
110 110
120 120
121# ----------------------------------------------------------------------------- 121# -----------------------------------------------------------------------------
122# @variable-external JAVA_PKG_FORCE_COMPILER 122# @variable-external JAVA_PKG_FORCE_COMPILER
123# 123#
124# Explicitly set a list of compilers to use. This is normally read from 124# Explicitly set a list of compilers to use. This is normally read from
125# JAVA_PKG_COMPILERS_CONF. 125# JAVA_PKG_COMPILERS_CONF.
126# 126#
127# @note This should only be used internally or for testing. 127# @note This should only be used internally or for testing.
128# @example Use jikes and javac, in that order 128# @example Use jikes and javac, in that order
129# JAVA_PKG_FORCE_COMPILER="jikes javac" 129# JAVA_PKG_FORCE_COMPILER="jikes javac"
130# ----------------------------------------------------------------------------- 130# -----------------------------------------------------------------------------
150# @ebuild-function java-pkg_dojar 150# @ebuild-function java-pkg_dojar
151# 151#
152# Installs any number of jars. 152# Installs any number of jars.
153# Jar's will be installed into /usr/share/${PN}(-${SLOT})/lib/ by default. 153# Jar's will be installed into /usr/share/${PN}(-${SLOT})/lib/ by default.
154# You can use java-pkg_jarinto to change this path. 154# You can use java-pkg_jarinto to change this path.
155# You should never install a jar with a package version in the filename. 155# You should never install a jar with a package version in the filename.
156# Instead, use java-pkg_newjar defined below. 156# Instead, use java-pkg_newjar defined below.
157# 157#
158# @example 158# @example
159# java-pkg_dojar dist/${PN}.jar dist/${PN}-core.jar 159# java-pkg_dojar dist/${PN}.jar dist/${PN}-core.jar
160# 160#
222# will not work, because: 222# will not work, because:
223# * the `for jar in "$@"` can't expand the path to jar file names, as they 223# * the `for jar in "$@"` can't expand the path to jar file names, as they
224# don't exist yet 224# don't exist yet
225# * all `if ...` inside for will fail - the file '/opt/my-java/lib/*.jar' 225# * all `if ...` inside for will fail - the file '/opt/my-java/lib/*.jar'
226# doesn't exist 226# doesn't exist
227# 227#
228# you have to use it as: 228# you have to use it as:
229# 229#
230# java-pkg_regjar ${D}/opt/my-java/lib/*.jar 230# java-pkg_regjar ${D}/opt/my-java/lib/*.jar
231# 231#
232# @param $@ - jars to record 232# @param $@ - jars to record
305} 305}
306 306
307 307
308# ------------------------------------------------------------------------------ 308# ------------------------------------------------------------------------------
309# @ebuild-function java-pkg_doso 309# @ebuild-function java-pkg_doso
310# 310#
311# Installs any number of JNI libraries 311# Installs any number of JNI libraries
312# They will be installed into /usr/lib by default, but java-pkg_sointo 312# They will be installed into /usr/lib by default, but java-pkg_sointo
313# can be used change this path 313# can be used change this path
314# 314#
315# Example: 315# Example:
370 java-pkg_check-phase install 370 java-pkg_check-phase install
371 371
372 [[ ${#} -lt 1 ]] && "at least one argument needed" 372 [[ ${#} -lt 1 ]] && "at least one argument needed"
373 373
374 java-pkg_init_paths_ 374 java-pkg_init_paths_
375 375
376 local lib target_dir 376 local lib target_dir
377 for lib in "$@" ; do 377 for lib in "$@" ; do
378 # Check the absolute path of the lib 378 # Check the absolute path of the lib
379 if [[ -e "${lib}" ]] ; then 379 if [[ -e "${lib}" ]] ; then
380 target_dir="$(java-pkg_expand_dir_ ${lib})" 380 target_dir="$(java-pkg_expand_dir_ ${lib})"
428# ------------------------------------------------------------------------------ 428# ------------------------------------------------------------------------------
429java-pkg_dohtml() { 429java-pkg_dohtml() {
430 debug-print-function ${FUNCNAME} $* 430 debug-print-function ${FUNCNAME} $*
431 431
432 [[ ${#} -lt 1 ]] && die "At least one argument required for ${FUNCNAME}" 432 [[ ${#} -lt 1 ]] && die "At least one argument required for ${FUNCNAME}"
433
433 # TODO-nichoj find out what exactly -f package-list does 434 # TODO-nichoj find out what exactly -f package-list does
434 dohtml -f package-list "$@" 435 dohtml -f package-list "$@"
435 # this probably shouldn't be here but it provides 436 # this probably shouldn't be here but it provides
436 # a reasonable way to catch # docs for all of the 437 # a reasonable way to catch # docs for all of the
437 # old ebuilds. 438 # old ebuilds.
458} 459}
459 460
460# ------------------------------------------------------------------------------ 461# ------------------------------------------------------------------------------
461# @ebuild-function java-pkg_dosrc 462# @ebuild-function java-pkg_dosrc
462# 463#
463# Installs a zip containing the source for a package, so it can used in 464# Installs a zip containing the source for a package, so it can used in
464# from IDEs like eclipse and netbeans. 465# from IDEs like eclipse and netbeans.
465# 466#
466# Ebuild needs to DEPEND on app-arch/zip to use this. 467# Ebuild needs to DEPEND on app-arch/zip to use this.
467# 468#
468# It also should be controlled by USE=source. 469# It also should be controlled by USE=source.
469# 470#
470# @example: 471# @example:
471# java-pkg_dosrc src/* 472# java-pkg_dosrc src/*
472# 473#
473# ------------------------------------------------------------------------------ 474# ------------------------------------------------------------------------------
474# TODO change so it the arguments it takes are the base directories containing 475# TODO change so it the arguments it takes are the base directories containing
475# source -nichoj 476# source -nichoj
476# TODO should we be able to handle multiple calls to dosrc? -nichoj 477# TODO should we be able to handle multiple calls to dosrc? -nichoj
477# TODO maybe we can take an existing zip/jar? -nichoj 478# TODO maybe we can take an existing zip/jar? -nichoj
478# FIXME apparently this fails if you give it an empty directories 479# FIXME apparently this fails if you give it an empty directories
479java-pkg_dosrc() { 480java-pkg_dosrc() {
480 debug-print-function ${FUNCNAME} $* 481 debug-print-function ${FUNCNAME} $*
481 482
482 [ ${#} -lt 1 ] && die "At least one argument needed" 483 [ ${#} -lt 1 ] && die "At least one argument needed"
483 if ! hasq source ${IUSE}; then 484 if ! hasq source ${IUSE}; then
484 echo "Java QA Notice: ${FUNCNAME} called without source in IUSE" 485 echo "Java QA Notice: ${FUNCNAME} called without source in IUSE"
485 fi 486 fi
486 487
487 java-pkg_check-phase install 488 java-pkg_check-phase install
488 489
489 [[ ${#} -lt 1 ]] && die "At least one argument needed" 490 [[ ${#} -lt 1 ]] && die "At least one argument needed"
490 491
491 java-pkg_init_paths_ 492 java-pkg_init_paths_
492 493
493 local zip_name="${PN}-src.zip" 494 local zip_name="${PN}-src.zip"
494 local zip_path="${T}/${zip_name}" 495 local zip_path="${T}/${zip_name}"
518# @ebuild-function java-pkg_dolauncher 519# @ebuild-function java-pkg_dolauncher
519# 520#
520# Make a wrapper script to lauch/start this package 521# Make a wrapper script to lauch/start this package
521# If necessary, the wrapper will switch to the appropriate VM. 522# If necessary, the wrapper will switch to the appropriate VM.
522# 523#
524# Can be called without parameters if the package installs only one jar
525# that has the Main-class attribute set. The wrapper will be named ${PN}.
526#
523# @param $1 - filename of launcher to create 527# @param $1 - filename of launcher to create
524# @param $2 - options, as follows: 528# @param $2 - options, as follows:
525# --main the.main.class.too.start 529# --main the.main.class.too.start
526# --jar /the/jar/too/launch.jar 530# --jar /the/jar/too/launch.jar or just <name>.jar
527# --java_args 'Extra arguments to pass too jave' 531# --java_args 'Extra arguments to pass to java'
528# --pkg_args 'extra arguments too pass too the package' 532# --pkg_args 'Extra arguments too pass to the package'
529# --pwd 533# --pwd
530# -into 534# -into
531# -pre 535# -pre
532# ------------------------------------------------------------------------------ 536# ------------------------------------------------------------------------------
533java-pkg_dolauncher() { 537java-pkg_dolauncher() {
534 debug-print-function ${FUNCNAME} $* 538 debug-print-function ${FUNCNAME} $*
535 539
536 java-pkg_check-phase install 540 java-pkg_check-phase install
537
538 [[ ${#} -lt 1 ]] && die "Need at least one argument"
539
540 java-pkg_init_paths_ 541 java-pkg_init_paths_
541 542
543 if [[ ${#} = 0 ]]; then
544 local name="${PN}"
545 else
542 local name="${1}" 546 local name="${1}"
547 shift
548 fi
549
543 # TODO rename to launcher 550 # TODO rename to launcher
544 local target="${T}/${name}" 551 local target="${T}/${name}"
552 local var_tmp="${T}/launcher_variables_tmp"
545 local target_dir pre 553 local target_dir pre
546 shift
547 554
548 echo "#!/bin/bash" > "${target}" 555 # Process the other the rest of the arguments
549 while [[ -n "${1}" && -n "${2}" ]]; do 556 while [[ -n "${1}" && -n "${2}" ]]; do
550 local var=${1} value=${2} 557 local var=${1} value=${2}
551 if [[ "${var:0:2}" == "--" ]]; then 558 if [[ "${var:0:2}" == "--" ]]; then
559 local var=${var:2}
552 echo "gjl_${var:2}=\"${value}\"" >> "${target}" 560 echo "gjl_${var}=\"${value}\"" >> "${var_tmp}"
561 local gjl_${var}="${value}"
553 elif [[ "${var}" == "-into" ]]; then 562 elif [[ "${var}" == "-into" ]]; then
554 target_dir="${value}" 563 target_dir="${value}"
555 elif [[ "${var}" == "-pre" ]]; then 564 elif [[ "${var}" == "-pre" ]]; then
556 pre="${value}" 565 pre="${value}"
557 fi 566 fi
558 shift 2 567 shift 2
559 done 568 done
569
570 # Test if no --jar and --main arguments were given and
571 # in that case check if the package only installs one jar
572 # and use that jar.
573 if [[ -z "${gjl_jar}" && -z "${gjl_main}" ]]; then
574 local cp="${JAVA_PKG_CLASSPATH}"
575 if [[ "${cp/:}" = "${cp}" && "${cp%.jar}" != "${cp}" ]]; then
576 echo "gjl_jar=\"${JAVA_PKG_CLASSPATH}\"" >> "${var_tmp}"
577 else
578 local msg="Not enough information to create a launcher given."
579 msg="${msg} Please give --jar or --main argument to ${FUNCNAME}."
580 die "${msg}"
581 fi
582 fi
583
584 # Write the actual script
585 echo "#!/bin/bash" > "${target}"
586 [[ -n "${pre}" ]] && [[ -f "${pre}" ]] && cat "${pre}" >> "${target}"
560 echo "gjl_package=${JAVA_PKG_NAME}" >> "${target}" 587 echo "gjl_package=${JAVA_PKG_NAME}" >> "${target}"
561 [[ -n "${pre}" ]] && [[ -f "${pre}" ]] && cat "${pre}" >> "${target}" 588 cat "${var_tmp}" >> "${target}"
589 rm -f "${var_tmp}"
562 echo "source /usr/share/java-config-2/launcher/launcher.bash" >> "${target}" 590 echo "source /usr/share/java-config-2/launcher/launcher.bash" >> "${target}"
563 591
564 if [[ -n "${into}" ]]; then 592 if [[ -n "${target_dir}" ]]; then
565 DESTTREE="${target_dir}" dobin "${target}" 593 DESTTREE="${target_dir}" dobin "${target}"
566 local ret=$? 594 local ret=$?
567 return ${ret} 595 return ${ret}
568 else 596 else
569 dobin "${target}" 597 dobin "${target}"
597 echo "dowar: warning, skipping directory ${war}" 625 echo "dowar: warning, skipping directory ${war}"
598 continue 626 continue
599 else 627 else
600 warpath="${war}" 628 warpath="${war}"
601 fi 629 fi
602 630
603 # Install those files like you mean it 631 # Install those files like you mean it
604 INSOPTIONS="-m 0644" \ 632 INSOPTIONS="-m 0644" \
605 INSDESTTREE=${JAVA_PKG_WARDEST} \ 633 INSDESTTREE=${JAVA_PKG_WARDEST} \
606 doins ${warpath} 634 doins ${warpath}
607 done 635 done
642# @ebuild-function java-pkg_jar-from 670# @ebuild-function java-pkg_jar-from
643# 671#
644# Makes a symlink to a jar from a certain package 672# Makes a symlink to a jar from a certain package
645# A lot of java packages include dependencies in a lib/ directory 673# A lot of java packages include dependencies in a lib/ directory
646# You can use this function to replace these bundled dependencies. 674# You can use this function to replace these bundled dependencies.
675# The dependency is recorded into package.env DEPEND line, unless "--build-only"
676# is passed as the very first argument, for jars that have to be present only
677# at build time and are not needed on runtime (junit testing etc).
647# 678#
648# Example: get all jars from xerces slot 2 679# Example: get all jars from xerces slot 2
649# java-pkg_jar-from xerces-2 680# java-pkg_jar-from xerces-2
650# Example: get a specific jar from xerces slot 2 681# Example: get a specific jar from xerces slot 2
651# java-pkg_jar-from xerces-2 xml-apis.jar 682# java-pkg_jar-from xerces-2 xml-apis.jar
652# Example get a specific jar from xerces slot 2, and name it diffrently 683# 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 684# java-pkg_jar-from xerces-2 xml-apis.jar xml.jar
685# Example: get junit.jar which is needed only for building
686# java-pkg_jar-from --build-only junit junit.jar
654# 687#
688# @param $1 - (optional) "--build-only" makes the jar(s) not added into
689# package.env DEPEND line.
655# @param $1 - Package to get jars from. 690# @param $1 - Package to get jars from.
656# @param $2 - jar from package. If not specified, all jars will be used. 691# @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 692# @param $3 - When a single jar is specified, destination filename of the
658# symlink. Defaults to the name of the jar. 693# symlink. Defaults to the name of the jar.
659# ------------------------------------------------------------------------------ 694# ------------------------------------------------------------------------------
660# TODO could probably be cleaned up a little 695# TODO could probably be cleaned up a little
661java-pkg_jar-from() { 696java-pkg_jar-from() {
662 debug-print-function ${FUNCNAME} $* 697 debug-print-function ${FUNCNAME} $*
663 698
699 local build_only=""
700
701 if [[ "${1}" = "--build-only" ]]; then
702 build_only="true"
703 shift
704 fi
705
664 local target_pkg="${1}" target_jar="${2}" destjar="${3}" 706 local target_pkg="${1}" target_jar="${2}" destjar="${3}"
665 707
666 [[ -z ${target_pkg} ]] && die "Must specify a package" 708 [[ -z ${target_pkg} ]] && die "Must specify a package"
667 709
668 # default destjar to the target jar 710 # default destjar to the target jar
669 [[ -z "${destjar}" ]] && destjar="${target_jar}" 711 [[ -z "${destjar}" ]] && destjar="${target_jar}"
670 712
713 local error_msg="There was a problem getting the classpath for ${target_pkg}."
714 local classpath
671 local classpath="$(java-config --classpath=${target_pkg})" 715 classpath="$(java-config --classpath=${target_pkg})"
672 [[ $? != 0 ]] && die "There was a problem getting the classpath for ${target_pkg}" 716 [[ $? != 0 ]] && die ${error_msg}
673 717
674 local jar 718 local jar
675 for jar in ${classpath//:/ }; do 719 for jar in ${classpath//:/ }; do
676 local jar_name=$(basename "${jar}") 720 local jar_name=$(basename "${jar}")
677 if [[ ! -f "${jar}" ]] ; then 721 if [[ ! -f "${jar}" ]] ; then
681 # If no specific target jar was indicated, link it 725 # If no specific target jar was indicated, link it
682 if [[ -z "${target_jar}" ]] ; then 726 if [[ -z "${target_jar}" ]] ; then
683 [[ -f "${target_jar}" ]] && rm "${target_jar}" 727 [[ -f "${target_jar}" ]] && rm "${target_jar}"
684 ln -snf "${jar}" \ 728 ln -snf "${jar}" \
685 || die "Failed to make symlink from ${jar} to ${jar_name}" 729 || die "Failed to make symlink from ${jar} to ${jar_name}"
686 java-pkg_record-jar_ "${target_pkg}" "${jar}" 730 [[ -z "${build_only}" ]] && java-pkg_record-jar_ "${target_pkg}" "${jar}"
687 # otherwise, if the current jar is the target jar, link it 731 # otherwise, if the current jar is the target jar, link it
688 elif [[ "${jar_name}" == "${target_jar}" ]] ; then 732 elif [[ "${jar_name}" == "${target_jar}" ]] ; then
689 [[ -f "${destjar}" ]] && rm "${destjar}" 733 [[ -f "${destjar}" ]] && rm "${destjar}"
690 ln -snf "${jar}" "${destjar}" \ 734 ln -snf "${jar}" "${destjar}" \
691 || die "Failed to make symlink from ${jar} to ${destjar}" 735 || die "Failed to make symlink from ${jar} to ${destjar}"
692 java-pkg_record-jar_ "${target_pkg}" "${jar}" 736 [[ -z "${build_only}" ]] && java-pkg_record-jar_ "${target_pkg}" "${jar}"
693 return 0 737 return 0
694 fi 738 fi
695 done 739 done
696 # if no target was specified, we're ok 740 # if no target was specified, we're ok
697 if [[ -z "${target_jar}" ]] ; then 741 if [[ -z "${target_jar}" ]] ; then
714# ------------------------------------------------------------------------------ 758# ------------------------------------------------------------------------------
715# @ebuild-function java-pkg_getjars 759# @ebuild-function java-pkg_getjars
716# 760#
717# Get the classpath provided by any number of packages 761# Get the classpath provided by any number of packages
718# Among other things, this can be passed to 'javac -classpath' or 'ant -lib'. 762# Among other things, this can be passed to 'javac -classpath' or 'ant -lib'.
763# The providing packages are recorded as dependencies into package.env DEPEND
764# line, unless "--build-only" is passed as the very first argument, for jars
765# that have to be present only at build time and are not needed on runtime
766# (junit testing etc).
719# 767#
720# Example: Get the classpath for xerces-2, 768# Example: Get the classpath for xerces-2,
721# java-pkg_getjars xerces-2 xalan 769# java-pkg_getjars xerces-2 xalan
722# Example Return: 770# Example Return:
723# /usr/share/xerces-2/lib/xml-apis.jar:/usr/share/xerces-2/lib/xmlParserAPIs.jar:/usr/share/xalan/lib/xalan.jar 771# /usr/share/xerces-2/lib/xml-apis.jar:/usr/share/xerces-2/lib/xmlParserAPIs.jar:/usr/share/xalan/lib/xalan.jar
724# 772#
773# @param $1 - (optional) "--build-only" makes the jar(s) not added into
774# package.env DEPEND line.
725# @param $@ - list of packages to get jars from 775# @param $@ - list of packages to get jars from
726# ------------------------------------------------------------------------------ 776# ------------------------------------------------------------------------------
727java-pkg_getjars() { 777java-pkg_getjars() {
728 debug-print-function ${FUNCNAME} $* 778 debug-print-function ${FUNCNAME} $*
779
780 local build_only=""
781
782 if [[ "${1}" = "--build-only" ]]; then
783 build_only="true"
784 shift
785 fi
729 786
730 [[ ${#} -lt 1 ]] && die "At least one argument needed" 787 [[ ${#} -lt 1 ]] && die "At least one argument needed"
731 788
732 # NOTE could probably just pass $@ to java-config --classpath. and return it 789 # NOTE could probably just pass $@ to java-config --classpath. and return it
733 local classpath pkg 790 local classpath pkg
734 for pkg in ${@//,/ }; do 791 for pkg in ${@//,/ }; do
735 #for pkg in $(echo "$@" | tr ',' ' '); do 792 #for pkg in $(echo "$@" | tr ',' ' '); do
736 jars="$(java-config --classpath=${pkg})" 793 jars="$(java-config --classpath=${pkg})"
794 [[ -z "${jars}" ]] && die "java-config --classpath=${pkg} failed"
737 debug-print "${pkg}:${jars}" 795 debug-print "${pkg}:${jars}"
738 # TODO should we ensure jars exist? 796
739 if [[ -z "${classpath}" ]]; then 797 if [[ -z "${classpath}" ]]; then
740 classpath="${jars}" 798 classpath="${jars}"
741 else 799 else
742 classpath="${classpath}:${jars}" 800 classpath="${classpath}:${jars}"
743 fi 801 fi
744 java-pkg_record-jar_ "${pkg}" 802 # Only record jars that aren't build-only
803 [[ -z "${build_only}" ]] && java-pkg_record-jar_ "${pkg}"
745 done 804 done
746 echo "${classpath}" 805 echo "${classpath}"
747} 806}
748 807
749# ------------------------------------------------------------------------------ 808# ------------------------------------------------------------------------------
750# @ebuild-function java-pkg_getjar 809# @ebuild-function java-pkg_getjar
751# 810#
752# Get the filename of a single jar from a package 811# Get the filename of a single jar from a package
812# The providing package is recorded as runtime dependency into package.env
813# DEPEND line, unless "--build-only" is passed as the very first argument, for
814# jars that have to be present only at build time and are not needed on runtime
815# (junit testing etc).
753# 816#
754# @example 817# @example
755# java-pkg_getjar xerces-2 xml-apis.jar 818# java-pkg_getjar xerces-2 xml-apis.jar
756# @example-return 819# @example-return
757# /usr/share/xerces-2/lib/xml-apis.jar 820# /usr/share/xerces-2/lib/xml-apis.jar
758# 821#
822# @param $1 - (optional) "--build-only" makes the jar not added into
823# package.env DEPEND line.
759# @param $1 - package to use 824# @param $1 - package to use
760# @param $2 - jar to get 825# @param $2 - jar to get
761# ------------------------------------------------------------------------------ 826# ------------------------------------------------------------------------------
762java-pkg_getjar() { 827java-pkg_getjar() {
763 debug-print-function ${FUNCNAME} $* 828 debug-print-function ${FUNCNAME} $*
829
830 local build_only=""
831
832 if [[ "${1}" = "--build-only" ]]; then
833 build_only="true"
834 shift
835 fi
764 836
765 local pkg="${1}" target_jar="${2}" jar 837 local pkg="${1}" target_jar="${2}" jar
766 [[ -z ${pkg} ]] && die "Must specify package to get a jar from" 838 [[ -z ${pkg} ]] && die "Must specify package to get a jar from"
767 [[ -z ${target_jar} ]] && die "Must specify jar to get" 839 [[ -z ${target_jar} ]] && die "Must specify jar to get"
768 840
769 # TODO check that package is actually installed 841 local error_msg="Could not find classpath for ${pkg}. Are you sure its installed?"
842 local classpath
770 local classpath=$(java-config --classpath=${pkg}) 843 classpath=$(java-config --classpath=${pkg})
771 [[ $? != 0 ]] && die "There could not find classpath for ${pkg}. Are you sure its installed?" 844 [[ $? != 0 ]] && die ${error_msg}
845
772 for jar in ${classpath//:/ }; do 846 for jar in ${classpath//:/ }; do
773 if [[ ! -f "${jar}" ]] ; then 847 if [[ ! -f "${jar}" ]] ; then
774 die "Installation problems with jars in ${pkg} - is it installed?" 848 die "Installation problem with jar ${jar} in ${pkg} - is it installed?"
775 fi 849 fi
776 850
777 if [[ "$(basename ${jar})" == "${target_jar}" ]] ; then 851 if [[ "$(basename ${jar})" == "${target_jar}" ]] ; then
778 java-pkg_record-jar_ "${pkg}" "${jar}" 852 # Only record jars that aren't build-only
853 [[ -z "${build_only}" ]] && java-pkg_record-jar_ "${pkg}" "${jar}"
779 echo "${jar}" 854 echo "${jar}"
780 return 0 855 return 0
781 fi 856 fi
782 done 857 done
783 858
784 die "Could not find ${target_jar} in ${pkg}" 859 die "Could not find ${target_jar} in ${pkg}"
785 return 1 860 return 1
786} 861}
787 862
788# This function reads stdin, and based on that input, figures out how to 863# This function reads stdin, and based on that input, figures out how to
802# line="${line// /}" 877# line="${line// /}"
803# 878#
804# # format: path=jarinfo 879# # format: path=jarinfo
805# local path=${line%%=*} 880# local path=${line%%=*}
806# local jarinfo=${line##*=} 881# local jarinfo=${line##*=}
807# 882#
808# # format: jar@package 883# # format: jar@package
809# local jar=${jarinfo%%@*}.jar 884# local jar=${jarinfo%%@*}.jar
810# local package=${jarinfo##*@} 885# local package=${jarinfo##*@}
811# if [[ -n ${replace_only} ]]; then 886# if [[ -n ${replace_only} ]]; then
812# [[ ! -f $path ]] && die "No jar exists at ${path}" 887# [[ ! -f $path ]] && die "No jar exists at ${path}"
825# @section-end query 900# @section-end query
826# ------------------------------------------------------------------------------ 901# ------------------------------------------------------------------------------
827 902
828# ------------------------------------------------------------------------------ 903# ------------------------------------------------------------------------------
829# @section-begin helper 904# @section-begin helper
830# @section-summary Helper functions 905# @section-summary Helper functions
831# 906#
832# Various other functions to use from an ebuild 907# Various other functions to use from an ebuild
833# ------------------------------------------------------------------------------ 908# ------------------------------------------------------------------------------
834 909
835# ------------------------------------------------------------------------------ 910# ------------------------------------------------------------------------------
841# jdbc-stdext 916# jdbc-stdext
842# jaf 917# jaf
843# jdbc-rowset 918# jdbc-rowset
844# jms 919# jms
845# 920#
846# @param $1 - Optionally indicate that the dependencies are controlled by 921# @param $1 - Optionally indicate that the dependencies are controlled by
847# a use flag by specifying '--use' Requires $2. 922# a use flag by specifying '--use' Requires $2.
848# @param $2 - USE flag which will enable the dependencies. 923# @param $2 - USE flag which will enable the dependencies.
849# @param $@ - virtual packages to add depenedencies for 924# @param $@ - virtual packages to add depenedencies for
850# ------------------------------------------------------------------------------ 925# ------------------------------------------------------------------------------
851# TODO rewrite to parse a line based declaration file instead -- karltk 926# TODO rewrite to parse a line based declaration file instead -- karltk
945 fi 1020 fi
946} 1021}
947 1022
948# ------------------------------------------------------------------------------ 1023# ------------------------------------------------------------------------------
949# @internal-function java-pkg_is-vm-version-sufficient 1024# @internal-function java-pkg_is-vm-version-sufficient
950# 1025#
951# @return zero - VM is sufficient 1026# @return zero - VM is sufficient
952# @return non-zero - VM is not sufficient 1027# @return non-zero - VM is not sufficient
953# ------------------------------------------------------------------------------ 1028# ------------------------------------------------------------------------------
954java-pkg_is-vm-version-sufficient() { 1029java-pkg_is-vm-version-sufficient() {
955 debug-print-function ${FUNCNAME} $* 1030 debug-print-function ${FUNCNAME} $*
975 die "Active Java VM too old" 1050 die "Active Java VM too old"
976 fi 1051 fi
977} 1052}
978 1053
979# ------------------------------------------------------------------------------ 1054# ------------------------------------------------------------------------------
980# @internal-function java-pkg_is-vm-version-eq 1055# @internal-function java-pkg_is-vm-version-eq
981# 1056#
982# @param $@ - VM version to compare current VM to 1057# @param $@ - VM version to compare current VM to
983# @return zero - VM versions are equal 1058# @return zero - VM versions are equal
984# @return non-zero - VM version are not equal 1059# @return non-zero - VM version are not equal
985# ------------------------------------------------------------------------------ 1060# ------------------------------------------------------------------------------
986java-pkg_is-vm-version-eq() { 1061java-pkg_is-vm-version-eq() {
1016# 1091#
1017# @param $@ - VM version to compare current to 1092# @param $@ - VM version to compare current to
1018# ------------------------------------------------------------------------------ 1093# ------------------------------------------------------------------------------
1019java-pkg_ensure-vm-version-ge() { 1094java-pkg_ensure-vm-version-ge() {
1020 debug-print-function ${FUNCNAME} $* 1095 debug-print-function ${FUNCNAME} $*
1021 1096
1022 if ! java-pkg_is-vm-version-ge "$@" ; then 1097 if ! java-pkg_is-vm-version-ge "$@" ; then
1023 debug-print "vm is not suffient" 1098 debug-print "vm is not suffient"
1024 eerror "This package requires a Java VM version >= $@" 1099 eerror "This package requires a Java VM version >= $@"
1025 einfo "Please use java-config -S to set the correct one" 1100 einfo "Please use java-config -S to set the correct one"
1026 die "Active Java VM too old" 1101 die "Active Java VM too old"
1027 fi 1102 fi
1028} 1103}
1029 1104
1030# ------------------------------------------------------------------------------ 1105# ------------------------------------------------------------------------------
1031# @internal-function java-pkg_is-vm-version-ge 1106# @internal-function java-pkg_is-vm-version-ge
1032# 1107#
1033# @param $@ - VM version to compare current VM to 1108# @param $@ - VM version to compare current VM to
1034# @return zero - current VM version is greater than checked version 1109# @return zero - current VM version is greater than checked version
1035# @return non-zero - current VM version is not greater than checked version 1110# @return non-zero - current VM version is not greater than checked version
1036# ------------------------------------------------------------------------------ 1111# ------------------------------------------------------------------------------
1037java-pkg_is-vm-version-ge() { 1112java-pkg_is-vm-version-ge() {
1051 return 1 1126 return 1
1052 fi 1127 fi
1053 fi 1128 fi
1054} 1129}
1055 1130
1131java-pkg_set-current-vm() {
1132 export GENTOO_VM=${1}
1133}
1134
1135java-pkg_get-current-vm() {
1136 echo ${GENTOO_VM}
1137}
1138
1139java-pkg_current-vm-matches() {
1140 hasq $(java-pkg_get-current-vm) ${@}
1141 return $?
1142}
1143
1056# ------------------------------------------------------------------------------ 1144# ------------------------------------------------------------------------------
1057# @ebuild-function java-pkg_get-source 1145# @ebuild-function java-pkg_get-source
1058# 1146#
1059# Determines what source version should be used, for passing to -source. 1147# 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 1148# Unless you want to break things you probably shouldn't set _WANT_SOURCE
1061# 1149#
1062# @return string - Either the lowest possible source, or JAVA_PKG_WANT_SOURCE 1150# @return string - Either the lowest possible source, or JAVA_PKG_WANT_SOURCE
1063# ------------------------------------------------------------------------------ 1151# ------------------------------------------------------------------------------
1068# ------------------------------------------------------------------------------ 1156# ------------------------------------------------------------------------------
1069# @ebuild-function java-pkg_get-target 1157# @ebuild-function java-pkg_get-target
1070# 1158#
1071# Determines what target version should be used, for passing to -target. 1159# 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 1160# If you don't care about lower versions, you can set _WANT_TARGET to the
1073# version of your JDK. 1161# version of your JDK.
1074# Remember doing this will mostly like cause things to break. 1162# Remember doing this will mostly like cause things to break.
1075# Doesn't allow it to be lower then the one in depend. 1163# Doesn't allow it to be lower then the one in depend.
1076# Doesn't allow it to be higher then the active vm. 1164# Doesn't allow it to be higher then the active vm.
1077# 1165#
1078# @return string - Either the lowest possible target, or JAVA_PKG_WANT_TARGET 1166# @return string - Either the lowest possible target, or JAVA_PKG_WANT_TARGET
1079# ------------------------------------------------------------------------------ 1167# ------------------------------------------------------------------------------
1080java-pkg_get-target() { 1168java-pkg_get-target() {
1081 local min=$(depend-java-query --get-lowest "${DEPEND} ${RDEPEND}") 1169 local min=$(depend-java-query --get-lowest "${DEPEND} ${RDEPEND}")
1082 if [[ -n "${JAVA_PKG_WANT_TARGET}" ]]; then 1170 if [[ -n "${JAVA_PKG_WANT_TARGET}" ]]; then
1083 local max="$(java-config --select-vm "${GENTOO_VM}" -g PROVIDES_VERSION)" 1171 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 1172 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} 1173 echo ${JAVA_PKG_WANT_TARGET}
1086 else 1174 else
1094} 1182}
1095 1183
1096java-pkg_get-javac() { 1184java-pkg_get-javac() {
1097 debug-print-function ${FUNCNAME} $* 1185 debug-print-function ${FUNCNAME} $*
1098 1186
1099 java-pkg_init-compiler_ 1187
1100 local compiler="${GENTOO_COMPILER}" 1188 local compiler="${GENTOO_COMPILER}"
1101 1189
1102 local compiler_executable 1190 local compiler_executable
1103 if [[ "${compiler}" = "javac" ]]; then 1191 if [[ "${compiler}" = "javac" ]]; then
1104 # nothing fancy needs to be done for javac 1192 # nothing fancy needs to be done for javac
1112 unset JAVAC 1200 unset JAVAC
1113 # try to get value of JAVAC 1201 # try to get value of JAVAC
1114 compiler_executable="$(source ${compiler_env} 1>/dev/null 2>&1; echo ${JAVAC})" 1202 compiler_executable="$(source ${compiler_env} 1>/dev/null 2>&1; echo ${JAVAC})"
1115 export JAVAC=${old_javac} 1203 export JAVAC=${old_javac}
1116 1204
1117 [[ -z ${compiler_executable} ]] && die "JAVAC is empty or undefined in ${compiler_env}" 1205 if [[ -z ${compiler_executable} ]]; then
1118 1206 echo "JAVAC is empty or undefined in ${compiler_env}"
1207 return 1
1208 fi
1209
1119 # check that it's executable 1210 # check that it's executable
1120 if [[ ! -x ${compiler_executable} ]]; then 1211 if [[ ! -x ${compiler_executable} ]]; then
1121 eerror "Could not find ${compiler_executable}!"
1122 die "${compiler_executable} doesn't exist, or isn't executable" 1212 echo "${compiler_executable} doesn't exist, or isn't executable"
1213 return 1
1123 fi 1214 fi
1124 else 1215 else
1125 eerror "Could not find environment file for ${compiler}" 1216 echo "Could not find environment file for ${compiler}"
1126 die "Could not find ${compiler_env}" 1217 return 1
1127 fi 1218 fi
1128 fi 1219 fi
1129 echo ${compiler_executable} 1220 echo ${compiler_executable}
1130} 1221}
1131 1222
1132# ------------------------------------------------------------------------------ 1223# ------------------------------------------------------------------------------
1133# @ebuild-function java-pkg_javac-args 1224# @ebuild-function java-pkg_javac-args
1134# 1225#
1135# If an ebuild uses javac directly, instead of using ejavac, it should call this 1226# If an ebuild uses javac directly, instead of using ejavac, it should call this
1136# to know what -source/-target to use. 1227# to know what -source/-target to use.
1137# 1228#
1138# @return string - arguments to pass to javac, complete with -target and -source 1229# @return string - arguments to pass to javac, complete with -target and -source
1141 debug-print-function ${FUNCNAME} $* 1232 debug-print-function ${FUNCNAME} $*
1142 1233
1143 local want_source="$(java-pkg_get-source)" 1234 local want_source="$(java-pkg_get-source)"
1144 local want_target="$(java-pkg_get-target)" 1235 local want_target="$(java-pkg_get-target)"
1145 1236
1146 local source_str="-source ${want_source}" 1237 local source_str="-source ${want_source}"
1147 local target_str="-target ${want_target}" 1238 local target_str="-target ${want_target}"
1148 1239
1149 debug-print "want source: ${want_source}" 1240 debug-print "want source: ${want_source}"
1150 debug-print "want target: ${want_target}" 1241 debug-print "want target: ${want_target}"
1151 1242
1152 if [[ -z "${want_source}" || -z "${want_target}" ]]; then 1243 if [[ -z "${want_source}" || -z "${want_target}" ]]; then
1153 debug-print "could not find valid -source/-target values" 1244 debug-print "could not find valid -source/-target values for javac"
1154 die "Could not find valid -source/-target values" 1245 echo "Could not find valid -source/-target values for javac"
1246 return 1
1155 else 1247 else
1156 if java-pkg_is-vm-version-ge "1.4"; then 1248 if java-pkg_is-vm-version-ge "1.4"; then
1157 echo "${source_str} ${target_str}" 1249 echo "${source_str} ${target_str}"
1158 else 1250 else
1159 echo "${target_str}" 1251 echo "${target_str}"
1180 ebeep 5 1272 ebeep 5
1181 die "No GCJ support found!" 1273 die "No GCJ support found!"
1182 fi 1274 fi
1183} 1275}
1184 1276
1277java-pkg_ensure-test() {
1278 if hasq test ${FEATURES} && ! hasq -test ${FEATURES} && ! use test; then
1279 eerror "You specified FEATURES=test, but USE=test is needed"
1280 eerror "to pull in the additional dependencies for testing"
1281 die "Need USE=test enabled"
1282 fi
1283}
1284
1185# ------------------------------------------------------------------------------ 1285# ------------------------------------------------------------------------------
1186# @section-end helper 1286# @section-end helper
1187# ------------------------------------------------------------------------------ 1287# ------------------------------------------------------------------------------
1188 1288
1189# ------------------------------------------------------------------------------ 1289# ------------------------------------------------------------------------------
1201# compiler. 1301# compiler.
1202# 1302#
1203# ------------------------------------------------------------------------------ 1303# ------------------------------------------------------------------------------
1204eant() { 1304eant() {
1205 debug-print-function ${FUNCNAME} $* 1305 debug-print-function ${FUNCNAME} $*
1306
1307 # FIXME get this working
1308# if is-java-strict && [[ ! ${DEPEND} =~ "dev-java/ant" ]]; then
1309# java-pkg_announce-qa-violation \
1310# "Using eant, but not depending on dev-java/ant or dev-java/ant-core"
1311# fi
1206 1312
1207 local antflags 1313 local antflags
1208 java-pkg_init-compiler_ 1314 java-pkg_init-compiler_
1209 local compiler="${GENTOO_COMPILER}" 1315 local compiler="${GENTOO_COMPILER}"
1210 1316
1229 1335
1230 if is-java-strict; then 1336 if is-java-strict; then
1231 einfo "Disabling system classpath for ant" 1337 einfo "Disabling system classpath for ant"
1232 antflags="${antflags} -Dbuild.sysclasspath=ignore" 1338 antflags="${antflags} -Dbuild.sysclasspath=ignore"
1233 fi 1339 fi
1234 1340
1235 if [[ -n ${JAVA_PKG_DEBUG} ]]; then 1341 if [[ -n ${JAVA_PKG_DEBUG} ]]; then
1236 antflags="${antflags} -debug" 1342 antflags="${antflags} -debug"
1237 fi 1343 fi
1238 1344
1239 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ant ${antflags} "${@}" 1345 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ant ${antflags} "${@}"
1240 ant ${antflags} "${@}" || die "eant failed" 1346 ant ${antflags} "${@}" || die "eant failed"
1241 1347
1242} 1348}
1243 1349
1244# ------------------------------------------------------------------------------ 1350# ------------------------------------------------------------------------------
1245# @ebuild-function ejavac 1351# @ebuild-function ejavac
1246# 1352#
1247# Javac wrapper function. Will use the appropriate compiler, based on 1353# Javac wrapper function. Will use the appropriate compiler, based on
1248# /etc/java-config/compilers.conf 1354# /etc/java-config/compilers.conf
1249# 1355#
1250# @param $@ - Arguments to be passed to the compiler 1356# @param $@ - Arguments to be passed to the compiler
1251# ------------------------------------------------------------------------------ 1357# ------------------------------------------------------------------------------
1252ejavac() { 1358ejavac() {
1253 debug-print-function ${FUNCNAME} $* 1359 debug-print-function ${FUNCNAME} $*
1254 1360
1255 # FIXME using get-javac ends up printing stuff with einfo 1361 java-pkg_init-compiler_
1362
1363 local compiler_executable
1256# local compiler_executable=$(java-pkg_get-javac) 1364 compiler_executable=$(java-pkg_get-javac)
1257 local compiler_executable="javac" 1365 if [[ ${?} != 0 ]]; then
1366 eerror "There was a problem determining compiler: ${compiler_executable}"
1367 die "get-javac failed"
1368 fi
1258 1369
1370 local javac_args
1371 javac_args="$(java-pkg_javac-args)"
1372 if [[ ${?} != 0 ]]; then
1373 eerror "There was a problem determining JAVACFLAGS: ${javac_args}"
1374 die "java-pkg_javac-args failed"
1375 fi
1376
1259 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ${compiler_executable} $(java-pkg_javac-args) "${@}" 1377 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ${compiler_executable} ${javac_args} "${@}"
1260 ${compiler_executable} $(java-pkg_javac-args) "${@}" || die "ejavac failed" 1378 ${compiler_executable} ${javac_args} "${@}" || die "ejavac failed"
1261} 1379}
1262 1380
1263# ------------------------------------------------------------------------------ 1381# ------------------------------------------------------------------------------
1264# @ebuild-function java-pkg_filter-compiler 1382# @ebuild-function java-pkg_filter-compiler
1265# 1383#
1266# Used to prevent the use of some compilers. Should be used in src_compile. 1384# Used to prevent the use of some compilers. Should be used in src_compile.
1267# Basically, it just appends onto JAVA_PKG_FILTER_COMPILER 1385# Basically, it just appends onto JAVA_PKG_FILTER_COMPILER
1268# 1386#
1269# @param $@ - compilers to filter 1387# @param $@ - compilers to filter
1270# ------------------------------------------------------------------------------ 1388# ------------------------------------------------------------------------------
1288# ------------------------------------------------------------------------------ 1406# ------------------------------------------------------------------------------
1289# @ebuild-function use_doc 1407# @ebuild-function use_doc
1290# 1408#
1291# Helper function for getting ant to build javadocs. If the user has USE=doc, 1409# 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. 1410# then 'javadoc' or the argument are returned. Otherwise, there is no return.
1293# 1411#
1294# The output of this should be passed to ant. 1412# The output of this should be passed to ant.
1295# 1413#
1296# Example: build javadocs by calling 'javadoc' target 1414# Example: build javadocs by calling 'javadoc' target
1297# eant $(use_doc) 1415# eant $(use_doc)
1298# Example: build javadocs by calling 'apidoc' target 1416# Example: build javadocs by calling 'apidoc' target
1306} 1424}
1307 1425
1308# ------------------------------------------------------------------------------ 1426# ------------------------------------------------------------------------------
1309# @section-end build 1427# @section-end build
1310# ------------------------------------------------------------------------------ 1428# ------------------------------------------------------------------------------
1311 1429
1312# ------------------------------------------------------------------------------ 1430# ------------------------------------------------------------------------------
1313# @section-begin internal 1431# @section-begin internal
1314# @section-summary Internal functions 1432# @section-summary Internal functions
1315# 1433#
1316# Do __NOT__ use any of these from an ebuild! These are only to be used from 1434# Do __NOT__ use any of these from an ebuild! These are only to be used from
1317# within the java eclasses. 1435# within the java eclasses.
1318# ------------------------------------------------------------------------------ 1436# ------------------------------------------------------------------------------
1319 1437
1320# ----------------------------------------------------------------------------- 1438# -----------------------------------------------------------------------------
1321# @function-internal java-pkg_init 1439# @function-internal java-pkg_init
1322# 1440#
1323# The purpose of this function, as the name might imply, is to initialize the 1441# 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 1442# 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 1443# that'll muss things up. It initializes some variables, which are used
1326# internally. And most importantly, it'll switch the VM if necessary. 1444# internally. And most importantly, it'll switch the VM if necessary.
1327# 1445#
1339 # TODO we will probably want to set JAVAC and JAVACFLAGS 1457 # TODO we will probably want to set JAVAC and JAVACFLAGS
1340 1458
1341 # Do some QA checks 1459 # Do some QA checks
1342 java-pkg_check-jikes 1460 java-pkg_check-jikes
1343 1461
1344 # When users have crazy classpaths some packages can fail to compile. 1462 # When users have crazy classpaths some packages can fail to compile.
1345 # and everything should work with empty CLASSPATH. 1463 # and everything should work with empty CLASSPATH.
1346 # This also helps prevent unexpected dependencies on random things 1464 # This also helps prevent unexpected dependencies on random things
1347 # from the CLASSPATH. 1465 # from the CLASSPATH.
1348 unset CLASSPATH 1466 unset CLASSPATH
1349} 1467}
1350 1468
1351# ------------------------------------------------------------------------------ 1469# ------------------------------------------------------------------------------
1352# @function-internal java-pkg-init-compiler_ 1470# @function-internal java-pkg-init-compiler_
1353# 1471#
1354# This function attempts to figure out what compiler should be used. It does 1472# 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 1473# this by reading the file at JAVA_PKG_COMPILERS_CONF, and checking the
1356# COMPILERS variable defined there. 1474# COMPILERS variable defined there.
1357# This can be overridden by a list in JAVA_PKG_FORCE_COMPILER 1475# This can be overridden by a list in JAVA_PKG_FORCE_COMPILER
1358# 1476#
1359# It will go through the list of compilers, and verify that it supports the 1477# 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 1478# 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 1479# compiler is checked. When JAVA_PKG_FORCE_COMPILER is defined, this checking
1362# isn't done. 1480# isn't done.
1363# 1481#
1385 if [[ -z ${JAVA_PKG_FORCE_COMPILER} ]]; then 1503 if [[ -z ${JAVA_PKG_FORCE_COMPILER} ]]; then
1386 compilers="$(source ${JAVA_PKG_COMPILERS_CONF} 1>/dev/null 2>&1; echo ${COMPILERS})" 1504 compilers="$(source ${JAVA_PKG_COMPILERS_CONF} 1>/dev/null 2>&1; echo ${COMPILERS})"
1387 else 1505 else
1388 compilers=${JAVA_PKG_FORCE_COMPILER} 1506 compilers=${JAVA_PKG_FORCE_COMPILER}
1389 fi 1507 fi
1390 1508
1391 debug-print "Read \"${compilers}\" from ${JAVA_PKG_COMPILERS_CONF}" 1509 debug-print "Read \"${compilers}\" from ${JAVA_PKG_COMPILERS_CONF}"
1392 1510
1393 # Figure out if we should announce what compiler we're using 1511 # Figure out if we should announce what compiler we're using
1394 local compiler 1512 local compiler
1395 for compiler in ${compilers}; do 1513 for compiler in ${compilers}; do
1398 if [[ ${compiler} = "javac" ]]; then 1516 if [[ ${compiler} = "javac" ]]; then
1399 debug-print "Found javac... breaking" 1517 debug-print "Found javac... breaking"
1400 export GENTOO_COMPILER="javac" 1518 export GENTOO_COMPILER="javac"
1401 break 1519 break
1402 fi 1520 fi
1403 1521
1404 if has ${compiler} ${JAVA_PKG_FILTER_COMPILER}; then 1522 if has ${compiler} ${JAVA_PKG_FILTER_COMPILER}; then
1405 if [[ -z ${JAVA_PKG_FORCE_COMPILER} ]]; then 1523 if [[ -z ${JAVA_PKG_FORCE_COMPILER} ]]; then
1406 einfo "Filtering ${compiler}" 1524 einfo "Filtering ${compiler}"
1407 continue 1525 continue
1408 fi 1526 fi
1409 fi 1527 fi
1410 1528
1411 # for non-javac, we need to make sure it supports the right target and 1529 # for non-javac, we need to make sure it supports the right target and
1412 # source 1530 # source
1413 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}" 1531 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}"
1414 if [[ -f ${compiler_env} ]]; then 1532 if [[ -f ${compiler_env} ]]; then
1415 local desired_target="$(java-pkg_get-target)" 1533 local desired_target="$(java-pkg_get-target)"
1500# TODO change to do-write, to match everything else 1618# TODO change to do-write, to match everything else
1501java-pkg_do_write_() { 1619java-pkg_do_write_() {
1502 # Create directory for package.env 1620 # Create directory for package.env
1503 dodir "${JAVA_PKG_SHAREPATH}" 1621 dodir "${JAVA_PKG_SHAREPATH}"
1504 if [[ -n "${JAVA_PKG_CLASSPATH}" || -n "${JAVA_PKG_LIBRARY}" || -f "${JAVA_PKG_DEPEND}" ]]; then 1622 if [[ -n "${JAVA_PKG_CLASSPATH}" || -n "${JAVA_PKG_LIBRARY}" || -f "${JAVA_PKG_DEPEND}" ]]; then
1623 java-pkg_init_paths_
1505 # Create package.env 1624 # Create package.env
1506 ( 1625 (
1507 echo "DESCRIPTION=\"${DESCRIPTION}\"" 1626 echo "DESCRIPTION=\"${DESCRIPTION}\""
1508 echo "GENERATION=\"2\"" 1627 echo "GENERATION=\"2\""
1509 1628
1511 [[ -n "${JAVA_PKG_LIBRARY}" ]] && echo "LIBRARY_PATH=\"${JAVA_PKG_LIBRARY}\"" 1630 [[ -n "${JAVA_PKG_LIBRARY}" ]] && echo "LIBRARY_PATH=\"${JAVA_PKG_LIBRARY}\""
1512 [[ -n "${JAVA_PROVIDE}" ]] && echo "PROVIDES=\"${JAVA_PROVIDE}\"" 1631 [[ -n "${JAVA_PROVIDE}" ]] && echo "PROVIDES=\"${JAVA_PROVIDE}\""
1513 [[ -f "${JAVA_PKG_DEPEND}" ]] && echo "DEPEND=\"$(cat ${JAVA_PKG_DEPEND} | uniq | tr '\n' ':')\"" 1632 [[ -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 ! 1633 echo "VM=\"$(echo ${RDEPEND} ${DEPEND} | sed -e 's/ /\n/g' | sed -n -e '/virtual\/\(jre\|jdk\)/ { p;q }')\"" # TODO cleanup !
1515 ) > "${JAVA_PKG_ENV}" 1634 ) > "${JAVA_PKG_ENV}"
1516 1635
1517 # register target/source 1636 # register target/source
1518 local target="$(java-pkg_get-target)" 1637 local target="$(java-pkg_get-target)"
1519 local source="$(java-pkg_get-source)" 1638 local source="$(java-pkg_get-source)"
1520 [[ -n ${target} ]] && echo "TARGET=\"${target}\"" >> "${JAVA_PKG_ENV}" 1639 [[ -n ${target} ]] && echo "TARGET=\"${target}\"" >> "${JAVA_PKG_ENV}"
1521 [[ -n ${source} ]] && echo "SOURCE=\"${source}\"" >> "${JAVA_PKG_ENV}" 1640 [[ -n ${source} ]] && echo "SOURCE=\"${source}\"" >> "${JAVA_PKG_ENV}"
1588 fi 1707 fi
1589} 1708}
1590 1709
1591# ------------------------------------------------------------------------------ 1710# ------------------------------------------------------------------------------
1592# @internal-function java-pkg_expand_dir_ 1711# @internal-function java-pkg_expand_dir_
1593# 1712#
1594# Gets the full path of the file/directory's parent. 1713# Gets the full path of the file/directory's parent.
1595# @param $1 - file/directory to find parent directory for 1714# @param $1 - file/directory to find parent directory for
1596# @return - path to $1's parent directory 1715# @return - path to $1's parent directory
1597# ------------------------------------------------------------------------------ 1716# ------------------------------------------------------------------------------
1598java-pkg_expand_dir_() { 1717java-pkg_expand_dir_() {
1625# ------------------------------------------------------------------------------ 1744# ------------------------------------------------------------------------------
1626java-pkg_setup-vm() { 1745java-pkg_setup-vm() {
1627 debug-print-function ${FUNCNAME} $* 1746 debug-print-function ${FUNCNAME} $*
1628 1747
1629 local vendor="$(java-pkg_get-vm-vendor)" 1748 local vendor="$(java-pkg_get-vm-vendor)"
1630 if [[ "${vendor}" == "sun" ]] && java-pkg_is-vm-version-ge 1 5; then 1749 if [[ "${vendor}" == "sun" ]] && java-pkg_is-vm-version-ge "1.5" ; then
1631 addpredict "/dev/random" 1750 addpredict "/dev/random"
1632 elif [[ "${vendor}" == "ibm" ]]; then 1751 elif [[ "${vendor}" == "ibm" ]]; then
1633 addpredict "/proc/self/maps" 1752 addpredict "/proc/self/maps"
1634 addpredict "/proc/cpuinfo" 1753 addpredict "/proc/cpuinfo"
1635 export LANG="C" LC_ALL="C" 1754 export LANG="C" LC_ALL="C"
1684# @return - The version of the current VM 1803# @return - The version of the current VM
1685# ------------------------------------------------------------------------------ 1804# ------------------------------------------------------------------------------
1686java-pkg_get-vm-version() { 1805java-pkg_get-vm-version() {
1687 debug-print-function ${FUNCNAME} $* 1806 debug-print-function ${FUNCNAME} $*
1688 1807
1689 java-pkg_get-current-vm | sed -e "s/.*-\([0-9.]\+\).*/\1/" 1808 java-config -g PROVIDES_VERSION
1690} 1809}
1691 1810
1692# ------------------------------------------------------------------------------ 1811# ------------------------------------------------------------------------------
1693# @internal-function java-pkg_switch-vm 1812# @internal-function java-pkg_switch-vm
1694# 1813#
1695# Switch VM if we're allowed to (controlled by JAVA_PKG_ALLOW_VM_CHANGE), and 1814# Switch VM if we're allowed to (controlled by JAVA_PKG_ALLOW_VM_CHANGE), and
1696# verify that the current VM is sufficient. 1815# verify that the current VM is sufficient.
1697# Setup the environment for the VM being used. 1816# Setup the environment for the VM being used.
1698# ------------------------------------------------------------------------------ 1817# ------------------------------------------------------------------------------
1699java-pkg_switch-vm() { 1818java-pkg_switch-vm() {
1700 if java-pkg_needs-vm; then 1819 if java-pkg_needs-vm; then
1704 export GENTOO_VM="${JAVA_PKG_FORCE_VM}" 1823 export GENTOO_VM="${JAVA_PKG_FORCE_VM}"
1705 # if we're allowed to switch the vm... 1824 # if we're allowed to switch the vm...
1706 elif [[ "${JAVA_PKG_ALLOW_VM_CHANGE}" == "yes" ]]; then 1825 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}" 1826 debug-print "depend-java-query: NV_DEPEND: ${JAVA_PKG_NV_DEPEND:-${DEPEND}} VNEED: ${JAVA_PKG_VNEED}"
1708 if [[ -n ${JAVA_PKG_VNEED} ]]; then 1827 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}}")" 1828 GENTOO_VM="$(depend-java-query --need-virtual "${JAVA_PKG_VNEED}" --get-vm "${JAVA_PKG_NV_DEPEND:-${DEPEND}}")"
1710 else 1829 else
1711 export GENTOO_VM="$(depend-java-query --get-vm "${JAVA_PKG_NV_DEPEND:-${DEPEND}}")" 1830 GENTOO_VM="$(depend-java-query --get-vm "${JAVA_PKG_NV_DEPEND:-${DEPEND}}")"
1831 fi
1832 if [[ -z "${GENTOO_VM}" || "${GENTOO_VM}" == "None" ]]; then
1833 eerror "Unable to determine VM for building from dependencies."
1834 echo "NV_DEPEND: ${JAVA_PKG_NV_DEPEND:-${DEPEND}}"
1835 echo "VNEED: ${JAVA_PKG_VNEED}"
1836 else
1837 export GENTOO_VM
1712 fi 1838 fi
1713 # otherwise just make sure the current VM is sufficient 1839 # otherwise just make sure the current VM is sufficient
1714 else 1840 else
1715 java-pkg_ensure-vm-version-sufficient 1841 java-pkg_ensure-vm-version-sufficient
1716 fi 1842 fi
1717 debug-print "Using: $(java-config -f)" 1843 debug-print "Using: $(java-config -f)"
1718 1844
1719 java-pkg_setup-vm 1845 java-pkg_setup-vm
1720 1846
1721 export JAVA=$(java-config --java) 1847 export JAVA=$(java-config --java)
1722 export JAVAC=$(java-config --javac) 1848 export JAVAC=$(java-config --javac)
1723 export JAVACFLAGS="$(java-pkg_javac-args)" 1849 JAVACFLAGS="$(java-pkg_javac-args)"
1850 if [[ ${?} != 0 ]]; then
1851 eerror "There was a problem determining JAVACFLAGS: ${JAVACFLAGS}"
1852 die "java-pkg_javac-args failed"
1853 fi
1724 [[ -n ${JAVACFLAGS_EXTRA} ]] && export JAVACFLAGS="${JAVACFLAGS_EXTRA} ${JAVACFLAGS}" 1854 [[ -n ${JAVACFLAGS_EXTRA} ]] && JAVACFLAGS="${JAVACFLAGS_EXTRA} ${JAVACFLAGS}"
1855 export JAVACFLAGS
1725 1856
1726 export JAVA_HOME="$(java-config -g JAVA_HOME)" 1857 export JAVA_HOME="$(java-config -g JAVA_HOME)"
1727 export JDK_HOME=${JAVA_HOME} 1858 export JDK_HOME=${JAVA_HOME}
1728 1859
1729 #TODO If you know a better solution let us know. 1860 #TODO If you know a better solution let us know.
1730 java-pkg_append_ LD_LIBRARY_PATH "$(java-config -g LDPATH)" 1861 java-pkg_append_ LD_LIBRARY_PATH "$(java-config -g LDPATH)"
1731 1862
1732 local tann="${T}/announced-vm" 1863 local tann="${T}/announced-vm"
1733 if [[ -n "${JAVA_PKG_DEBUG}" ]] || [[ ! -f "${tann}" ]] ; then 1864 if [[ -n "${JAVA_PKG_DEBUG}" ]] || [[ ! -f "${tann}" ]] ; then
1734 # Add a check for setup/preinst phase... to avoid duplicate outputs 1865 # Add a check for setup/preinst phase... to avoid duplicate outputs
1735 # for when FEATURES=buildpkg 1866 # for when FEATURES=buildpkg
1736 if [[ ${EBUILD_PHASE} != "setup" && ${EBUILD_PHASE} != "preinst" && ${EBUILD_PHASE} != "postinst" ]]; 1867 if [[ ${EBUILD_PHASE} != "setup" && ${EBUILD_PHASE} != "preinst" && ${EBUILD_PHASE} != "postinst" ]];
1780# TODO document 1911# TODO document
1781# Verify that the classes were compiled for the right source / target 1912# Verify that the classes were compiled for the right source / target
1782java-pkg_verify-classes() { 1913java-pkg_verify-classes() {
1783 ebegin "Verifying java class versions" 1914 ebegin "Verifying java class versions"
1784 #$(find ${D} -type f -name '*.jar' -o -name '*.class') 1915 #$(find ${D} -type f -name '*.jar' -o -name '*.class')
1785 class-version-verify.py -t $(java-pkg_get-target) -r ${D} 1916 class-version-verify.py -t $(java-pkg_get-target) -r ${D}
1786 result=$? 1917 result=$?
1787 eend ${result} 1918 eend ${result}
1788 if [[ ${result} == 0 ]]; then 1919 if [[ ${result} == 0 ]]; then
1789 einfo "All good" 1920 einfo "All good"
1790 else 1921 else
1791 ewarn "Possible problem" 1922 ewarn "Possible problem"
1792 die "Bad class files found" 1923 die "Bad class files found"
1793 fi 1924 fi
1794} 1925}
1795 1926
1796
1797# ------------------------------------------------------------------------------ 1927# ------------------------------------------------------------------------------
1798# @section-end internal 1928# @section-end internal
1799# ------------------------------------------------------------------------------ 1929# ------------------------------------------------------------------------------
1800 1930
1801java-pkg_check-phase() { 1931java-pkg_check-phase() {
1832 let "JAVA_PKG_QA_VIOLATIONS+=1" 1962 let "JAVA_PKG_QA_VIOLATIONS+=1"
1833 export JAVA_PKG_QA_VIOLATIONS 1963 export JAVA_PKG_QA_VIOLATIONS
1834} 1964}
1835 1965
1836is-java-strict() { 1966is-java-strict() {
1837 hasq java-strict ${FEATURES}; 1967 [[ -n ${JAVA_PKG_STRICT} ]]
1838 return $? 1968 return $?
1839} 1969}
1840 1970
1841# ------------------------------------------------------------------------------ 1971# ------------------------------------------------------------------------------
1842# @eclass-end 1972# @eclass-end

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

  ViewVC Help
Powered by ViewVC 1.1.20