/[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.19 Revision 1.33
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.33 2006/12/07 02:27:22 flameeyes 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
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#
287 cp "${original_jar}" "${new_jar_dest}" \ 290 cp "${original_jar}" "${new_jar_dest}" \
288 || die "Failed to copy ${original_jar} to ${new_jar_dest}" 291 || die "Failed to copy ${original_jar} to ${new_jar_dest}"
289 java-pkg_dojar "${new_jar_dest}" 292 java-pkg_dojar "${new_jar_dest}"
290} 293}
291 294
292
293# ------------------------------------------------------------------------------ 295# ------------------------------------------------------------------------------
294# @ebuild-function java-pkg_addcp 296# @ebuild-function java-pkg_addcp
295# 297#
296# Add something to the package's classpath. For jars, you should use dojar, 298# 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. 299# newjar, or regjar. This is typically used to add directories to the classpath.
301# ------------------------------------------------------------------------------ 303# ------------------------------------------------------------------------------
302java-pkg_addcp() { 304java-pkg_addcp() {
303 java-pkg_append_ JAVA_PKG_CLASSPATH "${@}" 305 java-pkg_append_ JAVA_PKG_CLASSPATH "${@}"
304 java-pkg_do_write_ 306 java-pkg_do_write_
305} 307}
306
307 308
308# ------------------------------------------------------------------------------ 309# ------------------------------------------------------------------------------
309# @ebuild-function java-pkg_doso 310# @ebuild-function java-pkg_doso
310# 311#
311# Installs any number of JNI libraries 312# Installs any number of JNI libraries
428# ------------------------------------------------------------------------------ 429# ------------------------------------------------------------------------------
429java-pkg_dohtml() { 430java-pkg_dohtml() {
430 debug-print-function ${FUNCNAME} $* 431 debug-print-function ${FUNCNAME} $*
431 432
432 [[ ${#} -lt 1 ]] && die "At least one argument required for ${FUNCNAME}" 433 [[ ${#} -lt 1 ]] && die "At least one argument required for ${FUNCNAME}"
433 # TODO-nichoj find out what exactly -f package-list does 434
435 # from /usr/lib/portage/bin/dohtml -h
436 # -f Set list of allowed extensionless file names.
434 dohtml -f package-list "$@" 437 dohtml -f package-list "$@"
438
435 # this probably shouldn't be here but it provides 439 # this probably shouldn't be here but it provides
436 # a reasonable way to catch # docs for all of the 440 # a reasonable way to catch # docs for all of the
437 # old ebuilds. 441 # old ebuilds.
438 java-pkg_recordjavadoc 442 java-pkg_recordjavadoc
439} 443}
440 444
441# TODO document 445# ------------------------------------------------------------------------------
446# @ebuild-function java-pkg_dojavadoc
447#
448# Installs javadoc documentation. This should be controlled by the doc use flag.
449#
450# @param $1: - The javadoc root directory.
451#
452# @example:
453# java-pkg_dojavadoc docs/api
454#
455# ------------------------------------------------------------------------------
442java-pkg_dojavadoc() { 456java-pkg_dojavadoc() {
443 local dir="$1" 457 local dir="$1"
444 458
445 java-pkg_check-phase install 459 java-pkg_check-phase install
446 460
518# @ebuild-function java-pkg_dolauncher 532# @ebuild-function java-pkg_dolauncher
519# 533#
520# Make a wrapper script to lauch/start this package 534# Make a wrapper script to lauch/start this package
521# If necessary, the wrapper will switch to the appropriate VM. 535# If necessary, the wrapper will switch to the appropriate VM.
522# 536#
537# Can be called without parameters if the package installs only one jar
538# that has the Main-class attribute set. The wrapper will be named ${PN}.
539#
523# @param $1 - filename of launcher to create 540# @param $1 - filename of launcher to create
524# @param $2 - options, as follows: 541# @param $2 - options, as follows:
525# --main the.main.class.too.start 542# --main the.main.class.too.start
526# --jar /the/jar/too/launch.jar 543# --jar /the/jar/too/launch.jar or just <name>.jar
527# --java_args 'Extra arguments to pass too jave' 544# --java_args 'Extra arguments to pass to java'
528# --pkg_args 'extra arguments too pass too the package' 545# --pkg_args 'Extra arguments too pass to the package'
529# --pwd 546# --pwd
530# -into 547# -into
531# -pre 548# -pre
532# ------------------------------------------------------------------------------ 549# ------------------------------------------------------------------------------
533java-pkg_dolauncher() { 550java-pkg_dolauncher() {
534 debug-print-function ${FUNCNAME} $* 551 debug-print-function ${FUNCNAME} $*
535 552
536 java-pkg_check-phase install 553 java-pkg_check-phase install
537
538 [[ ${#} -lt 1 ]] && die "Need at least one argument"
539
540 java-pkg_init_paths_ 554 java-pkg_init_paths_
541 555
556 if [[ ${#} = 0 ]]; then
557 local name="${PN}"
558 else
542 local name="${1}" 559 local name="${1}"
560 shift
561 fi
562
543 # TODO rename to launcher 563 # TODO rename to launcher
544 local target="${T}/${name}" 564 local target="${T}/${name}"
565 local var_tmp="${T}/launcher_variables_tmp"
545 local target_dir pre 566 local target_dir pre
546 shift
547 567
548 echo "#!/bin/bash" > "${target}" 568 # Process the other the rest of the arguments
549 while [[ -n "${1}" && -n "${2}" ]]; do 569 while [[ -n "${1}" && -n "${2}" ]]; do
550 local var=${1} value=${2} 570 local var=${1} value=${2}
551 if [[ "${var:0:2}" == "--" ]]; then 571 if [[ "${var:0:2}" == "--" ]]; then
572 local var=${var:2}
552 echo "gjl_${var:2}=\"${value}\"" >> "${target}" 573 echo "gjl_${var}=\"${value}\"" >> "${var_tmp}"
574 local gjl_${var}="${value}"
553 elif [[ "${var}" == "-into" ]]; then 575 elif [[ "${var}" == "-into" ]]; then
554 target_dir="${value}" 576 target_dir="${value}"
555 elif [[ "${var}" == "-pre" ]]; then 577 elif [[ "${var}" == "-pre" ]]; then
556 pre="${value}" 578 pre="${value}"
557 fi 579 fi
558 shift 2 580 shift 2
559 done 581 done
582
583 # Test if no --jar and --main arguments were given and
584 # in that case check if the package only installs one jar
585 # and use that jar.
586 if [[ -z "${gjl_jar}" && -z "${gjl_main}" ]]; then
587 local cp="${JAVA_PKG_CLASSPATH}"
588 if [[ "${cp/:}" = "${cp}" && "${cp%.jar}" != "${cp}" ]]; then
589 echo "gjl_jar=\"${JAVA_PKG_CLASSPATH}\"" >> "${var_tmp}"
590 else
591 local msg="Not enough information to create a launcher given."
592 msg="${msg} Please give --jar or --main argument to ${FUNCNAME}."
593 die "${msg}"
594 fi
595 fi
596
597 # Write the actual script
598 echo "#!/bin/bash" > "${target}"
599 [[ -n "${pre}" ]] && [[ -f "${pre}" ]] && cat "${pre}" >> "${target}"
560 echo "gjl_package=${JAVA_PKG_NAME}" >> "${target}" 600 echo "gjl_package=${JAVA_PKG_NAME}" >> "${target}"
561 [[ -n "${pre}" ]] && [[ -f "${pre}" ]] && cat "${pre}" >> "${target}" 601 cat "${var_tmp}" >> "${target}"
602 rm -f "${var_tmp}"
562 echo "source /usr/share/java-config-2/launcher/launcher.bash" >> "${target}" 603 echo "source /usr/share/java-config-2/launcher/launcher.bash" >> "${target}"
563 604
564 if [[ -n "${target_dir}" ]]; then 605 if [[ -n "${target_dir}" ]]; then
565 DESTTREE="${target_dir}" dobin "${target}" 606 DESTTREE="${target_dir}" dobin "${target}"
566 local ret=$? 607 local ret=$?
735# The providing packages are recorded as dependencies into package.env DEPEND 776# The providing packages are recorded as dependencies into package.env DEPEND
736# line, unless "--build-only" is passed as the very first argument, for jars 777# line, unless "--build-only" is passed as the very first argument, for jars
737# that have to be present only at build time and are not needed on runtime 778# that have to be present only at build time and are not needed on runtime
738# (junit testing etc). 779# (junit testing etc).
739# 780#
740# Example: Get the classpath for xerces-2, 781# Example: Get the classpath for xerces-2 and xalan,
741# java-pkg_getjars xerces-2 xalan 782# java-pkg_getjars xerces-2,xalan
742# Example Return: 783# Example Return:
743# /usr/share/xerces-2/lib/xml-apis.jar:/usr/share/xerces-2/lib/xmlParserAPIs.jar:/usr/share/xalan/lib/xalan.jar 784# /usr/share/xerces-2/lib/xml-apis.jar:/usr/share/xerces-2/lib/xmlParserAPIs.jar:/usr/share/xalan/lib/xalan.jar
744# 785#
745# @param $1 - (optional) "--build-only" makes the jar(s) not added into 786# @param $1 - (optional) "--build-only" makes the jar(s) not added into
746# package.env DEPEND line. 787# package.env DEPEND line.
747# @param $@ - list of packages to get jars from 788# @param $2 - list of packages to get jars from
789# (passed to java-config --classpath)
748# ------------------------------------------------------------------------------ 790# ------------------------------------------------------------------------------
749java-pkg_getjars() { 791java-pkg_getjars() {
750 debug-print-function ${FUNCNAME} $* 792 debug-print-function ${FUNCNAME} $*
751 793
752 local build_only="" 794 [[ ${#} -lt 1 || ${#} -gt 2 ]] && die "${FUNCNAME} takes only one or two arguments"
753 795
754 if [[ "${1}" = "--build-only" ]]; then 796 if [[ "${1}" = "--build-only" ]]; then
755 build_only="true" 797 local build_only="true"
756 shift 798 shift
757 fi 799 fi
758 800
759 [[ ${#} -lt 1 ]] && die "At least one argument needed"
760
761 # NOTE could probably just pass $@ to java-config --classpath. and return it
762 local classpath pkg 801 local classpath pkgs="${1}"
763 for pkg in ${@//,/ }; do
764 #for pkg in $(echo "$@" | tr ',' ' '); do
765 jars="$(java-config --classpath=${pkg})" 802 jars="$(java-config --classpath=${pkgs})"
766 [[ -z "${jars}" ]] && die "java-config --classpath=${pkg} failed" 803 [[ -z "${jars}" ]] && die "java-config --classpath=${pkgs} failed"
767 debug-print "${pkg}:${jars}" 804 debug-print "${pkgs}:${jars}"
768 805
769 if [[ -z "${classpath}" ]]; then 806 if [[ -z "${classpath}" ]]; then
770 classpath="${jars}" 807 classpath="${jars}"
771 else 808 else
772 classpath="${classpath}:${jars}" 809 classpath="${classpath}:${jars}"
773 fi 810 fi
811
774 # Only record jars that aren't build-only 812 # Only record jars that aren't build-only
775 [[ -z "${build_only}" ]] && java-pkg_record-jar_ "${pkg}" 813 if [[ -z "${build_only}" ]]; then
814 oldifs="${IFS}"
815 IFS=","
816 for pkg in ${pkgs}; do
817 java-pkg_record-jar_ "${pkg}"
776 done 818 done
819 IFS="${oldifs}"
820 fi
821
777 echo "${classpath}" 822 echo "${classpath}"
778} 823}
779 824
780# ------------------------------------------------------------------------------ 825# ------------------------------------------------------------------------------
781# @ebuild-function java-pkg_getjar 826# @ebuild-function java-pkg_getjar
1154} 1199}
1155 1200
1156java-pkg_get-javac() { 1201java-pkg_get-javac() {
1157 debug-print-function ${FUNCNAME} $* 1202 debug-print-function ${FUNCNAME} $*
1158 1203
1159 java-pkg_init-compiler_ 1204
1160 local compiler="${GENTOO_COMPILER}" 1205 local compiler="${GENTOO_COMPILER}"
1161 1206
1162 local compiler_executable 1207 local compiler_executable
1163 if [[ "${compiler}" = "javac" ]]; then 1208 if [[ "${compiler}" = "javac" ]]; then
1164 # nothing fancy needs to be done for javac 1209 # nothing fancy needs to be done for javac
1172 unset JAVAC 1217 unset JAVAC
1173 # try to get value of JAVAC 1218 # try to get value of JAVAC
1174 compiler_executable="$(source ${compiler_env} 1>/dev/null 2>&1; echo ${JAVAC})" 1219 compiler_executable="$(source ${compiler_env} 1>/dev/null 2>&1; echo ${JAVAC})"
1175 export JAVAC=${old_javac} 1220 export JAVAC=${old_javac}
1176 1221
1177 [[ -z ${compiler_executable} ]] && die "JAVAC is empty or undefined in ${compiler_env}" 1222 if [[ -z ${compiler_executable} ]]; then
1223 echo "JAVAC is empty or undefined in ${compiler_env}"
1224 return 1
1225 fi
1178 1226
1179 # check that it's executable 1227 # check that it's executable
1180 if [[ ! -x ${compiler_executable} ]]; then 1228 if [[ ! -x ${compiler_executable} ]]; then
1181 eerror "Could not find ${compiler_executable}!"
1182 die "${compiler_executable} doesn't exist, or isn't executable" 1229 echo "${compiler_executable} doesn't exist, or isn't executable"
1230 return 1
1183 fi 1231 fi
1184 else 1232 else
1185 eerror "Could not find environment file for ${compiler}" 1233 echo "Could not find environment file for ${compiler}"
1186 die "Could not find ${compiler_env}" 1234 return 1
1187 fi 1235 fi
1188 fi 1236 fi
1189 echo ${compiler_executable} 1237 echo ${compiler_executable}
1190} 1238}
1191 1239
1208 1256
1209 debug-print "want source: ${want_source}" 1257 debug-print "want source: ${want_source}"
1210 debug-print "want target: ${want_target}" 1258 debug-print "want target: ${want_target}"
1211 1259
1212 if [[ -z "${want_source}" || -z "${want_target}" ]]; then 1260 if [[ -z "${want_source}" || -z "${want_target}" ]]; then
1213 debug-print "could not find valid -source/-target values" 1261 debug-print "could not find valid -source/-target values for javac"
1214 die "Could not find valid -source/-target values" 1262 echo "Could not find valid -source/-target values for javac"
1263 return 1
1215 else 1264 else
1216 if java-pkg_is-vm-version-ge "1.4"; then 1265 if java-pkg_is-vm-version-ge "1.4"; then
1217 echo "${source_str} ${target_str}" 1266 echo "${source_str} ${target_str}"
1218 else 1267 else
1219 echo "${target_str}" 1268 echo "${target_str}"
1223 1272
1224# TODO document 1273# TODO document
1225java-pkg_get-jni-cflags() { 1274java-pkg_get-jni-cflags() {
1226 local flags="-I${JAVA_HOME}/include" 1275 local flags="-I${JAVA_HOME}/include"
1227 1276
1277 local platform="linux"
1278 use elibc_FreeBSD && platform="freebsd"
1279
1228 # TODO do a check that the directories are valid 1280 # TODO do a check that the directories are valid
1229 # TODO figure out how to cope with other things than linux...
1230 flags="${flags} -I${JAVA_HOME}/include/linux" 1281 flags="${flags} -I${JAVA_HOME}/include/${platform}"
1231 1282
1232 echo ${flags} 1283 echo ${flags}
1233} 1284}
1234 1285
1235java-pkg_ensure-gcj() { 1286java-pkg_ensure-gcj() {
1324# @param $@ - Arguments to be passed to the compiler 1375# @param $@ - Arguments to be passed to the compiler
1325# ------------------------------------------------------------------------------ 1376# ------------------------------------------------------------------------------
1326ejavac() { 1377ejavac() {
1327 debug-print-function ${FUNCNAME} $* 1378 debug-print-function ${FUNCNAME} $*
1328 1379
1329 # FIXME using get-javac ends up printing stuff with einfo 1380 java-pkg_init-compiler_
1381
1382 local compiler_executable
1330# local compiler_executable=$(java-pkg_get-javac) 1383 compiler_executable=$(java-pkg_get-javac)
1331 local compiler_executable="javac" 1384 if [[ ${?} != 0 ]]; then
1385 eerror "There was a problem determining compiler: ${compiler_executable}"
1386 die "get-javac failed"
1387 fi
1332 1388
1389 local javac_args
1390 javac_args="$(java-pkg_javac-args)"
1391 if [[ ${?} != 0 ]]; then
1392 eerror "There was a problem determining JAVACFLAGS: ${javac_args}"
1393 die "java-pkg_javac-args failed"
1394 fi
1395
1333 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ${compiler_executable} $(java-pkg_javac-args) "${@}" 1396 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ${compiler_executable} ${javac_args} "${@}"
1334 ${compiler_executable} $(java-pkg_javac-args) "${@}" || die "ejavac failed" 1397 ${compiler_executable} ${javac_args} "${@}" || die "ejavac failed"
1335} 1398}
1336 1399
1337# ------------------------------------------------------------------------------ 1400# ------------------------------------------------------------------------------
1338# @ebuild-function java-pkg_filter-compiler 1401# @ebuild-function java-pkg_filter-compiler
1339# 1402#
1571# Writes the package.env out to disk. 1634# Writes the package.env out to disk.
1572# 1635#
1573# ------------------------------------------------------------------------------ 1636# ------------------------------------------------------------------------------
1574# TODO change to do-write, to match everything else 1637# TODO change to do-write, to match everything else
1575java-pkg_do_write_() { 1638java-pkg_do_write_() {
1639 java-pkg_init_paths_
1576 # Create directory for package.env 1640 # Create directory for package.env
1577 dodir "${JAVA_PKG_SHAREPATH}" 1641 dodir "${JAVA_PKG_SHAREPATH}"
1578 if [[ -n "${JAVA_PKG_CLASSPATH}" || -n "${JAVA_PKG_LIBRARY}" || -f "${JAVA_PKG_DEPEND}" ]]; then 1642 if [[ -n "${JAVA_PKG_CLASSPATH}" || -n "${JAVA_PKG_LIBRARY}" || -f "${JAVA_PKG_DEPEND}" ]]; then
1579 # Create package.env 1643 # Create package.env
1580 ( 1644 (
1608 # Strip unnecessary leading and trailing colons 1672 # Strip unnecessary leading and trailing colons
1609 # TODO try to cleanup if possible 1673 # TODO try to cleanup if possible
1610 sed -e "s/=\":/=\"/" -e "s/:\"$/\"/" -i "${JAVA_PKG_ENV}" || die "Did you forget to call java_init ?" 1674 sed -e "s/=\":/=\"/" -e "s/:\"$/\"/" -i "${JAVA_PKG_ENV}" || die "Did you forget to call java_init ?"
1611 fi 1675 fi
1612} 1676}
1613
1614 1677
1615# ------------------------------------------------------------------------------ 1678# ------------------------------------------------------------------------------
1616# @internal-function java-pkg_record-jar_ 1679# @internal-function java-pkg_record-jar_
1617# 1680#
1618# Record a dependency to the package.env 1681# Record a dependency to the package.env
1699# ------------------------------------------------------------------------------ 1762# ------------------------------------------------------------------------------
1700java-pkg_setup-vm() { 1763java-pkg_setup-vm() {
1701 debug-print-function ${FUNCNAME} $* 1764 debug-print-function ${FUNCNAME} $*
1702 1765
1703 local vendor="$(java-pkg_get-vm-vendor)" 1766 local vendor="$(java-pkg_get-vm-vendor)"
1704 if [[ "${vendor}" == "sun" ]] && java-pkg_is-vm-version-ge 1 5; then 1767 if [[ "${vendor}" == "sun" ]] && java-pkg_is-vm-version-ge "1.5" ; then
1705 addpredict "/dev/random" 1768 addpredict "/dev/random"
1706 elif [[ "${vendor}" == "ibm" ]]; then 1769 elif [[ "${vendor}" == "ibm" ]]; then
1707 addpredict "/proc/self/maps" 1770 addpredict "/proc/self/maps"
1708 addpredict "/proc/cpuinfo" 1771 addpredict "/proc/cpuinfo"
1709 export LANG="C" LC_ALL="C" 1772 export LANG="C" LC_ALL="C"
1758# @return - The version of the current VM 1821# @return - The version of the current VM
1759# ------------------------------------------------------------------------------ 1822# ------------------------------------------------------------------------------
1760java-pkg_get-vm-version() { 1823java-pkg_get-vm-version() {
1761 debug-print-function ${FUNCNAME} $* 1824 debug-print-function ${FUNCNAME} $*
1762 1825
1763 java-pkg_get-current-vm | sed -e "s/.*-\([0-9.]\+\).*/\1/" 1826 java-config -g PROVIDES_VERSION
1764} 1827}
1765 1828
1766# ------------------------------------------------------------------------------ 1829# ------------------------------------------------------------------------------
1767# @internal-function java-pkg_switch-vm 1830# @internal-function java-pkg_switch-vm
1768# 1831#
1778 export GENTOO_VM="${JAVA_PKG_FORCE_VM}" 1841 export GENTOO_VM="${JAVA_PKG_FORCE_VM}"
1779 # if we're allowed to switch the vm... 1842 # if we're allowed to switch the vm...
1780 elif [[ "${JAVA_PKG_ALLOW_VM_CHANGE}" == "yes" ]]; then 1843 elif [[ "${JAVA_PKG_ALLOW_VM_CHANGE}" == "yes" ]]; then
1781 debug-print "depend-java-query: NV_DEPEND: ${JAVA_PKG_NV_DEPEND:-${DEPEND}} VNEED: ${JAVA_PKG_VNEED}" 1844 debug-print "depend-java-query: NV_DEPEND: ${JAVA_PKG_NV_DEPEND:-${DEPEND}} VNEED: ${JAVA_PKG_VNEED}"
1782 if [[ -n ${JAVA_PKG_VNEED} ]]; then 1845 if [[ -n ${JAVA_PKG_VNEED} ]]; then
1783 export GENTOO_VM="$(depend-java-query --need-virtual "${JAVA_PKG_VNEED}" --get-vm "${JAVA_PKG_NV_DEPEND:-${DEPEND}}")" 1846 GENTOO_VM="$(depend-java-query --need-virtual "${JAVA_PKG_VNEED}" --get-vm "${JAVA_PKG_NV_DEPEND:-${DEPEND}}")"
1784 else 1847 else
1785 export GENTOO_VM="$(depend-java-query --get-vm "${JAVA_PKG_NV_DEPEND:-${DEPEND}}")" 1848 GENTOO_VM="$(depend-java-query --get-vm "${JAVA_PKG_NV_DEPEND:-${DEPEND}}")"
1849 fi
1850 if [[ -z "${GENTOO_VM}" || "${GENTOO_VM}" == "None" ]]; then
1851 eerror "Unable to determine VM for building from dependencies:"
1852 echo "NV_DEPEND: ${JAVA_PKG_NV_DEPEND:-${DEPEND}}"
1853 echo "VNEED: ${JAVA_PKG_VNEED}"
1854 die "Failed to determine VM for building."
1855 else
1856 export GENTOO_VM
1786 fi 1857 fi
1787 # otherwise just make sure the current VM is sufficient 1858 # otherwise just make sure the current VM is sufficient
1788 else 1859 else
1789 java-pkg_ensure-vm-version-sufficient 1860 java-pkg_ensure-vm-version-sufficient
1790 fi 1861 fi
1792 1863
1793 java-pkg_setup-vm 1864 java-pkg_setup-vm
1794 1865
1795 export JAVA=$(java-config --java) 1866 export JAVA=$(java-config --java)
1796 export JAVAC=$(java-config --javac) 1867 export JAVAC=$(java-config --javac)
1797 export JAVACFLAGS="$(java-pkg_javac-args)" 1868 JAVACFLAGS="$(java-pkg_javac-args)"
1869 if [[ ${?} != 0 ]]; then
1870 eerror "There was a problem determining JAVACFLAGS: ${JAVACFLAGS}"
1871 die "java-pkg_javac-args failed"
1872 fi
1798 [[ -n ${JAVACFLAGS_EXTRA} ]] && export JAVACFLAGS="${JAVACFLAGS_EXTRA} ${JAVACFLAGS}" 1873 [[ -n ${JAVACFLAGS_EXTRA} ]] && JAVACFLAGS="${JAVACFLAGS_EXTRA} ${JAVACFLAGS}"
1874 export JAVACFLAGS
1799 1875
1800 export JAVA_HOME="$(java-config -g JAVA_HOME)" 1876 export JAVA_HOME="$(java-config -g JAVA_HOME)"
1801 export JDK_HOME=${JAVA_HOME} 1877 export JDK_HOME=${JAVA_HOME}
1802 1878
1803 #TODO If you know a better solution let us know. 1879 #TODO If you know a better solution let us know.
1865 ewarn "Possible problem" 1941 ewarn "Possible problem"
1866 die "Bad class files found" 1942 die "Bad class files found"
1867 fi 1943 fi
1868} 1944}
1869 1945
1870
1871# ------------------------------------------------------------------------------ 1946# ------------------------------------------------------------------------------
1872# @section-end internal 1947# @section-end internal
1873# ------------------------------------------------------------------------------ 1948# ------------------------------------------------------------------------------
1874 1949
1875java-pkg_check-phase() { 1950java-pkg_check-phase() {

Legend:
Removed from v.1.19  
changed lines
  Added in v.1.33

  ViewVC Help
Powered by ViewVC 1.1.20