gcc/libjava/scripts/jar.in

524 lines
13 KiB
Plaintext
Raw Normal View History

#! @SHELL@
# Copyright (C) 2006 Free Software Foundation
# Written by Paolo Bonzini.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published
# by the Free Software Foundation; either version 2 of the License,
# or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
# for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
# POSIX and NLS nuisances, taken from autoconf.
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
emulate sh
NULLCMD=:
# Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
# is contrary to our usage. Disable this feature.
alias -g '${1+"$@"}'='"$@"'
setopt NO_GLOB_SUBST
else
case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
fi
BIN_SH=xpg4; export BIN_SH # for Tru64
DUALCASE=1; export DUALCASE # for MKS sh
if test "${LANG+set}" = set; then LANG=C; export LANG; fi
if test "${LC_ALL+set}" = set; then LC_ALL=C; export LC_ALL; fi
if test "${LC_MESSAGES+set}" = set; then LC_MESSAGES=C; export LC_MESSAGES; fi
if test "${LC_CTYPE+set}" = set; then LC_CTYPE=C; export LC_CTYPE; fi
# Also make sure CDPATH is empty, and IFS is space, tab, \n in that order.
# Be careful to avoid that editors munge IFS
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
IFS=" "" ""
"
: ${TMPDIR=/tmp}
: ${ZIP="@ZIP@"}
: ${UNZIP="@UNZIP@"}
progname="$0"
# Emit a usage message and exit with error status 1
usage () {
cat >&2 <<EOF
Usage: $0 {ctxu}[vfm0Mi@] [jar-file] [manifest-file] {[-C dir] files} ...
Options:
-c create new archive
-t list table of contents for archive
-x extract named (or all) files from archive
-u update existing archive
-v generate verbose output on standard output
-f specify archive file name
-m include manifest information from specified manifest file
-0 store only; use no ZIP compression
-M do not create a manifest file for the entries
-i generate index information for the specified jar files
-@ instead of {[-C dir] files} ... accept one or more response files,
each containing one command-line argument
-C change to the specified directory and include the following file
If any file is a directory then it is processed recursively.
The manifest file name and the archive file name needs to be specified
in the same order the 'm' and 'f' flags are specified.
Example 1: to archive two class files into an archive called classes.jar:
jar cvf classes.jar Foo.class Bar.class
Example 2: use an existing manifest file 'mymanifest' and archive all the
files in the foo/ directory into 'classes.jar':
jar cvfm classes.jar mymanifest -C foo/ .
EOF
(exit 1); exit 1
}
# Emit an error message and exit with error status 1
error () {
echo "$progname: $*" >&2
(exit 1); exit 1
}
# Usage: copy SRC DEST
# Copy file SRC to directory DEST, which is the staging area of the jar file.
# Fail if it is already present or if it is not a regular file.
copy () {
if test -f "$1"; then
# A simple optimization. Optimistically assuming that ln will work
# cuts 60% of the run-time!
if ln "$1" "$2"/"$1" > /dev/null 2>&1; then
return 0
fi
if test -f "$2"/"$1"; then
error "$1": Duplicate entry.
fi
dir=`dirname "$1"`
$mkdir_p "$2"/"$dir"
ln "$1" "$2"/"$1" > /dev/null 2>&1 || cp "$1" "$2"/"$1"
elif test -e "$1"; then
error "$1": Invalid file type.
else
error "$1": File not found.
fi
}
# Make a temporary directory and store its name in the JARTMP variable.
make_tmp () {
test -n "$JARTMP" && return
{
JARTMP=`(umask 077 && mktemp -d "$TMPDIR/jarXXXXXX") 2>/dev/null` &&
test -n "$JARTMP" && test -d "$JARTMP"
} || {
JARTMP=$TMPDIR/jar$$-$RANDOM
(umask 077 && mkdir "$JARTMP")
} || exit $?
trap 'exit_status=$?
if test -n "$JARTMP"; then rm -rf "$JARTMP"; fi
exit $exit_status' 0
}
# Usage: make_manifest destfile kind [source-manifest]
# Create a manifest file and store it in destfile. KIND can be "default",
# or "user", in which case SOURCE-MANIFEST must be specified as well.
make_manifest () {
dir=`dirname "$1"`
$mkdir_p "$dir"
case $2 in
default)
cat > "$1" <<\EOF
Manifest-Version: 1.0
Created-By: @VERSION@
EOF
;;
user)
cp "$3" "$1"
;;
esac
}
# Usage: set_var var [value]
# Exit with an error if set_var was already called for the same VAR. Else
# set the variable VAR to the value VALUE (or the empty value if no parameter
# is given).
set_var () {
if eval test x\$set_$1 = xset; then
error Incompatible or repeated options.
else
eval $1=\$2
eval set_$1=set
fi
}
# Process the arguments, including -C options, and copy the whole tree
# to $JARTMP/files so that zip can be invoked later from there.
make_files () {
change=false
if $process_response_files; then
if test $# = 0; then
while read arg; do
make_files_1 "$arg"
done
else
for infile
do
exec 5<&0
exec 0< $infile
while read arg; do
make_files_1 "$arg"
done
exec 0<&5
exec 5<&-
done
fi
else
for arg
do
make_files_1 "$arg"
done
fi
cd "$old_dir"
}
# Usage: make_files_1 ARG
# Process one argument, ARG.
make_files_1 () {
if $change; then
change=false
if cd "$1"; then
return
else
(exit 1); exit 1
fi
fi
case "$1" in
-C)
change=:
;;
-C*)
cd `expr "$1" : '-C\(.*\)' `
return
;;
*)
if test -d "$1"; then
$mkdir_p "$JARTMP"/files/"$1"
find "$1" | while read file; do
if test -d "$file"; then
$mkdir_p "$JARTMP"/files/"$file"
else
copy "$file" "$JARTMP"/files
fi
done
else
copy "$1" "$JARTMP"/files
fi
;;
esac
cd "$old_dir"
}
# Same as "jar tf $1".
jar_list () {
$UNZIP -l "$1" | \
sed '1,/^ ----/d;/^ ----/,$d;s/^ *[0-9]* ..-..-.. ..:.. //'
}
# Same as "jar tvf $1".
jar_list_verbose () {
$UNZIP -l "$1" | \
@AWK@ 'BEGIN { yes = 0 }
/^ ----/ { yes = !yes; next }
yes {
size=$1
split ($2, d, "-")
split ($3, t, ":")
d[3] += (d[3] < 80) ? 2000 : 1900
timestamp=d[3] " " d[1] " " d[2] " " t[1] " " t[2] " 00"
gsub (/^ *[0-9]* ..-..-.. ..:.. /, "")
printf "%6d %s %s\n", size, strftime ("%a %b %d %H:%M:%S %Z %Y", mktime (timestamp)), $0
}'
}
# mkdir -p emulation based on the mkinstalldirs script.
func_mkdir_p () {
for file
do
case $file in
/*) pathcomp=/ ;;
*) pathcomp= ;;
esac
oIFS=$IFS
IFS=/
set fnord $file
shift
IFS=$oIFS
errstatus=0
for d
do
test "x$d" = x && continue
pathcomp=$pathcomp$d
case $pathcomp in
-*) pathcomp=./$pathcomp ;;
esac
if test ! -d "$pathcomp"; then
mkdir "$pathcomp" || lasterr=$?
test -d "$pathcomp" || errstatus=$lasterr
fi
pathcomp=$pathcomp/
done
done
return "$errstatus"
}
# Detect mkdir -p
# On NextStep and OpenStep, the `mkdir' command does not
# recognize any option. It will interpret all options as
# directories to create, and then abort because `.' already
# exists.
if mkdir -p --version . >/dev/null 2>&1 && test ! -d ./--version; then
mkdir_p='mkdir -p'
else
mkdir_p='func_mkdir_p'
test -d ./-p && rmdir ./-p
test -d ./--version && rmdir ./--version
fi
# Process the first command line option.
case "$1" in
-*) commands=`echo X"$1" | sed 's/^X-//' ` ;;
*) commands="$1"
esac
shift
# Operation to perform on the JAR file
mode=unknown
# First -C option on the command line
cur_dir=.
# Base directory for -C options
old_dir=`pwd`
# JAR file to operate on
jarfile=
# default for no {m,M} option, user for "m" option, none for "M" option
manifest_kind=default
# "-0" if the "0" option was given
store=
# true if the "v" option was given
verbose=false
# true if the non-standard "@" option was given
process_response_files=false
# An exec command if we need to redirect the zip/unzip commands' output
out_redirect=:
while test -n "$commands"; do
# Process a letter at a time
command=`expr "$commands" : '\(.\)'`
commands=`expr "$commands" : '.\(.*\)'`
case "$command" in
c)
set_var mode create
;;
t)
set_var mode list
;;
x)
set_var mode extract
;;
u)
set_var mode update
;;
f)
test $# = 0 && usage
# Multiple "f" options are accepted by Sun's JAR tool.
jarfile="$1"
test -z "$jarfile" && usage
shift
;;
m)
test $# = 0 && usage
# Multiple "m" options are accepted by Sun's JAR tool, but
# M always overrides m.
test "$manifest_kind" = default && manifest_kind=user
manifest_file="$1"
test -z "$manifest_file" && usage
shift
;;
0)
store=-0
;;
v)
verbose=:
;;
i)
# Not yet implemented, and probably never will.
;;
M)
manifest_kind=none
;;
C)
test $# = 0 && usage
cur_dir="$1"
shift
;;
@)
process_response_files=: ;;
*)
usage ;;
esac
done
set -e
case "X$jarfile" in
X)
# Work on stdin/stdout. Messages go to stderr, and if we need an input
# JAR file we save it temporarily in the temporary directory.
make_tmp
$mkdir_p "$JARTMP"/out
jarfile="$JARTMP"/out/tmp-stdin.jar
out_redirect='exec >&2'
case $mode in
update|extract|list)
if $process_response_files && test $# = 0; then
error Cannot use stdin for response file.
fi
cat > "$JARTMP"/out/tmp-stdin.jar
;;
esac
;;
X*/*)
# Make an absolute path.
dir=`dirname "$jarfile"`
jarfile=`cd $dir && pwd`/`basename "$jarfile"`
;;
X*)
# Make an absolute path from a filename in the current directory.
jarfile=`pwd`/`basename "$jarfile"`
;;
esac
# Perform a -C option if given right away.
cd "$cur_dir"
case $mode in
unknown)
usage
;;
extract)
make_tmp
# Extract the list of files in the JAR file
jar_list "$jarfile" > "$JARTMP"/list
# If there are files on the command line, expand directories and skip -C
# command line arguments
for arg
do
if $skip; then
skip=false
continue
fi
case "$arg" in
-C) skip=: ;;
-C*) ;;
*)
escaped=`echo "X$arg" | sed 's/^X//; s/[].[^$\\*]/\\\\&/g' `
grep "^$escaped/" "$JARTMP"/list >> "$JARTMP"/chosen || :
grep "^$escaped\$" "$JARTMP"/list >> "$JARTMP"/chosen || :
esac
done
test -f "$JARTMP"/chosen || cp "$JARTMP"/list "$JARTMP"/chosen
# Really execute unzip
if $verbose; then
sort < "$JARTMP"/chosen | uniq | xargs $UNZIP -o "$jarfile" | \
sed -ne 's/^ creating/ created/p' -e 's/^ inflating/extracted/p'
else
sort < "$JARTMP"/chosen | uniq | xargs $UNZIP -o "$jarfile" > /dev/null
fi
;;
create)
make_tmp
$mkdir_p "$JARTMP"/out
$mkdir_p "$JARTMP"/files
# Do not overwrite the JAR file if something goes wrong
tmp_jarfile="$JARTMP"/out/`basename "$jarfile"`
# Prepare the files in the temporary directory. This is necessary to
# support -C and still save relative paths in the JAR file.
make_files ${1+"$@"}
if test $manifest_kind != none; then
make_manifest "$JARTMP"/files/META-INF/MANIFEST.MF $manifest_kind "$manifest_file"
fi
# Really execute zip
if $verbose; then
(eval $out_redirect; cd "$JARTMP"/files && $ZIP -rv "$tmp_jarfile" $store .)
else
(cd "$JARTMP/files" && $ZIP -r "$tmp_jarfile" $store . > /dev/null)
fi
test "$jarfile" = "$tmp_jarfile" || mv "$tmp_jarfile" "$jarfile"
;;
update)
make_tmp
$mkdir_p "$JARTMP"/files
make_files ${1+"$@"}
# Same as above, but zip takes care of not overwriting the file
case $manifest_kind in
none)
$verbose && (eval $out_redirect; echo removing manifest)
$ZIP -d "$jarfile" META-INF/MANIFEST.MF > /dev/null 2>&1 || :
;;
*)
make_manifest "$JARTMP"/files/META-INF/MANIFEST.MF $manifest_kind "$manifest_file"
;;
esac
if $verbose; then
(eval $out_redirect; cd "$JARTMP"/files && $ZIP -ruv "$jarfile" $store .)
else
(cd "$JARTMP"/files && $ZIP -ru "$jarfile" $store . > /dev/null)
fi
;;
list)
# Everything's done in the functions
if $verbose; then
jar_list_verbose "$jarfile"
else
jar_list "$jarfile"
fi ;;
esac
if test "$out_redirect" != :; then
# Cat back to stdout if necessary
case $mode in
create|update) cat "$JARTMP"/out/tmp-stdin.jar ;;
esac
fi
exit 0