#! /bin/sh

# Bootstrap this package from CVS.

# Copyright (C) 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.

# 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 3, 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.

# Written by Paul Eggert and Sergey Poznyakoff.

nl='
'

# Ensure file names are sorted consistently across platforms.
# Also, ensure diagnostics are in English, e.g., "wget --help" below.
LC_ALL=C
export LC_ALL

usage() {
  echo >&2 "\
Usage: $0 [OPTION]...
Bootstrap this package from the checked-out sources.

Options:
 --paxutils-srcdir=DIRNAME  Specify the local directory where paxutils
                          sources reside. Use this if you already
                          have paxutils sources on your machine, and
                          do not want to waste your bandwidth dowloading
                          them again.
 --gnulib-srcdir=DIRNAME  Specify the local directory where gnulib
                          sources reside.  Use this if you already
                          have gnulib sources on your machine, and
                          do not want to waste your bandwidth dowloading
                          them again.
 --copy                   Copy files instead of creating symbolic links.
 --force                  Attempt to bootstrap even if the sources seem
                          not to have been checked out.
 --skip-po                Do not download po files.
 --update-po              Update po files and exit.
 --cvs-user=USERNAME      Set the CVS username to be used when accessing
                          the paxutils repository.

If the file bootstrap.conf exists in the current working directory, its
contents are read as shell variables to configure the bootstrap.

Local defaults can be provided by placing the file \`.bootstrap' in the
current working directory.  The file is read after bootstrap.conf, comments
and empty lines are removed, shell variables expanded and the result is
prepended to the command line options. 

Running without arguments will suffice in most cases.
"
}

checkout() {
  if [ ! -d $1 ]; then
    echo "$0: getting $1 files..."

    case $1 in
    paxutils)
      case ${CVS_AUTH-pserver} in
      pserver)
        CVS_PREFIX=':pserver:anonymous@';;
      ssh)
        CVS_PREFIX="$CVS_USER${CVS_USER+@}";;
      *)
        echo "$0: $CVS_AUTH: Unknown CVS access method" >&2
        exit 1;;
      esac

      case $CVS_RSH in
      '') CVS_RSH=ssh; export CVS_RSH;;
      esac

      CVSURL=${CVS_PREFIX}cvs.savannah.gnu.org:/cvsroot/"$1"
      ;;
      
    gnulib)
      CVSURL=:pserver:anonymous@pserver.git.sv.gnu.org:/gnulib.git
      ;;
      
    esac

    trap "cleanup $1" 1 2 13 15

    cvs -z3 -q -d $CVSURL co $1 || cleanup $1

    trap - 1 2 13 15
  fi
}

cleanup() {
  status=$?
  rm -fr $1
  exit $status
}

# Configuration.

# List of gnulib modules needed.
gnulib_modules=

# Any gnulib files needed that are not in modules.
gnulib_files=

# The command to download all .po files for a specified domain into
# a specified directory.  Fill in the first %s is the domain name, and
# the second with the destination directory.  Use rsync's -L and -r
# options because the latest/%s directory and the .po files within are
# all symlinks.
po_download_command_format=\
"rsync -Lrtvz 'translationproject.org::tp/latest/%s/' '%s'"

extract_package_name='
  /^AC_INIT(/{
     /.*,.*,.*,/{
       s///
       s/[][]//g
       p
       q
     }
     s/AC_INIT(\[*//
     s/]*,.*//
     s/^GNU //
     y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/
     s/[^A-Za-z0-9_]/-/g
     p
  }
'
package=`sed -n "$extract_package_name" configure.ac` || exit

# Extra files from gnulib, which override files from other sources.
gnulib_extra_files='
	build-aux/announce-gen
	build-aux/install-sh
	build-aux/missing
	build-aux/mdate-sh
	build-aux/texinfo.tex
	build-aux/depcomp
	build-aux/config.guess
	build-aux/config.sub
	doc/INSTALL
'

# Other locale categories that need message catalogs.
EXTRA_LOCALE_CATEGORIES=

# Additional xgettext options to use.  Use "\\\newline" to break lines.
XGETTEXT_OPTIONS='\\\
 --flag=_:1:pass-c-format\\\
 --flag=N_:1:pass-c-format\\\
 --flag=error:3:c-format --flag=error_at_line:5:c-format\\\
'

# Files we don't want to import.
excluded_files=

# File that should exist in the top directory of a checked out hierarchy,
# but not in a distribution tarball.
CVS_only_file=README-cvs

# Whether to use copies instead of symlinks.
copy=false

# Override the default configuration, if necessary.
test -r bootstrap.conf && . ./bootstrap.conf

# Read local configuration file
if [ -r .bootstrap ]; then
  echo "$0: Reading configuration file .bootstrap"
  eval set -- "`sed 's/#.*$//;/^$/d' .bootstrap | tr '\n' ' '` $*"
fi

# Translate configuration into internal form.

# Parse options.

for option
do
  case $option in
  --help)
    usage
    exit;;
  --paxutils-srcdir=*)
    PAXUTILS_SRCDIR=`expr "$option" : '--paxutils-srcdir=\(.*\)'`;;
  --gnulib-srcdir=*)
    GNULIB_SRCDIR=`expr "$option" : '--gnulib-srcdir=\(.*\)'`;;
  --cvs-user=*)
    CVS_USER=`expr "$option" : '--cvs-user=\(.*\)'`;;
  --skip-po | --no-po) # --no-po is for compatibility with 'tar' tradition.
    DOWNLOAD_PO=skip;;
  --update-po=*)
    DOWNLOAD_PO=`expr "$option" : '--update-po=\(.*\)'`;;
  --update-po)
    DOWNLOAD_PO=only;;
  --force)
    CVS_only_file=;;
  --copy)
    copy=true;;
  *)
    echo >&2 "$0: $option: unknown option"
    exit 1;;
  esac
done

if test -n "$CVS_only_file" && test ! -r "$CVS_only_file"; then
  echo "$0: Bootstrapping from a non-checked-out distribution is risky." >&2
  exit 1
fi

echo "$0: Bootstrapping CVS $package..."

# Get translations.

download_po_files() {
  subdir=$1
  domain=$2
  echo "$0: getting translations into $subdir for $domain..."
  cmd=`printf "$po_download_command_format" "$domain" "$subdir"`
  eval "$cmd"
}

# Download .po files to $po_dir/.reference and copy only the new
# or modified ones into $po_dir.  Also update $po_dir/LINGUAS.
update_po_files() {
  # Directory containing primary .po files.
  # Overwrite them only when we're sure a .po file is new.
  po_dir=$1
  domain=$2

  # Download *.po files into this dir.
  # Usually contains *.s1 checksum files.
  ref_po_dir="$po_dir/.reference"

  test -d $ref_po_dir || mkdir $ref_po_dir || return
  download_po_files $ref_po_dir $domain \
    && ls "$ref_po_dir"/*.po 2>/dev/null |
      sed 's|.*/||; s|\.po$||' > "$po_dir/LINGUAS"

  langs=`cd $ref_po_dir && echo *.po|sed 's/\.po//g'`
  test "$langs" = '*' && langs=x
  for po in `cd $ref_po_dir && echo *.po|sed 's/\.po//g'`; do
    case $po in x) continue;; esac
    new_po="$ref_po_dir/$po.po"
    cksum_file="$ref_po_dir/$po.s1"
    if ! test -f "$cksum_file" ||
	! test -f "$po_dir/$po.po" ||
	! sha1sum -c --status "$cksum_file" < "$new_po" > /dev/null; then
      echo "updated $po_dir/$po.po..."
      cp "$new_po" "$po_dir/$po.po" && sha1sum < "$new_po" > "$cksum_file"
    fi
  done
}

case $DOWNLOAD_PO in
'skip')
  ;;
'')
  if test -d po; then
    update_po_files po $package || exit
  fi
  ;;
'only')
  if test -d po; then
    update_po_files po $package || exit
  fi
  exit
  ;;
esac

# Get paxutils files.

case ${PAXUTILS_SRCDIR--} in
-) checkout paxutils
   PAXUTILS_SRCDIR=paxutils
esac

if [ -r $PAXUTILS_SRCDIR/gnulib.modules ]; then
  gnulib_modules=`
    (echo "$gnulib_modules"; grep '^[^#]' $PAXUTILS_SRCDIR/gnulib.modules) |
    sort -u
  `
fi

ignore_file_list=
cleanup_ifl() {
	test -n "$ignore_file_list" && rm -f $ignore_file_list
}

trap 'cleanup_ifl' 1 2 3 15

# ignorefile DIR FILE 
#  add FILE to the temporary ignorelist in the directory DIR
ignorefile() {
  file=$1/.ignore.$$ 
  echo "$2" >> $file
  if `echo $ignore_list | grep -qv $file`; then
    ignore_file_list="$ignore_file_list
$file"
  fi
}  

# copy_files srcdir dstdir
copy_files() {
  for file in `cat $1/DISTFILES`
  do
    case $file in
    "#*")  continue;;
    esac
    dst=`echo $file | sed 's^.*/^^'`
    if [ $# -eq 3 ]; then
      case $dst in
      ${3}*) ;;
      *) dst=${3}$dst;;
      esac
    fi
    echo "$0: Copying file $1/$file to $2/$dst"
    cp -p $1/$file $2/$dst
    ignorefile $2 $dst
  done
}

# Get gnulib files.

case ${GNULIB_SRCDIR--} in
-)
  checkout gnulib
  GNULIB_SRCDIR=gnulib
esac

gnulib_tool=$GNULIB_SRCDIR/gnulib-tool
<$gnulib_tool || exit

ensure_dir_exists()
{
  d=`dirname $dst`
  test -d "$d" || mkdir -p -- "$d"
}

symlink_to_gnulib()
{
  src=$GNULIB_SRCDIR/$1
  dst=${2-$1}

  test -f "$src" && {
    if $copy; then
      {
	test ! -h "$dst" || {
	  echo "$0: rm -f $dst" &&
	  rm -f "$dst"
	}
      } &&
      test -f "$dst" &&
      cmp -s "$src" "$dst" || {
	echo "$0: cp -fp $src $dst" &&
	ensure_dir_exists $dst &&
	cp -fp "$src" "$dst"
      }
    else
      test -h "$dst" &&
      src_ls=`ls -diL "$src" 2>/dev/null` && set $src_ls && src_i=$1 &&
      dst_ls=`ls -diL "$dst" 2>/dev/null` && set $dst_ls && dst_i=$1 &&
      test "$src_i" = "$dst_i" || {
	dot_dots=
	case $src in
	/*) ;;
	*)
	  case /$dst/ in
	  *//* | */../* | */./* | /*/*/*/*/*/)
	     echo >&2 "$0: invalid symlink calculation: $src -> $dst"
	     exit 1;;
	  /*/*/*/*/)	dot_dots=../../../;;
	  /*/*/*/)	dot_dots=../../;;
	  /*/*/)	dot_dots=../;;
	  esac;;
	esac

	echo "$0: ln -fs $dot_dots$src $dst" &&
	ensure_dir_exists $dst &&
	ln -fs "$dot_dots$src" "$dst"
      }
    fi
  }
}

cp_mark_as_generated()
{
  cp_src=$1
  cp_dst=$2

  if cmp -s "$cp_src" "$GNULIB_SRCDIR/$cp_dst"; then
    symlink_to_gnulib "$cp_dst"
  else
    case $cp_dst in
      *.[ch])             c1='/* '; c2=' */';;
      *.texi)             c1='@c '; c2=     ;;
      *.m4|*/Make*|Make*) c1='# ' ; c2=     ;;
      *)                  c1=     ; c2=     ;;
    esac

    if test -z "$c1"; then
      cmp -s "$cp_src" "$cp_dst" || {
	echo "$0: cp -f $cp_src $cp_dst" &&
	cp -f "$cp_src" "$cp_dst"
      }
    else
      # Copy the file first to get proper permissions if it
      # doesn't already exist.  Then overwrite the copy.
      cp "$cp_src" "$cp_dst-t" &&
      (
	echo "$c1-*- buffer-read-only: t -*- vi: set ro:$c2" &&
	echo "${c1}DO NOT EDIT! GENERATED AUTOMATICALLY!$c2" &&
	cat "$cp_src"
      ) > $cp_dst-t &&
      if cmp -s "$cp_dst-t" "$cp_dst"; then
	rm -f "$cp_dst-t"
      else
	echo "$0: cp $cp_src $cp_dst # with edits" &&
	mv -f "$cp_dst-t" "$cp_dst"
      fi
    fi
  fi
}

version_controlled_file() {
  dir=$1
  file=$2
  found=no
  if test -d CVS; then
    grep -F "/$file/" $dir/CVS/Entries 2>/dev/null |
	     grep '^/[^/]*/[0-9]' > /dev/null && found=yes
  elif test -d .git; then
    git-rm -n "$dir/$file" > /dev/null 2>&1 && found=yes
  else
    echo "$0: no version control for $dir/$file?" >&2
  fi
  test $found = yes
}

slurp() {
  for dir in . `(cd $1 && find * -type d -print)`; do
    copied=
    sep=
    for file in `ls $1/$dir`; do
      test -d $1/$dir/$file && continue
      for excluded_file in $excluded_files; do
	test "$dir/$file" = "$excluded_file" && continue 2
      done
      if test $file = Makefile.am; then
        copied=$copied${sep}gnulib.mk; sep=$nl
	remove_intl='/^[^#].*\/intl/s/^/#/;'"s,/$bt,,g"
        sed "$remove_intl" $1/$dir/$file | cmp -s - $dir/gnulib.mk || {
	  echo "$0: Copying $1/$dir/$file to $dir/gnulib.mk ..." &&
	  rm -f $dir/gnulib.mk &&
	  sed "$remove_intl" $1/$dir/$file >$dir/gnulib.mk
	}
      elif { test "${2+set}" = set && test -r $2/$dir/$file; } ||
	   version_controlled_file $dir $file; then
	echo "$0: $dir/$file overrides $1/$dir/$file"
      else
	copied=$copied$sep$file; sep=$nl
	if test $file = gettext.m4; then
	  echo "$0: patching m4/gettext.m4 to remove need for intl/* ..."
	  rm -f $dir/$file
	  sed '
	    /^AC_DEFUN(\[AM_INTL_SUBDIR],/,/^]/c\
	      AC_DEFUN([AM_INTL_SUBDIR], [
	    /^AC_DEFUN(\[gt_INTL_SUBDIR_CORE],/,/^]/c\
	      AC_DEFUN([gt_INTL_SUBDIR_CORE], [])
	    $a\
	      AC_DEFUN([gl_LOCK_EARLY], [])
	  ' $1/$dir/$file >$dir/$file
	else
	  cp_mark_as_generated $1/$dir/$file $dir/$file
	fi
      fi || exit
    done

    if test -n "$copied"; then
      copied="Makefile
Makefile.in
$copied"
      if test -d CVS; then
	dot_ig=.cvsignore
      else
        dor_ig=.gitignore
      fi

      ig=$dir/$dot_ig
      if [ -f $dir/.ignore.$$ ]; then
         tfile=$dir/.ignore.$$
      else
         tfile=
      fi
      if test -f $ig; then
	  echo "$copied" | sort -u - $ig | cmp -s - $ig ||
	  echo "$copied" | sort -u - $ig $tfile -o $ig
      else
          copied="$dot_ig
$copied"	  
	  if [ "$dir" = "po" ]; then
	    copied="LINGUAS
Makevars
POTFILES
*.mo
*.gmo
*.po
remove-potcdate.sed
stamp-po
$package.pot
$copied"
          fi  
          echo "$copied" | sort -u - $tfile -o $ig
      fi || exit
    fi
  done
}


# Create boot temporary directories to import from gnulib and gettext.

bt='.#bootmp'
bt2=${bt}2
rm -fr $bt $bt2 &&
mkdir $bt $bt2 || exit

# Import from gnulib.

test -d build-aux || {
  echo "$0: mkdir build-aux ..." &&
  mkdir build-aux
} || exit
gnulib_tool_options="\
 --import\
 --no-changelog\
 --aux-dir $bt/build-aux\
 --doc-base $bt/doc\
 --lib lib$package\
 --m4-base $bt/m4/\
 --source-base $bt/lib/\
 --tests-base $bt/tests\
 --local-dir gl\
"
echo "$0: $gnulib_tool $gnulib_tool_options --import ..."
$gnulib_tool $gnulib_tool_options --import $gnulib_modules &&
slurp $bt || exit

for file in $gnulib_files; do
  symlink_to_gnulib $file || exit
done


# Import from gettext.

echo "$0: (cd $bt2; autopoint) ..."
cp configure.ac $bt2 &&
(cd $bt2 && autopoint && rm configure.ac) &&
slurp $bt2 $bt || exit

rm -fr $bt $bt2 || exit

# Import from paxutils
copy_files ${PAXUTILS_SRCDIR}/m4 m4
echo "$0: Creating m4/paxutils.m4"
(echo "# This file is generated automatically. Please, do not edit."
 echo "#"
 echo "AC_DEFUN([${package}_PAXUTILS],["
 cat ${PAXUTILS_SRCDIR}/m4/DISTFILES | sed '/^#/d;s/\(.*\)\.m4/pu_\1/' | tr a-z A-Z
 echo "])") > ./m4/paxutils.m4
ignorefile m4 paxutils.m4

if [ -d rmt ]; then
   :
else
   mkdir rmt
fi

for dir in doc rmt lib tests
do
	copy_files ${PAXUTILS_SRCDIR}/$dir $dir
done

copy_files ${PAXUTILS_SRCDIR}/paxlib lib pax

# Reconfigure, getting other files.

for command in \
  'aclocal --force -I m4' \
  'autoconf --force' \
  'autoheader --force' \
  'automake --add-missing --copy --force-missing';
do
  echo "$0: $command ..."
  $command || exit
done


# Get some extra files from gnulib, overriding existing files.

for file in $gnulib_extra_files; do
  case $file in
  */INSTALL) dst=INSTALL;;
  *) dst=$file;;
  esac
  symlink_to_gnulib $file $dst || exit
done


# Create gettext configuration.
echo "$0: Creating po/Makevars from po/Makevars.template ..."
rm -f po/Makevars
sed '
  /^EXTRA_LOCALE_CATEGORIES *=/s/=.*/= '"$EXTRA_LOCALE_CATEGORIES"'/
  /^MSGID_BUGS_ADDRESS *=/s/=.*/= bug-'"$package"'@gnu.org/
  /^XGETTEXT_OPTIONS *=/{
    s/$/ \\/
    a\
	'"$XGETTEXT_OPTIONS"' $${end_of_xgettext_options+}
  }
' po/Makevars.template >po/Makevars

if test -d runtime-po; then
  # Similarly for runtime-po/Makevars, but not quite the same.
  rm -f runtime-po/Makevars
  sed '
    /^DOMAIN *=.*/s/=.*/= '"$package"'-runtime/
    /^subdir *=.*/s/=.*/= runtime-po/
    /^MSGID_BUGS_ADDRESS *=/s/=.*/= bug-'"$package"'@gnu.org/
    /^XGETTEXT_OPTIONS *=/{
      s/$/ \\/
      a\
	  '"$XGETTEXT_OPTIONS_RUNTIME"' $${end_of_xgettext_options+}
    }
  ' <po/Makevars.template >runtime-po/Makevars

  # Copy identical files from po to runtime-po.
  (cd po && cp -p Makefile.in.in *-quot *.header *.sed *.sin ../runtime-po)
fi
cleanup_ifl
echo "$0: done.  Now you can run './configure'."
