/[gentoo-x86]/eclass/java-utils-2.eclass
Gentoo

Diff of /eclass/java-utils-2.eclass

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

Revision 1.10 Revision 1.48
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.48 2007/01/21 21:12:52 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}"
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 $1 - (optional) "--build-only" makes the jar(s) not added into
763# package.env DEPEND line.
655# @param $1 - Package to get jars from. 764# @param $1 - Package to get jars from.
656# @param $2 - jar from package. If not specified, all jars will be used. 765# @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 766# @param $3 - When a single jar is specified, destination filename of the
658# symlink. Defaults to the name of the jar. 767# symlink. Defaults to the name of the jar.
659# ------------------------------------------------------------------------------ 768# ------------------------------------------------------------------------------
660# TODO could probably be cleaned up a little 769# TODO could probably be cleaned up a little
661java-pkg_jar-from() { 770java-pkg_jar-from() {
662 debug-print-function ${FUNCNAME} $* 771 debug-print-function ${FUNCNAME} $*
663 772
773 local build_only=""
774
775 if [[ "${1}" = "--build-only" || "${EBUILD_PHASE}" == "test" ]]; then
776 build_only="true"
777 shift
778 fi
779
780 if [[ "${1}" = "--with-dependencies" ]]; then
781 local deep="--with-dependencies"
782 shift
783 fi
784
664 local target_pkg="${1}" target_jar="${2}" destjar="${3}" 785 local target_pkg="${1}" target_jar="${2}" destjar="${3}"
665 786
666 [[ -z ${target_pkg} ]] && die "Must specify a package" 787 [[ -z ${target_pkg} ]] && die "Must specify a package"
667 788
668 # default destjar to the target jar 789 # default destjar to the target jar
669 [[ -z "${destjar}" ]] && destjar="${target_jar}" 790 [[ -z "${destjar}" ]] && destjar="${target_jar}"
670 791
792 local error_msg="There was a problem getting the classpath for ${target_pkg}."
793 local classpath
671 local classpath="$(java-config --classpath=${target_pkg})" 794 classpath="$(java-config ${deep} --classpath=${target_pkg})"
672 [[ $? != 0 ]] && die "There was a problem getting the classpath for ${target_pkg}" 795 [[ $? != 0 ]] && die ${error_msg}
673 796
674 local jar 797 local jar
675 for jar in ${classpath//:/ }; do 798 for jar in ${classpath//:/ }; do
676 local jar_name=$(basename "${jar}") 799 local jar_name=$(basename "${jar}")
677 if [[ ! -f "${jar}" ]] ; then 800 if [[ ! -f "${jar}" ]] ; then
681 # If no specific target jar was indicated, link it 804 # If no specific target jar was indicated, link it
682 if [[ -z "${target_jar}" ]] ; then 805 if [[ -z "${target_jar}" ]] ; then
683 [[ -f "${target_jar}" ]] && rm "${target_jar}" 806 [[ -f "${target_jar}" ]] && rm "${target_jar}"
684 ln -snf "${jar}" \ 807 ln -snf "${jar}" \
685 || die "Failed to make symlink from ${jar} to ${jar_name}" 808 || die "Failed to make symlink from ${jar} to ${jar_name}"
686 java-pkg_record-jar_ "${target_pkg}" "${jar}" 809 [[ -z "${build_only}" ]] && java-pkg_record-jar_ "${target_pkg}" "${jar}"
687 # otherwise, if the current jar is the target jar, link it 810 # otherwise, if the current jar is the target jar, link it
688 elif [[ "${jar_name}" == "${target_jar}" ]] ; then 811 elif [[ "${jar_name}" == "${target_jar}" ]] ; then
689 [[ -f "${destjar}" ]] && rm "${destjar}" 812 [[ -f "${destjar}" ]] && rm "${destjar}"
690 ln -snf "${jar}" "${destjar}" \ 813 ln -snf "${jar}" "${destjar}" \
691 || die "Failed to make symlink from ${jar} to ${destjar}" 814 || die "Failed to make symlink from ${jar} to ${destjar}"
692 java-pkg_record-jar_ "${target_pkg}" "${jar}" 815 [[ -z "${build_only}" ]] && java-pkg_record-jar_ "${target_pkg}" "${jar}"
693 return 0 816 return 0
694 fi 817 fi
695 done 818 done
696 # if no target was specified, we're ok 819 # if no target was specified, we're ok
697 if [[ -z "${target_jar}" ]] ; then 820 if [[ -z "${target_jar}" ]] ; then
714# ------------------------------------------------------------------------------ 837# ------------------------------------------------------------------------------
715# @ebuild-function java-pkg_getjars 838# @ebuild-function java-pkg_getjars
716# 839#
717# Get the classpath provided by any number of packages 840# Get the classpath provided by any number of packages
718# Among other things, this can be passed to 'javac -classpath' or 'ant -lib'. 841# Among other things, this can be passed to 'javac -classpath' or 'ant -lib'.
842# The providing packages are recorded as dependencies into package.env DEPEND
843# line, unless "--build-only" is passed as the very first argument, for jars
844# that have to be present only at build time and are not needed on runtime
845# (junit testing etc).
719# 846#
720# Example: Get the classpath for xerces-2, 847# Example: Get the classpath for xerces-2 and xalan,
721# java-pkg_getjars xerces-2 xalan 848# java-pkg_getjars xerces-2,xalan
722# Example Return: 849# Example Return:
723# /usr/share/xerces-2/lib/xml-apis.jar:/usr/share/xerces-2/lib/xmlParserAPIs.jar:/usr/share/xalan/lib/xalan.jar 850# /usr/share/xerces-2/lib/xml-apis.jar:/usr/share/xerces-2/lib/xmlParserAPIs.jar:/usr/share/xalan/lib/xalan.jar
724# 851#
852# @param $1 - (optional) "--build-only" makes the jar(s) not added into
853# package.env DEPEND line.
725# @param $@ - list of packages to get jars from 854# @param $2 - list of packages to get jars from
855# (passed to java-config --classpath)
726# ------------------------------------------------------------------------------ 856# ------------------------------------------------------------------------------
727java-pkg_getjars() { 857java-pkg_getjars() {
728 debug-print-function ${FUNCNAME} $* 858 debug-print-function ${FUNCNAME} $*
729 859
730 [[ ${#} -lt 1 ]] && die "At least one argument needed" 860 if [[ "${1}" = "--build-only" || "${EBUILD_PHASE}" == "test" ]]; then
861 local build_only="true"
862 shift
863 fi
731 864
732 # NOTE could probably just pass $@ to java-config --classpath. and return it 865 if [[ "${1}" = "--with-dependencies" ]]; then
866 local deep="--with-dependencies"
867 shift
868 fi
869
870 [[ ${#} -ne 1 ]] && die "${FUNCNAME} takes only one argument besides --build-only"
871
733 local classpath pkg 872 local classpath pkgs="${1}"
734 for pkg in ${@//,/ }; do
735 #for pkg in $(echo "$@" | tr ',' ' '); do
736 jars="$(java-config --classpath=${pkg})" 873 jars="$(java-config ${deep} --classpath=${pkgs})"
874 [[ -z "${jars}" ]] && die "java-config --classpath=${pkgs} failed"
737 debug-print "${pkg}:${jars}" 875 debug-print "${pkgs}:${jars}"
738 # TODO should we ensure jars exist? 876
739 if [[ -z "${classpath}" ]]; then 877 if [[ -z "${classpath}" ]]; then
740 classpath="${jars}" 878 classpath="${jars}"
741 else 879 else
742 classpath="${classpath}:${jars}" 880 classpath="${classpath}:${jars}"
743 fi 881 fi
882
883 # Only record jars that aren't build-only
884 if [[ -z "${build_only}" ]]; then
885 oldifs="${IFS}"
886 IFS=","
887 for pkg in ${pkgs}; do
744 java-pkg_record-jar_ "${pkg}" 888 java-pkg_record-jar_ "${pkg}"
745 done 889 done
890 IFS="${oldifs}"
891 fi
892
746 echo "${classpath}" 893 echo "${classpath}"
747} 894}
748 895
749# ------------------------------------------------------------------------------ 896# ------------------------------------------------------------------------------
750# @ebuild-function java-pkg_getjar 897# @ebuild-function java-pkg_getjar
751# 898#
752# Get the filename of a single jar from a package 899# Get the filename of a single jar from a package
900# The providing package is recorded as runtime dependency into package.env
901# DEPEND line, unless "--build-only" is passed as the very first argument, for
902# jars that have to be present only at build time and are not needed on runtime
903# (junit testing etc).
753# 904#
754# @example 905# @example
755# java-pkg_getjar xerces-2 xml-apis.jar 906# java-pkg_getjar xerces-2 xml-apis.jar
756# @example-return 907# @example-return
757# /usr/share/xerces-2/lib/xml-apis.jar 908# /usr/share/xerces-2/lib/xml-apis.jar
758# 909#
910# @param $1 - (optional) "--build-only" makes the jar not added into
911# package.env DEPEND line.
759# @param $1 - package to use 912# @param $1 - package to use
760# @param $2 - jar to get 913# @param $2 - jar to get
761# ------------------------------------------------------------------------------ 914# ------------------------------------------------------------------------------
762java-pkg_getjar() { 915java-pkg_getjar() {
763 debug-print-function ${FUNCNAME} $* 916 debug-print-function ${FUNCNAME} $*
917
918 local build_only=""
919
920 if [[ "${1}" = "--build-only" || "${EBUILD_PHASE}" == "test" ]]; then
921 build_only="true"
922 shift
923 fi
764 924
765 local pkg="${1}" target_jar="${2}" jar 925 local pkg="${1}" target_jar="${2}" jar
766 [[ -z ${pkg} ]] && die "Must specify package to get a jar from" 926 [[ -z ${pkg} ]] && die "Must specify package to get a jar from"
767 [[ -z ${target_jar} ]] && die "Must specify jar to get" 927 [[ -z ${target_jar} ]] && die "Must specify jar to get"
768 928
769 # TODO check that package is actually installed 929 local error_msg="Could not find classpath for ${pkg}. Are you sure its installed?"
930 local classpath
770 local classpath=$(java-config --classpath=${pkg}) 931 classpath=$(java-config --classpath=${pkg})
771 [[ $? != 0 ]] && die "There could not find classpath for ${pkg}. Are you sure its installed?" 932 [[ $? != 0 ]] && die ${error_msg}
933
772 for jar in ${classpath//:/ }; do 934 for jar in ${classpath//:/ }; do
773 if [[ ! -f "${jar}" ]] ; then 935 if [[ ! -f "${jar}" ]] ; then
774 die "Installation problems with jars in ${pkg} - is it installed?" 936 die "Installation problem with jar ${jar} in ${pkg} - is it installed?"
775 fi 937 fi
776 938
777 if [[ "$(basename ${jar})" == "${target_jar}" ]] ; then 939 if [[ "$(basename ${jar})" == "${target_jar}" ]] ; then
778 java-pkg_record-jar_ "${pkg}" "${jar}" 940 # Only record jars that aren't build-only
941 [[ -z "${build_only}" ]] && java-pkg_record-jar_ "${pkg}" "${jar}"
779 echo "${jar}" 942 echo "${jar}"
780 return 0 943 return 0
781 fi 944 fi
782 done 945 done
783 946
784 die "Could not find ${target_jar} in ${pkg}" 947 die "Could not find ${target_jar} in ${pkg}"
785 return 1 948 return 1
786} 949}
787 950
788# This function reads stdin, and based on that input, figures out how to 951# This function reads stdin, and based on that input, figures out how to
802# line="${line// /}" 965# line="${line// /}"
803# 966#
804# # format: path=jarinfo 967# # format: path=jarinfo
805# local path=${line%%=*} 968# local path=${line%%=*}
806# local jarinfo=${line##*=} 969# local jarinfo=${line##*=}
807# 970#
808# # format: jar@package 971# # format: jar@package
809# local jar=${jarinfo%%@*}.jar 972# local jar=${jarinfo%%@*}.jar
810# local package=${jarinfo##*@} 973# local package=${jarinfo##*@}
811# if [[ -n ${replace_only} ]]; then 974# if [[ -n ${replace_only} ]]; then
812# [[ ! -f $path ]] && die "No jar exists at ${path}" 975# [[ ! -f $path ]] && die "No jar exists at ${path}"
825# @section-end query 988# @section-end query
826# ------------------------------------------------------------------------------ 989# ------------------------------------------------------------------------------
827 990
828# ------------------------------------------------------------------------------ 991# ------------------------------------------------------------------------------
829# @section-begin helper 992# @section-begin helper
830# @section-summary Helper functions 993# @section-summary Helper functions
831# 994#
832# Various other functions to use from an ebuild 995# Various other functions to use from an ebuild
833# ------------------------------------------------------------------------------ 996# ------------------------------------------------------------------------------
834 997
835# ------------------------------------------------------------------------------ 998# ------------------------------------------------------------------------------
841# jdbc-stdext 1004# jdbc-stdext
842# jaf 1005# jaf
843# jdbc-rowset 1006# jdbc-rowset
844# jms 1007# jms
845# 1008#
846# @param $1 - Optionally indicate that the dependencies are controlled by 1009# @param $1 - Optionally indicate that the dependencies are controlled by
847# a use flag by specifying '--use' Requires $2. 1010# a use flag by specifying '--use' Requires $2.
848# @param $2 - USE flag which will enable the dependencies. 1011# @param $2 - USE flag which will enable the dependencies.
849# @param $@ - virtual packages to add depenedencies for 1012# @param $@ - virtual packages to add depenedencies for
850# ------------------------------------------------------------------------------ 1013# ------------------------------------------------------------------------------
851# TODO rewrite to parse a line based declaration file instead -- karltk 1014# TODO rewrite to parse a line based declaration file instead -- karltk
907# 1070#
908# export DEPEND="${DEPEND} ${depstr}" 1071# export DEPEND="${DEPEND} ${depstr}"
909# export RDEPEND="${RDEPEND} ${depstr}" 1072# export RDEPEND="${RDEPEND} ${depstr}"
910#} 1073#}
911 1074
1075# ------------------------------------------------------------------------------
1076# @ebuild-function java-pkg_find-normal-jars
1077#
1078# Find the files with suffix .jar file in the given directory or $WORKDIR
1079#
1080# @param $1 - The directory to search for jar files (default: ${WORKDIR})
1081# ------------------------------------------------------------------------------
1082java-pkg_find-normal-jars() {
1083 local dir=$1
1084 [[ "${dir}" ]] || dir="${WORKDIR}"
1085 local found
1086 for jar in $(find "${dir}" -name "*.jar" -type f); do
1087 echo "${jar}"
1088 found="true"
1089 done
1090 [[ "${found}" ]]
1091 return $?
1092}
1093
1094# ------------------------------------------------------------------------------
1095# @ebuild-function java-pkg_ensure-no-bundled-jars
1096#
1097# 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 1098# This function should be called after WORKDIR has been populated with symlink
913# TODO document 1099# to system jar files or bundled jars removed.
1100# ------------------------------------------------------------------------------
914java-pkg_ensure-no-bundled-jars() { 1101java-pkg_ensure-no-bundled-jars() {
915 debug-print-function ${FUNCNAME} $* 1102 debug-print-function ${FUNCNAME} $*
916 pushd ${WORKDIR} >/dev/null 2>/dev/null
917 1103
918 local bundled_jars=$(find . -name "*.jar" -type f) 1104 local bundled_jars=$(java-pkg_find-normal-jars)
919 if [[ -n ${bundled_jars} ]]; then 1105 if [[ -n ${bundled_jars} ]]; then
920 echo "Bundled jars found:" 1106 echo "Bundled jars found:"
921 local jar 1107 local jar
922 for jar in ${bundled_jars}; do 1108 for jar in ${bundled_jars}; do
923 echo $(pwd)${jar/./} 1109 echo $(pwd)${jar/./}
924 done 1110 done
925 die "Bundled jars found!" 1111 die "Bundled jars found!"
926
927 fi 1112 fi
928 popd >/dev/null 2>/dev/null
929} 1113}
930 1114
931# ------------------------------------------------------------------------------ 1115# ------------------------------------------------------------------------------
932# @internal-function java-pkg_ensure-vm-version-sufficient 1116# @internal-function java-pkg_ensure-vm-version-sufficient
933# 1117#
945 fi 1129 fi
946} 1130}
947 1131
948# ------------------------------------------------------------------------------ 1132# ------------------------------------------------------------------------------
949# @internal-function java-pkg_is-vm-version-sufficient 1133# @internal-function java-pkg_is-vm-version-sufficient
950# 1134#
951# @return zero - VM is sufficient 1135# @return zero - VM is sufficient
952# @return non-zero - VM is not sufficient 1136# @return non-zero - VM is not sufficient
953# ------------------------------------------------------------------------------ 1137# ------------------------------------------------------------------------------
954java-pkg_is-vm-version-sufficient() { 1138java-pkg_is-vm-version-sufficient() {
955 debug-print-function ${FUNCNAME} $* 1139 debug-print-function ${FUNCNAME} $*
975 die "Active Java VM too old" 1159 die "Active Java VM too old"
976 fi 1160 fi
977} 1161}
978 1162
979# ------------------------------------------------------------------------------ 1163# ------------------------------------------------------------------------------
980# @internal-function java-pkg_is-vm-version-eq 1164# @internal-function java-pkg_is-vm-version-eq
981# 1165#
982# @param $@ - VM version to compare current VM to 1166# @param $@ - VM version to compare current VM to
983# @return zero - VM versions are equal 1167# @return zero - VM versions are equal
984# @return non-zero - VM version are not equal 1168# @return non-zero - VM version are not equal
985# ------------------------------------------------------------------------------ 1169# ------------------------------------------------------------------------------
986java-pkg_is-vm-version-eq() { 1170java-pkg_is-vm-version-eq() {
1016# 1200#
1017# @param $@ - VM version to compare current to 1201# @param $@ - VM version to compare current to
1018# ------------------------------------------------------------------------------ 1202# ------------------------------------------------------------------------------
1019java-pkg_ensure-vm-version-ge() { 1203java-pkg_ensure-vm-version-ge() {
1020 debug-print-function ${FUNCNAME} $* 1204 debug-print-function ${FUNCNAME} $*
1021 1205
1022 if ! java-pkg_is-vm-version-ge "$@" ; then 1206 if ! java-pkg_is-vm-version-ge "$@" ; then
1023 debug-print "vm is not suffient" 1207 debug-print "vm is not suffient"
1024 eerror "This package requires a Java VM version >= $@" 1208 eerror "This package requires a Java VM version >= $@"
1025 einfo "Please use java-config -S to set the correct one" 1209 einfo "Please use java-config -S to set the correct one"
1026 die "Active Java VM too old" 1210 die "Active Java VM too old"
1027 fi 1211 fi
1028} 1212}
1029 1213
1030# ------------------------------------------------------------------------------ 1214# ------------------------------------------------------------------------------
1031# @internal-function java-pkg_is-vm-version-ge 1215# @internal-function java-pkg_is-vm-version-ge
1032# 1216#
1033# @param $@ - VM version to compare current VM to 1217# @param $@ - VM version to compare current VM to
1034# @return zero - current VM version is greater than checked version 1218# @return zero - current VM version is greater than checked version
1035# @return non-zero - current VM version is not greater than checked version 1219# @return non-zero - current VM version is not greater than checked version
1036# ------------------------------------------------------------------------------ 1220# ------------------------------------------------------------------------------
1037java-pkg_is-vm-version-ge() { 1221java-pkg_is-vm-version-ge() {
1051 return 1 1235 return 1
1052 fi 1236 fi
1053 fi 1237 fi
1054} 1238}
1055 1239
1240java-pkg_set-current-vm() {
1241 export GENTOO_VM=${1}
1242}
1243
1244java-pkg_get-current-vm() {
1245 echo ${GENTOO_VM}
1246}
1247
1248java-pkg_current-vm-matches() {
1249 hasq $(java-pkg_get-current-vm) ${@}
1250 return $?
1251}
1252
1056# ------------------------------------------------------------------------------ 1253# ------------------------------------------------------------------------------
1057# @ebuild-function java-pkg_get-source 1254# @ebuild-function java-pkg_get-source
1058# 1255#
1059# Determines what source version should be used, for passing to -source. 1256# Determines what source version should be used, for passing to -source.
1060# Unless you want to break things you probably shouldn't set _WANT_SOURCE 1257# Unless you want to break things you probably shouldn't set _WANT_SOURCE
1061# 1258#
1062# @return string - Either the lowest possible source, or JAVA_PKG_WANT_SOURCE 1259# @return string - Either the lowest possible source, or JAVA_PKG_WANT_SOURCE
1063# ------------------------------------------------------------------------------ 1260# ------------------------------------------------------------------------------
1068# ------------------------------------------------------------------------------ 1265# ------------------------------------------------------------------------------
1069# @ebuild-function java-pkg_get-target 1266# @ebuild-function java-pkg_get-target
1070# 1267#
1071# Determines what target version should be used, for passing to -target. 1268# Determines what target version should be used, for passing to -target.
1072# If you don't care about lower versions, you can set _WANT_TARGET to the 1269# If you don't care about lower versions, you can set _WANT_TARGET to the
1073# version of your JDK. 1270# version of your JDK.
1074# Remember doing this will mostly like cause things to break.
1075# Doesn't allow it to be lower then the one in depend.
1076# Doesn't allow it to be higher then the active vm.
1077# 1271#
1078# @return string - Either the lowest possible target, or JAVA_PKG_WANT_TARGET 1272# @return string - Either the lowest possible target, or JAVA_PKG_WANT_TARGET
1079# ------------------------------------------------------------------------------ 1273# ------------------------------------------------------------------------------
1080java-pkg_get-target() { 1274java-pkg_get-target() {
1081 local min=$(depend-java-query --get-lowest "${DEPEND} ${RDEPEND}")
1082 if [[ -n "${JAVA_PKG_WANT_TARGET}" ]]; then
1083 local max="$(java-config --select-vm "${GENTOO_VM}" -g PROVIDES_VERSION)"
1084 if version_is_at_least "${min}" "${JAVA_PKG_WANT_TARGET}" && version_is_at_least "${JAVA_PKG_WANT_TARGET}" "${max}"; then
1085 echo ${JAVA_PKG_WANT_TARGET}
1086 else
1087 echo ${min}
1088 fi
1089 else
1090 echo ${min}
1091 fi
1092
1093 #echo ${JAVA_PKG_WANT_TARGET:-$(depend-java-query --get-lowest "${DEPEND}")} 1275 echo ${JAVA_PKG_WANT_TARGET:-$(depend-java-query --get-lowest "${DEPEND} ${RDEPEND}")}
1094} 1276}
1095 1277
1096java-pkg_get-javac() { 1278java-pkg_get-javac() {
1097 debug-print-function ${FUNCNAME} $* 1279 debug-print-function ${FUNCNAME} $*
1098 1280
1099 java-pkg_init-compiler_ 1281
1100 local compiler="${GENTOO_COMPILER}" 1282 local compiler="${GENTOO_COMPILER}"
1101 1283
1102 local compiler_executable 1284 local compiler_executable
1103 if [[ "${compiler}" = "javac" ]]; then 1285 if [[ "${compiler}" = "javac" ]]; then
1104 # nothing fancy needs to be done for javac 1286 # nothing fancy needs to be done for javac
1112 unset JAVAC 1294 unset JAVAC
1113 # try to get value of JAVAC 1295 # try to get value of JAVAC
1114 compiler_executable="$(source ${compiler_env} 1>/dev/null 2>&1; echo ${JAVAC})" 1296 compiler_executable="$(source ${compiler_env} 1>/dev/null 2>&1; echo ${JAVAC})"
1115 export JAVAC=${old_javac} 1297 export JAVAC=${old_javac}
1116 1298
1117 [[ -z ${compiler_executable} ]] && die "JAVAC is empty or undefined in ${compiler_env}" 1299 if [[ -z ${compiler_executable} ]]; then
1118 1300 echo "JAVAC is empty or undefined in ${compiler_env}"
1301 return 1
1302 fi
1303
1119 # check that it's executable 1304 # check that it's executable
1120 if [[ ! -x ${compiler_executable} ]]; then 1305 if [[ ! -x ${compiler_executable} ]]; then
1121 eerror "Could not find ${compiler_executable}!"
1122 die "${compiler_executable} doesn't exist, or isn't executable" 1306 echo "${compiler_executable} doesn't exist, or isn't executable"
1307 return 1
1123 fi 1308 fi
1124 else 1309 else
1125 eerror "Could not find environment file for ${compiler}" 1310 echo "Could not find environment file for ${compiler}"
1126 die "Could not find ${compiler_env}" 1311 return 1
1127 fi 1312 fi
1128 fi 1313 fi
1129 echo ${compiler_executable} 1314 echo ${compiler_executable}
1130} 1315}
1131 1316
1132# ------------------------------------------------------------------------------ 1317# ------------------------------------------------------------------------------
1133# @ebuild-function java-pkg_javac-args 1318# @ebuild-function java-pkg_javac-args
1134# 1319#
1135# If an ebuild uses javac directly, instead of using ejavac, it should call this 1320# If an ebuild uses javac directly, instead of using ejavac, it should call this
1136# to know what -source/-target to use. 1321# to know what -source/-target to use.
1137# 1322#
1138# @return string - arguments to pass to javac, complete with -target and -source 1323# @return string - arguments to pass to javac, complete with -target and -source
1141 debug-print-function ${FUNCNAME} $* 1326 debug-print-function ${FUNCNAME} $*
1142 1327
1143 local want_source="$(java-pkg_get-source)" 1328 local want_source="$(java-pkg_get-source)"
1144 local want_target="$(java-pkg_get-target)" 1329 local want_target="$(java-pkg_get-target)"
1145 1330
1146 local source_str="-source ${want_source}" 1331 local source_str="-source ${want_source}"
1147 local target_str="-target ${want_target}" 1332 local target_str="-target ${want_target}"
1148 1333
1149 debug-print "want source: ${want_source}" 1334 debug-print "want source: ${want_source}"
1150 debug-print "want target: ${want_target}" 1335 debug-print "want target: ${want_target}"
1151 1336
1152 if [[ -z "${want_source}" || -z "${want_target}" ]]; then 1337 if [[ -z "${want_source}" || -z "${want_target}" ]]; then
1153 debug-print "could not find valid -source/-target values" 1338 debug-print "could not find valid -source/-target values for javac"
1154 die "Could not find valid -source/-target values" 1339 echo "Could not find valid -source/-target values for javac"
1340 return 1
1155 else 1341 else
1156 if java-pkg_is-vm-version-ge "1.4"; then 1342 if java-pkg_is-vm-version-ge "1.4"; then
1157 echo "${source_str} ${target_str}" 1343 echo "${source_str} ${target_str}"
1158 else 1344 else
1159 echo "${target_str}" 1345 echo "${target_str}"
1163 1349
1164# TODO document 1350# TODO document
1165java-pkg_get-jni-cflags() { 1351java-pkg_get-jni-cflags() {
1166 local flags="-I${JAVA_HOME}/include" 1352 local flags="-I${JAVA_HOME}/include"
1167 1353
1354 local platform="linux"
1355 use elibc_FreeBSD && platform="freebsd"
1356
1168 # TODO do a check that the directories are valid 1357 # TODO do a check that the directories are valid
1169 # TODO figure out how to cope with other things than linux...
1170 flags="${flags} -I${JAVA_HOME}/include/linux" 1358 flags="${flags} -I${JAVA_HOME}/include/${platform}"
1171 1359
1172 echo ${flags} 1360 echo ${flags}
1173} 1361}
1174 1362
1175java-pkg_ensure-gcj() { 1363java-pkg_ensure-gcj() {
1180 ebeep 5 1368 ebeep 5
1181 die "No GCJ support found!" 1369 die "No GCJ support found!"
1182 fi 1370 fi
1183} 1371}
1184 1372
1373java-pkg_ensure-test() {
1374 if hasq test ${FEATURES} && ! hasq -test ${FEATURES} \
1375 && hasq test ${IUSE} && ! use test;
1376 then
1377 eerror "You specified FEATURES=test, but USE=test is needed"
1378 eerror "to pull in the additional dependencies for testing"
1379 die "Need USE=test enabled"
1380 fi
1381}
1382
1383# ------------------------------------------------------------------------------
1384# @ebuild-function java-pkg_register-ant-task
1385#
1386# Register this package as ant task, so that ant will load it when no specific
1387# ANT_TASKS are specified. Note that even without this registering, all packages
1388# specified in ANT_TASKS will be loaded. Mostly used by the actual ant tasks
1389# packages, but can be also used by other ebuilds that used to symlink their
1390# .jar into /usr/share/ant-core/lib to get autoloaded, for backwards
1391# compatibility.
1392#
1393# @param --version x.y Register only for ant version x.y (otherwise for any ant
1394# version). Used by the ant-* packages to prevent loading of mismatched
1395# ant-core ant tasks after core was updated, before the tasks are updated,
1396# without a need for blockers.
1397# @param $1 Name to register as. Defaults to JAVA_PKG_NAME ($PN[-$SLOT])
1398# ------------------------------------------------------------------------------
1399java-pkg_register-ant-task() {
1400 local TASKS_DIR="tasks"
1401
1402 # check for --version x.y parameters
1403 while [[ -n "${1}" && -n "${2}" ]]; do
1404 local var="${1#--}"
1405 local val="${2}"
1406 if [[ "${var}" == "version" ]]; then
1407 TASKS_DIR="tasks-${val}"
1408 else
1409 die "Unknown parameter passed to java-pkg_register-ant-tasks: ${1} ${2}"
1410 fi
1411 shift 2
1412 done
1413
1414 local TASK_NAME="${1:-${JAVA_PKG_NAME}}"
1415
1416 dodir /usr/share/ant/${TASKS_DIR}
1417 touch "${D}/usr/share/ant/${TASKS_DIR}/${TASK_NAME}"
1418}
1419
1420# ------------------------------------------------------------------------------
1421# @internal-function java-pkg_ant-tasks-from-deps
1422#
1423# Function to determine ANT_TASKS from DEPEND variable for backwards
1424# compatibility with ebuilds that don't set ANT_TASKS before calling eant() or
1425# WANT_ANT_TASKS before inheriting java-pkg-2. If the DEPEND string contains
1426# "dev-java/ant" or "dev-java/ant-tasks", then it returns "all", otherwise
1427# "none". It's not smart enough to cope with USE flag depends but that shouldn't
1428# be a problem, the worst it can do is activace all tasks when not needed.
1429# Note that this is called only with JAVA_PKG_STRICT=1, to find ebuilds with
1430# insufficient dependencies, otherwise all available tasks are used for
1431# backwards compatilbility.
1432#
1433# @return "all" or "none"
1434# ------------------------------------------------------------------------------
1435java-pkg_ant-tasks-from-deps() {
1436 local found_ant found_ant_tasks
1437
1438 for dep in ${DEPEND}
1439 do
1440 local ant="$(awk '/(dev-java\/ant)/ { if (match($1, "(dev-java/ant)((-[0-9])+|$)", m)) print m[1] }' <<< ${dep})"
1441 [[ "${ant}" == "dev-java/ant" ]] && found_ant=true
1442 [[ "${dep}" == *"ant-tasks"* ]] && found_ant_tasks=true
1443 done
1444
1445 if [[ -n "${found_ant}" || -n "${found_ant_tasks}" ]]; then
1446 java-pkg_announce-qa-violation "The ebuild DEPENDS on deprecated ant or ant-tasks"
1447 echo "all"
1448 else
1449 # ebuild doesn't set ANT_TASKS and doesn't depend on ant-tasks or ant
1450 # so we deactivate all tasks that may be installed
1451 echo "none"
1452 fi
1453}
1454
1455# ------------------------------------------------------------------------------
1456# @internal-function java-pkg_ant-tasks-depend
1457#
1458# Translates the WANT_ANT_TASKS variable into valid dependencies.
1459# ------------------------------------------------------------------------------
1460java-pkg_ant-tasks-depend() {
1461 debug-print-function ${FUNCNAME} ${WANT_ANT_TASKS}
1462
1463 if [[ -n "${WANT_ANT_TASKS}" ]]; then
1464 local DEP=""
1465 for i in ${WANT_ANT_TASKS}
1466 do
1467 if [[ ${i} != ant-* ]]; then
1468 echo "Invalid atom in WANT_ANT_TASKS: ${i}"
1469 return 1
1470 fi
1471 DEP="${DEP}dev-java/${i} "
1472 done
1473 echo ${DEP}
1474 return 0
1475 else
1476 return 0
1477 fi
1478}
1479
1185# ------------------------------------------------------------------------------ 1480# ------------------------------------------------------------------------------
1186# @section-end helper 1481# @section-end helper
1187# ------------------------------------------------------------------------------ 1482# ------------------------------------------------------------------------------
1188 1483
1189# ------------------------------------------------------------------------------ 1484# ------------------------------------------------------------------------------
1196 1491
1197# ------------------------------------------------------------------------------ 1492# ------------------------------------------------------------------------------
1198# @ebuild-function eant 1493# @ebuild-function eant
1199# 1494#
1200# Ant wrapper function. Will use the appropriate compiler, based on user-defined 1495# Ant wrapper function. Will use the appropriate compiler, based on user-defined
1201# compiler. 1496# compiler. Will also set proper ANT_TASKS from the variable ANT_TASKS,
1202# 1497# variables:
1498# EANT_GENTOO_CLASSPATH - calls java-pkg_getjars for the value and adds to the
1499# gentoo.classpath property. Be sure to call
1500# java-ant_rewrite-classpath in src_unpack.
1501# *ANT_TASKS - used to determine ANT_TASKS before calling Ant.
1203# ------------------------------------------------------------------------------ 1502# ------------------------------------------------------------------------------
1204eant() { 1503eant() {
1205 debug-print-function ${FUNCNAME} $* 1504 debug-print-function ${FUNCNAME} $*
1206 1505
1207 local antflags 1506 # FIXME get this working
1507# if is-java-strict && [[ ! ${DEPEND} =~ "dev-java/ant" ]]; then
1508# java-pkg_announce-qa-violation \
1509# "Using eant, but not depending on dev-java/ant or dev-java/ant-core"
1510# fi
1511
1512 local antflags="-Dnoget=true -Dmaven.mode.offline=true"
1208 java-pkg_init-compiler_ 1513 java-pkg_init-compiler_
1209 local compiler="${GENTOO_COMPILER}" 1514 local compiler="${GENTOO_COMPILER}"
1210 1515
1211 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}" 1516 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}"
1212 1517
1214 if [[ "${compiler}" != "javac" && -z "${build_compiler}" ]]; then 1519 if [[ "${compiler}" != "javac" && -z "${build_compiler}" ]]; then
1215 die "ANT_BUILD_COMPILER undefined in ${compiler_env}" 1520 die "ANT_BUILD_COMPILER undefined in ${compiler_env}"
1216 fi 1521 fi
1217 1522
1218 if [[ ${compiler} != "javac" ]]; then 1523 if [[ ${compiler} != "javac" ]]; then
1219 antflags="-Dbuild.compiler=${build_compiler}" 1524 antflags="${antflags} -Dbuild.compiler=${build_compiler}"
1220 # Figure out any extra stuff to put on the classpath for compilers aside 1525 # Figure out any extra stuff to put on the classpath for compilers aside
1221 # from javac 1526 # from javac
1222 # ANT_BUILD_COMPILER_DEPS should be something that could be passed to 1527 # ANT_BUILD_COMPILER_DEPS should be something that could be passed to
1223 # java-config -p 1528 # java-config -p
1224 local build_compiler_deps="$(source ${JAVA_PKG_COMPILER_DIR}/${compiler} 1>/dev/null 2>&1; echo ${ANT_BUILD_COMPILER_DEPS})" 1529 local build_compiler_deps="$(source ${JAVA_PKG_COMPILER_DIR}/${compiler} 1>/dev/null 2>&1; echo ${ANT_BUILD_COMPILER_DEPS})"
1229 1534
1230 if is-java-strict; then 1535 if is-java-strict; then
1231 einfo "Disabling system classpath for ant" 1536 einfo "Disabling system classpath for ant"
1232 antflags="${antflags} -Dbuild.sysclasspath=ignore" 1537 antflags="${antflags} -Dbuild.sysclasspath=ignore"
1233 fi 1538 fi
1234 1539
1235 if [[ -n ${JAVA_PKG_DEBUG} ]]; then 1540 if has_version ">=dev-java/ant-core-1.7.0"; then
1236 antflags="${antflags} -debug" 1541 # default ANT_TASKS to WANT_ANT_TASKS, if ANT_TASKS is not set explicitly
1542 ANT_TASKS="${ANT_TASKS:-${WANT_ANT_TASKS}}"
1543
1544 # override ANT_TASKS with JAVA_PKG_FORCE_ANT_TASKS if it's set
1545 ANT_TASKS="${JAVA_PKG_FORCE_ANT_TASKS:-${ANT_TASKS}}"
1546
1547 if is-java-strict; then
1548 # if ant-tasks were not set by ebuild or forced, try to determine them from depends
1549 if [[ -z "${ANT_TASKS}" ]]; then
1550 ANT_TASKS="$(java-pkg_ant-tasks-from-deps)"
1551 fi
1552 else
1553 # if ant-tasks is not set by ebuild or forced, activate all of them
1554 ANT_TASKS="${ANT_TASKS:-all}"
1237 fi 1555 fi
1238 1556
1557 # at this point, ANT_TASKS should be "all", "none" or explicit list
1558 if [[ "${ANT_TASKS}" == "all" ]]; then
1559 einfo "Using all available ANT_TASKS"
1560 elif [[ "${ANT_TASKS}" == "none" ]]; then
1561 einfo "Disabling all optional ANT_TASKS"
1562 else
1563 einfo "Using following ANT_TASKS: ${ANT_TASKS}"
1564 fi
1565
1566 export ANT_TASKS
1567 fi
1568
1569 [[ -n ${JAVA_PKG_DEBUG} ]] && antflags="${antflags} --execdebug -debug"
1570 [[ -n ${PORTAGE_QUIET} ]] && antflags="${antflags} -q"
1571
1572 local gcp="${EANT_GENTOO_CLASSPATH}"
1573
1574 if [[ "${gcp}" ]]; then
1575 local cp="$(java-pkg_getjars ${gcp})"
1576 # It seems ant does not like single quotes around ${cp}
1577 antflags="${antflags} -Dgentoo.classpath=\"${cp}\""
1578 fi
1579
1239 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ant ${antflags} "${@}" 1580 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ant ${antflags} "${@}"
1581 debug-print "Calling ant: ${antflags} ${@}"
1240 ant ${antflags} "${@}" || die "eant failed" 1582 ant ${antflags} "${@}" || die "eant failed"
1241 1583
1242} 1584}
1243 1585
1244# ------------------------------------------------------------------------------ 1586# ------------------------------------------------------------------------------
1245# @ebuild-function ejavac 1587# @ebuild-function ejavac
1246# 1588#
1247# Javac wrapper function. Will use the appropriate compiler, based on 1589# Javac wrapper function. Will use the appropriate compiler, based on
1248# /etc/java-config/compilers.conf 1590# /etc/java-config/compilers.conf
1249# 1591#
1250# @param $@ - Arguments to be passed to the compiler 1592# @param $@ - Arguments to be passed to the compiler
1251# ------------------------------------------------------------------------------ 1593# ------------------------------------------------------------------------------
1252ejavac() { 1594ejavac() {
1253 debug-print-function ${FUNCNAME} $* 1595 debug-print-function ${FUNCNAME} $*
1254 1596
1255 # FIXME using get-javac ends up printing stuff with einfo 1597 java-pkg_init-compiler_
1598
1599 local compiler_executable
1256# local compiler_executable=$(java-pkg_get-javac) 1600 compiler_executable=$(java-pkg_get-javac)
1257 local compiler_executable="javac" 1601 if [[ ${?} != 0 ]]; then
1602 eerror "There was a problem determining compiler: ${compiler_executable}"
1603 die "get-javac failed"
1604 fi
1258 1605
1606 local javac_args
1607 javac_args="$(java-pkg_javac-args)"
1608 if [[ ${?} != 0 ]]; then
1609 eerror "There was a problem determining JAVACFLAGS: ${javac_args}"
1610 die "java-pkg_javac-args failed"
1611 fi
1612
1259 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ${compiler_executable} $(java-pkg_javac-args) "${@}" 1613 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ${compiler_executable} ${javac_args} "${@}"
1260 ${compiler_executable} $(java-pkg_javac-args) "${@}" || die "ejavac failed" 1614 ${compiler_executable} ${javac_args} "${@}" || die "ejavac failed"
1261} 1615}
1262 1616
1263# ------------------------------------------------------------------------------ 1617# ------------------------------------------------------------------------------
1264# @ebuild-function java-pkg_filter-compiler 1618# @ebuild-function java-pkg_filter-compiler
1265# 1619#
1266# Used to prevent the use of some compilers. Should be used in src_compile. 1620# Used to prevent the use of some compilers. Should be used in src_compile.
1267# Basically, it just appends onto JAVA_PKG_FILTER_COMPILER 1621# Basically, it just appends onto JAVA_PKG_FILTER_COMPILER
1268# 1622#
1269# @param $@ - compilers to filter 1623# @param $@ - compilers to filter
1270# ------------------------------------------------------------------------------ 1624# ------------------------------------------------------------------------------
1288# ------------------------------------------------------------------------------ 1642# ------------------------------------------------------------------------------
1289# @ebuild-function use_doc 1643# @ebuild-function use_doc
1290# 1644#
1291# Helper function for getting ant to build javadocs. If the user has USE=doc, 1645# Helper function for getting ant to build javadocs. If the user has USE=doc,
1292# then 'javadoc' or the argument are returned. Otherwise, there is no return. 1646# then 'javadoc' or the argument are returned. Otherwise, there is no return.
1293# 1647#
1294# The output of this should be passed to ant. 1648# The output of this should be passed to ant.
1295# 1649#
1296# Example: build javadocs by calling 'javadoc' target 1650# Example: build javadocs by calling 'javadoc' target
1297# eant $(use_doc) 1651# eant $(use_doc)
1298# Example: build javadocs by calling 'apidoc' target 1652# Example: build javadocs by calling 'apidoc' target
1303# ------------------------------------------------------------------------------ 1657# ------------------------------------------------------------------------------
1304use_doc() { 1658use_doc() {
1305 use doc && echo ${@:-javadoc} 1659 use doc && echo ${@:-javadoc}
1306} 1660}
1307 1661
1662
1308# ------------------------------------------------------------------------------ 1663# ------------------------------------------------------------------------------
1309# @section-end build 1664# @section-end build
1310# ------------------------------------------------------------------------------ 1665# ------------------------------------------------------------------------------
1311 1666
1312# ------------------------------------------------------------------------------ 1667# ------------------------------------------------------------------------------
1313# @section-begin internal 1668# @section-begin internal
1314# @section-summary Internal functions 1669# @section-summary Internal functions
1315# 1670#
1316# Do __NOT__ use any of these from an ebuild! These are only to be used from 1671# Do __NOT__ use any of these from an ebuild! These are only to be used from
1317# within the java eclasses. 1672# within the java eclasses.
1318# ------------------------------------------------------------------------------ 1673# ------------------------------------------------------------------------------
1319 1674
1320# ----------------------------------------------------------------------------- 1675# -----------------------------------------------------------------------------
1321# @function-internal java-pkg_init 1676# @function-internal java-pkg_init
1322# 1677#
1323# The purpose of this function, as the name might imply, is to initialize the 1678# The purpose of this function, as the name might imply, is to initialize the
1324# Java environment. It ensures that that there aren't any environment variables 1679# Java environment. It ensures that that there aren't any environment variables
1325# that'll muss things up. It initializes some variables, which are used 1680# that'll muss things up. It initializes some variables, which are used
1326# internally. And most importantly, it'll switch the VM if necessary. 1681# internally. And most importantly, it'll switch the VM if necessary.
1327# 1682#
1339 # TODO we will probably want to set JAVAC and JAVACFLAGS 1694 # TODO we will probably want to set JAVAC and JAVACFLAGS
1340 1695
1341 # Do some QA checks 1696 # Do some QA checks
1342 java-pkg_check-jikes 1697 java-pkg_check-jikes
1343 1698
1344 # When users have crazy classpaths some packages can fail to compile. 1699 # When users have crazy classpaths some packages can fail to compile.
1345 # and everything should work with empty CLASSPATH. 1700 # and everything should work with empty CLASSPATH.
1346 # This also helps prevent unexpected dependencies on random things 1701 # This also helps prevent unexpected dependencies on random things
1347 # from the CLASSPATH. 1702 # from the CLASSPATH.
1348 unset CLASSPATH 1703 unset CLASSPATH
1704
1705 # Unset external ANT_ stuff
1706 unset ANT_TASKS
1707 unset ANT_OPTS
1349} 1708}
1350 1709
1351# ------------------------------------------------------------------------------ 1710# ------------------------------------------------------------------------------
1352# @function-internal java-pkg-init-compiler_ 1711# @function-internal java-pkg-init-compiler_
1353# 1712#
1354# This function attempts to figure out what compiler should be used. It does 1713# This function attempts to figure out what compiler should be used. It does
1355# this by reading the file at JAVA_PKG_COMPILERS_CONF, and checking the 1714# this by reading the file at JAVA_PKG_COMPILERS_CONF, and checking the
1356# COMPILERS variable defined there. 1715# COMPILERS variable defined there.
1357# This can be overridden by a list in JAVA_PKG_FORCE_COMPILER 1716# This can be overridden by a list in JAVA_PKG_FORCE_COMPILER
1358# 1717#
1359# It will go through the list of compilers, and verify that it supports the 1718# It will go through the list of compilers, and verify that it supports the
1360# target and source that are needed. If it is not suitable, then the next 1719# target and source that are needed. If it is not suitable, then the next
1361# compiler is checked. When JAVA_PKG_FORCE_COMPILER is defined, this checking 1720# compiler is checked. When JAVA_PKG_FORCE_COMPILER is defined, this checking
1362# isn't done. 1721# isn't done.
1363# 1722#
1385 if [[ -z ${JAVA_PKG_FORCE_COMPILER} ]]; then 1744 if [[ -z ${JAVA_PKG_FORCE_COMPILER} ]]; then
1386 compilers="$(source ${JAVA_PKG_COMPILERS_CONF} 1>/dev/null 2>&1; echo ${COMPILERS})" 1745 compilers="$(source ${JAVA_PKG_COMPILERS_CONF} 1>/dev/null 2>&1; echo ${COMPILERS})"
1387 else 1746 else
1388 compilers=${JAVA_PKG_FORCE_COMPILER} 1747 compilers=${JAVA_PKG_FORCE_COMPILER}
1389 fi 1748 fi
1390 1749
1391 debug-print "Read \"${compilers}\" from ${JAVA_PKG_COMPILERS_CONF}" 1750 debug-print "Read \"${compilers}\" from ${JAVA_PKG_COMPILERS_CONF}"
1392 1751
1393 # Figure out if we should announce what compiler we're using 1752 # Figure out if we should announce what compiler we're using
1394 local compiler 1753 local compiler
1395 for compiler in ${compilers}; do 1754 for compiler in ${compilers}; do
1398 if [[ ${compiler} = "javac" ]]; then 1757 if [[ ${compiler} = "javac" ]]; then
1399 debug-print "Found javac... breaking" 1758 debug-print "Found javac... breaking"
1400 export GENTOO_COMPILER="javac" 1759 export GENTOO_COMPILER="javac"
1401 break 1760 break
1402 fi 1761 fi
1403 1762
1404 if has ${compiler} ${JAVA_PKG_FILTER_COMPILER}; then 1763 if has ${compiler} ${JAVA_PKG_FILTER_COMPILER}; then
1405 if [[ -z ${JAVA_PKG_FORCE_COMPILER} ]]; then 1764 if [[ -z ${JAVA_PKG_FORCE_COMPILER} ]]; then
1406 einfo "Filtering ${compiler}" 1765 einfo "Filtering ${compiler}"
1407 continue 1766 continue
1408 fi 1767 fi
1409 fi 1768 fi
1410 1769
1411 # for non-javac, we need to make sure it supports the right target and 1770 # for non-javac, we need to make sure it supports the right target and
1412 # source 1771 # source
1413 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}" 1772 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}"
1414 if [[ -f ${compiler_env} ]]; then 1773 if [[ -f ${compiler_env} ]]; then
1415 local desired_target="$(java-pkg_get-target)" 1774 local desired_target="$(java-pkg_get-target)"
1497# Writes the package.env out to disk. 1856# Writes the package.env out to disk.
1498# 1857#
1499# ------------------------------------------------------------------------------ 1858# ------------------------------------------------------------------------------
1500# TODO change to do-write, to match everything else 1859# TODO change to do-write, to match everything else
1501java-pkg_do_write_() { 1860java-pkg_do_write_() {
1861 java-pkg_init_paths_
1502 # Create directory for package.env 1862 # Create directory for package.env
1503 dodir "${JAVA_PKG_SHAREPATH}" 1863 dodir "${JAVA_PKG_SHAREPATH}"
1504 if [[ -n "${JAVA_PKG_CLASSPATH}" || -n "${JAVA_PKG_LIBRARY}" || -f "${JAVA_PKG_DEPEND}" ]]; then 1864 if [[ -n "${JAVA_PKG_CLASSPATH}" || -n "${JAVA_PKG_LIBRARY}" || -f "${JAVA_PKG_DEPEND}" ]]; then
1505 # Create package.env 1865 # Create package.env
1506 ( 1866 (
1511 [[ -n "${JAVA_PKG_LIBRARY}" ]] && echo "LIBRARY_PATH=\"${JAVA_PKG_LIBRARY}\"" 1871 [[ -n "${JAVA_PKG_LIBRARY}" ]] && echo "LIBRARY_PATH=\"${JAVA_PKG_LIBRARY}\""
1512 [[ -n "${JAVA_PROVIDE}" ]] && echo "PROVIDES=\"${JAVA_PROVIDE}\"" 1872 [[ -n "${JAVA_PROVIDE}" ]] && echo "PROVIDES=\"${JAVA_PROVIDE}\""
1513 [[ -f "${JAVA_PKG_DEPEND}" ]] && echo "DEPEND=\"$(cat ${JAVA_PKG_DEPEND} | uniq | tr '\n' ':')\"" 1873 [[ -f "${JAVA_PKG_DEPEND}" ]] && echo "DEPEND=\"$(cat ${JAVA_PKG_DEPEND} | uniq | tr '\n' ':')\""
1514 echo "VM=\"$(echo ${RDEPEND} ${DEPEND} | sed -e 's/ /\n/g' | sed -n -e '/virtual\/\(jre\|jdk\)/ { p;q }')\"" # TODO cleanup ! 1874 echo "VM=\"$(echo ${RDEPEND} ${DEPEND} | sed -e 's/ /\n/g' | sed -n -e '/virtual\/\(jre\|jdk\)/ { p;q }')\"" # TODO cleanup !
1515 ) > "${JAVA_PKG_ENV}" 1875 ) > "${JAVA_PKG_ENV}"
1516 1876
1517 # register target/source 1877 # register target/source
1518 local target="$(java-pkg_get-target)" 1878 local target="$(java-pkg_get-target)"
1519 local source="$(java-pkg_get-source)" 1879 local source="$(java-pkg_get-source)"
1520 [[ -n ${target} ]] && echo "TARGET=\"${target}\"" >> "${JAVA_PKG_ENV}" 1880 [[ -n ${target} ]] && echo "TARGET=\"${target}\"" >> "${JAVA_PKG_ENV}"
1521 [[ -n ${source} ]] && echo "SOURCE=\"${source}\"" >> "${JAVA_PKG_ENV}" 1881 [[ -n ${source} ]] && echo "SOURCE=\"${source}\"" >> "${JAVA_PKG_ENV}"
1534 # Strip unnecessary leading and trailing colons 1894 # Strip unnecessary leading and trailing colons
1535 # TODO try to cleanup if possible 1895 # TODO try to cleanup if possible
1536 sed -e "s/=\":/=\"/" -e "s/:\"$/\"/" -i "${JAVA_PKG_ENV}" || die "Did you forget to call java_init ?" 1896 sed -e "s/=\":/=\"/" -e "s/:\"$/\"/" -i "${JAVA_PKG_ENV}" || die "Did you forget to call java_init ?"
1537 fi 1897 fi
1538} 1898}
1539
1540 1899
1541# ------------------------------------------------------------------------------ 1900# ------------------------------------------------------------------------------
1542# @internal-function java-pkg_record-jar_ 1901# @internal-function java-pkg_record-jar_
1543# 1902#
1544# Record a dependency to the package.env 1903# Record a dependency to the package.env
1588 fi 1947 fi
1589} 1948}
1590 1949
1591# ------------------------------------------------------------------------------ 1950# ------------------------------------------------------------------------------
1592# @internal-function java-pkg_expand_dir_ 1951# @internal-function java-pkg_expand_dir_
1593# 1952#
1594# Gets the full path of the file/directory's parent. 1953# Gets the full path of the file/directory's parent.
1595# @param $1 - file/directory to find parent directory for 1954# @param $1 - file/directory to find parent directory for
1596# @return - path to $1's parent directory 1955# @return - path to $1's parent directory
1597# ------------------------------------------------------------------------------ 1956# ------------------------------------------------------------------------------
1598java-pkg_expand_dir_() { 1957java-pkg_expand_dir_() {
1625# ------------------------------------------------------------------------------ 1984# ------------------------------------------------------------------------------
1626java-pkg_setup-vm() { 1985java-pkg_setup-vm() {
1627 debug-print-function ${FUNCNAME} $* 1986 debug-print-function ${FUNCNAME} $*
1628 1987
1629 local vendor="$(java-pkg_get-vm-vendor)" 1988 local vendor="$(java-pkg_get-vm-vendor)"
1630 if [[ "${vendor}" == "sun" ]] && java-pkg_is-vm-version-ge 1 5; then 1989 if [[ "${vendor}" == "sun" ]] && java-pkg_is-vm-version-ge "1.5" ; then
1631 addpredict "/dev/random" 1990 addpredict "/dev/random"
1632 elif [[ "${vendor}" == "ibm" ]]; then 1991 elif [[ "${vendor}" == "ibm" ]]; then
1633 addpredict "/proc/self/maps" 1992 addpredict "/proc/self/maps"
1634 addpredict "/proc/cpuinfo" 1993 addpredict "/proc/cpuinfo"
1635 export LANG="C" LC_ALL="C" 1994 export LANG="C" LC_ALL="C"
1684# @return - The version of the current VM 2043# @return - The version of the current VM
1685# ------------------------------------------------------------------------------ 2044# ------------------------------------------------------------------------------
1686java-pkg_get-vm-version() { 2045java-pkg_get-vm-version() {
1687 debug-print-function ${FUNCNAME} $* 2046 debug-print-function ${FUNCNAME} $*
1688 2047
1689 java-pkg_get-current-vm | sed -e "s/.*-\([0-9.]\+\).*/\1/" 2048 java-config -g PROVIDES_VERSION
1690} 2049}
1691 2050
1692# ------------------------------------------------------------------------------ 2051# ------------------------------------------------------------------------------
1693# @internal-function java-pkg_switch-vm 2052# @internal-function java-pkg_switch-vm
1694# 2053#
1695# Switch VM if we're allowed to (controlled by JAVA_PKG_ALLOW_VM_CHANGE), and 2054# Switch VM if we're allowed to (controlled by JAVA_PKG_ALLOW_VM_CHANGE), and
1696# verify that the current VM is sufficient. 2055# verify that the current VM is sufficient.
1697# Setup the environment for the VM being used. 2056# Setup the environment for the VM being used.
1698# ------------------------------------------------------------------------------ 2057# ------------------------------------------------------------------------------
1699java-pkg_switch-vm() { 2058java-pkg_switch-vm() {
2059 debug-print-function ${FUNCNAME} $*
2060
1700 if java-pkg_needs-vm; then 2061 if java-pkg_needs-vm; then
1701 # Use the VM specified by JAVA_PKG_FORCE_VM 2062 # Use the VM specified by JAVA_PKG_FORCE_VM
1702 if [[ -n ${JAVA_PKG_FORCE_VM} ]]; then 2063 if [[ -n "${JAVA_PKG_FORCE_VM}" ]]; then
1703 # If you're forcing the VM, I hope you know what your doing... 2064 # If you're forcing the VM, I hope you know what your doing...
2065 debug-print "JAVA_PKG_FORCE_VM used: ${JAVA_PKG_FORCE_VM}"
1704 export GENTOO_VM="${JAVA_PKG_FORCE_VM}" 2066 export GENTOO_VM="${JAVA_PKG_FORCE_VM}"
1705 # if we're allowed to switch the vm... 2067 # if we're allowed to switch the vm...
1706 elif [[ "${JAVA_PKG_ALLOW_VM_CHANGE}" == "yes" ]]; then 2068 elif [[ "${JAVA_PKG_ALLOW_VM_CHANGE}" == "yes" ]]; then
1707 debug-print "depend-java-query: NV_DEPEND: ${JAVA_PKG_NV_DEPEND:-${DEPEND}} VNEED: ${JAVA_PKG_VNEED}" 2069 debug-print "depend-java-query: NV_DEPEND: ${JAVA_PKG_NV_DEPEND:-${DEPEND}} VNEED: ${JAVA_PKG_VNEED}"
1708 if [[ -n ${JAVA_PKG_VNEED} ]]; then 2070 if [[ -n ${JAVA_PKG_VNEED} ]]; then
1709 export GENTOO_VM="$(depend-java-query --need-virtual "${JAVA_PKG_VNEED}" --get-vm "${JAVA_PKG_NV_DEPEND:-${DEPEND}}")" 2071 GENTOO_VM="$(depend-java-query --need-virtual "${JAVA_PKG_VNEED}" --get-vm "${JAVA_PKG_NV_DEPEND:-${DEPEND}}")"
1710 else 2072 else
1711 export GENTOO_VM="$(depend-java-query --get-vm "${JAVA_PKG_NV_DEPEND:-${DEPEND}}")" 2073 GENTOO_VM="$(depend-java-query --get-vm "${JAVA_PKG_NV_DEPEND:-${DEPEND}}")"
2074 fi
2075 if [[ -z "${GENTOO_VM}" || "${GENTOO_VM}" == "None" ]]; then
2076 eerror "Unable to determine VM for building from dependencies:"
2077 echo "NV_DEPEND: ${JAVA_PKG_NV_DEPEND:-${DEPEND}}"
2078 echo "VNEED: ${JAVA_PKG_VNEED}"
2079 die "Failed to determine VM for building."
2080 else
2081 export GENTOO_VM
1712 fi 2082 fi
1713 # otherwise just make sure the current VM is sufficient 2083 # otherwise just make sure the current VM is sufficient
1714 else 2084 else
1715 java-pkg_ensure-vm-version-sufficient 2085 java-pkg_ensure-vm-version-sufficient
1716 fi 2086 fi
1717 debug-print "Using: $(java-config -f)" 2087 debug-print "Using: $(java-config -f)"
1718 2088
1719 java-pkg_setup-vm 2089 java-pkg_setup-vm
1720 2090
1721 export JAVA=$(java-config --java) 2091 export JAVA=$(java-config --java)
1722 export JAVAC=$(java-config --javac) 2092 export JAVAC=$(java-config --javac)
1723 export JAVACFLAGS="$(java-pkg_javac-args)" 2093 JAVACFLAGS="$(java-pkg_javac-args)"
2094 if [[ ${?} != 0 ]]; then
2095 eerror "There was a problem determining JAVACFLAGS: ${JAVACFLAGS}"
2096 die "java-pkg_javac-args failed"
2097 fi
1724 [[ -n ${JAVACFLAGS_EXTRA} ]] && export JAVACFLAGS="${JAVACFLAGS_EXTRA} ${JAVACFLAGS}" 2098 [[ -n ${JAVACFLAGS_EXTRA} ]] && JAVACFLAGS="${JAVACFLAGS_EXTRA} ${JAVACFLAGS}"
2099 export JAVACFLAGS
1725 2100
1726 export JAVA_HOME="$(java-config -g JAVA_HOME)" 2101 export JAVA_HOME="$(java-config -g JAVA_HOME)"
1727 export JDK_HOME=${JAVA_HOME} 2102 export JDK_HOME=${JAVA_HOME}
1728 2103
1729 #TODO If you know a better solution let us know. 2104 #TODO If you know a better solution let us know.
1730 java-pkg_append_ LD_LIBRARY_PATH "$(java-config -g LDPATH)" 2105 java-pkg_append_ LD_LIBRARY_PATH "$(java-config -g LDPATH)"
1731 2106
1732 local tann="${T}/announced-vm" 2107 local tann="${T}/announced-vm"
1733 if [[ -n "${JAVA_PKG_DEBUG}" ]] || [[ ! -f "${tann}" ]] ; then 2108 if [[ -n "${JAVA_PKG_DEBUG}" ]] || [[ ! -f "${tann}" ]] ; then
1734 # Add a check for setup/preinst phase... to avoid duplicate outputs 2109 # Add a check for setup/preinst phase... to avoid duplicate outputs
1735 # for when FEATURES=buildpkg 2110 # for when FEATURES=buildpkg
1736 if [[ ${EBUILD_PHASE} != "setup" && ${EBUILD_PHASE} != "preinst" && ${EBUILD_PHASE} != "postinst" ]]; 2111 if [[ ${EBUILD_PHASE} != "setup" && ${EBUILD_PHASE} != "preinst" && ${EBUILD_PHASE} != "postinst" ]];
1780# TODO document 2155# TODO document
1781# Verify that the classes were compiled for the right source / target 2156# Verify that the classes were compiled for the right source / target
1782java-pkg_verify-classes() { 2157java-pkg_verify-classes() {
1783 ebegin "Verifying java class versions" 2158 ebegin "Verifying java class versions"
1784 #$(find ${D} -type f -name '*.jar' -o -name '*.class') 2159 #$(find ${D} -type f -name '*.jar' -o -name '*.class')
1785 class-version-verify.py -t $(java-pkg_get-target) -r ${D} 2160 class-version-verify.py -t $(java-pkg_get-target) -r ${D}
1786 result=$? 2161 result=$?
1787 eend ${result} 2162 eend ${result}
1788 if [[ ${result} == 0 ]]; then 2163 if [[ ${result} == 0 ]]; then
1789 einfo "All good" 2164 einfo "All good"
1790 else 2165 else
1791 ewarn "Possible problem" 2166 ewarn "Possible problem"
1792 die "Bad class files found" 2167 die "Bad class files found"
1793 fi 2168 fi
1794} 2169}
1795 2170
1796
1797# ------------------------------------------------------------------------------ 2171# ------------------------------------------------------------------------------
1798# @section-end internal 2172# @section-end internal
1799# ------------------------------------------------------------------------------ 2173# ------------------------------------------------------------------------------
1800 2174
1801java-pkg_check-phase() { 2175java-pkg_check-phase() {
1832 let "JAVA_PKG_QA_VIOLATIONS+=1" 2206 let "JAVA_PKG_QA_VIOLATIONS+=1"
1833 export JAVA_PKG_QA_VIOLATIONS 2207 export JAVA_PKG_QA_VIOLATIONS
1834} 2208}
1835 2209
1836is-java-strict() { 2210is-java-strict() {
1837 hasq java-strict ${FEATURES}; 2211 [[ -n ${JAVA_PKG_STRICT} ]]
1838 return $? 2212 return $?
1839} 2213}
1840 2214
1841# ------------------------------------------------------------------------------ 2215# ------------------------------------------------------------------------------
1842# @eclass-end 2216# @eclass-end

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

  ViewVC Help
Powered by ViewVC 1.1.20