root/main/trunk/makepackage

#!/bin/bash

# ------------------------------------------------------------
#       autopackage creator program
# ------------------------------------------------------------

###
#
# This code is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library 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
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
# Copyright 2002-2005 Mike Hearn (mike@plan99.net),
# Hongli Lai (hongli@plan99.net) and others.
#


# Some important variables:
# $metadata_dir
# $payload_dir
#       These variables refer to the metadata and payload directories
#       of the package that's currently being created.

# Output a sample specfile if --mkspec is given.
if [[ "$1" == "--mkspec" ]]; then
        cat <<EOF
# -*-shell-script-*-

#
# This is an example specfile. Delete these comments when you're done.
#

[Meta]
RootName: @mysite.org/myproject:\$SOFTWAREVERSION
DisplayName: MyProject Strategy Game
ShortName: myproject
Maintainer: John Smith <smith@mysite.org>
Packager: John Smith <smith@mysite.org>
Summary: MyProject is an example
URL: http://www.mysite.org/
License: GNU General Public License, Version 2
SoftwareVersion: 1.0
# SoftwareVersion: @VERSION@
Repository: http://www.mysite.org/downloads/myproject.xml

# If you change the autopackage but not the software itself,
# increment this number.

# PackageVersion: 2

# This is the version of the autopackage runtime this package is
# written for. Increasing this number implies you have read the
# "Migrating to 1.X" document and understand the impact it will have
# on your package. Some APIs may change their behaviour and new
# features will be enabled depending on what this is set to.
AutopackageTarget: 1.4

# Only uncomment InterfaceVersion if your package exposes interfaces
# to other software, for instance if it includes DSOs or python/perl
# modules. See the developer guide for more info, or ask on
# autopackage-dev if you aren't sure about interface versioning.
#
# InterfaceVersion: 0.0

[BuildPrepare]
# For ./configure based systems this is a good default
prepareBuild --with-some-feature

[BuildUnprepare]
unprepareBuild

[Globals]
# Anything put here will be run during makeinstall and at
# install/uninstall time. Define useful variables here:

# export MY_VAR=1

[Imports]
# You may wish to delete some things first, eg libtool .la files or
# development files (headers)

# rm -r include
# rm libs/*.la

# This imports every file in $build_root
# (ie, that is installed by "make install")
echo '*' | import


[Prepare]
# Dependency checking

# You can use "require" and "recommend". They both try to find the
# given dependency, and install it if missing. But require will return
# 1 (causing failure) if it can't do that whereas recommend will
# simply show a notice at the end of the install.

# The second argument here identifies a skeleton file, which is
# a file that encapsulates a dependency check. The second number
# identifies the interface version you need. Use as many of these
# as you need.

require @whatever.you/need 1.0

# The user may have already installed the program from an RPM.
# Let's try and uninstall it first. We only need one call if 3rd party
# packages have split the program up into multiple packages.

removeOwningPackage \$PREFIX/bin/my-program

[Install]
# Put your installation script here. See the quickstart guide on
# the website for an API cheat-sheet
installExe bin/*

[Uninstall]
# Usually just the following line is enough to uninstall everything
uninstallFromLog
EOF
        exit
fi


# setup XDG configuration variables scoped for autopackage
#
#   AUTOPACKAGE_CONFIG_HOME     User configuration directory
#   AUTOPACKAGE_CONFIG_DIRS     System configuration directories
#   AUTOPACKAGE_CONFIG_DIR      Determined system configuration directory for autopackage

if [ -z "$AUTOPACKAGE_CONFIG_HOME" ]; then
    export AUTOPACKAGE_CONFIG_HOME
    if [ -z "$XDG_CONFIG_HOME" ]; then
        AUTOPACKAGE_CONFIG_HOME="$HOME/.config"
    else
        AUTOPACKAGE_CONFIG_HOME="$XDG_CONFIG_HOME"
    fi
fi

if [ -z "$AUTOPACKAGE_CONFIG_DIRS" ]; then
    export AUTOPACKAGE_CONFIG_DIRS
    if [ -z "$XDG_CONFIG_DIRS" ]; then
        AUTOPACKAGE_CONFIG_DIRS="/etc/xdg"
    else
        AUTOPACKAGE_CONFIG_DIRS="$XDG_CONFIG_DIRS"
    fi
fi

if [ -z "$AUTOPACKAGE_CONFIG_DIR" ]; then
    export AUTOPACKAGE_CONFIG_DIR
    _AUTOPACKAGE_CONFIG_DIRS=$( echo "$AUTOPACKAGE_CONFIG_DIRS" | tr ':' ' ' )
    for _CONFIGURATION_DIR in $_AUTOPACKAGE_CONFIG_DIRS; do
        if [ -e "$_CONFIGURATION_DIR/autopackage/config" ]; then
            AUTOPACKAGE_CONFIG_DIR="$_CONFIGURATION_DIR"
            break
        fi
    done
    unset _AUTOPACKAGE_CONFIG_DIRS
fi

# set defaults that might not be loaded from system configurations
export autopackage_deny_user=false

# load system configurations
[ -e /etc/autopackage/config ] && source /etc/autopackage/config;
[ -e "$AUTOPACKAGE_CONFIG_DIR/autopackage/config" ] && source "$AUTOPACKAGE_CONFIG_DIR/autopackage/config";

# load user configuration if allowed from system configuration
if ! $autopackage_deny_user; then
    [ -e "$AUTOPACKAGE_CONFIG_HOME/autopackage/config" ] && source "$AUTOPACKAGE_CONFIG_HOME/autopackage/config";
fi

[ -e "`dirname \"$0\"`/etc/config-not-installed" ] && source "`dirname \"$0\"`/etc/config-not-installed"

_apspec_dir="`pwd`/autopackage"

if [[ "$autopackage_prefix" != "" ]]; then
        pushd "$autopackage_share" >/dev/null
        source "apkg-funclib"
        popd >/dev/null
else
        # link to autopackage functions and environment
        # sideload by changing into dir to source files within that directory
        pushd "$autopackage_share" >/dev/null
        source "../etc/config"
        source "apkg-funclib"
        popd >/dev/null

        # check and install SVN directory apbuild
        _installApbuild -q
fi

myname=`basename "$0"`
mydir=`dirname "$0"`
mydir=`cd "$mydir"; pwd`
alias makepackage="$mydir/$myname"
unset myname
unset mydir

apkg_logfile="/dev/null"
apkg_filelist="/dev/null"

# initialize variables
_initializeAutopackage

checkConfigVersion || exit 1;

# error codes
ERROR_NO_STUB=1;
ERROR_NO_INSTALLER=2;
ERROR_NO_DOWNLOADER=3;
ERROR_MISSING_SKELETON=5;
ERROR_SKELETON_API_MISMATCH=6;

###############################################################
## start here

# check for command line arguments
while getopts ":hcms" Option
do
        case $Option in
                c )
                        export APKG_BUILD_SKIP_CONFIGURE=1
                        ;;
                m )
                        export APKG_BUILD_SKIP_MAKE=1
                        ;;

        s )
            export APKG_NO_STRIP=1
            ;;

                h | * ) # output help text and unknown cases
                        echo
                        out "autopackage installer builder
Usage from source directory root:
    makepackage [--mkspec] | ['apspec-filename1' 'apspec-filename2' ... ]

If --mkspec is given, makepackage will print a sample specfile to standard
output. You can use this as a starting point for writing a new specfile.

If --mkspec is not given, makepackage will create a new .package based
on the given specfiles. If no specfile filename is declared then
spec filename autopackage/default.apspec will be used.

The script will create a software package that will
be written to the file specified in the spec file.

Options:
   -c     Do not run './configure' when building this package
          (only useful if you use prepareBuild)
   -m     Do not run 'make' when building this package
          (only useful if you use prepareBuild)
   -s     Do not strip ELF binaries
          (useful if you want to send a debug build to somebody)
   -h     Show this help screen"
                        echo
                        exit 0;;
        esac
done
shift $(($OPTIND - 1))

# This function uses xsltproc to transform XDG spec mime-type files
# into the KDE 3.x equivalents. Symlinks are created so that installMime
# can automatically install both the XDG and KDE mime-types.
# XML files must be located located in $build_root/share/mime/packages, otherwise
# broken symlinks will be constructed (links are made relative to share/mime/packages).
# NOTE: Private function, do not use in specfiles.

function generateLegacyMime() {
    outn "Converting XDG MIME type definitions to KDE 3.x equivalents ... "
    if locateCommand xsltproc; then
        # deal with KDE mime-types

        mkdir -p "$payload_dir/share/mimelnk"
        pushd "$payload_dir/share/mimelnk" > /dev/null
        for mimefile in $@; do
            if ! grep -q "http://www.freedesktop.org/standards/shared-mime-info" "$mimefile"; then
                red; outn "WARNING: "; normal; out "The FreeDesktop.org MIME Type file `basename "$mimefile"` does not appear to have a namespace declaration. KDE 3.x MIME Type files will not be generated."
            fi

            local i=0 # counts number of .desktop files created from a single XML file (for symlinks--hello.xml.1)
            for mimetype in $( $lc_location $autopackage_share/apkg-mimetype.xsl $mimefile ); do
                let i+=1
                # this command is run from share/mimelnk (so xsltproc files land in the right placage)
                # which is why the symlink is constructed from ../../share/mime/packages to share/mimelnk/
                ln -fs "../../../share/mimelnk/$mimetype.desktop" ../../share/mime/packages/`basename $mimefile.$i`
            done
        done
        popd > /dev/null
    else
        err "You need xsltproc installed to process mime-types."
    fi
    green; out "done"; normal
}

function safeRemove()
{
    test -z "$1" -o -z "${TMP}" && return
    # Only remove paths in ${TMP}
    if [[ "$1" == ${TMP}/* ]]; then 
        rm -rf "$1"
    fi
}

function cleanUp()
{
    safeRemove "$payload_dir"
    safeRemove "$metadata_dir"
    safeRemove "$current_directory"
    safeRemove "$_virtual_build_root"
    safeRemove "$__apkg_errors_file"
    unset payload_dir
    unset metadata_dir
    unset build_root
    unset __apkg_errors_file
    # all temporary files are prefixed with apkg-
    rm -fr "${TMP}"/apkg-*
    return 0
}

trap cleanUp EXIT

# Process a specfile
function process()
{
        # **********************************************************
        #  Process for building a .package file
        #
        #  1. Setup environment variables and perform sanity checks
        #
        #  2. Parse package metadata from Meta section of specfile
        #
        #  3. Load template files and substitute values
        #
        #  4. Generate build_root and run BuildPrepare
        #
        #  5. Import files into package
        #
        #  6. Create script files in meta directory
        #
        #  7. Start creating the package file
        #
        #  8. Generate package output files depending on type
        # **********************************************************


        # **********************************************************
        #  1. Setup environment variables and sanity checks
        # **********************************************************
        local specfile="$1"
        # The working directory from which makepackage is invoked;
        # usually the directory containing the source code.
        export source_dir
        # The main data payload directory
        payload_dir="${TMP}/apkg-payload-dir$$-$RANDOM"
        # The metadata payload directory
        export metadata_dir="${TMP}/apkg-meta$RANDOM$$"

        # The compiled files get copied to this dir. The extraction script
        # will copy files from this dir to $payload_dir
        export build_root="."

        # The apspec directory to search for skeleton files which is used in
        # _locateSkeleton function from apkg-dep.
        local __apkg_errors_file
        local oIFS
        local language

        local f
        local l

        # Is this specfile generated from a .apspec.in template? If so,
        # check if .apspec.in is newer than .apspec, and if yes regen
        if [[ -e config.status && -e "${specfile}.in" ]]; then
            ./config.status --file="$specfile"
            local exitCode=$?

            if [ $exitCode != 0 ]; then
                return $exitCode
            fi
        fi

        if [ ! -e "$specfile" ]; then
                red; outn "FAIL: "; normal;
                out "$specfile could not be found"
                return 1
        fi

        if file "$specfile" | grep -q CRLF; then
                red; outn "ERROR: "; normal; out "Specfile %s contains Windows line terminators (CRLF) and is therefore not compatible with makepackage." "$specfile"
                if yesNo "Should makepackage fix this for you? (Y/n)"; then
                        sed 's/\r$//' -i "$specfile"
                else
                        return 1
                fi
        fi

        # Ensure we have an absolute path
        source_dir=`pwd`;
        if [[ ${specfile:0:1} != "/" ]]; then
            # Get absolute filename of specfile if it isn't an absolute filename already
            specfile="$source_dir/$specfile"
        fi

        mkdir -p "$payload_dir"
        chmod 700 "$payload_dir"

        # Check the specfile exists
        if [ ! -e "$specfile" ]; then
                red; out "$specfile could not be found"; normal;
                return 1
        fi


        drawHeaderBlue "Building installer for %s" "$specfile"

        # **********************************************************
        #  2. Parse package metadata from Meta section of specfile
        # **********************************************************

        # **********************************************************
        #  2.1 Load specfile meta data
        # **********************************************************
        local meta meta_localized meta_matched
        meta=`getSection "$specfile" Meta`
        meta=`stripComments "$meta"`
        # **********************************************************
        #  2.2 Convert Meta section keys to variables
        # **********************************************************
        trace processing Meta section keys to variables
        trace "$meta"
        if [[ "$meta" != "" ]]; then
                function subup()
                {
                        # grab non-localized keys to start
                        if (( `echo "$meta_localized" | grep -i "^$1:" | wc -l` > 1 )); then
                                err "Key $1 is duplicated, ignoring all but first"
                        fi

                        local line=`echo "$meta_localized" | grep -i "^$1:" | head -n 1`
                        local start=`echo "$line" | awk 'BEGIN { FS=": " } { print $1 }' | sed 's/@/\_\_at\_\_/g'`
                        local value=`echo "$line" | awk 'BEGIN { FS=": " } { print $2 }'`
                        # continue if the specKey is found in the Meta section keys
                        if [[ "$start" != "" ]]; then
                                # translate key to CAPITALS
                                local up=$( echo "$start" | tr 'a-z' 'A-Z' )
                                # write CAPITAL case key new meta variable which only allows specified specKeys
                                trace substituting meta key $start to be $up
                                meta_matched=$( echo "$meta_matched"; echo "${up}=\"${value}" );
                                # process localized keys
                                oIFS="$IFS"
                                IFS=$'\n'
                                for line in `echo "$meta_localized" | grep -i "^${start}\["`; do
                                        line=$( echo "$line" | sed "s/^${start}\[/${up}_/g" );
                                        meta_matched=$( echo "$meta_matched"; echo "${line}" );
                                done
                                IFS="$oIFS"
                        fi
                }

                # copy meta data to new variable
                meta_localized=`echo "$meta"`

                # converting Meta section keys to environment variables changes
                # the meta data between the listed formats and subup translates
                # the specKeys to be CAPITALS.
                # DisplayName: <data>           --->    DISPLAYNAME="<data>"
                # DisplayName[fr]: <data>       --->    DISPLAYNAME_fr="<data>"
                # Summary: <data>               --->    SUMMARY="<data>"
                # Summary[fr]: <data>           --->    SUMMARY_fr="<data>"
                # Summary[fr@Latn]: <data>      ---->   SUMMARY_fr__at__Latn="<data>"
                #
                # allow ':' to be used in Meta data, need to focus on the first instance of ':'
                # first instance can be determined on localized keys because of the ']: ' so substitute in '='
                # and non-localized keys are converted to variables in subup function
                meta_localized=`echo "$meta_localized" | sed 's/\]: /\=\"/g'`
                meta_localized=`echo "$meta_localized" | sed 's/\(.\)$/\1"/g'`

                for state in $specKeys; do
                        subup "${state}"
                done

                unset subup meta_localized
        fi

        # Unset specfile meta keys
        _resetKeys

        # Evaluate Meta section key
        trace evaluating Meta section key variables
        trace "$meta_matched"
        # evaluate to define values
        eval "$meta_matched" >/dev/null
        # allow any values to be substituted
        eval "$meta_matched" >/dev/null

        # **********************************************************
        #  2.3 Meta Sanity checks
        # **********************************************************
        if [[ "$DISPLAYNAME" == "" && "$PACKAGEDESKTOP" == "" ]]; then red; outn "FAIL: "; normal; out "No DisplayName key found in the [Meta] section. You need one"; cleanUp; return 1; fi
        if [[ "$SHORTNAME" == "" ]]; then red; outn "FAIL: "; normal; out "No ShortName key found in the [Meta] section."; cleanUp; return 1; fi
        if [[ "$ROOTNAME" == "" ]]; then red; outn "FAIL: "; normal; out "You forgot the RootName key in the [Meta] section. That's pretty important you know "; cleanUp; return 1; fi
        if [[ "$SOFTWAREVERSION" == "" ]]; then red; outn "FAIL: "; normal; out "No SoftwareVersion key found in the [Meta] section, please add one"; cleanUp; return 1; fi
        if [[ "$PACKAGEVERSION" != "" ]] && ! isInteger "$PACKAGEVERSION"; then red; outn "FAIL: "; normal; out "A valid PackageVersion key was not found in the [Meta] section. PackageVersion is an integer greater than 0."; cleanUp; return 1; fi
        if [[ "$UPDATEFOR" != "" && "$AUTOPACKAGETARGET" < "1.4" ]]; then red; outn "FAIL "; normal; out "You need to set AutopackageTarget to at least 1.4 to use UpdateFor."; cleanUp; return 1; fi

        trace ROOTNAME=$ROOTNAME
        trace SHORTNAME=$SHORTNAME
        trace SOFTWAREVERSION=$SOFTWAREVERSION
        trace INTERFACEVERSION=$INTERFACEVERSION
        trace DISPLAYNAME=$DISPLAYNAME
        trace AUTOPACKAGETARGET=$AUTOPACKAGETARGET

        # follow-up error checks on ROOTNAME
        unset _rootname_match
        # should be a leading @
        if [ -z "$_rootname_match" ]; then
                _rootname_match=$( expr index "$ROOTNAME" "@" )
                if ! (( _rootname_match == 1 )); then
                        _rootname_match="no leading @"
                else
                        unset _rootname_match
                fi
        fi
        # should be no spaces
        if [ -z "$_rootname_match" ]; then
                _rootname_match=$( expr index "$ROOTNAME" " " )
                if (( _rootname_match > 0 )); then
                        _rootname_match="spaces"
                else
                        unset _rootname_match
                fi
        fi
        # catch protocols
        if [ -z "$_rootname_match" ]; then
                _rootname_match=$( echo "$ROOTNAME" | grep 'http://' )
                [ -n "$_rootname_match" ] && _rootname_match="http://"
        fi
        if [ -z "$_rootname_match" ]; then
                _rootname_match=$( echo "$ROOTNAME" | grep 'https://' )
                [ -n "$_rootname_match" ] && _rootname_match="https://"
        fi
        if [ -z "$_rootname_match" ]; then
                _rootname_match=$( echo "$ROOTNAME" | grep 'ftp://' )
                [ -n "$_rootname_match" ] && _rootname_match="ftp://"
        fi
        # should be at least one forward slash
        if [ -z "$_rootname_match" ]; then
                _rootname_match=$( expr index "$ROOTNAME" "/" )
                if (( _rootname_match < 1 )); then
                        _rootname_match="no secondary description"
                else
                        unset _rootname_match
                fi
        fi
        # should be at least one colon
        if [ -z "$_rootname_match" ]; then
                _rootname_match=$( expr index "$ROOTNAME" ":" )
                if (( _rootname_match < 1 )); then
                        _rootname_match="no software version"
                else
                        unset _rootname_match
                fi
        fi
        # send error if match exists from any of the previous tests
        if [ -n "$_rootname_match" ]; then
                red; outn "ERROR: "; normal; out "Package RootName: '%s' is not correct because of '%s'. Please read Packagers Guide, Creating a package section for RootName guidelines." "$ROOTNAME" "$_rootname_match"
                return 1
        fi

        # follow-up warning checks on ROOTNAME
        # should not have server name be 'www'
        if [ -z "$_rootname_match" ]; then
                _rootname_match=$( echo "$ROOTNAME" | grep "@www" | wc -l )
                if (( _rootname_match > 0 )); then
                        _rootname_match="www is not needed"
                else
                        unset _rootname_match
                fi
        fi
        if [ -z "$_rootname_match" ]; then
                _rootname_match=$( versionFromRootName "$ROOTNAME" )
                if [[ "$_rootname_match" != "$SOFTWAREVERSION" ]]; then
                        _rootname_match="root name version does not match software version"
                else
                        unset _rootname_match
                fi
        fi
        # send warning if match exists from any of the previous tests
        if [ -n "$_rootname_match" ]; then
                red; outn "WARNING: "; normal; out "Package RootName: '%s' is not correct because of '%s'. Please read Packagers Guide, Creating a package section for RootName guidelines." "$ROOTNAME" "$_rootname_match"
        fi

        # follow-up checks on SHORTNAME
        unset _shortname_match
        # should be no spaces
        if [ -z "$_shortname_match" ]; then
                _shortname_match=$( expr index "$SHORTNAME" " " )
                if (( _shortname_match > 0 )); then
                        _shortname_match="spaces"
                else
                        unset _shortname_match
                fi
        fi
        # send error if match exists from any of the previous tests
        if [ -n "$_shortname_match" ]; then
                red; outn "ERROR: "; normal; out "Package ShortName: '%s' is not correct because of '%s'. Please read Packagers Guide, Creating a package section for ShortName guidelines." "$SHORTNAME" "$_shortname_match"
                return 1
        fi


        # **********************************************************
        #  2.4 Set Meta Defaults
        # **********************************************************

        # determine autopackage target api and normalize
        local apkgtarget_major=`getMajor "$AUTOPACKAGETARGET"`
        local apkgtarget_minor=`getMinor "$AUTOPACKAGETARGET"`
        if [ `expr index "$apkgtarget_major" '[abcdefghijklmnopqrstuvwxyz]'` -gt "0" ]; then
                apkgtarget_major="1"
                red; outn "WARNING: "; normal;
                out "No AutopackageTarget found in the specfile, default to '$apkgtarget_major'."
        fi
        if [ `expr index "$apkgtarget_minor" '[abcdefghijklmnopqrstuvwxyz]'` -gt "0" ] || [[ "$apkgtarget_minor" == "" ]]; then
                apkgtarget_minor="0"
        fi
        if [[ "$apkgtarget_major" != "" ]]; then
                AUTOPACKAGETARGET="$apkgtarget_major.$apkgtarget_minor"
        else
                AUTOPACKAGETARGET="1.2"
                red; outn "WARNING: "; normal;
                out "No AutopackageTarget found in the specfile, default to '$AUTOPACKAGETARGET'."
        fi
        trace setting api AUTOPACKAGETARGET=$AUTOPACKAGETARGET

        COMPRESSION=`echo "$COMPRESSION" | tr [:upper:] [:lower:]`
        if [[ "$COMPRESSION" != "" ]] &&
           [[ "$COMPRESSION" != "bzip2" ]] &&
           [[ "$COMPRESSION" != "lzma" ]]; then
                err "unknown compression method $COMPRESSION, selecting default"
                COMPRESSION=""
        fi

        if [[ "$COMPRESSION" == "" ]]; then
                if [[ "$AUTOPACKAGETARGET" == "1.0" ]]; then
                        COMPRESSION="bzip2"
                else
                        COMPRESSION="lzma"
                fi
        fi

        if [[ "$AUTOPACKAGETARGET" == "1.0" ]] && [[ "$COMPRESSION" == "lzma" ]]; then
                err "LZMA compression is not available when targetting the 1.0 runtime, using bzip2."
                COMPRESSION="bzip2"
        fi

        if [[ "$COMPRESSION" == "lzma" ]] && ! locateCommand autopackage-lzma; then
                red; outn "WARNING: "; normal; out "Command 'autopackage-lzma' not found. bzip2 compression will be used instead."
                COMPRESSION="bzip2"
        fi

        if [[ -n $CPUARCHITECTURE ]] && [[ "$AUTOPACKAGETARGET" == "1.4" ]]; then
                red; outn "WARNING: "; normal; out "CPUArchitecture is deprecated. Use CPUArchitectures instead."
        fi

        # determine interface version and normalize
        local interfaceversion_major=`getMajor "$INTERFACEVERSION"`
        local interfaceversion_minor=`getMinor "$INTERFACEVERSION"`
        if [[ -z "$INTERFACEVERSION" ]]; then
                trace defaulting INTERFACEVERSION=0.0
                INTERFACEVERSION="0.0"
        elif [[ "$interfaceversion_minor" == "" ]]; then
                trace normalizing INTERFACEVERSION=$interfaceversion_major.0
                INTERFACEVERSION="$interfaceversion_major.0"
        fi

        if (( PACKAGEVERSION < 1 )); then
                PACKAGEVERSION="1"
        fi

        ROOTINSTALLONLY=`echo "$ROOTINSTALLONLY" | tr [:upper:] [:lower:]`
        if [[ "$ROOTINSTALLONLY" == "yes" ]]; then
                ROOTINSTALLONLY="Yes"
        elif [[ "$ROOTINSTALLONLY" == "no" ]]; then
                ROOTINSTALLONLY="No"
        else
                trace defaulting ROOTINSTALLONLY="No"
                ROOTINSTALLONLY="No"
        fi

        PACKAGEREPORTING=`echo "$PACKAGEREPORTING" | tr [:upper:] [:lower:]`
        if [[ "$PACKAGEREPORTING" == "yes" ]]; then
                PACKAGEREPORTING="Yes"
        elif [[ "$PACKAGEREPORTING" == "no" ]]; then
                PACKAGEREPORTING="No"
        else
                trace defaulting PACKAGEREPORTING="Yes"
                PACKAGEREPORTING="Yes"
        fi

        if [ -z "$REPOSITORYFILENAME" ]; then
                trace defaulting REPOSITORYFILENAME="$SHORTNAME.xml"
                REPOSITORYFILENAME="$SHORTNAME.xml"
        fi

        # gather repository value from skeleton file if a skeleton file exists
        # always use skeleton repository value and warn if meta data also has a value set
        # save repository to environment file if meta data is used
        # set repository directory based on determined repository value
        local m_skelfile=`_locateSkeleton "$ROOTNAME"`
        if [ -n "$m_skelfile" ]; then
                m_repository=`getSectionKey "$m_skelfile" "Meta" "Repository"`
        fi
        local repository_dir=""
        if [ -n "$m_repository" ] && [ -n "$REPOSITORY" ]; then
                if [[ "$m_repository" != "$REPOSITORY" ]]; then
                        red; outn "WARNING: "; normal; out "Repository value from skeleton file '$m_skelfile' is being used instead of package meta data '$REPOSITORY'."
                fi
                # skeleton value is going to be used so clear meta data value
                REPOSITORY=""
                repository_dir=`dirname "$m_repository"`
                trace using skeleton repository value $m_repository instead of metadata value
        elif  [ -n "$m_repository" ]; then
                repository_dir=`dirname "$m_repository"`
                trace using skeleton repository value $m_repository
        elif  [ -n "$REPOSITORY" ]; then
                repository_dir=`dirname "$REPOSITORY"`
                trace using meta data repository value $REPOSITORY
        fi
        trace REPOSITORY=$REPOSITORY

        EULADISPLAY=`echo "$EULADISPLAY" | tr [:upper:] [:lower:]`
        if [[ "$EULADISPLAY" == "installation" ]]; then
            EULADISPLAY="Installation"
#       elif [[ "$EULADISPLAY" == "execution" ]]; then
#           EULADISPLAY="Execution"
#       elif [[ "$EULADISPLAY" == "both" ]]; then
#           EULADISPLAY="Both"
#       elif [[ "$EULADISPLAY" == "none" ]]; then
#           EULADISPLAY="None"
        else
            trace defaulting EULADISPLAY="None"
            EULADISPLAY="None"
        fi


        # **********************************************************
        #  3. Load template files and substitute values
        # **********************************************************
        if [[ "$AUTOPACKAGETARGET" == "1.0" ]]; then
                trace loading 1.0 template files
                local stub=`<"$autopackage_share/stub.template"` || { echo "Couldn't load stub.template"; return $ERROR_NO_STUB; }
                local downloader=`<"$autopackage_share/downloader.template"` || { echo "Couldn't load downloader.template"; return $ERROR_NO_DOWNLOADER; }
        elif [[ "$AUTOPACKAGETARGET" < "1.4" ]]; then
                trace loading 1.2 template files
                local stub=`<"$autopackage_share/stub.2.template"` || { echo "Couldn't load stub.2.template"; return $ERROR_NO_STUB; }
                local downloader=`<"$autopackage_share/downloader.2.template"` || { echo "Couldn't load downloader.2.template"; return $ERROR_NO_DOWNLOADER; }
        else
                trace loading 1.4 template files
                local stub=`<"$autopackage_share/stub.4.template"` || { echo "Couldn't load stub.4.template"; return $ERROR_NO_STUB; }
                stub=$(substituteCode "$autopackage_share/apkg-bashlib" "START COMPAREVERSIONS SIMPLE" "END COMPAREVERSIONS SIMPLE" "$stub" "%CompareVersions%")
                stub=$(substituteCode "$autopackage_share/apkg-bashlib" "START MESSAGE" "END MESSAGE" "$stub" "%Message%")
                local downloader=`<"$autopackage_share/downloader.2.template"` || { echo "Couldn't load downloader.2.template"; return $ERROR_NO_DOWNLOADER; }
        fi

        installer=$(_getInstallerTemplate)
        if (($? != 0)); then
                echo "Error loading installer template"
                return $ERROR_NO_INSTALLER
        fi
        
        if [[ -z "$autopackage_share/backend.template" ]]; then
                echo "backend.template doesn't exist";
                return $ERROR_NO_BACKEND;
        fi

        downloader=`substituteCode "$autopackage_share/apkg-funclib" "START INSTALLAUTOPACKAGE" "END INSTALLAUTOPACKAGE" "$downloader" "%InstallAutopackage%"`
        downloader=`substituteCode "$autopackage_share/apkg-bashlib" "START YESNO" "END YESNO" "$downloader" "%YesNo%"`
        downloader=`substituteCode "$autopackage_share/apkg-bashlib" "START STARTDOWNLOAD" "END STARTDOWNLOAD" "$downloader" "%StartDownload%"`
        downloader=`substituteCode "$autopackage_share/apkg-funclib" "START DOWNLOADAUTOPACKAGEINFO" "END DOWNLOADAUTOPACKAGEINFO" "$downloader" "%DownloadAutopackageInfo%"`
        downloader=`substituteCode "$autopackage_share/apkg-bashlib" "START DOWNLOADFUNCTION" "END DOWNLOADFUNCTION" "$downloader" "%DownloadFunction%"`
        downloader=`substituteCode "$autopackage_share/apkg-funclib" "START FINISHWINDOW" "END FINISHWINDOW" "$downloader" "%FinishWindow%"`
        downloader=`substituteCode "$autopackage_share/apkg-bashlib" "START LAUNCHINTERMINAL" "END LAUNCHINTERMINAL" "$downloader" "%LaunchInTerminal%"`
        downloader=`substituteCode "$autopackage_share/apkg-bashlib" "START LOCATECOMMAND" "END LOCATECOMMAND" "$downloader" "%LocateCommand%"`
        downloader=`substituteCode "$autopackage_share/apkg-bashlib" "START MESSAGE" "END MESSAGE" "$downloader" "%Message%"`
        downloader=`substituteCode "$autopackage_share/apkg-funclib" "START AUTOSUCOMMAND" "END AUTOSUCOMMAND" "$downloader" "%AutosuCommand%"`
        downloader=`substituteCode "$autopackage_share/apkg-bashlib" "START PUSHOPTE" "END PUSHOPTE" "$downloader" "%PushOptE%"`
        downloader=`substituteCode "$autopackage_share/apkg-bashlib" "START POPOPTE" "END POPOPTE" "$downloader" "%PopOptE%"`
        downloader=`substituteCode "$autopackage_share/apkg-bashlib" "START RESOLVELINK" "END RESOLVELINK" "$downloader" "%ResolveLink%"`
        downloader=`substituteCode "$autopackage_share/apkg-script-utils" "START SCANLDLIBPATH" "END SCANLDLIBPATH" "$downloader" "%ScanLDLibPath%"`
        downloader=`substituteCode "$autopackage_share/apkg-script-utils" "START GETLIBRARYPATHS" "END GETLIBRARYPATHS" "$downloader" "%GetLibraryPaths%"`
        downloader=`substituteCode "$autopackage_share/apkg-script-utils" "START TESTFORLIB" "END TESTFORLIB" "$downloader" "%TestForLib%"`
        downloader=`substituteCode "$autopackage_share/apkg-script-utils" "START ISLIBRARY32" "END ISLIBRARY32" "$downloader" "%IsLibrary32%"`
        trace loaded

        ###### Substitute values into templates

        # Sets _payload_dir and _meta_dir before package expansion; used by _retrieveLocalPackage
        stub=$( echo "$stub" | replaceStr "%AutopackageVersion%" "$autopackage_version" )
        stub=$( echo "$stub" | replaceStr "%RootName%" "$ROOTNAME" )
        stub=$( echo "$stub" | replaceStr "%ShortName%" "$SHORTNAME" )
        stub=$( echo "$stub" | replaceStr "%SoftwareVersion%" "$SOFTWAREVERSION" )
        stub=$( echo "$stub" | replaceStr "%InterfaceVersion%" "$INTERFACEVERSION" )
        stub=$( echo "$stub" | replaceStr "%PackageVersion%" "$PACKAGEVERSION" )
        stub=$( echo "$stub" | replaceStr "%CPUArchitecture%" "x86" ) # Pre 1.4 packages only support x86
        stub=$( echo "$stub" | replaceStr "%AutopackageTarget%" "$AUTOPACKAGETARGET" )

        # Make the built package require the current autopackage version
        installer=$( echo "$installer" | replaceStr "%RootName%" "$ROOTNAME" )


        ####

        # **********************************************************
        #  3. Generate package scripts
        # **********************************************************
        #  3.1. Prepare script
        # **********************************************************
        local prep_script=$( getSection "$specfile" Prepare )
        if [[ "$prep_script" == "" ]]; then
            red; outn "WARNING: "; normal; out "No prep script [Prepare] found in the specfile, you might want one of these";
        fi

        # **********************************************************
        #  3.1.1. Check for require calls
        # **********************************************************
        # Scan for proper "require*" and "recommend*" lines
    echo "$prep_script" | while read; do

        # skip blank and commented lines
        if [ -z "$REPLY" ] || [[ ${REPLY:0:1} == "#" ]]; then
            continue
        fi

        # prepare could have logic so try to capture at least space leading lines
        local mode_check=`echo "$REPLY" | awk 'BEGIN{FS=" "}; { print $1 }' - | tr -d "\";" | tr -d "\';"`
        local rootname_check=`echo "$REPLY" | awk 'BEGIN{FS=" "}; { print $2 }' - | tr -d "\";" | tr -d "\';"`
        local version_check=`echo "$REPLY" | awk 'BEGIN{FS=" "}; { print $3 }' - | tr -d "\";" | tr -d "\';"`

        if [[ "$mode_check" == "require" ]] || [[ "$mode_check" == "recommend" ]]; then
            if [ -n "`versionFromRootName $rootname_check`" ] || [ -z "$version_check" ]; then
                err "require/recommend needs an unversioned rootname and an interface version - '$REPLY'"
                return 1
            else
                trace prepare call verified mode=$mode_check rootname=$rootname_check version=$version_check
            fi
        fi

        if [[ "$mode_check" == "requireExact" ]] || [[ "$mode_check" == "requireAtLeast" ]] || [[ "$mode_check" == "recommendExact" ]] || [[ "$mode_check" == "recommendAtLeast" ]]; then
            if [ -z "`versionFromRootName $rootname_check`" ] || [ -n "$version_check" ]; then
                err "requireExact/requireAtLeast/recommendExact/recommendAtLeast needs an versioned rootname and an interface version - '$REPLY'"
                return 1
            else
                trace prepare call verified mode=$mode_check rootname=$rootname_check version=$version_check
            fi
        fi

        unset mode_check rootname_check version_check

    done

        # Incorporate "require*" and "recommend*" lines
        local requires=` echo "$prep_script" | awk '/^[ \t]*[require|recommend]*/ {
                i=1
                while (i < NF && $i != "#") {
                        if ( $i == "require" || $i == "requireExact" || $i == "requireAtLeast" || $i == "recommend" || $i == "recommendExact" || $i == "recommendAtLeast" ) {
                                i++;
                                print $i;
                        }
                        i++;
                }
        } ' | tr -d "\";" | tr -d "\';" `

        # **********************************************************
        #  3.1.2. Check for required skeletons
        # **********************************************************
        if [[ "$requires" != "" ]]; then
                # Ensure we have the needed skeleton packages
                i=1
                local requirement=` getLine "$requires" $i `
                local requirements=""
                local foundSkelFile
                while [[ "$requirement" != "" ]]; do
                        requirements="$requirements $requirement"; # Add to list, this accumulates versioned root names....
                        foundSkelFile=`_locateSkeleton "$requirement"`
                        res=$?
                        skels_to_copy_files="$skels_to_copy_files $foundSkelFile"

                        if [[ "$res" != "0" ]]; then # and this accumulates the file refs: @gnome.org/libxml/skeleton.2
                                if [[ "$res" == "1" ]]; then
                                        red; outn "FAIL: "; normal;  out "Could not locate skeleton package for '%s'" "$requirement";
                                        normal; out "Try running svn update in the skeletons directory to get the latest files"
                                        return $ERROR_MISSING_SKELETON;
                                elif [[ "$res" == "2" ]]; then
                                        red; outn "FAIL: "; normal; out "Bad skeleton for %s, not in ASCII text format" "$requirement";
                                        normal; out "Try running svn update in the skeletons directory to get the latest files"
                                        return $ERROR_MISSING_SKELETON;
                                elif [[ "$res" == "3" ]]; then
                                        red
                                        out "Skeleton for %s was found, but the skeleton file has an incorrect root name (%s)" "$requirement" "$foundSkelFile"
                                        normal
                                        return $ERROR_MISSING_SKELETON;
                                fi
                        fi

                        # check sanity of skelVersionReq, code stolen from check for $AUTOPACKAGETARGET
                        skelVersionReq=`getSectionKey "$foundSkelFile" Meta AutopackageTarget`
                        local skel_apkgtarget_major=`getMajor "$skelVersionReq"`
                        local skel_apkgtarget_minor=`getMinor "$skelVersionReq"`

                        if [ `expr index "$skel_apkgtarget_major" '[abcdefghijklmnopqrstuvwxyz]'` -gt "0" ]; then
                                skel_apkgtarget_major="1"
                        fi

                        if [ `expr index "$skel_apkgtarget_minor" '[abcdefghijklmnopqrstuvwxyz]'` -gt "0" ] || [[ "$skel_apkgtarget_minor" == "" ]]; then
                                skel_apkgtarget_minor="0"
                        fi

                        if [[ "$skel_apkgtarget_major" != "" ]]; then
                                skelVersionReq="$skel_apkgtarget_major.$skel_apkgtarget_minor"
                        else
                                skelVersionReq="1.0"
                        fi

                        if ! compareVersions $skelVersionReq $AUTOPACKAGETARGET; then
                                red; outn "FAIL: " ; normal; out "Skeleton for '%s' requires Autopackage API version $skelVersionReq. Increase AutopackageTarget in your specfile to $skelVersionReq." "$requirement"
                                return $ERROR_SKELETON_API_MISMATCH
                        fi

                        (( i++ ));
                        trace added requirement $requirement, `_locateSkeleton $requirement`
                        requirement=` getLine "$requires" $i `;
                done
        fi
        if [[ "$AUTOPACKAGETARGET" < "1.4" ]]; then
                prep_script=$(_getBackendTemplate "prep" "$prep_script")
        fi

        # **********************************************************
        #  3.2. Uninstall script
        # **********************************************************