gcc/libjava/scripts/jar.in

#! @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