/[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.75 Revision 1.101
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.75 2007/04/20 16:13:46 betelgeuse Exp $ 9# $Header: /var/cvsroot/gentoo-x86/eclass/java-utils-2.eclass,v 1.101 2008/01/12 15:03:13 caster Exp $
10
11 10
12# ----------------------------------------------------------------------------- 11# -----------------------------------------------------------------------------
13# @eclass-begin 12# @eclass-begin
14# @eclass-shortdesc Java Utility eclass 13# @eclass-shortdesc Java Utility eclass
15# @eclass-maintainer java@gentoo.org 14# @eclass-maintainer java@gentoo.org
58#WANT_ANT_TASKS 57#WANT_ANT_TASKS
59 58
60# ----------------------------------------------------------------------------- 59# -----------------------------------------------------------------------------
61# @variable-internal JAVA_PKG_PORTAGE_DEP 60# @variable-internal JAVA_PKG_PORTAGE_DEP
62# 61#
63# The version of portage we need to function properly. At this moment it's 62# The version of portage we need to function properly. Previously it was
64# portage with phase hooks support. 63# portage with phase hooks support but now we use a version with proper env
64# saving.
65# ----------------------------------------------------------------------------- 65# -----------------------------------------------------------------------------
66JAVA_PKG_PORTAGE_DEP=">=sys-apps/portage-2.1_pre1" 66JAVA_PKG_PORTAGE_DEP=">=sys-apps/portage-2.1.2.7"
67 67
68# ----------------------------------------------------------------------------- 68# -----------------------------------------------------------------------------
69# @variable-internal JAVA_PKG_E_DEPEND 69# @variable-internal JAVA_PKG_E_DEPEND
70# 70#
71# This is a convience variable to be used from the other java eclasses. This is 71# This is a convience variable to be used from the other java eclasses. This is
72# the version of java-config we want to use. We also need a recent version 72# the version of java-config we want to use. Usually the latest stable version
73# portage, that includes phase hooks. 73# so that ebuilds can use new features without depending on specific versions.
74# ----------------------------------------------------------------------------- 74# -----------------------------------------------------------------------------
75JAVA_PKG_E_DEPEND=">=dev-java/java-config-2.0.31 ${JAVA_PKG_PORTAGE_DEP}" 75JAVA_PKG_E_DEPEND=">=dev-java/java-config-2.0.33-r1 ${JAVA_PKG_PORTAGE_DEP}"
76hasq source ${JAVA_PKG_IUSE} && JAVA_PKG_E_DEPEND="${JAVA_PKG_E_DEPEND} source? ( app-arch/zip )"
76 77
77# ----------------------------------------------------------------------------- 78# -----------------------------------------------------------------------------
78# @variable-external JAVA_PKG_ALLOW_VM_CHANGE 79# @variable-external JAVA_PKG_ALLOW_VM_CHANGE
79# @variable-default yes 80# @variable-default yes
80# 81#
195# 196#
196# @example 197# @example
197# java-pkg_doexamples demo 198# java-pkg_doexamples demo
198# java-pkg_doexamples demo/* examples/* 199# java-pkg_doexamples demo/* examples/*
199# 200#
201# @param --subdir - If the examples need a certain directory structure
200# @param $* - list of files to install 202# @param $* - list of files to install
201# ------------------------------------------------------------------------------ 203# ------------------------------------------------------------------------------
202java-pkg_doexamples() { 204java-pkg_doexamples() {
203 debug-print-function ${FUNCNAME} $* 205 debug-print-function ${FUNCNAME} $*
204 206
205 [[ ${#} -lt 1 ]] && die "At least one argument needed" 207 [[ ${#} -lt 1 ]] && die "At least one argument needed"
206 208
207 java-pkg_check-phase install 209 java-pkg_check-phase install
208 210
209 local dest=/usr/share/doc/${PF}/examples 211 local dest=/usr/share/doc/${PF}/examples
212 if [[ ${1} == --subdir ]]; then
213 local dest=${dest}/${2}
214 dodir ${dest}
215 shift 2
216 fi
217
210 if [[ ${#} = 1 && -d ${1} ]]; then 218 if [[ ${#} = 1 && -d ${1} ]]; then
211 ( # dont want to pollute calling env 219 ( # dont want to pollute calling env
212 insinto "${dest}" 220 insinto "${dest}"
213 doins -r ${1}/* 221 doins -r ${1}/*
214 ) || die "Installing examples failed" 222 ) || die "Installing examples failed"
549# ------------------------------------------------------------------------------ 557# ------------------------------------------------------------------------------
550# @ebuild-function java-pkg_dojavadoc 558# @ebuild-function java-pkg_dojavadoc
551# 559#
552# Installs javadoc documentation. This should be controlled by the doc use flag. 560# Installs javadoc documentation. This should be controlled by the doc use flag.
553# 561#
562# @param $1: optional --symlink creates to symlink like this for html
563# documentation bundles.
554# @param $1: - The javadoc root directory. 564# @param $2: - The javadoc root directory.
555# 565#
556# @example: 566# @example:
557# java-pkg_dojavadoc docs/api 567# java-pkg_dojavadoc docs/api
568# java-pkg_dojavadoc --symlink apidocs docs/api
558# 569#
559# ------------------------------------------------------------------------------ 570# ------------------------------------------------------------------------------
560java-pkg_dojavadoc() { 571java-pkg_dojavadoc() {
561 debug-print-function ${FUNCNAME} $* 572 debug-print-function ${FUNCNAME} $*
573
574 # For html documentation bundles that link to Javadoc
575 local symlink
576 if [[ ${1} = --symlink ]]; then
577 symlink=${2}
578 shift 2
579 fi
580
562 local dir="$1" 581 local dir="$1"
582 local dest=/usr/share/doc/${PF}/html
563 583
564 # QA checks 584 # QA checks
565 585
566 java-pkg_check-phase install 586 java-pkg_check-phase install
567 587
571 local msg="No index.html in javadoc directory" 591 local msg="No index.html in javadoc directory"
572 ewarn "${msg}" 592 ewarn "${msg}"
573 is-java-strict && die "${msg}" 593 is-java-strict && die "${msg}"
574 fi 594 fi
575 595
596 if [[ -e ${D}/${dest}/api ]]; then
597 eerror "${dest} already exists. Will not overwrite."
598 die "${dest}"
599 fi
600
576 # Renaming to match our directory layout 601 # Renaming to match our directory layout
577 602
578 local dir_to_install="${dir}" 603 local dir_to_install="${dir}"
579 if [[ "$(basename "${dir}")" != "api" ]]; then 604 if [[ "$(basename "${dir}")" != "api" ]]; then
580 dir_to_install="${T}/api" 605 dir_to_install="${T}/api"
582 cp -r "${dir}" "${dir_to_install}" || die "cp failed" 607 cp -r "${dir}" "${dir_to_install}" || die "cp failed"
583 fi 608 fi
584 609
585 # Actual installation 610 # Actual installation
586 611
587 java-pkg_dohtml -r ${dir_to_install} 612 java-pkg_dohtml -r "${dir_to_install}"
613
614 # Let's make a symlink to the directory we have everything else under
615 dosym ${dest}/api "${JAVA_PKG_SHAREPATH}/api" || die
616
617 if [[ ${symlink} ]]; then
618 dosym ${dest}/{api,${symlink}} || die
619 fi
588} 620}
589 621
590# ------------------------------------------------------------------------------ 622# ------------------------------------------------------------------------------
591# @ebuild-function java-pkg_dosrc 623# @ebuild-function java-pkg_dosrc
592# 624#
831# @param $opt 863# @param $opt
832# --build-only - makes the jar(s) not added into package.env DEPEND line. 864# --build-only - makes the jar(s) not added into package.env DEPEND line.
833# (assumed automatically when called inside src_test) 865# (assumed automatically when called inside src_test)
834# --with-dependencies - get jars also from requested package's dependencies 866# --with-dependencies - get jars also from requested package's dependencies
835# transitively. 867# transitively.
868# --virtual - Packages passed to this function are to be handled as virtuals
869# and will not have individual jar dependencies recorded.
836# --into $dir - symlink jar(s) into $dir (must exist) instead of . 870# --into $dir - symlink jar(s) into $dir (must exist) instead of .
837# @param $1 - Package to get jars from. 871# @param $1 - Package to get jars from, or comma-separated list of packages in
872# case other parameters are not used.
838# @param $2 - jar from package. If not specified, all jars will be used. 873# @param $2 - jar from package. If not specified, all jars will be used.
839# @param $3 - When a single jar is specified, destination filename of the 874# @param $3 - When a single jar is specified, destination filename of the
840# symlink. Defaults to the name of the jar. 875# symlink. Defaults to the name of the jar.
841# ------------------------------------------------------------------------------ 876# ------------------------------------------------------------------------------
842# TODO could probably be cleaned up a little 877# TODO could probably be cleaned up a little
844 debug-print-function ${FUNCNAME} $* 879 debug-print-function ${FUNCNAME} $*
845 880
846 local build_only="" 881 local build_only=""
847 local destdir="." 882 local destdir="."
848 local deep="" 883 local deep=""
884 local virtual=""
849 885
850 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="true" 886 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="build"
851 887
852 while [[ "${1}" == --* ]]; do 888 while [[ "${1}" == --* ]]; do
853 if [[ "${1}" = "--build-only" ]]; then 889 if [[ "${1}" = "--build-only" ]]; then
854 build_only="true" 890 build_only="build"
855 elif [[ "${1}" = "--with-dependencies" ]]; then 891 elif [[ "${1}" = "--with-dependencies" ]]; then
856 deep="--with-dependencies" 892 deep="--with-dependencies"
893 elif [[ "${1}" = "--virtual" ]]; then
894 virtual="true"
857 elif [[ "${1}" = "--into" ]]; then 895 elif [[ "${1}" = "--into" ]]; then
858 destdir="${2}" 896 destdir="${2}"
859 shift 897 shift
860 else 898 else
861 die "java-pkg_jar-from called with unknown parameter: ${1}" 899 die "java-pkg_jar-from called with unknown parameter: ${1}"
873 local error_msg="There was a problem getting the classpath for ${target_pkg}." 911 local error_msg="There was a problem getting the classpath for ${target_pkg}."
874 local classpath 912 local classpath
875 classpath="$(java-config ${deep} --classpath=${target_pkg})" 913 classpath="$(java-config ${deep} --classpath=${target_pkg})"
876 [[ $? != 0 ]] && die ${error_msg} 914 [[ $? != 0 ]] && die ${error_msg}
877 915
916 # When we have commas this functions is called to bring jars from multiple
917 # packages. This affects recording of dependencencies performed later
918 # which expects one package only, so we do it here.
919 if [[ ${target_pkg} = *,* ]]; then
920 for pkg in ${target_pkg//,/ }; do
921 java-pkg_ensure-dep "${build_only}" "${pkg}"
922 [[ -z "${build_only}" ]] && java-pkg_record-jar_ "${pkg}"
923 done
924 # setting this disables further record-jar_ calls later
925 build_only="build"
926 else
878 java-pkg_ensure-dep "${build_only}" "${target_pkg}" 927 java-pkg_ensure-dep "${build_only}" "${target_pkg}"
928 fi
929
930 # Record the entire virtual as a dependency so that
931 # no jars are missed.
932 if [[ -z "${build_only}" && -n "${virtual}" ]]; then
933 java-pkg_record-jar_ "${target_pkg}"
934 # setting this disables further record-jars_ calls later
935 build_only="build"
936 fi
879 937
880 pushd ${destdir} > /dev/null \ 938 pushd ${destdir} > /dev/null \
881 || die "failed to change directory to ${destdir}" 939 || die "failed to change directory to ${destdir}"
882
883 # When we have commas this functions is called to bring jars from multiple
884 # packages. This affects recording of dependencencies because that syntax uses :
885 # if we don't change them to : gjl and java-config -d -p break
886 if [[ ${target_pkg} = *,* ]]; then
887 build_only="true"
888 java-pkg_record-jar_ ${target_pkg//,/:}
889 fi
890 940
891 local jar 941 local jar
892 for jar in ${classpath//:/ }; do 942 for jar in ${classpath//:/ }; do
893 local jar_name=$(basename "${jar}") 943 local jar_name=$(basename "${jar}")
894 if [[ ! -f "${jar}" ]] ; then 944 if [[ ! -f "${jar}" ]] ; then
957 debug-print-function ${FUNCNAME} $* 1007 debug-print-function ${FUNCNAME} $*
958 1008
959 local build_only="" 1009 local build_only=""
960 local deep="" 1010 local deep=""
961 1011
962 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="true" 1012 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="build"
963 1013
964 while [[ "${1}" == --* ]]; do 1014 while [[ "${1}" == --* ]]; do
965 if [[ "${1}" = "--build-only" ]]; then 1015 if [[ "${1}" = "--build-only" ]]; then
966 build_only="true" 1016 build_only="build"
967 elif [[ "${1}" = "--with-dependencies" ]]; then 1017 elif [[ "${1}" = "--with-dependencies" ]]; then
968 deep="--with-dependencies" 1018 deep="--with-dependencies"
969 else 1019 else
970 die "java-pkg_jar-from called with unknown parameter: ${1}" 1020 die "java-pkg_jar-from called with unknown parameter: ${1}"
971 fi 1021 fi
990 classpath="${classpath}:${jars}" 1040 classpath="${classpath}:${jars}"
991 fi 1041 fi
992 1042
993 # Only record jars that aren't build-only 1043 # Only record jars that aren't build-only
994 if [[ -z "${build_only}" ]]; then 1044 if [[ -z "${build_only}" ]]; then
995 oldifs="${IFS}"
996 IFS=","
997 for pkg in ${pkgs}; do 1045 for pkg in ${pkgs//,/ }; do
998 java-pkg_record-jar_ "${pkg}" 1046 java-pkg_record-jar_ "${pkg}"
999 done 1047 done
1000 IFS="${oldifs}"
1001 fi 1048 fi
1002 1049
1003 echo "${classpath}" 1050 echo "${classpath}"
1004} 1051}
1005 1052
1017# @example-return 1064# @example-return
1018# /usr/share/xerces-2/lib/xml-apis.jar 1065# /usr/share/xerces-2/lib/xml-apis.jar
1019# 1066#
1020# @param $opt 1067# @param $opt
1021# --build-only - makes the jar not added into package.env DEPEND line. 1068# --build-only - makes the jar not added into package.env DEPEND line.
1069# --virtual - Packages passed to this function are to be handled as virtuals
1070# and will not have individual jar dependencies recorded.
1022# @param $1 - package to use 1071# @param $1 - package to use
1023# @param $2 - jar to get 1072# @param $2 - jar to get
1024# ------------------------------------------------------------------------------ 1073# ------------------------------------------------------------------------------
1025java-pkg_getjar() { 1074java-pkg_getjar() {
1026 debug-print-function ${FUNCNAME} $* 1075 debug-print-function ${FUNCNAME} $*
1027 1076
1028 local build_only="" 1077 local build_only=""
1078 local virtual=""
1029 1079
1030 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="true" 1080 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="build"
1031 1081
1032 while [[ "${1}" == --* ]]; do 1082 while [[ "${1}" == --* ]]; do
1033 if [[ "${1}" = "--build-only" ]]; then 1083 if [[ "${1}" = "--build-only" ]]; then
1034 build_only="true" 1084 build_only="build"
1085 elif [[ "${1}" == "--virtual" ]]; then
1086 virtual="true"
1035 else 1087 else
1036 die "java-pkg_jar-from called with unknown parameter: ${1}" 1088 die "java-pkg_jar-from called with unknown parameter: ${1}"
1037 fi 1089 fi
1038 shift 1090 shift
1039 done 1091 done
1048 local classpath 1100 local classpath
1049 classpath=$(java-config --classpath=${pkg}) 1101 classpath=$(java-config --classpath=${pkg})
1050 [[ $? != 0 ]] && die ${error_msg} 1102 [[ $? != 0 ]] && die ${error_msg}
1051 1103
1052 java-pkg_ensure-dep "${build_only}" "${pkg}" 1104 java-pkg_ensure-dep "${build_only}" "${pkg}"
1105
1106 # Record the package(Virtual) as a dependency and then set build_only
1107 # So that individual jars are not recorded.
1108 if [[ -n "${virtual}" ]]; then
1109 java-pkg_record-jar_ "${pkg}"
1110 build_only="true"
1111 fi
1053 1112
1054 for jar in ${classpath//:/ }; do 1113 for jar in ${classpath//:/ }; do
1055 if [[ ! -f "${jar}" ]] ; then 1114 if [[ ! -f "${jar}" ]] ; then
1056 die "Installation problem with jar ${jar} in ${pkg} - is it installed?" 1115 die "Installation problem with jar ${jar} in ${pkg} - is it installed?"
1057 fi 1116 fi
1064 fi 1123 fi
1065 done 1124 done
1066 1125
1067 die "Could not find ${target_jar} in ${pkg}" 1126 die "Could not find ${target_jar} in ${pkg}"
1068 return 1 1127 return 1
1128}
1129
1130# ------------------------------------------------------------------------------
1131# @ebuild-function java-pkg_register-dependency
1132#
1133# Registers runtime dependency on a package, list of packages, or a single jar
1134# from a package, into package.env DEPEND line. Can only be called in
1135# src_install phase.
1136# Intended for binary packages where you don't need to symlink the jars or get
1137# their classpath during build. As such, the dependencies only need to be
1138# specified in ebuild's RDEPEND, and should be omitted in DEPEND.
1139#
1140# @param $1 - comma-separated list of packages, or a single package
1141# @param $2 - if param $1 is a single package, optionally specify the jar
1142# to depend on
1143#
1144# Example: Record the dependency on whole xerces-2 and xalan,
1145# java-pkg_register-dependency xerces-2,xalan
1146# Example: Record the dependency on ant.jar from ant-core
1147# java-pkg_register-dependency ant-core ant.jar
1148#
1149# Note: Passing both list of packages as the first parameter AND specifying the
1150# jar as the second is not allowed and will cause the function to die. We assume
1151# that there's more chance one passes such combination as a mistake, than that
1152# there are more packages providing identically named jar without class
1153# collisions.
1154# ------------------------------------------------------------------------------
1155java-pkg_register-dependency() {
1156 debug-print-function ${FUNCNAME} $*
1157
1158 java-pkg_check-phase install
1159
1160 [[ ${#} -gt 2 ]] && die "${FUNCNAME} takes at most two arguments"
1161
1162 local pkgs="${1}"
1163 local jar="${2}"
1164
1165 [[ -z "${pkgs}" ]] && die "${FUNCNAME} called with no package(s) specified"
1166
1167 if [[ -z "${jar}" ]]; then
1168 for pkg in ${pkgs//,/ }; do
1169 java-pkg_ensure-dep runtime "${pkg}"
1170 java-pkg_record-jar_ "${pkg}"
1171 done
1172 else
1173 [[ ${pkgs} == *,* ]] && \
1174 die "${FUNCNAME} called with both package list and jar name"
1175 java-pkg_ensure-dep runtime "${pkgs}"
1176 java-pkg_record-jar_ "${pkgs}" "${jar}"
1177 fi
1178
1179 java-pkg_do_write_
1180}
1181
1182# ------------------------------------------------------------------------------
1183# @ebuild-function java-pkg_register-optional-dependency
1184#
1185# Registers optional runtime dependency on a package, list of packages, or a
1186# single jar from a package, into package.env OPTIONAL_DEPEND line. Can only be
1187# called in src_install phase.
1188# Intended for packages that can use other packages when those are in classpath.
1189# Will be put on classpath by launcher if they are installed. Typical case is
1190# JDBC implementations for various databases. It's better than having USE flag
1191# for each implementation triggering hard dependency.
1192#
1193# @param $1 - comma-separated list of packages, or a single package
1194# @param $2 - if param $1 is a single package, optionally specify the jar
1195# to depend on
1196#
1197# Example: Record the optional dependency on some jdbc providers
1198# java-pkg_register-optional-dependency jdbc-jaybird,jtds-1.2,jdbc-mysql
1199#
1200# Note: Passing both list of packages as the first parameter AND specifying the
1201# jar as the second is not allowed and will cause the function to die. We assume
1202# that there's more chance one passes such combination as a mistake, than that
1203# there are more packages providing identically named jar without class
1204# collisions.
1205# ------------------------------------------------------------------------------
1206java-pkg_register-optional-dependency() {
1207 debug-print-function ${FUNCNAME} $*
1208
1209 java-pkg_check-phase install
1210
1211 [[ ${#} -gt 2 ]] && die "${FUNCNAME} takes at most two arguments"
1212
1213 local pkgs="${1}"
1214 local jar="${2}"
1215
1216 [[ -z "${pkgs}" ]] && die "${FUNCNAME} called with no package(s) specified"
1217
1218 if [[ -z "${jar}" ]]; then
1219 for pkg in ${pkgs//,/ }; do
1220 java-pkg_record-jar_ --optional "${pkg}"
1221 done
1222 else
1223 [[ ${pkgs} == *,* ]] && \
1224 die "${FUNCNAME} called with both package list and jar name"
1225 java-pkg_record-jar_ --optional "${pkgs}" "${jar}"
1226 fi
1227
1228 java-pkg_do_write_
1229}
1230
1231# ------------------------------------------------------------------------------
1232# @ebuild-function java-pkg_register-environment-variable
1233#
1234# Register an arbitrary environment variable into package.env. The gjl launcher
1235# for this package or any package depending on this will export it into
1236# environement before executing java command.
1237# Must only be called in src_install phase.
1238#
1239# @param $1 - variable name
1240# @param $2 - variable value
1241# ------------------------------------------------------------------------------
1242JAVA_PKG_EXTRA_ENV="${T}/java-pkg-extra-env"
1243JAVA_PKG_EXTRA_ENV_VARS=""
1244java-pkg_register-environment-variable() {
1245 debug-print-function ${FUNCNAME} $*
1246
1247 java-pkg_check-phase install
1248
1249 [[ ${#} != 2 ]] && die "${FUNCNAME} takes two arguments"
1250
1251 echo "${1}=\"${2}\"" >> ${JAVA_PKG_EXTRA_ENV}
1252 JAVA_PKG_EXTRA_ENV_VARS="${JAVA_PKG_EXTRA_ENV_VARS} ${1}"
1253
1254 java-pkg_do_write_
1069} 1255}
1070 1256
1071# This function reads stdin, and based on that input, figures out how to 1257# This function reads stdin, and based on that input, figures out how to
1072# populate jars from the filesystem. 1258# populate jars from the filesystem.
1073# Need to figure out a good way of making use of this, ie be able to use a 1259# Need to figure out a good way of making use of this, ie be able to use a
1561 [[ "${ant}" == "dev-java/ant" ]] && found_ant=true 1747 [[ "${ant}" == "dev-java/ant" ]] && found_ant=true
1562 [[ "${dep}" == *"ant-tasks"* ]] && found_ant_tasks=true 1748 [[ "${dep}" == *"ant-tasks"* ]] && found_ant_tasks=true
1563 done 1749 done
1564 1750
1565 if [[ -n "${found_ant}" || -n "${found_ant_tasks}" ]]; then 1751 if [[ -n "${found_ant}" || -n "${found_ant_tasks}" ]]; then
1566 java-pkg_announce-qa-violation "The ebuild DEPENDS on deprecated ant or ant-tasks" 1752 java-pkg_announce-qa-violation --nodie "The ebuild DEPENDS on deprecated ant or ant-tasks"
1567 echo "all" 1753 echo "all"
1568 else 1754 else
1569 # ebuild doesn't set ANT_TASKS and doesn't depend on ant-tasks or ant 1755 # ebuild doesn't set ANT_TASKS and doesn't depend on ant-tasks or ant
1570 # so we deactivate all tasks that may be installed 1756 # so we deactivate all tasks that may be installed
1571 echo "none" 1757 echo "none"
1596 return 0 1782 return 0
1597 fi 1783 fi
1598} 1784}
1599 1785
1600# ------------------------------------------------------------------------------ 1786# ------------------------------------------------------------------------------
1787# @ebuild-function ejunit
1788#
1789# Junit wrapper function. Makes it easier to run the tests and checks for
1790# dev-java/junit in DEPEND. Launches the tests using junit.textui.TestRunner.
1791#
1792# Examples:
1793# ejunit -cp build/classes org.blinkenlights.jid3.test.AllTests
1794# ejunit org.blinkenlights.jid3.test.AllTests
1795#
1796# @param $1 - -cp or -classpath
1797# @param $2 - classpath; junit and recorded dependencies get appended
1798# @param $@ - the rest of the parameters are passed to java
1799# ------------------------------------------------------------------------------
1800ejunit() {
1801 debug-print-function ${FUNCNAME} $*
1802
1803 local pkgs
1804 for atom in $(cat ${JAVA_PKG_DEPEND_FILE} | tr : ' '); do
1805 pkgs=${pkgs},$(echo ${atom} | sed -re "s/^.*@//")
1806 done
1807
1808 local cp=$(java-pkg_getjars --with-dependencies junit${pkgs})
1809 if [[ ${1} = -cp || ${1} = -classpath ]]; then
1810 cp="${2}:${cp}"
1811 shift 2
1812 else
1813 cp=".:${cp}"
1814 fi
1815
1816 local runner=junit.textui.TestRunner
1817 debug-print "Calling: java -cp \"${cp}\" -Djava.awt.headless=true ${runner} ${@}"
1818 java -cp "${cp}" -Djava.awt.headless=true ${runner} "${@}" || die "Running junit failed"
1819}
1820
1821# ------------------------------------------------------------------------------
1601# @section-end helper 1822# @section-end helper
1602# ------------------------------------------------------------------------------ 1823# ------------------------------------------------------------------------------
1603 1824
1604# ------------------------------------------------------------------------------ 1825# ------------------------------------------------------------------------------
1605# @section-begin build 1826# @section-begin build
1616# compiler. Will also set proper ANT_TASKS from the variable ANT_TASKS, 1837# compiler. Will also set proper ANT_TASKS from the variable ANT_TASKS,
1617# variables: 1838# variables:
1618# EANT_GENTOO_CLASSPATH - calls java-pkg_getjars for the value and adds to the 1839# EANT_GENTOO_CLASSPATH - calls java-pkg_getjars for the value and adds to the
1619# gentoo.classpath property. Be sure to call 1840# gentoo.classpath property. Be sure to call
1620# java-ant_rewrite-classpath in src_unpack. 1841# java-ant_rewrite-classpath in src_unpack.
1842# JAVA_PKG_NO_BUNDLED_SEARCH - Don't search for bundled jars or class files
1621# *ANT_TASKS - used to determine ANT_TASKS before calling Ant. 1843# *ANT_TASKS - used to determine ANT_TASKS before calling Ant.
1622# ------------------------------------------------------------------------------ 1844# ------------------------------------------------------------------------------
1623eant() { 1845eant() {
1624 debug-print-function ${FUNCNAME} $* 1846 debug-print-function ${FUNCNAME} $*
1625 1847
1626 # FIXME get this working 1848 if [[ ${EBUILD_PHASE} = compile ]]; then
1627# if is-java-strict && [[ ! ${DEPEND} =~ "dev-java/ant" ]]; then 1849 # Used to be done in hooks in java-ant-2.eclass but moved here so that we can
1628# java-pkg_announce-qa-violation \ 1850 # finally get rid of the hooks without breaking stuff
1629# "Using eant, but not depending on dev-java/ant or dev-java/ant-core" 1851
1852 [[ "${JAVA_ANT_IGNORE_SYSTEM_CLASSES}" && "${JAVA_PKG_BSFIX}" ]] \
1853 && java-ant_ignore-system-classes "${S}/build.xml"
1854
1855 if hasq java-ant-2 ${INHERITED}; then
1856 java-ant_bsfix
1857 fi
1858
1859 # eant can be called multiple times
1860 JAVA_PKG_BSFIX="off"
1861
1862 if [[ -z ${JAVA_PKG_NO_BUNDLED_SEARCH} ]] && is-java-strict; then
1863 echo "Searching for bundled jars:"
1864 java-pkg_find-normal-jars || echo "None found."
1865 echo "Searching for bundled classes (no output if none found):"
1866 find "${WORKDIR}" -name "*.class"
1867 echo "Search done."
1868 JAVA_PKG_NO_BUNDLED_SEARCH=true # eant can be called many times
1869 fi
1630# fi 1870 fi
1631 1871
1632 if ! hasq java-ant-2 ${INHERITED} && is-java-strict; then 1872 if ! hasq java-ant-2 ${INHERITED}; then
1633 local msg="You should inherit java-ant-2 when using eant" 1873 local msg="You should inherit java-ant-2 when using eant"
1634 java-pkg_announce-qa-violation ${msg} 1874 java-pkg_announce-qa-violation "${msg}"
1635 die ${msg}
1636 fi 1875 fi
1637 1876
1638 local antflags="-Dnoget=true -Dmaven.mode.offline=true" 1877 local antflags="-Dnoget=true -Dmaven.mode.offline=true -Dbuild.sysclasspath=ignore"
1639 1878
1640 java-pkg_init-compiler_ 1879 java-pkg_init-compiler_
1641 local compiler="${GENTOO_COMPILER}" 1880 local compiler="${GENTOO_COMPILER}"
1642 1881
1643 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}" 1882 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}"
1644
1645 local build_compiler="$(source ${compiler_env} 1>/dev/null 2>&1; echo ${ANT_BUILD_COMPILER})" 1883 local build_compiler="$(source ${compiler_env} 1>/dev/null 2>&1; echo ${ANT_BUILD_COMPILER})"
1646 if [[ "${compiler}" != "javac" && -z "${build_compiler}" ]]; then 1884 if [[ "${compiler}" != "javac" && -z "${build_compiler}" ]]; then
1647 die "ANT_BUILD_COMPILER undefined in ${compiler_env}" 1885 die "ANT_BUILD_COMPILER undefined in ${compiler_env}"
1648 fi 1886 fi
1649 1887
1655 # java-config -p 1893 # java-config -p
1656 local build_compiler_deps="$(source ${JAVA_PKG_COMPILER_DIR}/${compiler} 1>/dev/null 2>&1; echo ${ANT_BUILD_COMPILER_DEPS})" 1894 local build_compiler_deps="$(source ${JAVA_PKG_COMPILER_DIR}/${compiler} 1>/dev/null 2>&1; echo ${ANT_BUILD_COMPILER_DEPS})"
1657 if [[ -n ${build_compiler_deps} ]]; then 1895 if [[ -n ${build_compiler_deps} ]]; then
1658 antflags="${antflags} -lib $(java-config -p ${build_compiler_deps})" 1896 antflags="${antflags} -lib $(java-config -p ${build_compiler_deps})"
1659 fi 1897 fi
1660 fi
1661
1662 if is-java-strict; then
1663 einfo "Disabling system classpath for ant"
1664 antflags="${antflags} -Dbuild.sysclasspath=ignore"
1665 fi 1898 fi
1666 1899
1667 for arg in "${@}"; do 1900 for arg in "${@}"; do
1668 if [[ ${arg} = -lib ]]; then 1901 if [[ ${arg} = -lib ]]; then
1669 if is-java-strict; then 1902 if is-java-strict; then
1678 echo "more info." 1911 echo "more info."
1679 fi 1912 fi
1680 fi 1913 fi
1681 done 1914 done
1682 1915
1916 # we use this in src_* so we run ant from /
1683 if has_version ">=dev-java/ant-core-1.7.0"; then 1917 if ROOT=/ has_version ">=dev-java/ant-core-1.7.0"; then
1684 # default ANT_TASKS to WANT_ANT_TASKS, if ANT_TASKS is not set explicitly 1918 # default ANT_TASKS to WANT_ANT_TASKS, if ANT_TASKS is not set explicitly
1685 ANT_TASKS="${ANT_TASKS:-${WANT_ANT_TASKS}}" 1919 ANT_TASKS="${ANT_TASKS:-${WANT_ANT_TASKS}}"
1686 1920
1687 # override ANT_TASKS with JAVA_PKG_FORCE_ANT_TASKS if it's set 1921 # override ANT_TASKS with JAVA_PKG_FORCE_ANT_TASKS if it's set
1688 ANT_TASKS="${JAVA_PKG_FORCE_ANT_TASKS:-${ANT_TASKS}}" 1922 ANT_TASKS="${JAVA_PKG_FORCE_ANT_TASKS:-${ANT_TASKS}}"
1711 1945
1712 [[ -n ${JAVA_PKG_DEBUG} ]] && antflags="${antflags} --execdebug -debug" 1946 [[ -n ${JAVA_PKG_DEBUG} ]] && antflags="${antflags} --execdebug -debug"
1713 [[ -n ${PORTAGE_QUIET} ]] && antflags="${antflags} -q" 1947 [[ -n ${PORTAGE_QUIET} ]] && antflags="${antflags} -q"
1714 1948
1715 local gcp="${EANT_GENTOO_CLASSPATH}" 1949 local gcp="${EANT_GENTOO_CLASSPATH}"
1950 local getjarsarg=""
1716 1951
1717 if [[ ${EBUILD_PHASE} = "test" ]]; then 1952 if [[ ${EBUILD_PHASE} = "test" ]]; then
1718 antflags="${antflags} -DJunit.present=true" 1953 antflags="${antflags} -DJunit.present=true"
1719 [[ ${gcp} && ${ANT_TASKS} = *ant-junit* ]] && gcp="${gcp} junit" 1954 [[ ${gcp} && ${ANT_TASKS} = *ant-junit* ]] && gcp="${gcp} junit"
1720 local getjarsarg="--with-dependencies" 1955 getjarsarg="--with-dependencies"
1721 fi 1956 fi
1722 1957
1723 local cp 1958 local cp
1724 1959
1725 for atom in ${gcp}; do 1960 for atom in ${gcp}; do
1836# This shouldn't be used directly. Instead, java-pkg and java-pkg-opt will 2071# This shouldn't be used directly. Instead, java-pkg and java-pkg-opt will
1837# call it during each of the phases of the merge process. 2072# call it during each of the phases of the merge process.
1838# 2073#
1839# ----------------------------------------------------------------------------- 2074# -----------------------------------------------------------------------------
1840java-pkg_init() { 2075java-pkg_init() {
2076 debug-print-function ${FUNCNAME} $*
1841 unset JAVAC 2077 unset JAVAC
1842 unset JAVA_HOME 2078 unset JAVA_HOME
1843 2079
1844 # People do all kinds of weird things. 2080 # People do all kinds of weird things.
1845 # http://forums.gentoo.org/viewtopic-p-3943166.html 2081 # http://forums.gentoo.org/viewtopic-p-3943166.html
1853 ewarn "make.conf for example) to silence this warning or" 2089 ewarn "make.conf for example) to silence this warning or"
1854 ewarn "I_WANT_GLOBAL_JAVA_OPTIONS to not filter it." 2090 ewarn "I_WANT_GLOBAL_JAVA_OPTIONS to not filter it."
1855 fi 2091 fi
1856 2092
1857 if [[ -z ${accept} ]]; then 2093 if [[ -z ${accept} ]]; then
2094 # export _JAVA_OPTIONS= doesn't work because it will show up in java
2095 # -version output
1858 unset _JAVA_OPTIONS 2096 unset _JAVA_OPTIONS
1859 # phase hooks make this run many times without this 2097 # phase hooks make this run many times without this
1860 I_WANT_GLOBAL_JAVA_OPTIONS="true" 2098 I_WANT_GLOBAL_JAVA_OPTIONS="true"
1861 fi 2099 fi
1862 2100
2101 if java-pkg_func-exists ant_src_unpack; then
2102 java-pkg_announce-qa-violation "Using old ant_src_unpack. Should be src_unpack"
2103 fi
2104
1863 java-pkg_init_paths_ 2105 java-pkg_init_paths_
1864 java-pkg_switch-vm 2106 java-pkg_switch-vm
1865 PATH=${JAVA_HOME}/bin:${PATH} 2107 PATH=${JAVA_HOME}/bin:${PATH}
1866 2108
1867 # TODO we will probably want to set JAVAC and JAVACFLAGS 2109 # TODO we will probably want to set JAVAC and JAVACFLAGS
1868 2110
1869 # Do some QA checks 2111 # Do some QA checks
1870 java-pkg_check-jikes 2112 java-pkg_check-jikes
2113
2114 # Can't use unset here because Portage does not save the unset
2115 # see https://bugs.gentoo.org/show_bug.cgi?id=189417#c11
1871 2116
1872 # When users have crazy classpaths some packages can fail to compile. 2117 # When users have crazy classpaths some packages can fail to compile.
1873 # and everything should work with empty CLASSPATH. 2118 # and everything should work with empty CLASSPATH.
1874 # This also helps prevent unexpected dependencies on random things 2119 # This also helps prevent unexpected dependencies on random things
1875 # from the CLASSPATH. 2120 # from the CLASSPATH.
1876 unset CLASSPATH 2121 export CLASSPATH=
1877 2122
1878 # Unset external ANT_ stuff 2123 # Unset external ANT_ stuff
1879 unset ANT_TASKS 2124 export ANT_TASKS=
1880 unset ANT_OPTS 2125 export ANT_OPTS=
1881} 2126}
1882 2127
1883# ------------------------------------------------------------------------------ 2128# ------------------------------------------------------------------------------
1884# @function-internal java-pkg-init-compiler_ 2129# @function-internal java-pkg-init-compiler_
1885# 2130#
2007 fi 2252 fi
2008 2253
2009 JAVA_PKG_SHAREPATH="${DESTTREE}/share/${JAVA_PKG_NAME}" 2254 JAVA_PKG_SHAREPATH="${DESTTREE}/share/${JAVA_PKG_NAME}"
2010 JAVA_PKG_SOURCESPATH="${JAVA_PKG_SHAREPATH}/sources/" 2255 JAVA_PKG_SOURCESPATH="${JAVA_PKG_SHAREPATH}/sources/"
2011 JAVA_PKG_ENV="${D}${JAVA_PKG_SHAREPATH}/package.env" 2256 JAVA_PKG_ENV="${D}${JAVA_PKG_SHAREPATH}/package.env"
2257 JAVA_PKG_VIRTUALS_PATH="${DESTTREE}/share/java-config-2/virtuals"
2258 JAVA_PKG_VIRTUAL_PROVIDER="${D}/${JAVA_PKG_VIRTUALS_PATH}/${JAVA_PKG_NAME}"
2012 2259
2013 [[ -z "${JAVA_PKG_JARDEST}" ]] && JAVA_PKG_JARDEST="${JAVA_PKG_SHAREPATH}/lib" 2260 [[ -z "${JAVA_PKG_JARDEST}" ]] && JAVA_PKG_JARDEST="${JAVA_PKG_SHAREPATH}/lib"
2014 [[ -z "${JAVA_PKG_LIBDEST}" ]] && JAVA_PKG_LIBDEST="${DESTTREE}/$(get_libdir)/${JAVA_PKG_NAME}" 2261 [[ -z "${JAVA_PKG_LIBDEST}" ]] && JAVA_PKG_LIBDEST="${DESTTREE}/$(get_libdir)/${JAVA_PKG_NAME}"
2015 [[ -z "${JAVA_PKG_WARDEST}" ]] && JAVA_PKG_WARDEST="${JAVA_PKG_SHAREPATH}/webapps" 2262 [[ -z "${JAVA_PKG_WARDEST}" ]] && JAVA_PKG_WARDEST="${JAVA_PKG_SHAREPATH}/webapps"
2016 2263
2029# Writes the package.env out to disk. 2276# Writes the package.env out to disk.
2030# 2277#
2031# ------------------------------------------------------------------------------ 2278# ------------------------------------------------------------------------------
2032# TODO change to do-write, to match everything else 2279# TODO change to do-write, to match everything else
2033java-pkg_do_write_() { 2280java-pkg_do_write_() {
2281 debug-print-function ${FUNCNAME} $*
2034 java-pkg_init_paths_ 2282 java-pkg_init_paths_
2035 # Create directory for package.env 2283 # Create directory for package.env
2036 dodir "${JAVA_PKG_SHAREPATH}" 2284 dodir "${JAVA_PKG_SHAREPATH}"
2037 if [[ -n "${JAVA_PKG_CLASSPATH}" || -n "${JAVA_PKG_LIBRARY}" || -f "${JAVA_PKG_DEPEND}" ]]; then 2285 if [[ -n "${JAVA_PKG_CLASSPATH}" || -n "${JAVA_PKG_LIBRARY}" || -f \
2286 "${JAVA_PKG_DEPEND_FILE}" || -f \
2287 "${JAVA_PKG_OPTIONAL_DEPEND_FILE}" ]]; then
2038 # Create package.env 2288 # Create package.env
2039 ( 2289 (
2040 echo "DESCRIPTION=\"${DESCRIPTION}\"" 2290 echo "DESCRIPTION=\"${DESCRIPTION}\""
2041 echo "GENERATION=\"2\"" 2291 echo "GENERATION=\"2\""
2042 2292
2043 [[ -n "${JAVA_PKG_CLASSPATH}" ]] && echo "CLASSPATH=\"${JAVA_PKG_CLASSPATH}\"" 2293 [[ -n "${JAVA_PKG_CLASSPATH}" ]] && echo "CLASSPATH=\"${JAVA_PKG_CLASSPATH}\""
2044 [[ -n "${JAVA_PKG_LIBRARY}" ]] && echo "LIBRARY_PATH=\"${JAVA_PKG_LIBRARY}\"" 2294 [[ -n "${JAVA_PKG_LIBRARY}" ]] && echo "LIBRARY_PATH=\"${JAVA_PKG_LIBRARY}\""
2045 [[ -n "${JAVA_PROVIDE}" ]] && echo "PROVIDES=\"${JAVA_PROVIDE}\"" 2295 [[ -n "${JAVA_PROVIDE}" ]] && echo "PROVIDES=\"${JAVA_PROVIDE}\""
2046 [[ -f "${JAVA_PKG_DEPEND}" ]] && echo "DEPEND=\"$(cat ${JAVA_PKG_DEPEND} | uniq | tr '\n' ':')\"" 2296 [[ -f "${JAVA_PKG_DEPEND_FILE}" ]] \
2297 && echo "DEPEND=\"$(cat "${JAVA_PKG_DEPEND_FILE}" | uniq | tr '\n' ':')\""
2298 [[ -f "${JAVA_PKG_OPTIONAL_DEPEND_FILE}" ]] \
2299 && echo "OPTIONAL_DEPEND=\"$(cat "${JAVA_PKG_OPTIONAL_DEPEND_FILE}" | uniq | tr '\n' ':')\""
2047 echo "VM=\"$(echo ${RDEPEND} ${DEPEND} | sed -e 's/ /\n/g' | sed -n -e '/virtual\/\(jre\|jdk\)/ { p;q }')\"" # TODO cleanup ! 2300 echo "VM=\"$(echo ${RDEPEND} ${DEPEND} | sed -e 's/ /\n/g' | sed -n -e '/virtual\/\(jre\|jdk\)/ { p;q }')\"" # TODO cleanup !
2048 ) > "${JAVA_PKG_ENV}" 2301 ) > "${JAVA_PKG_ENV}"
2049 2302
2050 # register target/source 2303 # register target/source
2051 local target="$(java-pkg_get-target)" 2304 local target="$(java-pkg_get-target)"
2062 2315
2063 2316
2064 echo "MERGE_VM=\"${GENTOO_VM}\"" >> "${JAVA_PKG_ENV}" 2317 echo "MERGE_VM=\"${GENTOO_VM}\"" >> "${JAVA_PKG_ENV}"
2065 [[ -n ${GENTOO_COMPILER} ]] && echo "MERGE_COMPILER=\"${GENTOO_COMPILER}\"" >> "${JAVA_PKG_ENV}" 2318 [[ -n ${GENTOO_COMPILER} ]] && echo "MERGE_COMPILER=\"${GENTOO_COMPILER}\"" >> "${JAVA_PKG_ENV}"
2066 2319
2320 # extra env variables
2321 if [[ -n "${JAVA_PKG_EXTRA_ENV_VARS}" ]]; then
2322 cat "${JAVA_PKG_EXTRA_ENV}" >> "${JAVA_PKG_ENV}" || die
2323 # nested echo to remove leading/trailing spaces
2324 echo "ENV_VARS=\"$(echo ${JAVA_PKG_EXTRA_ENV_VARS})\"" \
2325 >> "${JAVA_PKG_ENV}" || die
2326 fi
2327
2067 # Strip unnecessary leading and trailing colons 2328 # Strip unnecessary leading and trailing colons
2068 # TODO try to cleanup if possible 2329 # TODO try to cleanup if possible
2069 sed -e "s/=\":/=\"/" -e "s/:\"$/\"/" -i "${JAVA_PKG_ENV}" || die "Did you forget to call java_init ?" 2330 sed -e "s/=\":/=\"/" -e "s/:\"$/\"/" -i "${JAVA_PKG_ENV}" || die "Did you forget to call java_init ?"
2331 else
2332 debug-print "JAVA_PKG_CLASSPATH, JAVA_PKG_LIBRARY, JAVA_PKG_DEPEND_FILE"
2333 debug-print "or JAVA_PKG_OPTIONAL_DEPEND_FILE not defined so can't"
2334 debug-print "write package.env."
2070 fi 2335 fi
2071} 2336}
2072 2337
2073# ------------------------------------------------------------------------------ 2338# ------------------------------------------------------------------------------
2074# @internal-function java-pkg_record-jar_ 2339# @internal-function java-pkg_record-jar_
2075# 2340#
2076# Record a dependency to the package.env 2341# Record an (optional) dependency to the package.env
2077# 2342# @param --optional - record dependency as optional
2343# @param $1 - package to record
2344# @param $2 - (optional) jar of package to record
2078# ------------------------------------------------------------------------------ 2345# ------------------------------------------------------------------------------
2079JAVA_PKG_DEPEND="${T}/java-pkg-depend" 2346JAVA_PKG_DEPEND_FILE="${T}/java-pkg-depend"
2347JAVA_PKG_OPTIONAL_DEPEND_FILE="${T}/java-pkg-optional-depend"
2080 2348
2081java-pkg_record-jar_() { 2349java-pkg_record-jar_() {
2082 debug-print-function ${FUNCNAME} $* 2350 debug-print-function ${FUNCNAME} $*
2351
2352 local depend_file="${JAVA_PKG_DEPEND_FILE}"
2353 if [[ "${1}" == "--optional" ]]; then
2354 depend_file="${JAVA_PKG_OPTIONAL_DEPEND_FILE}"
2355 shift
2356 fi
2083 2357
2084 local pkg=${1} jar=${2} append 2358 local pkg=${1} jar=${2} append
2085 if [[ -z "${jar}" ]]; then 2359 if [[ -z "${jar}" ]]; then
2086 append="${pkg}" 2360 append="${pkg}"
2087 else 2361 else
2088 append="$(basename ${jar})@${pkg}" 2362 append="$(basename ${jar})@${pkg}"
2089 fi 2363 fi
2090 2364
2091 echo ${append} >> ${JAVA_PKG_DEPEND} 2365 echo "${append}" >> "${depend_file}"
2092} 2366}
2093 2367
2094# ------------------------------------------------------------------------------ 2368# ------------------------------------------------------------------------------
2095# @internal-function java-pkg_append_ 2369# @internal-function java-pkg_append_
2096# 2370#
2156# 2430#
2157# ------------------------------------------------------------------------------ 2431# ------------------------------------------------------------------------------
2158java-pkg_setup-vm() { 2432java-pkg_setup-vm() {
2159 debug-print-function ${FUNCNAME} $* 2433 debug-print-function ${FUNCNAME} $*
2160 2434
2435 export LANG="C" LC_ALL="C"
2436
2161 local vendor="$(java-pkg_get-vm-vendor)" 2437 local vendor="$(java-pkg_get-vm-vendor)"
2162 if [[ "${vendor}" == "sun" ]] && java-pkg_is-vm-version-ge "1.5" ; then 2438 if [[ "${vendor}" == "sun" ]] && java-pkg_is-vm-version-ge "1.5" ; then
2163 addpredict "/dev/random" 2439 addpredict "/dev/random"
2164 elif [[ "${vendor}" == "ibm" ]]; then 2440 elif [[ "${vendor}" == "ibm" ]]; then
2165 addpredict "/proc/self/maps" 2441 addpredict "/proc/self/maps"
2166 addpredict "/proc/cpuinfo" 2442 addpredict "/proc/cpuinfo"
2167 export LANG="C" LC_ALL="C"
2168 elif [[ "${vendor}" == "jrockit" ]]; then 2443 elif [[ "${vendor}" == "jrockit" ]]; then
2169 addpredict "/proc/cpuinfo" 2444 addpredict "/proc/cpuinfo"
2170 fi 2445 fi
2171} 2446}
2172 2447
2276 2551
2277 #TODO If you know a better solution let us know. 2552 #TODO If you know a better solution let us know.
2278 java-pkg_append_ LD_LIBRARY_PATH "$(java-config -g LDPATH)" 2553 java-pkg_append_ LD_LIBRARY_PATH "$(java-config -g LDPATH)"
2279 2554
2280 local tann="${T}/announced-vm" 2555 local tann="${T}/announced-vm"
2556 # With the hooks we should only get here once from pkg_setup but better safe than sorry
2557 # if people have for example modified eclasses some where
2281 if [[ -n "${JAVA_PKG_DEBUG}" ]] || [[ ! -f "${tann}" ]] ; then 2558 if [[ -n "${JAVA_PKG_DEBUG}" ]] || [[ ! -f "${tann}" ]] ; then
2282 # Add a check for setup/preinst phase... to avoid duplicate outputs
2283 # for when FEATURES=buildpkg
2284 if [[ ${EBUILD_PHASE} != "setup" && ${EBUILD_PHASE} != "preinst" && ${EBUILD_PHASE} != "postinst" ]];
2285 then
2286 einfo "Using: $(java-config -f)" 2559 einfo "Using: $(java-config -f)"
2287 [[ ! -f "${tann}" ]] && touch "${tann}" 2560 [[ ! -f "${tann}" ]] && touch "${tann}"
2288 fi
2289 fi 2561 fi
2290 2562
2291 else 2563 else
2292 [[ -n "${JAVA_PKG_DEBUG}" ]] && ewarn "!!! This package inherits java-pkg but doesn't depend on a JDK. -bin or broken dependency!!!" 2564 [[ -n "${JAVA_PKG_DEBUG}" ]] && ewarn "!!! This package inherits java-pkg but doesn't depend on a JDK. -bin or broken dependency!!!"
2293 fi 2565 fi
2357 2629
2358# ---------------------------------------------------------------------------- 2630# ----------------------------------------------------------------------------
2359# @internal-function java-pkg_ensure-dep 2631# @internal-function java-pkg_ensure-dep
2360# Check that a package being used in jarfrom, getjars and getjar is contained 2632# Check that a package being used in jarfrom, getjars and getjar is contained
2361# within DEPEND or RDEPEND. 2633# within DEPEND or RDEPEND.
2362# @param $1 - Is the package a runtime dependency 2634# @param $1 - empty - check both vars; "runtime" or "build" - check only
2635# RDEPEND, resp. DEPEND
2363# @param $2 - Package name and slot. 2636# @param $2 - Package name and slot.
2364 2637
2365java-pkg_ensure-dep() { 2638java-pkg_ensure-dep() {
2366 debug-print-function ${FUNCNAME} $* 2639 debug-print-function ${FUNCNAME} $*
2367 2640
2368 local build_only="${1}" 2641 local limit_to="${1}"
2369 local target_pkg="${2}" 2642 local target_pkg="${2}"
2370 local dev_error="" 2643 local dev_error=""
2371 2644
2372 local stripped_pkg=$(echo "${target_pkg}" | sed \ 2645 local stripped_pkg=$(echo "${target_pkg}" | sed \
2373 's/-[0-9]*\(\.[0-9]\)*$//') 2646 's/-[0-9]*\(\.[0-9]\)*$//')
2374 2647
2648 debug-print "Matching against: ${stripped_pkg}"
2649
2375 if [[ ! ( "${DEPEND}" =~ "$stripped_pkg" ) ]]; then 2650 if [[ ${limit_to} != runtime && ! ( "${DEPEND}" =~ "$stripped_pkg" ) ]]; then
2376 dev_error="The ebuild is attempting to use ${target_pkg} that is not" 2651 dev_error="The ebuild is attempting to use ${target_pkg} that is not"
2377 dev_error="${dev_error} declared in DEPEND." 2652 dev_error="${dev_error} declared in DEPEND."
2378 if is-java-strict; then 2653 if is-java-strict; then
2654 eerror "${dev_error}"
2379 die "${dev_error}" 2655 die "${dev_error}"
2380 elif [[ ${BASH_SUBSHELL} = 0 ]]; then 2656 elif [[ ${BASH_SUBSHELL} = 0 ]]; then
2381 eerror "${dev_error}" 2657 eerror "${dev_error}"
2382 elog "Because you have this package installed the package will" 2658 elog "Because you have this package installed the package will"
2383 elog "build without problems, but please report this to" 2659 elog "build without problems, but please report this to"
2384 elog "http://bugs.gentoo.org" 2660 elog "http://bugs.gentoo.org"
2385 fi 2661 fi
2386 fi 2662 fi
2387 2663
2664 if [[ ${limit_to} != build ]]; then
2388 if [[ -z ${build_only} && ! ( ${RDEPEND} =~ "${stripped_pkg}" ) ]]; then 2665 if [[ ! ( ${RDEPEND} =~ "${stripped_pkg}" ) ]]; then
2666 if [[ ! ( ${PDEPEND} =~ "${stripped_pkg}" ) ]]; then
2389 dev_error="The ebuild is attempting to use ${target_pkg}," 2667 dev_error="The ebuild is attempting to use ${target_pkg},"
2390 dev_error="${dev_error} without specifying --build-only, that is not declared in RDEPEND." 2668 dev_error="${dev_error} without specifying --build-only, that is not declared in RDEPEND"
2669 dev_error="${dev_error} or PDEPEND."
2391 if is-java-strict; then 2670 if is-java-strict; then
2671 eerror "${dev_error}"
2392 die "${dev_error}" 2672 die "${dev_error}"
2393 elif [[ ${BASH_SUBSHELL} = 0 ]]; then 2673 elif [[ ${BASH_SUBSHELL} = 0 ]]; then
2394 eerror "${dev_error}" 2674 eerror "${dev_error}"
2395 elog "Because you have this package installed the package will" 2675 elog "The package will build without problems, but may fail to run"
2396 elog "build without problems, but please report this to" 2676 elog "if you don't have ${target_pkg} installed, so please report"
2397 elog "http://bugs.gentoo.org" 2677 elog "this to http://bugs.gentoo.org"
2678 fi
2679 fi
2398 fi 2680 fi
2399 fi 2681 fi
2400} 2682}
2401 2683
2402# ------------------------------------------------------------------------------ 2684# ------------------------------------------------------------------------------
2403# @section-end internal 2685# @section-end internal
2404# ------------------------------------------------------------------------------ 2686# ------------------------------------------------------------------------------
2405 2687
2406java-pkg_check-phase() { 2688java-pkg_check-phase() {
2407 local phase=${1} 2689 local phase=${1}
2408 local funcname=${2} 2690 local funcname=${FUNCNAME[1]}
2409 if is-java-strict && [[ ${EBUILD_PHASE} != ${phase} ]]; then 2691 if [[ ${EBUILD_PHASE} != ${phase} ]]; then
2410 java-pkg_announce-qa-violation \
2411 "${funcname} used outside of src_${phase}" 2692 local msg="${funcname} used outside of src_${phase}"
2693 java-pkg_announce-qa-violation "${msg}"
2412 fi 2694 fi
2413} 2695}
2414 2696
2415java-pkg_check-versioned-jar() { 2697java-pkg_check-versioned-jar() {
2416 local jar=${1} 2698 local jar=${1}
2425 java-pkg_announce-qa-violation "deprecated USE flag 'jikes' in IUSE" 2707 java-pkg_announce-qa-violation "deprecated USE flag 'jikes' in IUSE"
2426 fi 2708 fi
2427} 2709}
2428 2710
2429java-pkg_announce-qa-violation() { 2711java-pkg_announce-qa-violation() {
2430 if is-java-strict; then 2712 local nodie
2713 if [[ ${1} == "--nodie" ]]; then
2714 nodie="true"
2715 shift
2716 fi
2431 echo "Java QA Notice: $@" >&2 2717 echo "Java QA Notice: $@" >&2
2432 increment-qa-violations 2718 increment-qa-violations
2433 fi 2719 [[ -z "${nodie}" ]] && is-java-strict && die "${@}"
2434} 2720}
2435 2721
2436increment-qa-violations() { 2722increment-qa-violations() {
2437 let "JAVA_PKG_QA_VIOLATIONS+=1" 2723 let "JAVA_PKG_QA_VIOLATIONS+=1"
2438 export JAVA_PKG_QA_VIOLATIONS 2724 export JAVA_PKG_QA_VIOLATIONS

Legend:
Removed from v.1.75  
changed lines
  Added in v.1.101

  ViewVC Help
Powered by ViewVC 1.1.20