# a silly hack that generates autoregen.sh but it's handy

 echo "#!/bin/sh" > autoregen.sh

 echo "./autogen.sh $@ \$@" >> autoregen.sh

 chmod +x autoregen.sh

 # helper functions for autogen.sh

 debug ()

 # print out a debug message if DEBUG is a defined variable

 {

   if test ! -z "$DEBUG"

   then

     echo "DEBUG: $1"

   fi

 }

 version_check ()

 # check the version of a package

 # first argument : package name (executable)

 # second argument : optional path where to look for it instead

 # third argument : source download url

 # rest of arguments : major, minor, micro version

 # all consecutive ones : suggestions for binaries to use

 # (if not specified in second argument)

 {

   PACKAGE=$1

   PKG_PATH=$2

   URL=$3

   MAJOR=$4

   MINOR=$5

   MICRO=$6

   # for backwards compatibility, we let PKG_PATH=PACKAGE when PKG_PATH null

   if test -z "$PKG_PATH"; then PKG_PATH=$PACKAGE; fi

   debug "major $MAJOR minor $MINOR micro $MICRO"

   VERSION=$MAJOR

   if test ! -z "$MINOR"; then VERSION=$VERSION.$MINOR; else MINOR=0; fi

   if test ! -z "$MICRO"; then VERSION=$VERSION.$MICRO; else MICRO=0; fi

   debug "major $MAJOR minor $MINOR micro $MICRO"

   for SUGGESTION in $PKG_PATH; do 

     COMMAND="$SUGGESTION"

     # don't check if asked not to

     test -z "$NOCHECK" && {

       echo -n "  checking for $COMMAND >= $VERSION ... "

     } || {

       # we set a var with the same name as the package, but stripped of

       # unwanted chars

       VAR=`echo $PACKAGE | sed 's/-//g'`

       debug "setting $VAR"

       eval $VAR="$COMMAND"

       return 0

     }

     debug "checking version with $COMMAND"

     ($COMMAND --version) < /dev/null > /dev/null 2>&1 || 

     {

       echo "not found."

       continue

     }

     # strip everything that's not a digit, then use cut to get the first field

     pkg_version=`$COMMAND --version|head -n 1|sed 's/^[^0-9]*//'|cut -d' ' -f1`

     debug "pkg_version $pkg_version"

     # remove any non-digit characters from the version numbers to permit numeric

     # comparison

     pkg_major=`echo $pkg_version | cut -d. -f1 | sed s/[a-zA-Z\-].*//g`

     pkg_minor=`echo $pkg_version | cut -d. -f2 | sed s/[a-zA-Z\-].*//g`

     pkg_micro=`echo $pkg_version | cut -d. -f3 | sed s/[a-zA-Z\-].*//g`

     test -z "$pkg_major" && pkg_major=0

     test -z "$pkg_minor" && pkg_minor=0

     test -z "$pkg_micro" && pkg_micro=0

     debug "found major $pkg_major minor $pkg_minor micro $pkg_micro"

     #start checking the version

     debug "version check"

     # reset check

     WRONG=

     if [ ! "$pkg_major" -gt "$MAJOR" ]; then

       debug "major: $pkg_major <= $MAJOR"

       if [ "$pkg_major" -lt "$MAJOR" ]; then

         debug "major: $pkg_major < $MAJOR"

         WRONG=1

       elif [ ! "$pkg_minor" -gt "$MINOR" ]; then

         debug "minor: $pkg_minor <= $MINOR"

         if [ "$pkg_minor" -lt "$MINOR" ]; then

           debug "minor: $pkg_minor < $MINOR"

           WRONG=1

         elif [ "$pkg_micro" -lt "$MICRO" ]; then

           debug "micro: $pkg_micro < $MICRO"

 	  WRONG=1

         fi

       fi

     fi

     if test ! -z "$WRONG"; then

       echo "found $pkg_version, not ok !"

       continue

     else

       echo "found $pkg_version, ok."

       # we set a var with the same name as the package, but stripped of

       # unwanted chars

       VAR=`echo $PACKAGE | sed 's/-//g'`

       debug "setting $VAR"

       eval $VAR="$COMMAND"

       return 0

     fi

   done

   echo "not found !"

   echo "You must have $PACKAGE installed to compile $package."

   echo "Download the appropriate package for your distribution,"

   echo "or get the source tarball at $URL"

   return 1;

 }

 aclocal_check ()

 {

   # normally aclocal is part of automake

   # so we expect it to be in the same place as automake

   # so if a different automake is supplied, we need to adapt as well

   # so how's about replacing automake with aclocal in the set var,

   # and saving that in $aclocal ?

   # note, this will fail if the actual automake isn't called automake*

   # or if part of the path before it contains it

   if [ -z "$automake" ]; then

     echo "Error: no automake variable set !"

     return 1

   else

     aclocal=`echo $automake | sed s/automake/aclocal/`

     debug "aclocal: $aclocal"

     if [ "$aclocal" != "aclocal" ];

     then

       CONFIGURE_DEF_OPT="$CONFIGURE_DEF_OPT --with-aclocal=$aclocal"

     fi

     if [ ! -x `which $aclocal` ]; then

       echo "Error: cannot execute $aclocal !"

       return 1

     fi

   fi

 }

 autoheader_check ()

 {

   # same here - autoheader is part of autoconf

   # use the same voodoo

   if [ -z "$autoconf" ]; then

     echo "Error: no autoconf variable set !"

     return 1

   else

     autoheader=`echo $autoconf | sed s/autoconf/autoheader/`

     debug "autoheader: $autoheader"

     if [ "$autoheader" != "autoheader" ];

     then

       CONFIGURE_DEF_OPT="$CONFIGURE_DEF_OPT --with-autoheader=$autoheader"

     fi

     if [ ! -x `which $autoheader` ]; then

       echo "Error: cannot execute $autoheader !"

       return 1

     fi

   fi

 }

 autoconf_2_52d_check ()

 {

   # autoconf 2.52d has a weird issue involving a yes:no error

   # so don't allow it's use

   test -z "$NOCHECK" && {

     ac_version=`$autoconf --version|head -n 1|sed 's/^[a-zA-Z\.\ ()]*//;s/ .*$//'`

     if test "$ac_version" = "2.52d"; then

       echo "autoconf 2.52d has an issue with our current build."

       echo "We don't know who's to blame however.  So until we do, get a"

       echo "regular version.  RPM's of a working version are on the gstreamer site."

       exit 1

     fi

   }

   return 0

 }

 die_check ()

 {

   # call with $DIE

   # if set to 1, we need to print something helpful then die

   DIE=$1

   if test "x$DIE" = "x1";

   then

     echo

     echo "- Please get the right tools before proceeding."

     echo "- Alternatively, if you're sure we're wrong, run with --nocheck."

     exit 1

   fi

 }

 autogen_options ()

 {

   if test "x$1" = "x"; then

     return 0

   fi

   while test "x$1" != "x" ; do

     optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`

     case "$1" in

       --noconfigure)

           NOCONFIGURE=defined

 	  AUTOGEN_EXT_OPT="$AUTOGEN_EXT_OPT --noconfigure"

           echo "+ configure run disabled"

           shift

           ;;

       --nocheck)

 	  AUTOGEN_EXT_OPT="$AUTOGEN_EXT_OPT --nocheck"

           NOCHECK=defined

           echo "+ autotools version check disabled"

           shift

           ;;

       --debug)

           DEBUG=defined

 	  AUTOGEN_EXT_OPT="$AUTOGEN_EXT_OPT --debug"

           echo "+ debug output enabled"

           shift

           ;;

       --prefix=*)

 	  CONFIGURE_EXT_OPT="$CONFIGURE_EXT_OPT --prefix=$optarg"

 	  echo "+ passing --prefix=$optarg to configure"

           shift

           ;;

       --prefix)

 	  shift

 	  echo "DEBUG: $1"

 	  CONFIGURE_EXT_OPT="$CONFIGURE_EXT_OPT --prefix=$1"

 	  echo "+ passing --prefix=$1 to configure"

           shift

           ;;

       -h|--help)

           echo "autogen.sh (autogen options) -- (configure options)"

           echo "autogen.sh help options: "

           echo " --noconfigure            don't run the configure script"

           echo " --nocheck                don't do version checks"

           echo " --debug                  debug the autogen process"

 	  echo " --prefix		  will be passed on to configure"

           echo

           echo " --with-autoconf PATH     use autoconf in PATH"

           echo " --with-automake PATH     use automake in PATH"

           echo

           echo "to pass options to configure, put them as arguments after -- "

 	  exit 1

           ;;

       --with-automake=*)

           AUTOMAKE=$optarg

           echo "+ using alternate automake in $optarg"

 	  CONFIGURE_DEF_OPT="$CONFIGURE_DEF_OPT --with-automake=$AUTOMAKE"

           shift

           ;;

       --with-autoconf=*)

           AUTOCONF=$optarg

           echo "+ using alternate autoconf in $optarg"

 	  CONFIGURE_DEF_OPT="$CONFIGURE_DEF_OPT --with-autoconf=$AUTOCONF"

           shift

           ;;

       --disable*|--enable*|--with*)

           echo "+ passing option $1 to configure"

 	  CONFIGURE_EXT_OPT="$CONFIGURE_EXT_OPT $1"

           shift

           ;;

        --) shift ; break ;;

       *) echo "- ignoring unknown autogen.sh argument $1"; shift ;;

     esac

   done

   for arg do CONFIGURE_EXT_OPT="$CONFIGURE_EXT_OPT $arg"; done

   if test ! -z "$CONFIGURE_EXT_OPT"

   then

     echo "+ options passed to configure: $CONFIGURE_EXT_OPT"

   fi

 }

 toplevel_check ()

 {

   srcfile=$1

   test -f $srcfile || {

         echo "You must run this script in the top-level $package directory"

         exit 1

   }

 }

 tool_run ()

 {

   tool=$1

   options=$2

   run_if_fail=$3

   echo "+ running $tool $options..."

   $tool $options || {

     echo

     echo $tool failed

     eval $run_if_fail

     exit 1

   }

 }