buildtool_old

#!/bin/bash

DOWNLOAD_DIRS="$HOME/download/programming/vim /tools/software/vim"

function usage()
{
    cat <<EOF
Usage: `basename "$0"` VIM_SOURCE_PATH [ACTION+]

VIM_SOURCE_PATH must end in a Vim version number in the form MAJOR.MINOR
and may be relative or absolute, e.g.:
  7.3
  ../sources/7.3
  /download/vim/7.3

Relative paths will be searched in the current directory, then in these
"standard" locations:
EOF
    for d in $DOWNLOAD_DIRS; do
        echo "  $d"
    done
    cat <<EOF
Valid ACTIONs are:
  update            - use "git pull" to update git/ directory
  unpack            - unpack Vim sources below CWD
  configure         - configure Vim with standard build options
  build             - build Vim and create binary tarball
Default action list: unpack configure build

Building takes place in "vim-MAJOR.MINOR" in current working directory.
Vim source must be MAJOR.MINOR/git/ or MAJOR.MINOR/vim-MAJOR.MINOR.tar.bz2.
Checkout vim with git, e.g.:
  cd .../vim
  git clone https://github.com/vim/vim.git git
EOF
}

function die()
{
    if [ -n "$1" ]; then
        echo "$1"
    fi
    echo "For usage instructions, run with no arguments."
    exit
}

function setup()
{
    DIR="$1"
    if [ -z "$DIR" ]; then
        usage
        exit
    fi
    VERSION=`basename "$DIR"`
    if ! echo $VERSION | grep -q '^[0-9]\+\.[0-9]\+$'; then
        die "Version \"$VERSION\" not in form MAJOR.MINOR"
    fi
    if [ ! -d "$DIR" ]; then
        for d in $DOWNLOAD_DIRS; do
            probeDir="$d/$DIR"
            if [ -d "$probeDir" ]; then
                DIR="$probeDir"
                break
            fi
        done
    fi

    if [ ! -d "$DIR" ]; then
        die "Cannot find source directory $DIR"
    fi

    echo "Vim $VERSION sources in $DIR"
    VIMNAME=vim-$VERSION
    VIMDIR=$VIMNAME
    echo "Vim build directory in $VIMDIR"
}

function update()
{
    gitDir="$DIR/git"
    if [ -d "$gitDir" ]; then
        (cd "$gitDir"; git pull)
    else
        die "Cannot update; missing path \"$gitDir\""
    fi
}

function patchlevel()
{
    grep -A 3 '^static int included_patches' "$VIMDIR"/src/version.c |
        tail -n 1 | perl -pe 's/^\s*(\d+).*/$1/'
}

# Return list of matching paths, reverse-sorted by version number.
# listVersions /path/to/vim-7.3. .tar.bz2
# ==>
# /path/to/vim-7.3.100.tar.bz2
# /path/to/vim-7.3.99.tar.bz2
# ...
# /path/to/vim-7.3.2.tar.bz2
# /path/to/vim-7.3.1.tar.bz2
function listVersions()
{
    prefix="$1"
    suffix="$2"

    for i in $prefix[0-9]{,[0-9]{,[0-9]{,[0-9]}}}$suffix; do
        echo "${i:${#prefix}}"
    done | sort -rn | while read tail; do
        echo "$prefix$tail"
    done
}

function latestVersion()
{
    prefix="$1"
    suffix="$2"

    largest=`listVersions "$prefix" "$suffix" | head -1`
    echo "$largest"
}

function unpack()
{
    if [ -d "$VIMDIR" ]; then
        die "Must remove directory $VIMDIR manually before continuing"
    fi
    echo "Unpacking Vim $VERSION..."
    if [ -d "$DIR/git" ]; then
        echo "  Extracting source from git to $VIMDIR..."
        mkdir "$VIMDIR" || die "Couldn't create $VIMDIR"
        (cd "$DIR/git"; git archive master) | tar -C "$VIMDIR" -x
        TARNAME="$VIMDIR.`patchlevel`.tar.bz2"
        SRCTAR="$VIMDIR/$TARNAME"
        echo "  Creating source archive $SRCTAR..."
        tar -jcf "$TARNAME" --exclude "$TARNAME" "$VIMDIR"
        mv "$TARNAME" "$SRCTAR"
    else
        TARPREFIX="$DIR/$VIMNAME."
        suffix=".tar.bz2"
        TARNAME=`latestVersion "$TARPREFIX" "$suffix"`
        if [ -n "$TARNAME" -a -f "$TARNAME" ]; then
            echo "  Unpacking $TARNAME..."
            tar -jxf "$TARNAME"
        else
            die "Error: couldn't find $VIMNAME sources; exiting"
        fi
    fi
}

function configure()
{
    echo "Configuring in $VIMDIR..."
    (
        cd $VIMDIR;
        ./configure \
            --quiet \
            --with-features=huge    \
            --enable-perlinterp     \
            --enable-pythoninterp     \
            --enable-tclinterp     \
            --enable-rubyinterp     \
            --enable-cscope     \
            --with-compiledby=vim@drmikehenry.com     \

    )
}

function build()
{
    echo "Building in $VIMDIR..."
    PATCHLEVEL=`patchlevel`
    VIMFULLNAME="$VIMNAME.$PATCHLEVEL"
    tar --version | grep 'GNU tar' > /dev/null 2>&1 &&
        TAROPTS="--owner=0 --group=0"

    (
        TARNAME="$VIMFULLNAME.`uname -m`.tar.gz"
        cd $VIMDIR
        echo "  Removing DESTDIR..."
        rm -rf DESTDIR
        mkdir DESTDIR
        echo "  Compiling $VIMFULLNAME..." && \
            make && \
            echo "  Installing in $VIMDIR/DESTDIR..." && \
            make install DESTDIR=`pwd`/DESTDIR && \
            chmod -R u=rwX,go=rX DESTDIR && \
            echo "  Creating tar from $VIMDIR/DESTDIR" && \
            tar -C DESTDIR --numeric-owner $TAROPTS -zcf $TARNAME . && \
            echo "  Created archive $VIMDIR/$TARNAME"
    )
}

# Trap any exiting, setup to exit on any failures.
trap "trap - EXIT; echo Aborting" EXIT
set -e

setup "$1"
shift
if [ -z "$1" ]; then
    unpack
    configure
    build
else
    while [ -n "$1" ]; do
        $1
        shift
    done
fi

# Reset exit trap.
trap - EXIT