/[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.12 Revision 1.52
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.52 2007/01/28 20:58:29 betelgeuse Exp $
9 10
10 11
11# ----------------------------------------------------------------------------- 12# -----------------------------------------------------------------------------
12# @eclass-begin 13# @eclass-begin
13# @eclass-shortdesc Java Utility eclass 14# @eclass-shortdesc Java Utility eclass
14# @eclass-maintainer java@gentoo.org 15# @eclass-maintainer java@gentoo.org
15# 16#
16# This eclass provides functionality which is used by 17# This eclass provides functionality which is used by
17# java-pkg.eclass and java-pkg-opt.eclass as well as from ebuilds. 18# java-pkg.eclass and java-pkg-opt.eclass as well as from ebuilds.
18# 19#
19# @warning 20# @warning
20# You probably don't want to inherit this directly from an ebuild. Instead, 21# You probably don't want to inherit this directly from an ebuild. Instead,
21# you should inherit java-ant for Ant-based Java packages, java-pkg for other 22# you should inherit java-ant for Ant-based Java packages, java-pkg for other
22# Java packages, or java-pkg-opt for packages that have optional Java support. 23# Java packages, or java-pkg-opt for packages that have optional Java support.
23# 24#
24# ----------------------------------------------------------------------------- 25# -----------------------------------------------------------------------------
25 26
26inherit eutils versionator multilib 27inherit eutils versionator multilib
28
29IUSE="elibc_FreeBSD"
27 30
28# ----------------------------------------------------------------------------- 31# -----------------------------------------------------------------------------
29# @section-begin variables 32# @section-begin variables
30# @section-title Variables 33# @section-title Variables
31# 34#
33# ----------------------------------------------------------------------------- 36# -----------------------------------------------------------------------------
34 37
35# Make sure we use java-config-2 38# Make sure we use java-config-2
36export WANT_JAVA_CONFIG="2" 39export WANT_JAVA_CONFIG="2"
37 40
38# TODO document 41# -----------------------------------------------------------------------------
42# @variable-external WANT_ANT_TASKS
43# @variable-default ""
44#
45# An $IFS separated list of ant tasks.
46# Ebuild can specify this variable before inheriting java-ant-2 eclass to
47# determine ANT_TASKS it needs. They will be automatically translated to
48# DEPEND variable and ANT_TASKS variable. JAVA_PKG_FORCE_ANT_TASKS can override
49# ANT_TASKS set by WANT_ANT_TASKS, but not the DEPEND due to caching.
50# Ebuilds that need to depend conditionally on certain tasks and specify them
51# differently for different eant calls can't use this simplified approach.
52# You also cannot specify version or anything else than ant-*.
53#
54# @example WANT_ANT_TASKS="ant-junit ant-trax"
55#
56# @seealso JAVA_PKG_FORCE_ANT_TASKS
57# -----------------------------------------------------------------------------
58#WANT_ANT_TASKS
59
60# @variable-internal JAVA_PKG_PORTAGE_DEP
61#
62# The version of portage we need to function properly. At this moment it's
63# portage with phase hooks support.
64# -----------------------------------------------------------------------------
39JAVA_PKG_PORTAGE_DEP=">=sys-apps/portage-2.1_pre1" 65JAVA_PKG_PORTAGE_DEP=">=sys-apps/portage-2.1_pre1"
40 66
41# ----------------------------------------------------------------------------- 67# -----------------------------------------------------------------------------
42# @variable-internal JAVA_PKG_E_DEPEND 68# @variable-internal JAVA_PKG_E_DEPEND
43# 69#
44# This is a convience variable to be used from the other java eclasses. This is 70# 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 71# the version of java-config we want to use. We also need a recent version
46# portage, that includes phase hooks. 72# portage, that includes phase hooks.
47# ----------------------------------------------------------------------------- 73# -----------------------------------------------------------------------------
48JAVA_PKG_E_DEPEND=">=dev-java/java-config-2.0.19-r1 ${JAVA_PKG_PORTAGE_DEP}" 74JAVA_PKG_E_DEPEND=">=dev-java/java-config-2.0.19-r1 ${JAVA_PKG_PORTAGE_DEP}"
49 75
50# ----------------------------------------------------------------------------- 76# -----------------------------------------------------------------------------
100# ----------------------------------------------------------------------------- 126# -----------------------------------------------------------------------------
101 127
102# ----------------------------------------------------------------------------- 128# -----------------------------------------------------------------------------
103# @variable-internal JAVA_PKG_COMPILER_DIR 129# @variable-internal JAVA_PKG_COMPILER_DIR
104# @default /usr/share/java-config-2/compiler 130# @default /usr/share/java-config-2/compiler
105# 131#
106# Directory where compiler settings are saved, without trailing slash. 132# Directory where compiler settings are saved, without trailing slash.
107# Probably shouldn't touch this variable. 133# Probably shouldn't touch this variable.
108# ----------------------------------------------------------------------------- 134# -----------------------------------------------------------------------------
109JAVA_PKG_COMPILER_DIR=${JAVA_PKG_COMPILER_DIR:="/usr/share/java-config-2/compiler"} 135JAVA_PKG_COMPILER_DIR=${JAVA_PKG_COMPILER_DIR:="/usr/share/java-config-2/compiler"}
110 136
120 146
121# ----------------------------------------------------------------------------- 147# -----------------------------------------------------------------------------
122# @variable-external JAVA_PKG_FORCE_COMPILER 148# @variable-external JAVA_PKG_FORCE_COMPILER
123# 149#
124# Explicitly set a list of compilers to use. This is normally read from 150# Explicitly set a list of compilers to use. This is normally read from
125# JAVA_PKG_COMPILERS_CONF. 151# JAVA_PKG_COMPILERS_CONF.
126# 152#
127# @note This should only be used internally or for testing. 153# @note This should only be used internally or for testing.
128# @example Use jikes and javac, in that order 154# @example Use jikes and javac, in that order
129# JAVA_PKG_FORCE_COMPILER="jikes javac" 155# JAVA_PKG_FORCE_COMPILER="jikes javac"
130# ----------------------------------------------------------------------------- 156# -----------------------------------------------------------------------------
131 157
158# -----------------------------------------------------------------------------
159# @variable-external JAVA_PKG_FORCE_ANT_TASKS
160#
161# An $IFS separated list of ant tasks. Can be set in environment before calling
162# emerge/ebuild to override variables set in ebuild, mainly for testing before
163# putting the resulting (WANT_)ANT_TASKS into ebuild. Affects only ANT_TASKS in
164# eant() call, not the dependencies specified in WANT_ANT_TASKS.
165#
166# @example JAVA_PKG_FORCE_ANT_TASKS="ant-junit ant-trax" \
167# ebuild foo.ebuild compile
168#
169# @seealso WANT_ANT_TASKS
170# -----------------------------------------------------------------------------
171
132# TODO document me 172# TODO document me
133JAVA_PKG_QA_VIOLATIONS=0 173JAVA_PKG_QA_VIOLATIONS=0
134 174
135# ----------------------------------------------------------------------------- 175# -----------------------------------------------------------------------------
136# @section-end variables 176# @section-end variables
150# @ebuild-function java-pkg_dojar 190# @ebuild-function java-pkg_dojar
151# 191#
152# Installs any number of jars. 192# Installs any number of jars.
153# Jar's will be installed into /usr/share/${PN}(-${SLOT})/lib/ by default. 193# Jar's will be installed into /usr/share/${PN}(-${SLOT})/lib/ by default.
154# You can use java-pkg_jarinto to change this path. 194# You can use java-pkg_jarinto to change this path.
155# You should never install a jar with a package version in the filename. 195# You should never install a jar with a package version in the filename.
156# Instead, use java-pkg_newjar defined below. 196# Instead, use java-pkg_newjar defined below.
157# 197#
158# @example 198# @example
159# java-pkg_dojar dist/${PN}.jar dist/${PN}-core.jar 199# java-pkg_dojar dist/${PN}.jar dist/${PN}-core.jar
160# 200#
171 # Create JARDEST if it doesn't exist 211 # Create JARDEST if it doesn't exist
172 dodir ${JAVA_PKG_JARDEST} 212 dodir ${JAVA_PKG_JARDEST}
173 213
174 local jar 214 local jar
175 # for each jar 215 # for each jar
176 for jar in "$@"; do 216 for jar in "${@}"; do
177 local jar_basename=$(basename "${jar}") 217 local jar_basename=$(basename "${jar}")
178 218
179 java-pkg_check-versioned-jar ${jar_basename} 219 java-pkg_check-versioned-jar ${jar_basename}
180 220
181 # check if it exists 221 # check if it exists
182 if [[ -e "${jar}" ]] ; then 222 if [[ -e "${jar}" ]] ; then
223 # Don't overwrite if jar has already been installed with the same
224 # name
225 local dest="${D}${JAVA_PKG_JARDEST}/${jar_basename}"
226 if [[ -e "${dest}" ]]; then
227 ewarn "Overwriting ${dest}"
228 fi
229
183 # install it into JARDEST if it's a non-symlink 230 # install it into JARDEST if it's a non-symlink
184 if [[ ! -L "${jar}" ]] ; then 231 if [[ ! -L "${jar}" ]] ; then
185 INSDESTTREE="${JAVA_PKG_JARDEST}" \ 232 INSDESTTREE="${JAVA_PKG_JARDEST}" \
186 doins "${jar}" || die "failed to install ${jar}" 233 doins "${jar}" || die "failed to install ${jar}"
187 java-pkg_append_ JAVA_PKG_CLASSPATH "${JAVA_PKG_JARDEST}/${jar_basename}" 234 java-pkg_append_ JAVA_PKG_CLASSPATH "${JAVA_PKG_JARDEST}/${jar_basename}"
200 247
201 java-pkg_do_write_ 248 java-pkg_do_write_
202} 249}
203 250
204 251
252# ------------------------------------------------------------------------------
253# @internal-function depend-java-query
254#
255# Wrapper for the depend-java-query binary to enable passing USE in env.
256# Using env variables keeps this eclass working with java-config versions that
257# do not handle use flags.
258# ------------------------------------------------------------------------------
259
260depend-java-query() {
261 USE="${USE}" $(which depend-java-query) "${@}"
262}
205 263
206# ------------------------------------------------------------------------------ 264# ------------------------------------------------------------------------------
207# @ebuild-function java-pkg_regjar 265# @ebuild-function java-pkg_regjar
208# 266#
209# Records an already installed jar in the package.env 267# Records an already installed jar in the package.env
222# will not work, because: 280# will not work, because:
223# * the `for jar in "$@"` can't expand the path to jar file names, as they 281# * the `for jar in "$@"` can't expand the path to jar file names, as they
224# don't exist yet 282# don't exist yet
225# * all `if ...` inside for will fail - the file '/opt/my-java/lib/*.jar' 283# * all `if ...` inside for will fail - the file '/opt/my-java/lib/*.jar'
226# doesn't exist 284# doesn't exist
227# 285#
228# you have to use it as: 286# you have to use it as:
229# 287#
230# java-pkg_regjar ${D}/opt/my-java/lib/*.jar 288# java-pkg_regjar ${D}/opt/my-java/lib/*.jar
231# 289#
232# @param $@ - jars to record 290# @param $@ - jars to record
240 [[ ${#} -lt 1 ]] && die "at least one argument needed" 298 [[ ${#} -lt 1 ]] && die "at least one argument needed"
241 299
242 java-pkg_init_paths_ 300 java-pkg_init_paths_
243 301
244 local jar jar_dir jar_file 302 local jar jar_dir jar_file
245 for jar in "$@"; do 303 for jar in "${@}"; do
246 # TODO use java-pkg_check-versioned-jar 304 # TODO use java-pkg_check-versioned-jar
247 if [[ -e "${jar}" ]]; then 305 if [[ -e "${jar}" || -e "${D}${jar}" ]]; then
306 [[ -d "${jar}" || -d "${D}${jar}" ]] \
307 && die "Called ${FUNCNAME} on a directory $*"
248 # nelchael: we should strip ${D} in this case too, here's why: 308 # nelchael: we should strip ${D} in this case too, here's why:
249 # imagine such call: 309 # imagine such call:
250 # java-pkg_regjar ${D}/opt/java/*.jar 310 # java-pkg_regjar ${D}/opt/java/*.jar
251 # such call will fall into this case (-e ${jar}) and will 311 # such call will fall into this case (-e ${jar}) and will
252 # record paths with ${D} in package.env 312 # record paths with ${D} in package.env
253 java-pkg_append_ JAVA_PKG_CLASSPATH "${jar#${D}}" 313 java-pkg_append_ JAVA_PKG_CLASSPATH "${jar#${D}}"
254 elif [[ -e "${D}${jar}" ]]; then
255 java-pkg_append_ JAVA_PKG_CLASSPATH "${jar#${D}}"
256 else 314 else
257 die "${jar} does not exist" 315 die "${jar} does not exist"
258 fi 316 fi
259 done 317 done
260 318
261 java-pkg_do_write_ 319 java-pkg_do_write_
262} 320}
263
264 321
265# ------------------------------------------------------------------------------ 322# ------------------------------------------------------------------------------
266# @ebuild-function java-pkg_newjar 323# @ebuild-function java-pkg_newjar
267# 324#
268# Installs a jar with a new name 325# Installs a jar with a new name
279 local original_jar="${1}" 336 local original_jar="${1}"
280 local new_jar="${2:-${PN}.jar}" 337 local new_jar="${2:-${PN}.jar}"
281 local new_jar_dest="${T}/${new_jar}" 338 local new_jar_dest="${T}/${new_jar}"
282 339
283 [[ -z ${original_jar} ]] && die "Must specify a jar to install" 340 [[ -z ${original_jar} ]] && die "Must specify a jar to install"
284 [[ ! -f ${original_jar} ]] && die "${original_jar} does not exist!" 341 [[ ! -f ${original_jar} ]] \
342 && die "${original_jar} does not exist or is not a file!"
285 343
286 rm -f "${new_jar_dest}" || die "Failed to remove ${new_jar_dest}" 344 rm -f "${new_jar_dest}" || die "Failed to remove ${new_jar_dest}"
287 cp "${original_jar}" "${new_jar_dest}" \ 345 cp "${original_jar}" "${new_jar_dest}" \
288 || die "Failed to copy ${original_jar} to ${new_jar_dest}" 346 || die "Failed to copy ${original_jar} to ${new_jar_dest}"
289 java-pkg_dojar "${new_jar_dest}" 347 java-pkg_dojar "${new_jar_dest}"
290} 348}
291 349
292
293# ------------------------------------------------------------------------------ 350# ------------------------------------------------------------------------------
294# @ebuild-function java-pkg_addcp 351# @ebuild-function java-pkg_addcp
295# 352#
296# Add something to the package's classpath. For jars, you should use dojar, 353# 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. 354# newjar, or regjar. This is typically used to add directories to the classpath.
302java-pkg_addcp() { 359java-pkg_addcp() {
303 java-pkg_append_ JAVA_PKG_CLASSPATH "${@}" 360 java-pkg_append_ JAVA_PKG_CLASSPATH "${@}"
304 java-pkg_do_write_ 361 java-pkg_do_write_
305} 362}
306 363
307
308# ------------------------------------------------------------------------------ 364# ------------------------------------------------------------------------------
309# @ebuild-function java-pkg_doso 365# @ebuild-function java-pkg_doso
310# 366#
311# Installs any number of JNI libraries 367# Installs any number of JNI libraries
312# They will be installed into /usr/lib by default, but java-pkg_sointo 368# They will be installed into /usr/lib by default, but java-pkg_sointo
313# can be used change this path 369# can be used change this path
314# 370#
315# Example: 371# Example:
370 java-pkg_check-phase install 426 java-pkg_check-phase install
371 427
372 [[ ${#} -lt 1 ]] && "at least one argument needed" 428 [[ ${#} -lt 1 ]] && "at least one argument needed"
373 429
374 java-pkg_init_paths_ 430 java-pkg_init_paths_
375 431
376 local lib target_dir 432 local lib target_dir
377 for lib in "$@" ; do 433 for lib in "$@" ; do
378 # Check the absolute path of the lib 434 # Check the absolute path of the lib
379 if [[ -e "${lib}" ]] ; then 435 if [[ -e "${lib}" ]] ; then
380 target_dir="$(java-pkg_expand_dir_ ${lib})" 436 target_dir="$(java-pkg_expand_dir_ ${lib})"
428# ------------------------------------------------------------------------------ 484# ------------------------------------------------------------------------------
429java-pkg_dohtml() { 485java-pkg_dohtml() {
430 debug-print-function ${FUNCNAME} $* 486 debug-print-function ${FUNCNAME} $*
431 487
432 [[ ${#} -lt 1 ]] && die "At least one argument required for ${FUNCNAME}" 488 [[ ${#} -lt 1 ]] && die "At least one argument required for ${FUNCNAME}"
433 # TODO-nichoj find out what exactly -f package-list does 489
490 # from /usr/lib/portage/bin/dohtml -h
491 # -f Set list of allowed extensionless file names.
434 dohtml -f package-list "$@" 492 dohtml -f package-list "$@"
493
435 # this probably shouldn't be here but it provides 494 # this probably shouldn't be here but it provides
436 # a reasonable way to catch # docs for all of the 495 # a reasonable way to catch # docs for all of the
437 # old ebuilds. 496 # old ebuilds.
438 java-pkg_recordjavadoc 497 java-pkg_recordjavadoc
439} 498}
440 499
441# TODO document 500# ------------------------------------------------------------------------------
501# @ebuild-function java-pkg_dojavadoc
502#
503# Installs javadoc documentation. This should be controlled by the doc use flag.
504#
505# @param $1: - The javadoc root directory.
506#
507# @example:
508# java-pkg_dojavadoc docs/api
509#
510# ------------------------------------------------------------------------------
442java-pkg_dojavadoc() { 511java-pkg_dojavadoc() {
443 local dir="$1" 512 local dir="$1"
444 513
445 java-pkg_check-phase install 514 java-pkg_check-phase install
446 515
458} 527}
459 528
460# ------------------------------------------------------------------------------ 529# ------------------------------------------------------------------------------
461# @ebuild-function java-pkg_dosrc 530# @ebuild-function java-pkg_dosrc
462# 531#
463# Installs a zip containing the source for a package, so it can used in 532# Installs a zip containing the source for a package, so it can used in
464# from IDEs like eclipse and netbeans. 533# from IDEs like eclipse and netbeans.
465# 534#
466# Ebuild needs to DEPEND on app-arch/zip to use this. 535# Ebuild needs to DEPEND on app-arch/zip to use this.
467# 536#
468# It also should be controlled by USE=source. 537# It also should be controlled by USE=source.
469# 538#
470# @example: 539# @example:
471# java-pkg_dosrc src/* 540# java-pkg_dosrc src/*
472# 541#
473# ------------------------------------------------------------------------------ 542# ------------------------------------------------------------------------------
474# TODO change so it the arguments it takes are the base directories containing 543# TODO change so it the arguments it takes are the base directories containing
475# source -nichoj 544# source -nichoj
476# TODO should we be able to handle multiple calls to dosrc? -nichoj 545# TODO should we be able to handle multiple calls to dosrc? -nichoj
477# TODO maybe we can take an existing zip/jar? -nichoj 546# TODO maybe we can take an existing zip/jar? -nichoj
478# FIXME apparently this fails if you give it an empty directories 547# FIXME apparently this fails if you give it an empty directories
479java-pkg_dosrc() { 548java-pkg_dosrc() {
480 debug-print-function ${FUNCNAME} $* 549 debug-print-function ${FUNCNAME} $*
481 550
482 [ ${#} -lt 1 ] && die "At least one argument needed" 551 [ ${#} -lt 1 ] && die "At least one argument needed"
483 if ! hasq source ${IUSE}; then 552 if ! hasq source ${IUSE}; then
484 echo "Java QA Notice: ${FUNCNAME} called without source in IUSE" 553 echo "Java QA Notice: ${FUNCNAME} called without source in IUSE"
485 fi 554 fi
486 555
487 java-pkg_check-phase install 556 java-pkg_check-phase install
488 557
489 [[ ${#} -lt 1 ]] && die "At least one argument needed" 558 [[ ${#} -lt 1 ]] && die "At least one argument needed"
490 559
491 java-pkg_init_paths_ 560 java-pkg_init_paths_
492 561
493 local zip_name="${PN}-src.zip" 562 local zip_name="${PN}-src.zip"
494 local zip_path="${T}/${zip_name}" 563 local zip_path="${T}/${zip_name}"
495 local dir 564 local dir
496 for dir in ${@}; do 565 for dir in "${@}"; do
497 local dir_parent=$(dirname "${dir}") 566 local dir_parent=$(dirname "${dir}")
498 local dir_name=$(basename "${dir}") 567 local dir_name=$(basename "${dir}")
499 pushd ${dir_parent} > /dev/null || die "problem entering ${dir_parent}" 568 pushd ${dir_parent} > /dev/null || die "problem entering ${dir_parent}"
500 zip -q -r ${zip_path} ${dir_name} -i '*.java' 569 zip -q -r ${zip_path} ${dir_name} -i '*.java'
501 local result=$? 570 local result=$?
518# @ebuild-function java-pkg_dolauncher 587# @ebuild-function java-pkg_dolauncher
519# 588#
520# Make a wrapper script to lauch/start this package 589# Make a wrapper script to lauch/start this package
521# If necessary, the wrapper will switch to the appropriate VM. 590# If necessary, the wrapper will switch to the appropriate VM.
522# 591#
592# Can be called without parameters if the package installs only one jar
593# that has the Main-class attribute set. The wrapper will be named ${PN}.
594#
523# @param $1 - filename of launcher to create 595# @param $1 - filename of launcher to create
524# @param $2 - options, as follows: 596# @param $2 - options, as follows:
525# --main the.main.class.too.start 597# --main the.main.class.too.start
526# --jar /the/jar/too/launch.jar 598# --jar /the/jar/too/launch.jar or just <name>.jar
527# --java_args 'Extra arguments to pass too jave' 599# --java_args 'Extra arguments to pass to java'
528# --pkg_args 'extra arguments too pass too the package' 600# --pkg_args 'Extra arguments to pass to the package'
529# --pwd 601# --pwd Directory the launcher changes to before executing java
530# -into 602# -into Directory to install the launcher to, instead of /usr/bin
531# -pre 603# -pre Prepend contents of this file to the launcher
532# ------------------------------------------------------------------------------ 604# ------------------------------------------------------------------------------
533java-pkg_dolauncher() { 605java-pkg_dolauncher() {
534 debug-print-function ${FUNCNAME} $* 606 debug-print-function ${FUNCNAME} $*
535 607
536 java-pkg_check-phase install 608 java-pkg_check-phase install
537
538 [[ ${#} -lt 1 ]] && die "Need at least one argument"
539
540 java-pkg_init_paths_ 609 java-pkg_init_paths_
541 610
611 if [[ ${#} = 0 ]]; then
612 local name="${PN}"
613 else
542 local name="${1}" 614 local name="${1}"
615 shift
616 fi
617
543 # TODO rename to launcher 618 # TODO rename to launcher
544 local target="${T}/${name}" 619 local target="${T}/${name}"
620 local var_tmp="${T}/launcher_variables_tmp"
545 local target_dir pre 621 local target_dir pre
546 shift
547 622
548 echo "#!/bin/bash" > "${target}" 623 # Process the other the rest of the arguments
549 while [[ -n "${1}" && -n "${2}" ]]; do 624 while [[ -n "${1}" && -n "${2}" ]]; do
550 local var=${1} value=${2} 625 local var="${1}" value="${2}"
551 if [[ "${var:0:2}" == "--" ]]; then 626 if [[ "${var:0:2}" == "--" ]]; then
627 local var=${var:2}
552 echo "gjl_${var:2}=\"${value}\"" >> "${target}" 628 echo "gjl_${var}=\"${value}\"" >> "${var_tmp}"
629 local gjl_${var}="${value}"
553 elif [[ "${var}" == "-into" ]]; then 630 elif [[ "${var}" == "-into" ]]; then
554 target_dir="${value}" 631 target_dir="${value}"
555 elif [[ "${var}" == "-pre" ]]; then 632 elif [[ "${var}" == "-pre" ]]; then
556 pre="${value}" 633 pre="${value}"
557 fi 634 fi
558 shift 2 635 shift 2
559 done 636 done
637
638 # Test if no --jar and --main arguments were given and
639 # in that case check if the package only installs one jar
640 # and use that jar.
641 if [[ -z "${gjl_jar}" && -z "${gjl_main}" ]]; then
642 local cp="${JAVA_PKG_CLASSPATH}"
643 if [[ "${cp/:}" = "${cp}" && "${cp%.jar}" != "${cp}" ]]; then
644 echo "gjl_jar=\"${JAVA_PKG_CLASSPATH}\"" >> "${var_tmp}"
645 else
646 local msg="Not enough information to create a launcher given."
647 msg="${msg} Please give --jar or --main argument to ${FUNCNAME}."
648 die "${msg}"
649 fi
650 fi
651
652 # Write the actual script
653 echo "#!/bin/bash" > "${target}"
654 if [[ -n "${pre}" ]]; then
655 if [[ -f "${pre}" ]]; then
656 cat "${pre}" >> "${target}"
657 else
658 die "-pre specified file '${pre}' does not exist"
659 fi
660 fi
560 echo "gjl_package=${JAVA_PKG_NAME}" >> "${target}" 661 echo "gjl_package=${JAVA_PKG_NAME}" >> "${target}"
561 [[ -n "${pre}" ]] && [[ -f "${pre}" ]] && cat "${pre}" >> "${target}" 662 cat "${var_tmp}" >> "${target}"
663 rm -f "${var_tmp}"
562 echo "source /usr/share/java-config-2/launcher/launcher.bash" >> "${target}" 664 echo "source /usr/share/java-config-2/launcher/launcher.bash" >> "${target}"
563 665
564 if [[ -n "${into}" ]]; then 666 if [[ -n "${target_dir}" ]]; then
565 DESTTREE="${target_dir}" dobin "${target}" 667 DESTTREE="${target_dir}" dobin "${target}"
566 local ret=$? 668 local ret=$?
567 return ${ret} 669 return ${ret}
568 else 670 else
569 dobin "${target}" 671 dobin "${target}"
597 echo "dowar: warning, skipping directory ${war}" 699 echo "dowar: warning, skipping directory ${war}"
598 continue 700 continue
599 else 701 else
600 warpath="${war}" 702 warpath="${war}"
601 fi 703 fi
602 704
603 # Install those files like you mean it 705 # Install those files like you mean it
604 INSOPTIONS="-m 0644" \ 706 INSOPTIONS="-m 0644" \
605 INSDESTTREE=${JAVA_PKG_WARDEST} \ 707 INSDESTTREE=${JAVA_PKG_WARDEST} \
606 doins ${warpath} 708 doins ${warpath}
607 done 709 done
642# @ebuild-function java-pkg_jar-from 744# @ebuild-function java-pkg_jar-from
643# 745#
644# Makes a symlink to a jar from a certain package 746# Makes a symlink to a jar from a certain package
645# A lot of java packages include dependencies in a lib/ directory 747# A lot of java packages include dependencies in a lib/ directory
646# You can use this function to replace these bundled dependencies. 748# You can use this function to replace these bundled dependencies.
749# The dependency is recorded into package.env DEPEND line, unless "--build-only"
750# is passed as the very first argument, for jars that have to be present only
751# at build time and are not needed on runtime (junit testing etc).
647# 752#
648# Example: get all jars from xerces slot 2 753# Example: get all jars from xerces slot 2
649# java-pkg_jar-from xerces-2 754# java-pkg_jar-from xerces-2
650# Example: get a specific jar from xerces slot 2 755# Example: get a specific jar from xerces slot 2
651# java-pkg_jar-from xerces-2 xml-apis.jar 756# java-pkg_jar-from xerces-2 xml-apis.jar
652# Example get a specific jar from xerces slot 2, and name it diffrently 757# 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 758# java-pkg_jar-from xerces-2 xml-apis.jar xml.jar
759# Example: get junit.jar which is needed only for building
760# java-pkg_jar-from --build-only junit junit.jar
654# 761#
762# @param $opt
763# --build-only - makes the jar(s) not added into package.env DEPEND line.
764# (assumed automatically when called inside src_test)
765# --with-dependencies - get jars also from requested package's dependencies
766# transitively.
767# --into $dir - symlink jar(s) into $dir (must exist) instead of .
655# @param $1 - Package to get jars from. 768# @param $1 - Package to get jars from.
656# @param $2 - jar from package. If not specified, all jars will be used. 769# @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 770# @param $3 - When a single jar is specified, destination filename of the
658# symlink. Defaults to the name of the jar. 771# symlink. Defaults to the name of the jar.
659# ------------------------------------------------------------------------------ 772# ------------------------------------------------------------------------------
660# TODO could probably be cleaned up a little 773# TODO could probably be cleaned up a little
661java-pkg_jar-from() { 774java-pkg_jar-from() {
662 debug-print-function ${FUNCNAME} $* 775 debug-print-function ${FUNCNAME} $*
663 776
664 local target_pkg="${1}" target_jar="${2}" destjar="${3}" 777 local build_only=""
778 local destdir="."
779 local deep=""
665 780
781 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="true"
782
783 while [[ "${1}" == --* ]]; do
784 if [[ "${1}" = "--build-only" ]]; then
785 build_only="true"
786 elif [[ "${1}" = "--with-dependencies" ]]; then
787 deep="--with-dependencies"
788 elif [[ "${1}" = "--into" ]]; then
789 destdir="${2}"
790 shift
791 else
792 die "java-pkg_jar-from called with unknown parameter: ${1}"
793 fi
794 shift
795 done
796
797 local target_pkg="${1}" target_jar="${2}" destjar="${3}"
798
666 [[ -z ${target_pkg} ]] && die "Must specify a package" 799 [[ -z ${target_pkg} ]] && die "Must specify a package"
667 800
668 # default destjar to the target jar 801 # default destjar to the target jar
669 [[ -z "${destjar}" ]] && destjar="${target_jar}" 802 [[ -z "${destjar}" ]] && destjar="${target_jar}"
670 803
804 local error_msg="There was a problem getting the classpath for ${target_pkg}."
805 local classpath
671 local classpath="$(java-config --classpath=${target_pkg})" 806 classpath="$(java-config ${deep} --classpath=${target_pkg})"
672 [[ $? != 0 ]] && die "There was a problem getting the classpath for ${target_pkg}" 807 [[ $? != 0 ]] && die ${error_msg}
673 808
809 pushd ${destdir} > /dev/null \
810 || die "failed to change directory to ${destdir}"
674 local jar 811 local jar
675 for jar in ${classpath//:/ }; do 812 for jar in ${classpath//:/ }; do
676 local jar_name=$(basename "${jar}") 813 local jar_name=$(basename "${jar}")
677 if [[ ! -f "${jar}" ]] ; then 814 if [[ ! -f "${jar}" ]] ; then
678 debug-print "${jar} from ${target_pkg} does not exist" 815 debug-print "${jar} from ${target_pkg} does not exist"
681 # If no specific target jar was indicated, link it 818 # If no specific target jar was indicated, link it
682 if [[ -z "${target_jar}" ]] ; then 819 if [[ -z "${target_jar}" ]] ; then
683 [[ -f "${target_jar}" ]] && rm "${target_jar}" 820 [[ -f "${target_jar}" ]] && rm "${target_jar}"
684 ln -snf "${jar}" \ 821 ln -snf "${jar}" \
685 || die "Failed to make symlink from ${jar} to ${jar_name}" 822 || die "Failed to make symlink from ${jar} to ${jar_name}"
686 java-pkg_record-jar_ "${target_pkg}" "${jar}" 823 [[ -z "${build_only}" ]] && java-pkg_record-jar_ "${target_pkg}" "${jar}"
687 # otherwise, if the current jar is the target jar, link it 824 # otherwise, if the current jar is the target jar, link it
688 elif [[ "${jar_name}" == "${target_jar}" ]] ; then 825 elif [[ "${jar_name}" == "${target_jar}" ]] ; then
689 [[ -f "${destjar}" ]] && rm "${destjar}" 826 [[ -f "${destjar}" ]] && rm "${destjar}"
690 ln -snf "${jar}" "${destjar}" \ 827 ln -snf "${jar}" "${destjar}" \
691 || die "Failed to make symlink from ${jar} to ${destjar}" 828 || die "Failed to make symlink from ${jar} to ${destjar}"
692 java-pkg_record-jar_ "${target_pkg}" "${jar}" 829 [[ -z "${build_only}" ]] && java-pkg_record-jar_ "${target_pkg}" "${jar}"
693 return 0 830 return 0
694 fi 831 fi
695 done 832 done
833 popd > /dev/null
696 # if no target was specified, we're ok 834 # if no target was specified, we're ok
697 if [[ -z "${target_jar}" ]] ; then 835 if [[ -z "${target_jar}" ]] ; then
698 return 0 836 return 0
699 # otherwise, die bitterly 837 # otherwise, die bitterly
700 else 838 else
714# ------------------------------------------------------------------------------ 852# ------------------------------------------------------------------------------
715# @ebuild-function java-pkg_getjars 853# @ebuild-function java-pkg_getjars
716# 854#
717# Get the classpath provided by any number of packages 855# Get the classpath provided by any number of packages
718# Among other things, this can be passed to 'javac -classpath' or 'ant -lib'. 856# Among other things, this can be passed to 'javac -classpath' or 'ant -lib'.
857# The providing packages are recorded as dependencies into package.env DEPEND
858# line, unless "--build-only" is passed as the very first argument, for jars
859# that have to be present only at build time and are not needed on runtime
860# (junit testing etc).
719# 861#
720# Example: Get the classpath for xerces-2, 862# Example: Get the classpath for xerces-2 and xalan,
721# java-pkg_getjars xerces-2 xalan 863# java-pkg_getjars xerces-2,xalan
722# Example Return: 864# Example Return:
723# /usr/share/xerces-2/lib/xml-apis.jar:/usr/share/xerces-2/lib/xmlParserAPIs.jar:/usr/share/xalan/lib/xalan.jar 865# /usr/share/xerces-2/lib/xml-apis.jar:/usr/share/xerces-2/lib/xmlParserAPIs.jar:/usr/share/xalan/lib/xalan.jar
724# 866#
867# @param $opt
868# --build-only - makes the jar(s) not added into package.env DEPEND line.
869# (assumed automatically when called inside src_test)
870# --with-dependencies - get jars also from requested package's dependencies
871# transitively.
725# @param $@ - list of packages to get jars from 872# @param $1 - list of packages to get jars from
873# (passed to java-config --classpath)
726# ------------------------------------------------------------------------------ 874# ------------------------------------------------------------------------------
727java-pkg_getjars() { 875java-pkg_getjars() {
728 debug-print-function ${FUNCNAME} $* 876 debug-print-function ${FUNCNAME} $*
729 877
730 [[ ${#} -lt 1 ]] && die "At least one argument needed" 878 local build_only=""
879 local deep=""
880
881 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="true"
731 882
732 # NOTE could probably just pass $@ to java-config --classpath. and return it 883 while [[ "${1}" == --* ]]; do
733 local classpath pkg 884 if [[ "${1}" = "--build-only" ]]; then
734 for pkg in ${@//,/ }; do 885 build_only="true"
735 #for pkg in $(echo "$@" | tr ',' ' '); do 886 elif [[ "${1}" = "--with-dependencies" ]]; then
736 jars="$(java-config --classpath=${pkg})" 887 deep="--with-dependencies"
737 debug-print "${pkg}:${jars}"
738 # TODO should we ensure jars exist?
739 if [[ -z "${classpath}" ]]; then
740 classpath="${jars}"
741 else 888 else
742 classpath="${classpath}:${jars}" 889 die "java-pkg_jar-from called with unknown parameter: ${1}"
743 fi 890 fi
744 java-pkg_record-jar_ "${pkg}" 891 shift
745 done 892 done
893
894 [[ ${#} -ne 1 ]] && die "${FUNCNAME} takes only one argument besides --*"
895
896 local classpath pkgs="${1}"
897 jars="$(java-config ${deep} --classpath=${pkgs})"
898 [[ -z "${jars}" ]] && die "java-config --classpath=${pkgs} failed"
899 debug-print "${pkgs}:${jars}"
900
901 if [[ -z "${classpath}" ]]; then
902 classpath="${jars}"
903 else
904 classpath="${classpath}:${jars}"
905 fi
906
907 # Only record jars that aren't build-only
908 if [[ -z "${build_only}" ]]; then
909 oldifs="${IFS}"
910 IFS=","
911 for pkg in ${pkgs}; do
912 java-pkg_record-jar_ "${pkg}"
913 done
914 IFS="${oldifs}"
915 fi
916
746 echo "${classpath}" 917 echo "${classpath}"
747} 918}
748 919
749# ------------------------------------------------------------------------------ 920# ------------------------------------------------------------------------------
750# @ebuild-function java-pkg_getjar 921# @ebuild-function java-pkg_getjar
751# 922#
752# Get the filename of a single jar from a package 923# Get the filename of a single jar from a package
924# The providing package is recorded as runtime dependency into package.env
925# DEPEND line, unless "--build-only" is passed as the very first argument, for
926# jars that have to be present only at build time and are not needed on runtime
927# (junit testing etc).
753# 928#
754# @example 929# @example
755# java-pkg_getjar xerces-2 xml-apis.jar 930# java-pkg_getjar xerces-2 xml-apis.jar
756# @example-return 931# @example-return
757# /usr/share/xerces-2/lib/xml-apis.jar 932# /usr/share/xerces-2/lib/xml-apis.jar
758# 933#
934# @param $opt
935# --build-only - makes the jar not added into package.env DEPEND line.
759# @param $1 - package to use 936# @param $1 - package to use
760# @param $2 - jar to get 937# @param $2 - jar to get
761# ------------------------------------------------------------------------------ 938# ------------------------------------------------------------------------------
762java-pkg_getjar() { 939java-pkg_getjar() {
763 debug-print-function ${FUNCNAME} $* 940 debug-print-function ${FUNCNAME} $*
941
942 local build_only=""
943
944 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="true"
945
946 while [[ "${1}" == --* ]]; do
947 if [[ "${1}" = "--build-only" ]]; then
948 build_only="true"
949 else
950 die "java-pkg_jar-from called with unknown parameter: ${1}"
951 fi
952 shift
953 done
954
955 [[ ${#} -ne 2 ]] && die "${FUNCNAME} takes only two arguments besides --*"
764 956
765 local pkg="${1}" target_jar="${2}" jar 957 local pkg="${1}" target_jar="${2}" jar
766 [[ -z ${pkg} ]] && die "Must specify package to get a jar from" 958 [[ -z ${pkg} ]] && die "Must specify package to get a jar from"
767 [[ -z ${target_jar} ]] && die "Must specify jar to get" 959 [[ -z ${target_jar} ]] && die "Must specify jar to get"
768 960
769 # TODO check that package is actually installed 961 local error_msg="Could not find classpath for ${pkg}. Are you sure its installed?"
962 local classpath
770 local classpath=$(java-config --classpath=${pkg}) 963 classpath=$(java-config --classpath=${pkg})
771 [[ $? != 0 ]] && die "There could not find classpath for ${pkg}. Are you sure its installed?" 964 [[ $? != 0 ]] && die ${error_msg}
965
772 for jar in ${classpath//:/ }; do 966 for jar in ${classpath//:/ }; do
773 if [[ ! -f "${jar}" ]] ; then 967 if [[ ! -f "${jar}" ]] ; then
774 die "Installation problems with jars in ${pkg} - is it installed?" 968 die "Installation problem with jar ${jar} in ${pkg} - is it installed?"
775 fi 969 fi
776 970
777 if [[ "$(basename ${jar})" == "${target_jar}" ]] ; then 971 if [[ "$(basename ${jar})" == "${target_jar}" ]] ; then
778 java-pkg_record-jar_ "${pkg}" "${jar}" 972 # Only record jars that aren't build-only
973 [[ -z "${build_only}" ]] && java-pkg_record-jar_ "${pkg}" "${jar}"
779 echo "${jar}" 974 echo "${jar}"
780 return 0 975 return 0
781 fi 976 fi
782 done 977 done
783 978
784 die "Could not find ${target_jar} in ${pkg}" 979 die "Could not find ${target_jar} in ${pkg}"
785 return 1 980 return 1
786} 981}
787 982
788# This function reads stdin, and based on that input, figures out how to 983# This function reads stdin, and based on that input, figures out how to
802# line="${line// /}" 997# line="${line// /}"
803# 998#
804# # format: path=jarinfo 999# # format: path=jarinfo
805# local path=${line%%=*} 1000# local path=${line%%=*}
806# local jarinfo=${line##*=} 1001# local jarinfo=${line##*=}
807# 1002#
808# # format: jar@package 1003# # format: jar@package
809# local jar=${jarinfo%%@*}.jar 1004# local jar=${jarinfo%%@*}.jar
810# local package=${jarinfo##*@} 1005# local package=${jarinfo##*@}
811# if [[ -n ${replace_only} ]]; then 1006# if [[ -n ${replace_only} ]]; then
812# [[ ! -f $path ]] && die "No jar exists at ${path}" 1007# [[ ! -f $path ]] && die "No jar exists at ${path}"
825# @section-end query 1020# @section-end query
826# ------------------------------------------------------------------------------ 1021# ------------------------------------------------------------------------------
827 1022
828# ------------------------------------------------------------------------------ 1023# ------------------------------------------------------------------------------
829# @section-begin helper 1024# @section-begin helper
830# @section-summary Helper functions 1025# @section-summary Helper functions
831# 1026#
832# Various other functions to use from an ebuild 1027# Various other functions to use from an ebuild
833# ------------------------------------------------------------------------------ 1028# ------------------------------------------------------------------------------
834 1029
835# ------------------------------------------------------------------------------ 1030# ------------------------------------------------------------------------------
841# jdbc-stdext 1036# jdbc-stdext
842# jaf 1037# jaf
843# jdbc-rowset 1038# jdbc-rowset
844# jms 1039# jms
845# 1040#
846# @param $1 - Optionally indicate that the dependencies are controlled by 1041# @param $1 - Optionally indicate that the dependencies are controlled by
847# a use flag by specifying '--use' Requires $2. 1042# a use flag by specifying '--use' Requires $2.
848# @param $2 - USE flag which will enable the dependencies. 1043# @param $2 - USE flag which will enable the dependencies.
849# @param $@ - virtual packages to add depenedencies for 1044# @param $@ - virtual packages to add depenedencies for
850# ------------------------------------------------------------------------------ 1045# ------------------------------------------------------------------------------
851# TODO rewrite to parse a line based declaration file instead -- karltk 1046# TODO rewrite to parse a line based declaration file instead -- karltk
907# 1102#
908# export DEPEND="${DEPEND} ${depstr}" 1103# export DEPEND="${DEPEND} ${depstr}"
909# export RDEPEND="${RDEPEND} ${depstr}" 1104# export RDEPEND="${RDEPEND} ${depstr}"
910#} 1105#}
911 1106
1107# ------------------------------------------------------------------------------
1108# @ebuild-function java-pkg_find-normal-jars
1109#
1110# Find the files with suffix .jar file in the given directory or $WORKDIR
1111#
1112# @param $1 - The directory to search for jar files (default: ${WORKDIR})
1113# ------------------------------------------------------------------------------
1114java-pkg_find-normal-jars() {
1115 local dir=$1
1116 [[ "${dir}" ]] || dir="${WORKDIR}"
1117 local found
1118 for jar in $(find "${dir}" -name "*.jar" -type f); do
1119 echo "${jar}"
1120 found="true"
1121 done
1122 [[ "${found}" ]]
1123 return $?
1124}
1125
1126# ------------------------------------------------------------------------------
1127# @ebuild-function java-pkg_ensure-no-bundled-jars
1128#
1129# Try to locate bundled jar files in ${WORKDIR} and die if found.
912# This should be used after S has been populated with symlinks to jars 1130# This function should be called after WORKDIR has been populated with symlink
913# TODO document 1131# to system jar files or bundled jars removed.
1132# ------------------------------------------------------------------------------
914java-pkg_ensure-no-bundled-jars() { 1133java-pkg_ensure-no-bundled-jars() {
915 debug-print-function ${FUNCNAME} $* 1134 debug-print-function ${FUNCNAME} $*
916 pushd ${WORKDIR} >/dev/null 2>/dev/null
917 1135
918 local bundled_jars=$(find . -name "*.jar" -type f) 1136 local bundled_jars=$(java-pkg_find-normal-jars)
919 if [[ -n ${bundled_jars} ]]; then 1137 if [[ -n ${bundled_jars} ]]; then
920 echo "Bundled jars found:" 1138 echo "Bundled jars found:"
921 local jar 1139 local jar
922 for jar in ${bundled_jars}; do 1140 for jar in ${bundled_jars}; do
923 echo $(pwd)${jar/./} 1141 echo $(pwd)${jar/./}
924 done 1142 done
925 die "Bundled jars found!" 1143 die "Bundled jars found!"
926
927 fi 1144 fi
928 popd >/dev/null 2>/dev/null
929} 1145}
930 1146
931# ------------------------------------------------------------------------------ 1147# ------------------------------------------------------------------------------
932# @internal-function java-pkg_ensure-vm-version-sufficient 1148# @internal-function java-pkg_ensure-vm-version-sufficient
933# 1149#
945 fi 1161 fi
946} 1162}
947 1163
948# ------------------------------------------------------------------------------ 1164# ------------------------------------------------------------------------------
949# @internal-function java-pkg_is-vm-version-sufficient 1165# @internal-function java-pkg_is-vm-version-sufficient
950# 1166#
951# @return zero - VM is sufficient 1167# @return zero - VM is sufficient
952# @return non-zero - VM is not sufficient 1168# @return non-zero - VM is not sufficient
953# ------------------------------------------------------------------------------ 1169# ------------------------------------------------------------------------------
954java-pkg_is-vm-version-sufficient() { 1170java-pkg_is-vm-version-sufficient() {
955 debug-print-function ${FUNCNAME} $* 1171 debug-print-function ${FUNCNAME} $*
975 die "Active Java VM too old" 1191 die "Active Java VM too old"
976 fi 1192 fi
977} 1193}
978 1194
979# ------------------------------------------------------------------------------ 1195# ------------------------------------------------------------------------------
980# @internal-function java-pkg_is-vm-version-eq 1196# @internal-function java-pkg_is-vm-version-eq
981# 1197#
982# @param $@ - VM version to compare current VM to 1198# @param $@ - VM version to compare current VM to
983# @return zero - VM versions are equal 1199# @return zero - VM versions are equal
984# @return non-zero - VM version are not equal 1200# @return non-zero - VM version are not equal
985# ------------------------------------------------------------------------------ 1201# ------------------------------------------------------------------------------
986java-pkg_is-vm-version-eq() { 1202java-pkg_is-vm-version-eq() {
1016# 1232#
1017# @param $@ - VM version to compare current to 1233# @param $@ - VM version to compare current to
1018# ------------------------------------------------------------------------------ 1234# ------------------------------------------------------------------------------
1019java-pkg_ensure-vm-version-ge() { 1235java-pkg_ensure-vm-version-ge() {
1020 debug-print-function ${FUNCNAME} $* 1236 debug-print-function ${FUNCNAME} $*
1021 1237
1022 if ! java-pkg_is-vm-version-ge "$@" ; then 1238 if ! java-pkg_is-vm-version-ge "$@" ; then
1023 debug-print "vm is not suffient" 1239 debug-print "vm is not suffient"
1024 eerror "This package requires a Java VM version >= $@" 1240 eerror "This package requires a Java VM version >= $@"
1025 einfo "Please use java-config -S to set the correct one" 1241 einfo "Please use java-config -S to set the correct one"
1026 die "Active Java VM too old" 1242 die "Active Java VM too old"
1027 fi 1243 fi
1028} 1244}
1029 1245
1030# ------------------------------------------------------------------------------ 1246# ------------------------------------------------------------------------------
1031# @internal-function java-pkg_is-vm-version-ge 1247# @internal-function java-pkg_is-vm-version-ge
1032# 1248#
1033# @param $@ - VM version to compare current VM to 1249# @param $@ - VM version to compare current VM to
1034# @return zero - current VM version is greater than checked version 1250# @return zero - current VM version is greater than checked version
1035# @return non-zero - current VM version is not greater than checked version 1251# @return non-zero - current VM version is not greater than checked version
1036# ------------------------------------------------------------------------------ 1252# ------------------------------------------------------------------------------
1037java-pkg_is-vm-version-ge() { 1253java-pkg_is-vm-version-ge() {
1060java-pkg_get-current-vm() { 1276java-pkg_get-current-vm() {
1061 echo ${GENTOO_VM} 1277 echo ${GENTOO_VM}
1062} 1278}
1063 1279
1064java-pkg_current-vm-matches() { 1280java-pkg_current-vm-matches() {
1065 hasq java-pkg_get-currenv-vm ${@} 1281 hasq $(java-pkg_get-current-vm) ${@}
1066 return $? 1282 return $?
1067} 1283}
1068 1284
1069# ------------------------------------------------------------------------------ 1285# ------------------------------------------------------------------------------
1070# @ebuild-function java-pkg_get-source 1286# @ebuild-function java-pkg_get-source
1071# 1287#
1072# Determines what source version should be used, for passing to -source. 1288# Determines what source version should be used, for passing to -source.
1073# Unless you want to break things you probably shouldn't set _WANT_SOURCE 1289# Unless you want to break things you probably shouldn't set _WANT_SOURCE
1074# 1290#
1075# @return string - Either the lowest possible source, or JAVA_PKG_WANT_SOURCE 1291# @return string - Either the lowest possible source, or JAVA_PKG_WANT_SOURCE
1076# ------------------------------------------------------------------------------ 1292# ------------------------------------------------------------------------------
1081# ------------------------------------------------------------------------------ 1297# ------------------------------------------------------------------------------
1082# @ebuild-function java-pkg_get-target 1298# @ebuild-function java-pkg_get-target
1083# 1299#
1084# Determines what target version should be used, for passing to -target. 1300# Determines what target version should be used, for passing to -target.
1085# If you don't care about lower versions, you can set _WANT_TARGET to the 1301# If you don't care about lower versions, you can set _WANT_TARGET to the
1086# version of your JDK. 1302# version of your JDK.
1087# Remember doing this will mostly like cause things to break.
1088# Doesn't allow it to be lower then the one in depend.
1089# Doesn't allow it to be higher then the active vm.
1090# 1303#
1091# @return string - Either the lowest possible target, or JAVA_PKG_WANT_TARGET 1304# @return string - Either the lowest possible target, or JAVA_PKG_WANT_TARGET
1092# ------------------------------------------------------------------------------ 1305# ------------------------------------------------------------------------------
1093java-pkg_get-target() { 1306java-pkg_get-target() {
1094 local min=$(depend-java-query --get-lowest "${DEPEND} ${RDEPEND}")
1095 if [[ -n "${JAVA_PKG_WANT_TARGET}" ]]; then
1096 local max="$(java-config --select-vm "${GENTOO_VM}" -g PROVIDES_VERSION)"
1097 if version_is_at_least "${min}" "${JAVA_PKG_WANT_TARGET}" && version_is_at_least "${JAVA_PKG_WANT_TARGET}" "${max}"; then
1098 echo ${JAVA_PKG_WANT_TARGET}
1099 else
1100 echo ${min}
1101 fi
1102 else
1103 echo ${min}
1104 fi
1105
1106 #echo ${JAVA_PKG_WANT_TARGET:-$(depend-java-query --get-lowest "${DEPEND}")} 1307 echo ${JAVA_PKG_WANT_TARGET:-$(depend-java-query --get-lowest "${DEPEND} ${RDEPEND}")}
1107} 1308}
1108 1309
1109java-pkg_get-javac() { 1310java-pkg_get-javac() {
1110 debug-print-function ${FUNCNAME} $* 1311 debug-print-function ${FUNCNAME} $*
1111 1312
1112 java-pkg_init-compiler_ 1313
1113 local compiler="${GENTOO_COMPILER}" 1314 local compiler="${GENTOO_COMPILER}"
1114 1315
1115 local compiler_executable 1316 local compiler_executable
1116 if [[ "${compiler}" = "javac" ]]; then 1317 if [[ "${compiler}" = "javac" ]]; then
1117 # nothing fancy needs to be done for javac 1318 # nothing fancy needs to be done for javac
1125 unset JAVAC 1326 unset JAVAC
1126 # try to get value of JAVAC 1327 # try to get value of JAVAC
1127 compiler_executable="$(source ${compiler_env} 1>/dev/null 2>&1; echo ${JAVAC})" 1328 compiler_executable="$(source ${compiler_env} 1>/dev/null 2>&1; echo ${JAVAC})"
1128 export JAVAC=${old_javac} 1329 export JAVAC=${old_javac}
1129 1330
1130 [[ -z ${compiler_executable} ]] && die "JAVAC is empty or undefined in ${compiler_env}" 1331 if [[ -z ${compiler_executable} ]]; then
1131 1332 echo "JAVAC is empty or undefined in ${compiler_env}"
1333 return 1
1334 fi
1335
1132 # check that it's executable 1336 # check that it's executable
1133 if [[ ! -x ${compiler_executable} ]]; then 1337 if [[ ! -x ${compiler_executable} ]]; then
1134 eerror "Could not find ${compiler_executable}!"
1135 die "${compiler_executable} doesn't exist, or isn't executable" 1338 echo "${compiler_executable} doesn't exist, or isn't executable"
1339 return 1
1136 fi 1340 fi
1137 else 1341 else
1138 eerror "Could not find environment file for ${compiler}" 1342 echo "Could not find environment file for ${compiler}"
1139 die "Could not find ${compiler_env}" 1343 return 1
1140 fi 1344 fi
1141 fi 1345 fi
1142 echo ${compiler_executable} 1346 echo ${compiler_executable}
1143} 1347}
1144 1348
1145# ------------------------------------------------------------------------------ 1349# ------------------------------------------------------------------------------
1146# @ebuild-function java-pkg_javac-args 1350# @ebuild-function java-pkg_javac-args
1147# 1351#
1148# If an ebuild uses javac directly, instead of using ejavac, it should call this 1352# If an ebuild uses javac directly, instead of using ejavac, it should call this
1149# to know what -source/-target to use. 1353# to know what -source/-target to use.
1150# 1354#
1151# @return string - arguments to pass to javac, complete with -target and -source 1355# @return string - arguments to pass to javac, complete with -target and -source
1154 debug-print-function ${FUNCNAME} $* 1358 debug-print-function ${FUNCNAME} $*
1155 1359
1156 local want_source="$(java-pkg_get-source)" 1360 local want_source="$(java-pkg_get-source)"
1157 local want_target="$(java-pkg_get-target)" 1361 local want_target="$(java-pkg_get-target)"
1158 1362
1159 local source_str="-source ${want_source}" 1363 local source_str="-source ${want_source}"
1160 local target_str="-target ${want_target}" 1364 local target_str="-target ${want_target}"
1161 1365
1162 debug-print "want source: ${want_source}" 1366 debug-print "want source: ${want_source}"
1163 debug-print "want target: ${want_target}" 1367 debug-print "want target: ${want_target}"
1164 1368
1165 if [[ -z "${want_source}" || -z "${want_target}" ]]; then 1369 if [[ -z "${want_source}" || -z "${want_target}" ]]; then
1166 debug-print "could not find valid -source/-target values" 1370 debug-print "could not find valid -source/-target values for javac"
1167 die "Could not find valid -source/-target values" 1371 echo "Could not find valid -source/-target values for javac"
1372 return 1
1168 else 1373 else
1169 if java-pkg_is-vm-version-ge "1.4"; then 1374 if java-pkg_is-vm-version-ge "1.4"; then
1170 echo "${source_str} ${target_str}" 1375 echo "${source_str} ${target_str}"
1171 else 1376 else
1172 echo "${target_str}" 1377 echo "${target_str}"
1176 1381
1177# TODO document 1382# TODO document
1178java-pkg_get-jni-cflags() { 1383java-pkg_get-jni-cflags() {
1179 local flags="-I${JAVA_HOME}/include" 1384 local flags="-I${JAVA_HOME}/include"
1180 1385
1386 local platform="linux"
1387 use elibc_FreeBSD && platform="freebsd"
1388
1181 # TODO do a check that the directories are valid 1389 # TODO do a check that the directories are valid
1182 # TODO figure out how to cope with other things than linux...
1183 flags="${flags} -I${JAVA_HOME}/include/linux" 1390 flags="${flags} -I${JAVA_HOME}/include/${platform}"
1184 1391
1185 echo ${flags} 1392 echo ${flags}
1186} 1393}
1187 1394
1188java-pkg_ensure-gcj() { 1395java-pkg_ensure-gcj() {
1193 ebeep 5 1400 ebeep 5
1194 die "No GCJ support found!" 1401 die "No GCJ support found!"
1195 fi 1402 fi
1196} 1403}
1197 1404
1405java-pkg_ensure-test() {
1406 if hasq test ${FEATURES} && ! hasq -test ${FEATURES} \
1407 && hasq test ${IUSE} && ! use test;
1408 then
1409 eerror "You specified FEATURES=test, but USE=test is needed"
1410 eerror "to pull in the additional dependencies for testing"
1411 die "Need USE=test enabled"
1412 fi
1413}
1414
1415# ------------------------------------------------------------------------------
1416# @ebuild-function java-pkg_register-ant-task
1417#
1418# Register this package as ant task, so that ant will load it when no specific
1419# ANT_TASKS are specified. Note that even without this registering, all packages
1420# specified in ANT_TASKS will be loaded. Mostly used by the actual ant tasks
1421# packages, but can be also used by other ebuilds that used to symlink their
1422# .jar into /usr/share/ant-core/lib to get autoloaded, for backwards
1423# compatibility.
1424#
1425# @param --version x.y Register only for ant version x.y (otherwise for any ant
1426# version). Used by the ant-* packages to prevent loading of mismatched
1427# ant-core ant tasks after core was updated, before the tasks are updated,
1428# without a need for blockers.
1429# @param $1 Name to register as. Defaults to JAVA_PKG_NAME ($PN[-$SLOT])
1430# ------------------------------------------------------------------------------
1431java-pkg_register-ant-task() {
1432 local TASKS_DIR="tasks"
1433
1434 # check for --version x.y parameters
1435 while [[ -n "${1}" && -n "${2}" ]]; do
1436 local var="${1#--}"
1437 local val="${2}"
1438 if [[ "${var}" == "version" ]]; then
1439 TASKS_DIR="tasks-${val}"
1440 else
1441 die "Unknown parameter passed to java-pkg_register-ant-tasks: ${1} ${2}"
1442 fi
1443 shift 2
1444 done
1445
1446 local TASK_NAME="${1:-${JAVA_PKG_NAME}}"
1447
1448 dodir /usr/share/ant/${TASKS_DIR}
1449 touch "${D}/usr/share/ant/${TASKS_DIR}/${TASK_NAME}"
1450}
1451
1452# ------------------------------------------------------------------------------
1453# @internal-function java-pkg_ant-tasks-from-deps
1454#
1455# Function to determine ANT_TASKS from DEPEND variable for backwards
1456# compatibility with ebuilds that don't set ANT_TASKS before calling eant() or
1457# WANT_ANT_TASKS before inheriting java-pkg-2. If the DEPEND string contains
1458# "dev-java/ant" or "dev-java/ant-tasks", then it returns "all", otherwise
1459# "none". It's not smart enough to cope with USE flag depends but that shouldn't
1460# be a problem, the worst it can do is activace all tasks when not needed.
1461# Note that this is called only with JAVA_PKG_STRICT=1, to find ebuilds with
1462# insufficient dependencies, otherwise all available tasks are used for
1463# backwards compatilbility.
1464#
1465# @return "all" or "none"
1466# ------------------------------------------------------------------------------
1467java-pkg_ant-tasks-from-deps() {
1468 local found_ant found_ant_tasks
1469
1470 for dep in ${DEPEND}
1471 do
1472 local ant="$(awk '/(dev-java\/ant)/ { if (match($1, "(dev-java/ant)((-[0-9])+|$)", m)) print m[1] }' <<< ${dep})"
1473 [[ "${ant}" == "dev-java/ant" ]] && found_ant=true
1474 [[ "${dep}" == *"ant-tasks"* ]] && found_ant_tasks=true
1475 done
1476
1477 if [[ -n "${found_ant}" || -n "${found_ant_tasks}" ]]; then
1478 java-pkg_announce-qa-violation "The ebuild DEPENDS on deprecated ant or ant-tasks"
1479 echo "all"
1480 else
1481 # ebuild doesn't set ANT_TASKS and doesn't depend on ant-tasks or ant
1482 # so we deactivate all tasks that may be installed
1483 echo "none"
1484 fi
1485}
1486
1487# ------------------------------------------------------------------------------
1488# @internal-function java-pkg_ant-tasks-depend
1489#
1490# Translates the WANT_ANT_TASKS variable into valid dependencies.
1491# ------------------------------------------------------------------------------
1492java-pkg_ant-tasks-depend() {
1493 debug-print-function ${FUNCNAME} ${WANT_ANT_TASKS}
1494
1495 if [[ -n "${WANT_ANT_TASKS}" ]]; then
1496 local DEP=""
1497 for i in ${WANT_ANT_TASKS}
1498 do
1499 if [[ ${i} != ant-* ]]; then
1500 echo "Invalid atom in WANT_ANT_TASKS: ${i}"
1501 return 1
1502 fi
1503 DEP="${DEP}dev-java/${i} "
1504 done
1505 echo ${DEP}
1506 return 0
1507 else
1508 return 0
1509 fi
1510}
1511
1198# ------------------------------------------------------------------------------ 1512# ------------------------------------------------------------------------------
1199# @section-end helper 1513# @section-end helper
1200# ------------------------------------------------------------------------------ 1514# ------------------------------------------------------------------------------
1201 1515
1202# ------------------------------------------------------------------------------ 1516# ------------------------------------------------------------------------------
1209 1523
1210# ------------------------------------------------------------------------------ 1524# ------------------------------------------------------------------------------
1211# @ebuild-function eant 1525# @ebuild-function eant
1212# 1526#
1213# Ant wrapper function. Will use the appropriate compiler, based on user-defined 1527# Ant wrapper function. Will use the appropriate compiler, based on user-defined
1214# compiler. 1528# compiler. Will also set proper ANT_TASKS from the variable ANT_TASKS,
1215# 1529# variables:
1530# EANT_GENTOO_CLASSPATH - calls java-pkg_getjars for the value and adds to the
1531# gentoo.classpath property. Be sure to call
1532# java-ant_rewrite-classpath in src_unpack.
1533# *ANT_TASKS - used to determine ANT_TASKS before calling Ant.
1216# ------------------------------------------------------------------------------ 1534# ------------------------------------------------------------------------------
1217eant() { 1535eant() {
1218 debug-print-function ${FUNCNAME} $* 1536 debug-print-function ${FUNCNAME} $*
1219 1537
1220 # FIXME get this working 1538 # FIXME get this working
1221# if is-java-strict && [[ ! ${DEPEND} =~ "dev-java/ant" ]]; then 1539# if is-java-strict && [[ ! ${DEPEND} =~ "dev-java/ant" ]]; then
1222# java-pkg_announce-qa-violation \ 1540# java-pkg_announce-qa-violation \
1223# "Using eant, but not depending on dev-java/ant or dev-java/ant-core" 1541# "Using eant, but not depending on dev-java/ant or dev-java/ant-core"
1224# fi 1542# fi
1225 1543
1226 local antflags 1544 if ! hasq java-ant-2 ${INHERITED} && is-java-strict; then
1545 local msg="You should inherit java-ant-2 when using eant"
1546 java-pkg_announce-qa-violation ${msg}
1547 die ${msg}
1548 fi
1549
1550 local antflags="-Dnoget=true -Dmaven.mode.offline=true"
1227 java-pkg_init-compiler_ 1551 java-pkg_init-compiler_
1228 local compiler="${GENTOO_COMPILER}" 1552 local compiler="${GENTOO_COMPILER}"
1229 1553
1230 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}" 1554 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}"
1231 1555
1233 if [[ "${compiler}" != "javac" && -z "${build_compiler}" ]]; then 1557 if [[ "${compiler}" != "javac" && -z "${build_compiler}" ]]; then
1234 die "ANT_BUILD_COMPILER undefined in ${compiler_env}" 1558 die "ANT_BUILD_COMPILER undefined in ${compiler_env}"
1235 fi 1559 fi
1236 1560
1237 if [[ ${compiler} != "javac" ]]; then 1561 if [[ ${compiler} != "javac" ]]; then
1238 antflags="-Dbuild.compiler=${build_compiler}" 1562 antflags="${antflags} -Dbuild.compiler=${build_compiler}"
1239 # Figure out any extra stuff to put on the classpath for compilers aside 1563 # Figure out any extra stuff to put on the classpath for compilers aside
1240 # from javac 1564 # from javac
1241 # ANT_BUILD_COMPILER_DEPS should be something that could be passed to 1565 # ANT_BUILD_COMPILER_DEPS should be something that could be passed to
1242 # java-config -p 1566 # java-config -p
1243 local build_compiler_deps="$(source ${JAVA_PKG_COMPILER_DIR}/${compiler} 1>/dev/null 2>&1; echo ${ANT_BUILD_COMPILER_DEPS})" 1567 local build_compiler_deps="$(source ${JAVA_PKG_COMPILER_DIR}/${compiler} 1>/dev/null 2>&1; echo ${ANT_BUILD_COMPILER_DEPS})"
1248 1572
1249 if is-java-strict; then 1573 if is-java-strict; then
1250 einfo "Disabling system classpath for ant" 1574 einfo "Disabling system classpath for ant"
1251 antflags="${antflags} -Dbuild.sysclasspath=ignore" 1575 antflags="${antflags} -Dbuild.sysclasspath=ignore"
1252 fi 1576 fi
1253 1577
1254 if [[ -n ${JAVA_PKG_DEBUG} ]]; then 1578 for arg in "${@}"; do
1255 antflags="${antflags} -debug" 1579 if [[ ${arg} = -lib ]]; then
1580 if is-java-strict; then
1581 eerror "You should not use the -lib argument to eant because it will fail"
1582 eerror "with JAVA_PKG_STRICT. Please use for example java-pkg_jar-from or"
1583 eerror "or ant properties to make dependencies available."
1584 eerror "For ant tasks use WANT_ANT_TASKS or ANT_TASKS from."
1585 eerror "split ant (>=dev-java/ant-core-1.7)."
1586 die "eant -lib is deprecated/forbidden"
1587 else
1588 echo "eant -lib is deprecated. Turn JAVA_PKG_STRICT on for"
1589 echo "more info."
1590 fi
1256 fi 1591 fi
1257 1592 done
1593
1594 if has_version ">=dev-java/ant-core-1.7.0"; then
1595 # default ANT_TASKS to WANT_ANT_TASKS, if ANT_TASKS is not set explicitly
1596 ANT_TASKS="${ANT_TASKS:-${WANT_ANT_TASKS}}"
1597
1598 # override ANT_TASKS with JAVA_PKG_FORCE_ANT_TASKS if it's set
1599 ANT_TASKS="${JAVA_PKG_FORCE_ANT_TASKS:-${ANT_TASKS}}"
1600
1601 if is-java-strict; then
1602 # if ant-tasks were not set by ebuild or forced, try to determine them from depends
1603 if [[ -z "${ANT_TASKS}" ]]; then
1604 ANT_TASKS="$(java-pkg_ant-tasks-from-deps)"
1605 fi
1606 else
1607 # if ant-tasks is not set by ebuild or forced, activate all of them
1608 ANT_TASKS="${ANT_TASKS:-all}"
1609 fi
1610
1611 # at this point, ANT_TASKS should be "all", "none" or explicit list
1612 if [[ "${ANT_TASKS}" == "all" ]]; then
1613 einfo "Using all available ANT_TASKS"
1614 elif [[ "${ANT_TASKS}" == "none" ]]; then
1615 einfo "Disabling all optional ANT_TASKS"
1616 else
1617 einfo "Using following ANT_TASKS: ${ANT_TASKS}"
1618 fi
1619
1620 export ANT_TASKS
1621 fi
1622
1623 [[ -n ${JAVA_PKG_DEBUG} ]] && antflags="${antflags} --execdebug -debug"
1624 [[ -n ${PORTAGE_QUIET} ]] && antflags="${antflags} -q"
1625
1626 local gcp="${EANT_GENTOO_CLASSPATH}"
1627
1628 if [[ "${gcp}" ]]; then
1629 local cp="$(java-pkg_getjars ${gcp})"
1630 # It seems ant does not like single quotes around ${cp}
1631 antflags="${antflags} -Dgentoo.classpath=\"${cp}\""
1632 fi
1633
1258 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ant ${antflags} "${@}" 1634 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ant ${antflags} "${@}"
1635 debug-print "Calling ant: ${antflags} ${@}"
1259 ant ${antflags} "${@}" || die "eant failed" 1636 ant ${antflags} "${@}" || die "eant failed"
1260 1637
1261} 1638}
1262 1639
1263# ------------------------------------------------------------------------------ 1640# ------------------------------------------------------------------------------
1264# @ebuild-function ejavac 1641# @ebuild-function ejavac
1265# 1642#
1266# Javac wrapper function. Will use the appropriate compiler, based on 1643# Javac wrapper function. Will use the appropriate compiler, based on
1267# /etc/java-config/compilers.conf 1644# /etc/java-config/compilers.conf
1268# 1645#
1269# @param $@ - Arguments to be passed to the compiler 1646# @param $@ - Arguments to be passed to the compiler
1270# ------------------------------------------------------------------------------ 1647# ------------------------------------------------------------------------------
1271ejavac() { 1648ejavac() {
1272 debug-print-function ${FUNCNAME} $* 1649 debug-print-function ${FUNCNAME} $*
1273 1650
1274 # FIXME using get-javac ends up printing stuff with einfo 1651 java-pkg_init-compiler_
1652
1653 local compiler_executable
1275# local compiler_executable=$(java-pkg_get-javac) 1654 compiler_executable=$(java-pkg_get-javac)
1276 local compiler_executable="javac" 1655 if [[ ${?} != 0 ]]; then
1656 eerror "There was a problem determining compiler: ${compiler_executable}"
1657 die "get-javac failed"
1658 fi
1277 1659
1660 local javac_args
1661 javac_args="$(java-pkg_javac-args)"
1662 if [[ ${?} != 0 ]]; then
1663 eerror "There was a problem determining JAVACFLAGS: ${javac_args}"
1664 die "java-pkg_javac-args failed"
1665 fi
1666
1278 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ${compiler_executable} $(java-pkg_javac-args) "${@}" 1667 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ${compiler_executable} ${javac_args} "${@}"
1279 ${compiler_executable} $(java-pkg_javac-args) "${@}" || die "ejavac failed" 1668 ${compiler_executable} ${javac_args} "${@}" || die "ejavac failed"
1280} 1669}
1281 1670
1282# ------------------------------------------------------------------------------ 1671# ------------------------------------------------------------------------------
1283# @ebuild-function java-pkg_filter-compiler 1672# @ebuild-function java-pkg_filter-compiler
1284# 1673#
1285# Used to prevent the use of some compilers. Should be used in src_compile. 1674# Used to prevent the use of some compilers. Should be used in src_compile.
1286# Basically, it just appends onto JAVA_PKG_FILTER_COMPILER 1675# Basically, it just appends onto JAVA_PKG_FILTER_COMPILER
1287# 1676#
1288# @param $@ - compilers to filter 1677# @param $@ - compilers to filter
1289# ------------------------------------------------------------------------------ 1678# ------------------------------------------------------------------------------
1307# ------------------------------------------------------------------------------ 1696# ------------------------------------------------------------------------------
1308# @ebuild-function use_doc 1697# @ebuild-function use_doc
1309# 1698#
1310# Helper function for getting ant to build javadocs. If the user has USE=doc, 1699# Helper function for getting ant to build javadocs. If the user has USE=doc,
1311# then 'javadoc' or the argument are returned. Otherwise, there is no return. 1700# then 'javadoc' or the argument are returned. Otherwise, there is no return.
1312# 1701#
1313# The output of this should be passed to ant. 1702# The output of this should be passed to ant.
1314# 1703#
1315# Example: build javadocs by calling 'javadoc' target 1704# Example: build javadocs by calling 'javadoc' target
1316# eant $(use_doc) 1705# eant $(use_doc)
1317# Example: build javadocs by calling 'apidoc' target 1706# Example: build javadocs by calling 'apidoc' target
1322# ------------------------------------------------------------------------------ 1711# ------------------------------------------------------------------------------
1323use_doc() { 1712use_doc() {
1324 use doc && echo ${@:-javadoc} 1713 use doc && echo ${@:-javadoc}
1325} 1714}
1326 1715
1716
1327# ------------------------------------------------------------------------------ 1717# ------------------------------------------------------------------------------
1328# @section-end build 1718# @section-end build
1329# ------------------------------------------------------------------------------ 1719# ------------------------------------------------------------------------------
1330 1720
1331# ------------------------------------------------------------------------------ 1721# ------------------------------------------------------------------------------
1332# @section-begin internal 1722# @section-begin internal
1333# @section-summary Internal functions 1723# @section-summary Internal functions
1334# 1724#
1335# Do __NOT__ use any of these from an ebuild! These are only to be used from 1725# Do __NOT__ use any of these from an ebuild! These are only to be used from
1336# within the java eclasses. 1726# within the java eclasses.
1337# ------------------------------------------------------------------------------ 1727# ------------------------------------------------------------------------------
1338 1728
1339# ----------------------------------------------------------------------------- 1729# -----------------------------------------------------------------------------
1340# @function-internal java-pkg_init 1730# @function-internal java-pkg_init
1341# 1731#
1342# The purpose of this function, as the name might imply, is to initialize the 1732# The purpose of this function, as the name might imply, is to initialize the
1343# Java environment. It ensures that that there aren't any environment variables 1733# Java environment. It ensures that that there aren't any environment variables
1344# that'll muss things up. It initializes some variables, which are used 1734# that'll muss things up. It initializes some variables, which are used
1345# internally. And most importantly, it'll switch the VM if necessary. 1735# internally. And most importantly, it'll switch the VM if necessary.
1346# 1736#
1358 # TODO we will probably want to set JAVAC and JAVACFLAGS 1748 # TODO we will probably want to set JAVAC and JAVACFLAGS
1359 1749
1360 # Do some QA checks 1750 # Do some QA checks
1361 java-pkg_check-jikes 1751 java-pkg_check-jikes
1362 1752
1363 # When users have crazy classpaths some packages can fail to compile. 1753 # When users have crazy classpaths some packages can fail to compile.
1364 # and everything should work with empty CLASSPATH. 1754 # and everything should work with empty CLASSPATH.
1365 # This also helps prevent unexpected dependencies on random things 1755 # This also helps prevent unexpected dependencies on random things
1366 # from the CLASSPATH. 1756 # from the CLASSPATH.
1367 unset CLASSPATH 1757 unset CLASSPATH
1758
1759 # Unset external ANT_ stuff
1760 unset ANT_TASKS
1761 unset ANT_OPTS
1368} 1762}
1369 1763
1370# ------------------------------------------------------------------------------ 1764# ------------------------------------------------------------------------------
1371# @function-internal java-pkg-init-compiler_ 1765# @function-internal java-pkg-init-compiler_
1372# 1766#
1373# This function attempts to figure out what compiler should be used. It does 1767# This function attempts to figure out what compiler should be used. It does
1374# this by reading the file at JAVA_PKG_COMPILERS_CONF, and checking the 1768# this by reading the file at JAVA_PKG_COMPILERS_CONF, and checking the
1375# COMPILERS variable defined there. 1769# COMPILERS variable defined there.
1376# This can be overridden by a list in JAVA_PKG_FORCE_COMPILER 1770# This can be overridden by a list in JAVA_PKG_FORCE_COMPILER
1377# 1771#
1378# It will go through the list of compilers, and verify that it supports the 1772# It will go through the list of compilers, and verify that it supports the
1379# target and source that are needed. If it is not suitable, then the next 1773# target and source that are needed. If it is not suitable, then the next
1380# compiler is checked. When JAVA_PKG_FORCE_COMPILER is defined, this checking 1774# compiler is checked. When JAVA_PKG_FORCE_COMPILER is defined, this checking
1381# isn't done. 1775# isn't done.
1382# 1776#
1404 if [[ -z ${JAVA_PKG_FORCE_COMPILER} ]]; then 1798 if [[ -z ${JAVA_PKG_FORCE_COMPILER} ]]; then
1405 compilers="$(source ${JAVA_PKG_COMPILERS_CONF} 1>/dev/null 2>&1; echo ${COMPILERS})" 1799 compilers="$(source ${JAVA_PKG_COMPILERS_CONF} 1>/dev/null 2>&1; echo ${COMPILERS})"
1406 else 1800 else
1407 compilers=${JAVA_PKG_FORCE_COMPILER} 1801 compilers=${JAVA_PKG_FORCE_COMPILER}
1408 fi 1802 fi
1409 1803
1410 debug-print "Read \"${compilers}\" from ${JAVA_PKG_COMPILERS_CONF}" 1804 debug-print "Read \"${compilers}\" from ${JAVA_PKG_COMPILERS_CONF}"
1411 1805
1412 # Figure out if we should announce what compiler we're using 1806 # Figure out if we should announce what compiler we're using
1413 local compiler 1807 local compiler
1414 for compiler in ${compilers}; do 1808 for compiler in ${compilers}; do
1417 if [[ ${compiler} = "javac" ]]; then 1811 if [[ ${compiler} = "javac" ]]; then
1418 debug-print "Found javac... breaking" 1812 debug-print "Found javac... breaking"
1419 export GENTOO_COMPILER="javac" 1813 export GENTOO_COMPILER="javac"
1420 break 1814 break
1421 fi 1815 fi
1422 1816
1423 if has ${compiler} ${JAVA_PKG_FILTER_COMPILER}; then 1817 if has ${compiler} ${JAVA_PKG_FILTER_COMPILER}; then
1424 if [[ -z ${JAVA_PKG_FORCE_COMPILER} ]]; then 1818 if [[ -z ${JAVA_PKG_FORCE_COMPILER} ]]; then
1425 einfo "Filtering ${compiler}" 1819 einfo "Filtering ${compiler}"
1426 continue 1820 continue
1427 fi 1821 fi
1428 fi 1822 fi
1429 1823
1430 # for non-javac, we need to make sure it supports the right target and 1824 # for non-javac, we need to make sure it supports the right target and
1431 # source 1825 # source
1432 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}" 1826 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}"
1433 if [[ -f ${compiler_env} ]]; then 1827 if [[ -f ${compiler_env} ]]; then
1434 local desired_target="$(java-pkg_get-target)" 1828 local desired_target="$(java-pkg_get-target)"
1516# Writes the package.env out to disk. 1910# Writes the package.env out to disk.
1517# 1911#
1518# ------------------------------------------------------------------------------ 1912# ------------------------------------------------------------------------------
1519# TODO change to do-write, to match everything else 1913# TODO change to do-write, to match everything else
1520java-pkg_do_write_() { 1914java-pkg_do_write_() {
1915 java-pkg_init_paths_
1521 # Create directory for package.env 1916 # Create directory for package.env
1522 dodir "${JAVA_PKG_SHAREPATH}" 1917 dodir "${JAVA_PKG_SHAREPATH}"
1523 if [[ -n "${JAVA_PKG_CLASSPATH}" || -n "${JAVA_PKG_LIBRARY}" || -f "${JAVA_PKG_DEPEND}" ]]; then 1918 if [[ -n "${JAVA_PKG_CLASSPATH}" || -n "${JAVA_PKG_LIBRARY}" || -f "${JAVA_PKG_DEPEND}" ]]; then
1524 # Create package.env 1919 # Create package.env
1525 ( 1920 (
1530 [[ -n "${JAVA_PKG_LIBRARY}" ]] && echo "LIBRARY_PATH=\"${JAVA_PKG_LIBRARY}\"" 1925 [[ -n "${JAVA_PKG_LIBRARY}" ]] && echo "LIBRARY_PATH=\"${JAVA_PKG_LIBRARY}\""
1531 [[ -n "${JAVA_PROVIDE}" ]] && echo "PROVIDES=\"${JAVA_PROVIDE}\"" 1926 [[ -n "${JAVA_PROVIDE}" ]] && echo "PROVIDES=\"${JAVA_PROVIDE}\""
1532 [[ -f "${JAVA_PKG_DEPEND}" ]] && echo "DEPEND=\"$(cat ${JAVA_PKG_DEPEND} | uniq | tr '\n' ':')\"" 1927 [[ -f "${JAVA_PKG_DEPEND}" ]] && echo "DEPEND=\"$(cat ${JAVA_PKG_DEPEND} | uniq | tr '\n' ':')\""
1533 echo "VM=\"$(echo ${RDEPEND} ${DEPEND} | sed -e 's/ /\n/g' | sed -n -e '/virtual\/\(jre\|jdk\)/ { p;q }')\"" # TODO cleanup ! 1928 echo "VM=\"$(echo ${RDEPEND} ${DEPEND} | sed -e 's/ /\n/g' | sed -n -e '/virtual\/\(jre\|jdk\)/ { p;q }')\"" # TODO cleanup !
1534 ) > "${JAVA_PKG_ENV}" 1929 ) > "${JAVA_PKG_ENV}"
1535 1930
1536 # register target/source 1931 # register target/source
1537 local target="$(java-pkg_get-target)" 1932 local target="$(java-pkg_get-target)"
1538 local source="$(java-pkg_get-source)" 1933 local source="$(java-pkg_get-source)"
1539 [[ -n ${target} ]] && echo "TARGET=\"${target}\"" >> "${JAVA_PKG_ENV}" 1934 [[ -n ${target} ]] && echo "TARGET=\"${target}\"" >> "${JAVA_PKG_ENV}"
1540 [[ -n ${source} ]] && echo "SOURCE=\"${source}\"" >> "${JAVA_PKG_ENV}" 1935 [[ -n ${source} ]] && echo "SOURCE=\"${source}\"" >> "${JAVA_PKG_ENV}"
1553 # Strip unnecessary leading and trailing colons 1948 # Strip unnecessary leading and trailing colons
1554 # TODO try to cleanup if possible 1949 # TODO try to cleanup if possible
1555 sed -e "s/=\":/=\"/" -e "s/:\"$/\"/" -i "${JAVA_PKG_ENV}" || die "Did you forget to call java_init ?" 1950 sed -e "s/=\":/=\"/" -e "s/:\"$/\"/" -i "${JAVA_PKG_ENV}" || die "Did you forget to call java_init ?"
1556 fi 1951 fi
1557} 1952}
1558
1559 1953
1560# ------------------------------------------------------------------------------ 1954# ------------------------------------------------------------------------------
1561# @internal-function java-pkg_record-jar_ 1955# @internal-function java-pkg_record-jar_
1562# 1956#
1563# Record a dependency to the package.env 1957# Record a dependency to the package.env
1607 fi 2001 fi
1608} 2002}
1609 2003
1610# ------------------------------------------------------------------------------ 2004# ------------------------------------------------------------------------------
1611# @internal-function java-pkg_expand_dir_ 2005# @internal-function java-pkg_expand_dir_
1612# 2006#
1613# Gets the full path of the file/directory's parent. 2007# Gets the full path of the file/directory's parent.
1614# @param $1 - file/directory to find parent directory for 2008# @param $1 - file/directory to find parent directory for
1615# @return - path to $1's parent directory 2009# @return - path to $1's parent directory
1616# ------------------------------------------------------------------------------ 2010# ------------------------------------------------------------------------------
1617java-pkg_expand_dir_() { 2011java-pkg_expand_dir_() {
1644# ------------------------------------------------------------------------------ 2038# ------------------------------------------------------------------------------
1645java-pkg_setup-vm() { 2039java-pkg_setup-vm() {
1646 debug-print-function ${FUNCNAME} $* 2040 debug-print-function ${FUNCNAME} $*
1647 2041
1648 local vendor="$(java-pkg_get-vm-vendor)" 2042 local vendor="$(java-pkg_get-vm-vendor)"
1649 if [[ "${vendor}" == "sun" ]] && java-pkg_is-vm-version-ge 1 5; then 2043 if [[ "${vendor}" == "sun" ]] && java-pkg_is-vm-version-ge "1.5" ; then
1650 addpredict "/dev/random" 2044 addpredict "/dev/random"
1651 elif [[ "${vendor}" == "ibm" ]]; then 2045 elif [[ "${vendor}" == "ibm" ]]; then
1652 addpredict "/proc/self/maps" 2046 addpredict "/proc/self/maps"
1653 addpredict "/proc/cpuinfo" 2047 addpredict "/proc/cpuinfo"
1654 export LANG="C" LC_ALL="C" 2048 export LANG="C" LC_ALL="C"
1703# @return - The version of the current VM 2097# @return - The version of the current VM
1704# ------------------------------------------------------------------------------ 2098# ------------------------------------------------------------------------------
1705java-pkg_get-vm-version() { 2099java-pkg_get-vm-version() {
1706 debug-print-function ${FUNCNAME} $* 2100 debug-print-function ${FUNCNAME} $*
1707 2101
1708 java-pkg_get-current-vm | sed -e "s/.*-\([0-9.]\+\).*/\1/" 2102 java-config -g PROVIDES_VERSION
1709} 2103}
1710 2104
1711# ------------------------------------------------------------------------------ 2105# ------------------------------------------------------------------------------
1712# @internal-function java-pkg_switch-vm 2106# @internal-function java-pkg_switch-vm
1713# 2107#
1714# Switch VM if we're allowed to (controlled by JAVA_PKG_ALLOW_VM_CHANGE), and 2108# Switch VM if we're allowed to (controlled by JAVA_PKG_ALLOW_VM_CHANGE), and
1715# verify that the current VM is sufficient. 2109# verify that the current VM is sufficient.
1716# Setup the environment for the VM being used. 2110# Setup the environment for the VM being used.
1717# ------------------------------------------------------------------------------ 2111# ------------------------------------------------------------------------------
1718java-pkg_switch-vm() { 2112java-pkg_switch-vm() {
2113 debug-print-function ${FUNCNAME} $*
2114
1719 if java-pkg_needs-vm; then 2115 if java-pkg_needs-vm; then
1720 # Use the VM specified by JAVA_PKG_FORCE_VM 2116 # Use the VM specified by JAVA_PKG_FORCE_VM
1721 if [[ -n ${JAVA_PKG_FORCE_VM} ]]; then 2117 if [[ -n "${JAVA_PKG_FORCE_VM}" ]]; then
1722 # If you're forcing the VM, I hope you know what your doing... 2118 # If you're forcing the VM, I hope you know what your doing...
2119 debug-print "JAVA_PKG_FORCE_VM used: ${JAVA_PKG_FORCE_VM}"
1723 export GENTOO_VM="${JAVA_PKG_FORCE_VM}" 2120 export GENTOO_VM="${JAVA_PKG_FORCE_VM}"
1724 # if we're allowed to switch the vm... 2121 # if we're allowed to switch the vm...
1725 elif [[ "${JAVA_PKG_ALLOW_VM_CHANGE}" == "yes" ]]; then 2122 elif [[ "${JAVA_PKG_ALLOW_VM_CHANGE}" == "yes" ]]; then
1726 debug-print "depend-java-query: NV_DEPEND: ${JAVA_PKG_NV_DEPEND:-${DEPEND}} VNEED: ${JAVA_PKG_VNEED}" 2123 debug-print "depend-java-query: NV_DEPEND: ${JAVA_PKG_NV_DEPEND:-${DEPEND}} VNEED: ${JAVA_PKG_VNEED}"
1727 if [[ -n ${JAVA_PKG_VNEED} ]]; then 2124 if [[ -n ${JAVA_PKG_VNEED} ]]; then
1728 export GENTOO_VM="$(depend-java-query --need-virtual "${JAVA_PKG_VNEED}" --get-vm "${JAVA_PKG_NV_DEPEND:-${DEPEND}}")" 2125 GENTOO_VM="$(depend-java-query --need-virtual "${JAVA_PKG_VNEED}" --get-vm "${JAVA_PKG_NV_DEPEND:-${DEPEND}}")"
1729 else 2126 else
1730 export GENTOO_VM="$(depend-java-query --get-vm "${JAVA_PKG_NV_DEPEND:-${DEPEND}}")" 2127 GENTOO_VM="$(depend-java-query --get-vm "${JAVA_PKG_NV_DEPEND:-${DEPEND}}")"
2128 fi
2129 if [[ -z "${GENTOO_VM}" || "${GENTOO_VM}" == "None" ]]; then
2130 eerror "Unable to determine VM for building from dependencies:"
2131 echo "NV_DEPEND: ${JAVA_PKG_NV_DEPEND:-${DEPEND}}"
2132 echo "VNEED: ${JAVA_PKG_VNEED}"
2133 die "Failed to determine VM for building."
2134 else
2135 export GENTOO_VM
1731 fi 2136 fi
1732 # otherwise just make sure the current VM is sufficient 2137 # otherwise just make sure the current VM is sufficient
1733 else 2138 else
1734 java-pkg_ensure-vm-version-sufficient 2139 java-pkg_ensure-vm-version-sufficient
1735 fi 2140 fi
1736 debug-print "Using: $(java-config -f)" 2141 debug-print "Using: $(java-config -f)"
1737 2142
1738 java-pkg_setup-vm 2143 java-pkg_setup-vm
1739 2144
1740 export JAVA=$(java-config --java) 2145 export JAVA=$(java-config --java)
1741 export JAVAC=$(java-config --javac) 2146 export JAVAC=$(java-config --javac)
1742 export JAVACFLAGS="$(java-pkg_javac-args)" 2147 JAVACFLAGS="$(java-pkg_javac-args)"
2148 if [[ ${?} != 0 ]]; then
2149 eerror "There was a problem determining JAVACFLAGS: ${JAVACFLAGS}"
2150 die "java-pkg_javac-args failed"
2151 fi
1743 [[ -n ${JAVACFLAGS_EXTRA} ]] && export JAVACFLAGS="${JAVACFLAGS_EXTRA} ${JAVACFLAGS}" 2152 [[ -n ${JAVACFLAGS_EXTRA} ]] && JAVACFLAGS="${JAVACFLAGS_EXTRA} ${JAVACFLAGS}"
2153 export JAVACFLAGS
1744 2154
1745 export JAVA_HOME="$(java-config -g JAVA_HOME)" 2155 export JAVA_HOME="$(java-config -g JAVA_HOME)"
1746 export JDK_HOME=${JAVA_HOME} 2156 export JDK_HOME=${JAVA_HOME}
1747 2157
1748 #TODO If you know a better solution let us know. 2158 #TODO If you know a better solution let us know.
1749 java-pkg_append_ LD_LIBRARY_PATH "$(java-config -g LDPATH)" 2159 java-pkg_append_ LD_LIBRARY_PATH "$(java-config -g LDPATH)"
1750 2160
1751 local tann="${T}/announced-vm" 2161 local tann="${T}/announced-vm"
1752 if [[ -n "${JAVA_PKG_DEBUG}" ]] || [[ ! -f "${tann}" ]] ; then 2162 if [[ -n "${JAVA_PKG_DEBUG}" ]] || [[ ! -f "${tann}" ]] ; then
1753 # Add a check for setup/preinst phase... to avoid duplicate outputs 2163 # Add a check for setup/preinst phase... to avoid duplicate outputs
1754 # for when FEATURES=buildpkg 2164 # for when FEATURES=buildpkg
1755 if [[ ${EBUILD_PHASE} != "setup" && ${EBUILD_PHASE} != "preinst" && ${EBUILD_PHASE} != "postinst" ]]; 2165 if [[ ${EBUILD_PHASE} != "setup" && ${EBUILD_PHASE} != "preinst" && ${EBUILD_PHASE} != "postinst" ]];
1799# TODO document 2209# TODO document
1800# Verify that the classes were compiled for the right source / target 2210# Verify that the classes were compiled for the right source / target
1801java-pkg_verify-classes() { 2211java-pkg_verify-classes() {
1802 ebegin "Verifying java class versions" 2212 ebegin "Verifying java class versions"
1803 #$(find ${D} -type f -name '*.jar' -o -name '*.class') 2213 #$(find ${D} -type f -name '*.jar' -o -name '*.class')
1804 class-version-verify.py -t $(java-pkg_get-target) -r ${D} 2214 class-version-verify.py -t $(java-pkg_get-target) -r ${D}
1805 result=$? 2215 result=$?
1806 eend ${result} 2216 eend ${result}
1807 if [[ ${result} == 0 ]]; then 2217 if [[ ${result} == 0 ]]; then
1808 einfo "All good" 2218 einfo "All good"
1809 else 2219 else
1810 ewarn "Possible problem" 2220 ewarn "Possible problem"
1811 die "Bad class files found" 2221 die "Bad class files found"
1812 fi 2222 fi
1813} 2223}
1814 2224
1815
1816# ------------------------------------------------------------------------------ 2225# ------------------------------------------------------------------------------
1817# @section-end internal 2226# @section-end internal
1818# ------------------------------------------------------------------------------ 2227# ------------------------------------------------------------------------------
1819 2228
1820java-pkg_check-phase() { 2229java-pkg_check-phase() {
1851 let "JAVA_PKG_QA_VIOLATIONS+=1" 2260 let "JAVA_PKG_QA_VIOLATIONS+=1"
1852 export JAVA_PKG_QA_VIOLATIONS 2261 export JAVA_PKG_QA_VIOLATIONS
1853} 2262}
1854 2263
1855is-java-strict() { 2264is-java-strict() {
1856 hasq java-strict ${FEATURES} && ! hasq -java-strict ${FEATURES} 2265 [[ -n ${JAVA_PKG_STRICT} ]]
1857 return $? 2266 return $?
1858} 2267}
1859 2268
1860# ------------------------------------------------------------------------------ 2269# ------------------------------------------------------------------------------
1861# @eclass-end 2270# @eclass-end

Legend:
Removed from v.1.12  
changed lines
  Added in v.1.52

  ViewVC Help
Powered by ViewVC 1.1.20