# $Id: s_winmsi.fcn,v 1.12 2006/09/14 15:50:51 mjc Exp $
#
# The common functions used by the s_winmsi scripts (both
# for core DB and DB/XML).
#
# This script uses several bash extensions that are convenient
# since we "know" it will always run under Cygwin: shell functions,
# 'return', declaration of 'local' variables, $(command) syntax,
# ${#X} (counting chars), ${X#regexp} (searching) $((expr)) (arithmetic)
#
# These functions use 'global' variables:
# ERRORLOG - a filename
# PRODUCT_NAME - e.g. "Berkeley DB"
# PRODUCT_VERSION - e.g. "4.1.25", derived from dist/RELEASE
# PRODUCT_MAJOR - e.g. "4", (for release 4.1.25) from dist/RELEASE
# PRODUCT_MINOR - e.g. "1", (for release 4.1.25) from dist/RELEASE
# PRODUCT_PATCH - e.g. "25", (for release 4.1.25) from dist/RELEASE
# PRODUCT_MAJMIN - e.g. "41", (for release 4.1.25) from dist/RELEASE
# PRODUCT_STAGE - the staging directory for temp files and builds
# PRODUCT_LICENSEDIR - the tree containing LICENSE and README
# PRODUCT_SUB_BLDDIR - top of the subproduct build e.g. "dbxml-2.0.1/dbxml"
# PRODUCT_BLDDIR - top of the build tree e.g. "dbxml-2.0.1"
# PRODUCT_SRCDIR - the dir we unzip to e.g. "dbxml-2.0.1"
# PRODUCT_DBBUILDDIR - where build_unix dir is for Berkeley DB (for Perl)
# PRODUCT_SHARED_WINMSIDIR - where the master winmsi directory is
# PRODUCT_IMAGEDIR - where the images are (usually winmsi/images)
# PRODUCT_ZIP_FILEFMT - what zip file looks like e.g. "db-X.Y.Z.NC.zip"
# PRODUCT_MSI_FILEFMT - what msi file looks like e.g. "db-X.Y.Z.NC.msi"
#
# Some of these may seem redundant, but there are options to take
# an already built tree from a different place than where we'll unzip
# to and take our sources from, for example. This allows a lot of flexibility
# for development and debugging (especially when these trees can be huge).
# This is the magic tag that creates a new unique GUID in Wix.
# GUIDs are needed on every <Component ... > entry to ensure
# that the component can be uninstalled.
GENGUID='Guid="GUID_CREATE_UNIQUE()"'
PERSISTGUID='Guid="WIX_DB_PERSISTENT_GUID()"'
# MakeRtf()
# Standard input is plain text, standard output is RTF.
#
MakeRtf() {
temp1=/tmp/sbm$$a
cat > $temp1
# Courier is a good font, but the lines with all caps
# overflows our current dialog size:
# {\rtf1\ansi\deff0{\fonttbl{\f0\fnil\fcharset0 Courier New;}}
# \viewkind4\uc1\pard\lang1033\f0\fs16
#
# Using Small fonts works:
# {\rtf1\ansi\deff0{\fonttbl{\f0\fswiss\fprq2\fcharset0 Small Fonts;}}
# {\colortbl ;\red0\green0\blue0;}
# \viewkind4\uc1\pard\cf1\lang1033\f0\fs14
# Arial is the best compromise:
sed -e 's/^ *//' << 'EndOfRTFHeader'
{\rtf1\ansi\deff0{\fonttbl{\f0\fswiss\fprq2\fcharset0 Arial;}}
{\colortbl ;\red0\green0\blue0;}
\viewkind4\uc1\pard\cf1\lang1033\f0\fs16
EndOfRTFHeader
# Embedded '<' and '>' can cause problems for Wix
sed -e 's:$:\\par:' -e 's:<: \\lquote :' -e 's:>: \\rquote :' < $temp1
echo -n '}'
rm -f $temp1
}
# NextId()
# Get the next available unique id, a simple integer counter.
# We use a file, rather than a shell variable to track the
# number, because this is called from subshells at various
# points, and they cannot affect the variables in the parent shell.
#
ComponentID=component.id
NextId()
{
local id=`cat $ComponentID 2>/dev/null`
if [ "$id" = '' ]; then
id=0
fi
id=$(($id + 1))
echo "$id" > $ComponentID
echo "$id"
}
# CleanFileName(FILENAME)
# Removes any strange characters in file names,
# returning the new name on standard output.
CleanFileName()
{
echo "$1" | sed -e 's/[-%@!]//g'
}
# GetShortName(FILENAME)
# Get a Windows short name for the file,
# to fit into the 8.3 name space.
# This is not a great algorithm, but it works.
# The fact is, the names must be unique, but on
# Win2000 and WinXP, we'll never see them.
ShortID=short.id
GetShortName()
{
local name=`echo "$1" | tr '[a-z]' '[A-Z]'`
# See if the name fits into 8.3. If so,
# return it right away.
#
case "$name" in
?????????*.* ) ;;
*.????* ) ;;
*.*.* ) ;;
*[-%@!]* ) ;;
*.* ) echo "$name"
return
;;
* )
if [ "${#1}" -le 8 ]; then
echo "$name"
return
fi
;;
esac
# From NAMEISLONG.EXTLONG, build a name
# like NAME~ZZZ.EXT, where ZZZ is a unique (hex)
# number we build. This is
local id=`cat $ShortID 2>/dev/null`
if [ "$id" = '' ]; then
id=0
fi
id=$(($id + 1))
echo "$id" > $ShortID
if [ "$id" -ge 4096 ]; then
echo "BADBADBAD.TXT" # return something that will give an error
Error "ShortId overflow"
exit 1
fi
# Convert the id to hex (I ran out of space using decimal)
# This is too slow: id=`echo 16 o $id p | dc`
id=`printf "%x" $id`
# Collect and clean up the part of the name before, and after, the dot
local before=`CleanFileName "$name" | sed -e 's/^\([^.]*\)[.].*$/\1/'`
local after=`CleanFileName "$name" | sed -e 's/^[^.]*[.]\(.*\)$/\1/'`
# Make sure the before part fits in 5 chars (not 8, since
# we need a few for the unique number).
if [ "${#before}" -gt 5 ]; then
before=`echo "$before" | sed -e 's/^\(.....\).*/\1/'`
fi
if [ "${#after}" -gt 3 ]; then
after=`echo "$after" | sed -e 's/^\(...\).*/\1/'`
fi
echo "${before}~${id}.${after}"
}
# Progress([OPTION,]STRING...)
# Show a major processing step via echo to stdout and to the error log.
# An OPTION is "-minor", indicating no big banner.
#
Progress()
{
if [ "$1" = -minor ]; then
shift
else
echo "" >> $ERRORLOG
echo "============================" >> $ERRORLOG
fi
echo "$@" >> $ERRORLOG
echo "$@" >&15
}
# Error(STRING...)
# Show an error in a standard way.
#
Error()
{
echo "" >> $ERRORLOG
echo "****************** FAIL ******************" >> $ERRORLOG
echo "ERROR: $@" >> $ERRORLOG
echo "ERROR: $@" >&15
echo "See $ERRORLOG for details" >&15
return 1
}
# RequireFileInPath(NAME, PATHVAL, FILE)
# Look for FILE in the path that has value PATHVAL.
# The path's name is NAME if it needs to be shown.
#
RequireFileInPath()
{
local type="$1"
local origpath="$2"
local file="$3"
local upath="$origpath"
if [ "$1" != PATH ]; then
upath=`cygpath -up "$origpath"`
fi
SAVEIFS="$IFS"
IFS=":"
found=no
for dir in $upath; do
if [ -f "$dir/$file" ]; then
IFS="$SAVEIFS"
return
fi
done
IFS="$SAVEIFS"
Error "File $file not found in $type path: $origpath"
exit 1
}
# Rand4X()
# Return 4 random hex digits on output
#
Rand4X() {
# The sed command pads the front with 0's as needed
(echo 'obase=16'; echo $RANDOM ) | bc |
sed -e 's/^/0000/' -e 's/^.*\(....\)$/\1/'
}
# RunM4()
# Run M4, making appropriate substitutions.
# This function uses GLOBAL variables: PRODUCT_VERSION (e.g. "4.1.25")
# and PRODUCT_LICENSEDIR, which is where certain text files are found
#
RunM4() {
# Given a version number, like 2.3.45, we want to
# create a 8 character name for the directory like db2_3_45.
# This name is under a "Oracle" directory,
# so it only needs to be unique within the universe of BDB versions.
# TODO: instead of using a version number like $DB_VERSION,
# maybe use $DB_VERSION_UNIQUE_NAME which looks like "_2003"
local DB_8CHAR_VERSION=`echo $PRODUCT_VERSION | sed -e 's/[.]/_/g'`
if [ ${#DB_8CHAR_VERSION} -le 6 ]; then
DB_8CHAR_VERSION="db$DB_8CHAR_VERSION"
elif [ ${#DB_8CHAR_VERSION} -le 7 ]; then
DB_8CHAR_VERSION="d$DB_8CHAR_VERSION"
else
Error "Version number too large for simple version number algorithm"
exit 1
fi
# Remove leading ./ from PRODUCT_LICENSEDIR if present.
local licensedir=`cygpath -w "$PRODUCT_LICENSEDIR"`
# Create a GUID prefix of the form: ????????-????-????-????-????
# This leaves 8 digits of GUID to be manipulated by m4.
local GUID_PREFIX="`Rand4X``Rand4X`-`Rand4X`-`Rand4X`-`Rand4X`-`Rand4X`"
# -P requires that all m4 macros, like define, eval, etc.
# are prefixed, like m4_define, m4_eval, etc. This avoids
# various name conflicts with input files.
# TODO: rename DB_SRCDIR as DB_LICENSEDIR
m4 -P \
-DWIX_DB_VERSION="$PRODUCT_VERSION" \
-DWIX_DB_8CHAR_VERSION="$DB_8CHAR_VERSION" \
-DWIX_DB_GUID_PREFIX="$GUID_PREFIX" \
-DWIX_DB_PRODUCT_NAME="$PRODUCT_NAME" \
-DWIX_DB_SRCDIR="$licensedir" \
-DWIX_DB_TOP="`cygpath -w $PRODUCT_BLDDIR`" \
-DWIX_DB_SHARED_WINMSIDIR="$PRODUCT_SHARED_WINMSIDIR" \
-DWIX_DB_IMAGEDIR="`cygpath -w $PRODUCT_IMAGEDIR`" \
-DWIX_DB_FEATURE_STRUCTURE="m4_include(features.wixinc)" \
-DWIX_DB_DIRECTORY_STRUCTURE="m4_include(directory.wixinc)" \
-DWIX_DB_LINKS="m4_include(links.wixinc)" \
-DWIX_DB_LICENSE_RTF="m4_include(license.rtf)" \
-DWIX_DB_ENV_FEATURE_PROPS="m4_include(envprops.wixinc)" \
-DWIX_DB_ENV_FEATURE_SET="m4_include(envset.wixinc)" \
-DWIX_DB_ENV_FEATURE_SHOW="m4_include(envshow.wixinc)"
}
# RunTallow(DIR, OPTIONS)
# Run Tallow, a tool from the WiX distribution
RunTallow() {
local dir="$1"
shift
Id1=`NextId`
Id2=`NextId`
Id3=`NextId`
# Tallow is a tool that walks a tree, producing
# a WiX directory heirarchy naming the files.
# The IDs it produces are not unique (between tallow
# runs), so we must make them so here. Thus "directory78"
# becomes "MyFeatureName.123.78" where 123 is an id from NextId.
# Secondly, instead of using the tallow output as a separately
# compiled fragment, we want to include it directly, so
# we need to strip out some extraneous XML entries at the top
# and bottom of its output.
#
# Another thing we do is when we see <Directory></Directory>
# pairs, we call m4 macros WIX_DB_{BEGIN,END}_SUBDIR because
# we need to track the current directory to generate 'persistent'
# GUIDs. See the discussion about GUIDs in dbwix.m4 .
#
# !!! For stripping out the extraneous XML, we rely heavily
# !!! on the output format, so this is likely to be fragile
# !!! between versions of tallow. Fortunately, it should fail hard.
#
echo "=============" >> tallow.log
echo tallow -nologo -d `cygpath -w "$dir"` "$@" >> tallow.log
echo " <!-- TALLOW output begins here -->"
tallow -nologo -d `cygpath -w "$dir"` "$@" > tallow.out || exit 1
cat tallow.out >> tallow.log
echo "-------------" >> tallow.log
sed -e '1,/<DirectoryRef/d' -e '/<\/DirectoryRef/,$d' \
-e "s/Id=\"directory/Id=\"$feature.$Id1./" \
-e "s/Id=\"component/Id=\"$feature.$Id2./" \
-e "s/Id=\"file/Id=\"$feature.$Id3./" \
-e '/^ <Directory/d' \
-e '/^ <\/Directory/d' \
-e '/<Directory/s/Name=\"\([^"]*\)"/Name="\1" WIX_DB_BEGIN_SUBDIR(\1) /' \
-e '/<\/Directory>/s/$/ WIX_DB_END_SUBDIR()/' \
-e "/<Component/s/>/ $PERSISTGUID>/" \
< tallow.out > tallow.postsed || exit 1
echo 'WIX_DB_SET_CURFILE()'
echo 'WIX_DB_CLEAR_SUBDIR()'
cat tallow.postsed
echo 'WIX_DB_CLEAR_SUBDIR()'
cat tallow.postsed >> tallow.log
echo " <!-- TALLOW output ends here -->"
}
# ProcessFeatures(INFILES, INFEATURES, INENV, OUTDIRECTORIES, OUTFEATURES,
# OUTSET)
# Use the files.in and features.in files as
# input to create two output files, one containing a WiX XML
# fragment showing directories and needed files,
# and another containing a WiX XML fragment showing
# the features in a dependency tree.
#
# This creates the heart of the installer flexibility.
#
ProcessFeatures() {
InFiles="infiles.tmp"; CleanInputFile "$1" "$InFiles" 3 4
InFeatures="infeatures.tmp"; CleanInputFile "$2" "$InFeatures" 3 4
InEnv="inenv.tmp"; CleanInputFile "$3" "$InEnv" 3 4
OutDirs="$4"
OutFeatures="$5"
OutSet="$6"
rm -f $OutDirs; touch $OutDirs
rm -f $OutFeatures; touch $OutFeatures
# Initialize the feature list.
# This will be expanded (per feature) in ProcessOneFeature
#
XmlLevel=4
Xecho "<Publish Property=\"FeatureList\" Value=\"[NULL]\">" >> $OutSet
Xecho " <![CDATA[1]]></Publish>" >> $OutSet
Dirs=`cut -f 3 < $InFiles | sort | uniq`
Prevdir="/"
ProcessDirTransition "$Prevdir" "/" >> $OutDirs
for Dir in $Dirs; do
ProcessDirTransition "$Prevdir" "$Dir" >> $OutDirs
ProcessOneDirectory "$Dir" < $InFiles >> $OutDirs || exit 1
Prevdir="$Dir"
done
ProcessDirTransition "$Prevdir" "/" >> $OutDirs
cat $InEnv | (
read line
while [ "$line" != '' ]; do
local FeatureName=`echo "$line" | cut -f 1`
local EnvVariable=`echo "$line" | cut -f 2`
local EnvValue=`echo "$line" | cut -f 3`
local EnvOption=`echo "$line" | cut -f 4`
ProcessOneEnv "$FeatureName" "$EnvVariable" "$EnvValue" "$EnvOption" "$OutDirs" "$OutSet"
read line
done
return 0
) || Error "Error processing environment" || exit 1
cat $InFeatures | (
read line
while [ "$line" != '' ]; do
local FeaturePath=`echo "$line" | cut -f 1`
local ShortName=`echo "$line" | cut -f 2 | StripDoubleQuotes`
local Description=`echo "$line" | cut -f 3 | StripDoubleQuotes`
local FeatureOptions=`echo "$line" | cut -f 4 | StripDoubleQuotes`
ProcessOneFeature "$FeaturePath" "$ShortName" "$Description" "$FeatureOptions" "$OutDirs" "$OutFeatures" "$OutSet"
read line
done
return 0
) || Error "Error processing features" || exit 1
# (PBR)
# This test code didn't work. My hope was that I could force INSTALLLEVEL
# to 4 and this would then enable the debug features.
# Xecho "<Publish Property=\"INSTALLLEVEL\" Value=\"4\" />" >> $OutSet
# Xecho "<Publish Event=\"SetInstallLevel\" Value=\"4\" />" >> $OutSet
}
# ProcessLinks(INLINKS, OUTFEATURES)
# Process the INLINKS file, and produce XML on stdout.
# Each line of the input file requires the creation
# of a '.URL' file in the installation, and a Shortcut
# in the Windows menu to point to that.
# Also add the components generated to a feature, put in OUTFEATURES.
#
# TODO: We ought to have a Features column in the links.in file,
# otherwise, the local doc link is always installed.
#
ProcessLinks() {
# Set a var to a carriage return without actually putting one in this file
local CR=`echo A | tr A '\015'`
local InLinks="infiles.tmp"; CleanInputFile "$1" "$InLinks" 3 4
local here_win=`cygpath -w $(pwd)`
# TODO: maybe get a real modification time, but not sure why we need it.
local MODTIMEHEX="0000000007DCC301DE"
XmlLevel=6
local OutFeatures="$2"
Xecho + "<Feature Id=\"LinksFeature\" Title=\"Links\"" >> $OutFeatures
Xecho " Description=\"Links\" Display=\"hidden\"" >> $OutFeatures
Xecho " Level=\"1\" AllowAdvertise=\"no\"" >> $OutFeatures
Xecho " ConfigurableDirectory=\"INSTALLUTIL\"" >> $$OUTFeatures
Xecho " Absent=\"disallow\">" >> $OutFeatures
Xecho "<DirectoryRef Id=\"INSTALLUTIL\">"
Xecho " <Directory Id=\"INSTALLURL\" Name=\"url\">"
Xecho "WIX_DB_SET_CURDIR(/installutil/url)"
cat $InLinks | (
read line
while [ "$line" != '' ]; do
local Shortname=`echo "$line" | cut -f 1 | StripDoubleQuotes`
local Name=`echo "$line" | cut -f 2 | StripDoubleQuotes`
local Url=`echo "$line" | cut -f 3 | StripDoubleQuotes`
read line
# We register the name .bdbsc extension to get the proper icon
local UrlName="$Shortname.bdbsc"
local UrlShortName="$Shortname.d1b"
local TargetFile="[INSTALLDIR]\\installutil\\url\\$UrlName"
local CreateUrlFile=true
local CommandShortcut=false
local Program=""
case "$Url" in
file:* ) CreateUrlFile=false
TargetFile=`echo $Url | sed -e 's/file://'`
TargetFile="[INSTALLDIR]"`cygpath -w $TargetFile`;;
cmd:* ) CreateUrlFile=false
UrlName="$Shortname.bat"
UrlShortName="$Shortname.bat"
TargetFile="[INSTALLDIR]\\installutil\\url\\$UrlName"
Program=`echo $Url | sed -e 's/cmd://'`
CommandShortcut=true;;
esac
Xecho "WIX_DB_SET_CURFILE($Shortname)"
Xecho + "<Component Id=\"Links.$Shortname\""
Xecho " $PERSISTGUID"
Xecho " SharedDllRefCount=\"yes\" Location=\"either\">"
if $CreateUrlFile; then
echo "[Default]$CR" > $UrlName
echo "BASEURL=$Url$CR" | RunM4 >> $UrlName || exit 1
echo "[InternetShortcut]$CR" >> $UrlName
echo "URL=$Url$CR" | RunM4 >> $UrlName || exit 1
echo "Modified=$MODTIMEHEX$CR" >> $UrlName
# TODO: we could have an Entry for IconFile=oracleweb.ico IconIndex=1?
echo ''
Xecho "<File Id=\"File.$Shortname\" "
Xecho " LongName=\"$UrlName\" Name=\"$UrlShortName\""
Xecho " Compressed=\"yes\" DiskId=\"1\""
Xecho " src=\"$here_win\\$UrlName\" />"
fi
if $CommandShortcut; then
echo "@echo off" > $UrlName
echo "set DBROOTDIR=" >> $UrlName
echo "for /F \"tokens=3 delims= \" %%A in ('REG QUERY \"HKLM\\SOFTWARE\\Oracle\\$PRODUCT_NAME\\$PRODUCT_VERSION\" /v RootDirectory') do set DBROOTDIR=%%A" >> $UrlName
echo "if ERRORLEVEL 2 goto MISSING" >> $UrlName
echo "if not defined DBROOTDIR goto MISSING" >> $UrlName
echo "set FN=\"%DBROOTDIR%$Program\"" >> $UrlName
echo "if not exist %FN% goto NOTFOUND" >> $UrlName
echo "cmd /k \"%DBROOTDIR%$Program\"$CR" >> $UrlName
echo "goto END" >> $UrlName
echo ":NOTFOUND" >> $UrlName
echo "echo" >> $UrlName
echo "echo Error: The program does not appear to be installed." >> $UrlName
echo "echo" >> $UrlName
echo "cmd /k" >> $UrlName
echo "goto END" >> $UrlName
echo ":MISSING" >> $UrlName
echo "echo" >> $UrlName
echo "echo NOTE:" >> $UrlName
echo "echo The $PRODUCT_NAME version could not be determined." >> $UrlName
echo "echo If you are running on Windows 2000, make sure the" >> $UrlName
echo "echo REG.EXE program is installed from the Tools disk" >> $UrlName
echo "echo" >> $UrlName
echo "cmd /k" >> $UrlName
echo ":END" >> $UrlName
Xecho "<File Id=\"File.$Shortname\" "
Xecho " LongName=\"$UrlName\" Name=\"$UrlShortName\""
Xecho " Compressed=\"yes\" DiskId=\"1\""
Xecho " src=\"$here_win\\$UrlName\" />"
Xecho "<Shortcut Id=\"Short.$Shortname\" Directory=\"BerkeleyDbMenu\""
Xecho " Name=\"$Shortname\" LongName=\"$Name\""
Xecho " WorkingDirectory=\"[INSTALLDIR]\""
Xecho " Target='$TargetFile'"
Xecho " Show=\"normal\" />"
else
Xecho "<Shortcut Id=\"Short.$Shortname\" Directory=\"BerkeleyDbMenu\""
Xecho " Name=\"$Shortname\" LongName=\"$Name\""
Xecho " Target='$TargetFile'"
Xecho " Show=\"normal\" />"
fi
Xecho - "</Component>"
Xecho "<ComponentRef Id=\"Links.$Shortname\" />" >> $OutFeatures
done
return 0
) || Error "Error processing links" || exit 1
Xecho "</Directory>"
Xecho "</DirectoryRef>"
Xecho - "</Feature>" >> $OutFeatures
}
# ProcessOneDirectory(DIRECTORYNAME)
# Called by ProcessFeatures.
# Argument is the directory name to process
# Standard input is cleaned up files.in (dirname is 3rd column)
# Standard output will be WiX XML Component/File entries
#
ProcessOneDirectory()
{
Dir="$1"
grep " ${Dir} " | (
read line
while [ "$line" != '' ]; do
local feature=`echo "$line" | cut -f 1`
local srcfile=`echo "$line" | cut -f 2`
local targetdir=`echo "$line" | cut -f 3`
local shortname=`echo "$line" | cut -f 4`
ProcessOneDirectoryFile "$feature" "$srcfile" "$targetdir" "$shortname" || exit 1
read line
done
return 0
) || Error "Error processing directory $Dir" || exit 1
}
# ProcessOneDirectoryFile(DIRECTORYNAME)
# Called by ProcessOneDirectory to process a single file in a directory.
# Standard output will be a single WiX XML Component/File entries
#
ProcessOneDirectoryFile()
{
local feature="$1"
local srcfile="$2"
local targetdir="$3"
local shortname="$4"
local base=`basename $srcfile`
#echo "processing file $srcfile in $feature to directory $targetdir..." >&2
# Prepend the WIX_DB_TOP unless the source file is absolute
local root=
local checkfile=
local wsrcfile=
case "$srcfile" in
/* ) root=""
wsrcfile=`cygpath -w $srcfile`
checkfile="$srcfile"
;;
* ) root="$PRODUCT_BLDDIR/"
wsrcfile="WIX_DB_TOP()\\`cygpath -w $srcfile`"
checkfile="$PRODUCT_BLDDIR/$srcfile"
;;
esac
# If srcfile ends in / then we'll use tallow to walk the directory
case "$srcfile" in
*/ ) if [ ! -d "$root$srcfile" ]; then
Error "$root$srcfile: not a directory"
exit 1
fi
Progress -minor " expanding $root$srcfile..."
RunTallow "$root$srcfile"
return 0
;;
*'*'* )
local dirname=`dirname "$root$srcfile"`
RunTallow "$dirname" -df "$base"
return 0
;;
esac
if [ "$shortname" = '' ]; then
shortname=`GetShortName "$base"`
fi
ID=`NextId`
if [ ! -r "$checkfile" ]; then
Error "$srcfile: file in feature $feature does not exist"
Error " curdir=`pwd`, pathname=$checkfile"
exit 1
fi
Xecho "WIX_DB_SET_CURFILE(${base})"
Xecho + "<Component Id=\"$feature.$ID\" Location=\"either\" $PERSISTGUID>"
Xecho "<File Id=\"${feature}.${ID}\" Name=\"${shortname}\" LongName=\"${base}\" Compressed=\"yes\" KeyPath=\"yes\" DiskId=\"1\" src=\"${wsrcfile}\" />"
Xecho - "</Component>"
return 0
}
# ProcessOneFeature(FEATUREPATH, SHORTNAME, DESCRIPTION, OPTS, INDIRECTORYFILE,
# OUTFEATURE, OUTSET)
# Called by ProcessFeatures to process a line in the features.in file.
# The first three arguments are the values of the first three columns:
# the feature dependency path (e.g. "Java/JavaExamples"), the short
# name, and a descriptive name. The last argument is the directory
# file that lists the components. We use the last name of the feature
# path (e.g. JavaExamples) to locate all components (really directories)
# named accordingly, so they can be listed as needed parts of the Feature.
# Standard output will be WiX XML Feature entries.
#
ProcessOneFeature() {
local featurename="$1"
local shortname="$2"
local opts="$4"
local dirfile="$5"
local outfeature="$6"
local outset="$7"
XmlLevel=4
local featcount=0
local featurestring=""
if [ $(SlashCount $featurename) -gt 0 ]; then
local parent=`echo $featurename | sed -e 's:/[^/]*$::' -e 's:.*/::'`
featurename=`echo $featurename | sed -e 's:^.*/::'`
featcount=1
Xecho "<FeatureRef Id=\"$parent\">" >> $outfeature
fi
# TODO: how to get +default to work?
# have tried messing with level="0" (doesn't show it)
# InstallDefault=\"source\" (doesn't make a difference)
#
local leveldebug="Level=\"4\""
local levelparam="Level=\"1\""
local leveldisable="Level=\"0\""
local defparam="InstallDefault=\"source\""
local displayparam="Display=\"expand\""
local params="AllowAdvertise=\"no\""
local regfeature=""
local descparam=""
if [ "$3" != '' ]; then
descparam="Description=\"$3\""
fi
local opt
local reqtext=""
local isdebugFeature=false
for opt in $opts; do
case "$opt" in
+default ) ;;
+required ) params="$params Absent=\"disallow\""
reqtext=" (required)";;
+invisible ) displayparam="Display=\"hidden\""
params="$params Absent=\"disallow\"";;
+debug ) isdebugFeature=true;;
* ) Error "features.in: Bad option $opt"
exit 1;;
esac
done
# (PBR)
# I tried to get debugging features to work but I could not. The last thing I
# tried was to set either ADDSOURCE or INSTALLLEVEL. Neither of these solutions
# will cause the feature conditions to rerun. The only thing I've found to do
# that is to rerun CostFinalize. The problem with this is it will re-enable all
# the options again. I'm keeping the basic framework for +debug support
if "$isdebugFeature"; then
regfeature="${featurename:1}"
echo "regfeature = $regfeature"
Xecho + "<Feature Id=\"$featurename\" Title=\"$shortname$reqtext\" $descparam $params $displayparam $leveldebug $defparam>" >> $outfeature
else
Xecho + "<Feature Id=\"$featurename\" Title=\"$shortname$reqtext\" $descparam $params $displayparam $levelparam $defparam>" >> $outfeature
fi
grep 'Component.*Id="'$featurename'[.0-9]*"' "$dirfile" | sed -e 's/\(Id="[^"]*"\).*/\1 \/>/' -e 's/Component /ComponentRef /' >> $outfeature
# Create a separate subfeature for any environment variables
# associated with the main feature.
# The <Condition> stuff is the magic that enables/disables
# setting the environment variables depending on the check box property.
Xecho + "<Feature Id=\"env.$featurename\" Title=\"env vars\" $params Display=\"hidden\" $levelparam $defparam>" >> $outfeature
Xecho "<Condition $leveldisable><![CDATA[EnvironmentSetCheck<>1]]></Condition>" >> $outfeature
Xecho "<Condition $levelparam><![CDATA[EnvironmentSetCheck=1]]></Condition>" >> $outfeature
grep 'Component.*Id="env\.'$featurename'[.0-9]*"' "$dirfile" | sed -e 's/\(Id="[^"]*"\).*/\1 \/>/' -e 's/Component /ComponentRef /' >> $outfeature
Xecho - "</Feature>" >> $outfeature
Xecho - "</Feature>" >> $outfeature
while [ "$featcount" -gt 0 ]; do
Xecho - "</FeatureRef>" >> $outfeature
featcount=$(($featcount - 1))
done
# Append the name to the feature list if it is to be installed.
# This publish fragment gets 'executed' when leaving the
# dialog to select features. Note that we have to quote
# the comma for m4 (`,') since this appears in a macro usage.
#
# (PBR)
# This code sets ADDSOURCE to show which debug options to include. This does not work
# If this is a debug feature, only turn on the value if the parent is on
if "$isdebugFeature"; then
regfeature="${featurename:1}"
# Xecho "<Publish Property=\"ADDSOURCE\" Value=\"[ADDSOURCE]\`,'\">" >> $outset
# Xecho " <![CDATA[&${regfeature} = 3 AND DebugCheck=\"yes\" AND ADDSOURCE <> NULL]]></Publish>" >> $outset
# Xecho "<Publish Property=\"ADDSOURCE\" Value=\"[ADDSOURCE]${featurename}\">" >> $outset
# Xecho " <![CDATA[&${regfeature} = 3 AND DebugCheck=\"yes\"]]></Publish>" >> $outset
Xecho "<Publish Property=\"FeatureList\" Value=\"[FeatureList]\`,' ${shortname}\">" >> $outset
Xecho " <![CDATA[&${regfeature} = 3 AND DebugCheck=\"yes\"]]></Publish>" >> $outset
else
Xecho "<Publish Property=\"FeatureList\" Value=\"[FeatureList]\`,' ${shortname}\">" >> $outset
Xecho " <![CDATA[&${featurename} = 3]]></Publish>" >> $outset
fi
}
# ProcessOneEnv(FEATURE, ENVNAME, ENVVALUE, OPTS, OUTDIRS, OUTSET)
# Called by ProcessFeatures to process a line in the environment.in file.
# The four arguments are the values of the four columns.
# The output will be into two files:
# OUTDIRS: WiX XML Component entries, that contain environment values.
# This controls the actual setting of the variables.
# OUTSET: WiX XML to set the installer variables if an env variable
# is set or a feature selected.
#
ProcessOneEnv() {
local feature="$1"
local envname="$2"
local envvalue="$3"
local opts="$4"
local outdirs="$5"
local outset="$6"
# Make the path uniform.
# echo "c:\Program Files\...\/Lib/Hello" | sed -e 's:\\/:\\:' -e 's:/:\\:g`
# This produces c:\Program Files\...\Lib\Hello
case "$envvalue" in
/* ) envvalue=`echo "$envvalue" | sed -e 's:^/::'`
esac
local path="[INSTALLDIR]$envvalue"
local opt
part="last"
for opt in $opts; do
case "$opt" in
+first ) part="first";;
+last ) part="last";;
* ) Error "environment.in: Bad option $opt"
exit 1;;
esac
done
# Generate the OUTDIRS fragment
# This looks like:
#
# <Component Id="env.CoreAPI.43" Guid="4B75755F-1129-292C-3434-238410000247">
# <Environment Id="env.44" Name="+-LIB" Action="set"
# Permanent="no" Part="first" Value="[INSTALLDIR]Lib" />
# </Component>
#
# Having a unique guid makes uninstall work.
# Note: We really want these installed as System rather than
# User vars (using the System="yes" tag), but only if user
# installs for *all* users. There is no convenient way to
# do that, so we leave them as default (User variables).
XmlLevel=4
local Id=`NextId`
Xecho "WIX_DB_SET_CURFILE(${envname})" >> $outdirs
Xecho + "<Component Id=\"env.$feature.$Id\" $PERSISTGUID>" >> $outdirs
Id=`NextId`
Xecho "<Environment Id=\"env.$Id\" Name=\"+-$envname\" Action=\"set\"" >> $outdirs
Xecho " Permanent=\"no\" Part=\"$part\" Value=\"$path\" />" >> $outdirs
Xecho "</Component>" >> $outdirs
# Generate the OUTSET fragment
# This looks like:
#
# <Publish Property="CLASSPATHValue" Value="[INSTALLDIR]Lib/db.jar;[CLASSPATHValue]">
# <![CDATA[&JavaAPI = 3]]></Publish>
# <Publish Property="CLASSPATHEscValue" Value="[INSTALLDIR]Lib/db.jar;[CLASSPATHEscValue]">
# <![CDATA[&JavaAPI = 3]]></Publish>
#
# This is equivalent to pseudocode:
# if (InstallFeature(JavaAPI)) {
# Prepend CLASSPATHValue with "Lib/db.jar;"
# Prepend CLASSPATHEscValue with "Lib/db.jar;"
# }
#
XmlLevel=4
Xecho "<Publish Property=\"${envname}Value\" Value=\"[INSTALLDIR]${envvalue};[${envname}Value]\">" >> $outset
Xecho " <![CDATA[&${feature} = 3]]></Publish>" >> $outset
Xecho "<Publish Property=\"${envname}EscValue\" Value=\"[INSTALLDIR]${envvalue};[${envname}EscValue]\">" >> $outset
Xecho " <![CDATA[&${feature} = 3]]></Publish>" >> $outset
}
# CreateProperty(ID, VALUE)
# Generate a <Property...> tag on the stdout
CreateProperty() {
Xecho "<Property Id=\"$1\" Hidden=\"yes\"><![CDATA[$2]]></Property>"
}
# ProcessTagProperties(OUTPROPS)
# Generate some identification tags as properties.
# This will let us look at an installer and figure out
# when it was built, etc.
ProcessTagProperties() {
local outprops="$1"
local insdate=`date`
XmlLevel=4
CreateProperty _DB_MSI_INSTALLER_DATE "$insdate" >> $outprops
CreateProperty _DB_MSI_PRODUCT_NAME "$PRODUCT_NAME" >> $outprops
CreateProperty _DB_MSI_PRODUCT_VERSION "$PRODUCT_VERSION" >> $outprops
CreateProperty ARPCOMMENTS "Installer for $PRODUCT_NAME $PRODUCT_VERSION built on $insdate" >> $outprops
}
# ProcessEnv(INENVFILE, INBATFILE, OUTPROPS, OUTSET, OUTSHOW)
# We generate some Property magic to show the user what is set.
#
ProcessEnv() {
InEnv="inenv.tmp"; CleanInputFile "$1" "$InEnv" 3 4
inbat="$2"
outprops="$3"
outset="$4"
outshow="$5"
# Get a list of the environment variables
local envvar
local envvars=`cut -f 2 < $InEnv | sort | uniq`
# For each environment var, create lines that declare
# a pair of properties in the envprops.wixinc file like:
#
# <Property Id="CLASSPATHValue" Hidden="yes"></Property>
# <Property Id="CLASSPATHEscValue" Hidden="yes"></Property>
#
# And create lines in the envset.wixinc file like:
#
# <Publish Property="CLASSPATHValue" Value="%CLASSPATH%">
# <![CDATA[1]]></Publish>
# <Publish Property="CLASSPATHEscValue" Value="\\%CLASSPATH\\%">
# <![CDATA[1]]></Publish>
#
# More will be added to that file later.
# Then, create lines in the envshow.wixinc file like:
#
# <Control Id="CLASSPATHText" Type="Text"
# X="23" Width="316" PARTIALHEIGHT(10, 2)
# TabSkip="no" Text="CLASSPATH:" />
#
# <Control Id="CLASSPATHValueText" Type="Text"
# X="37" Width="316" PARTIALHEIGHT(20, 7)
# TabSkip="no" Text="[CLASSPATHValue]" />
for envvar in $envvars; do
XmlLevel=4
CreateProperty "${envvar}Value" "" >> $outprops
CreateProperty "${envvar}EscValue" "" >> $outprops
XmlLevel=4
Xecho "<Publish Property=\"${envvar}Value\" Value=\"%${envvar}%\">" >> $outset
Xecho " <![CDATA[1]]></Publish>" >> $outset
Xecho "<Publish Property=\"${envvar}EscValue\" Value=\"\\%${envvar}\\%\">" >> $outset
Xecho " <![CDATA[1]]></Publish>" >> $outset
XmlLevel=4
Xecho "<Control Id=\"${envvar}Text\" Type=\"Text\"" >> $outshow
Xecho " X=\"23\" Width=\"316\" PARTIALHEIGHT(10, 2)" >> $outshow
Xecho " TabSkip=\"no\" Text=\"${envvar}:\" />" >> $outshow
Xecho "<Control Id=\"${envvar}ValueText\" Type=\"Text\"" >> $outshow
Xecho " X=\"37\" Width=\"316\" PARTIALHEIGHT(20, 7)" >> $outshow
Xecho " TabSkip=\"no\" Text=\"[${envvar}Value]\" />" >> $outshow
done
# Create the dbvars.bat file from the .bat template file
# TODO: the bat template file currently knows the variables
# and their values, it should get them from the environment.in
RunM4 <"$inbat" >"$PRODUCT_STAGE/dbvars.bat" || Error "m4 failed" || exit 1
}
# CleanInputFile(INFILENAME, OUTFILENAME, MINELEMENTS, MAXELEMENTS)
# A filter to preprocess and validate input files.
# We end up without comment lines, a single tab between elements,
# and a trailing tab.
# Also some selected shell variables are expanded for convenience.
# We verify that each line has the number of elements that fall within
# the given min and max.
#
CleanInputFile() {
sed \
-e 's/#.*//' \
-e 's/ * / /g' \
-e 's/ */ /g' \
-e '/^[ ]*$/d' \
-e 's/$/ /' \
-e 's/ */ /g' \
-e 's:\${PRODUCT_VERSION}:'"${PRODUCT_VERSION}":g \
-e 's:\${PRODUCT_MAJOR}:'"${PRODUCT_MAJOR}":g \
-e 's:\${PRODUCT_MINOR}:'"${PRODUCT_MINOR}":g \
-e 's:\${PRODUCT_PATCH}:'"${PRODUCT_PATCH}":g \
-e 's:\${PRODUCT_MAJMIN}:'"${PRODUCT_MAJMIN}":g \
-e 's:\${PRODUCT_STAGE}:'"${PRODUCT_STAGE}":g \
-e 's:\${PRODUCT_SHARED_WINMSIDIR}:'"${PRODUCT_SHARED_WINMSIDIR}":g \
-e 's/^[
\t]*$//' \
< "$1" > "$2"
# count tabs on each line
sed -e 's/[^\t]//g' -e 's/[\t]/x/g' < "$2" | (
read line
linecount=1
while [ "$line" != '' ]; do
chars=`echo "$line" | wc -c`
chars=$(($chars - 1)) # Remove newline
if [ "$chars" -lt "$3" -o "$chars" -gt "$4" ]; then
Error "$1: Input file error on or after line $linecount"
fi
read line
linecount=$(($linecount + 1))
done
)
}
# StripDoubleQuotes()
# In some input files, we allow double quotes around
# multi-word strings for readability. We strip them
# here from standard input and write to standard output.
# We only expect them at the beginning and end.
#
StripDoubleQuotes() {
sed -e 's/^"//' -e 's/"$//'
}
# IndentXml(PLUSMINUS_ARG)
# A global variable $XmlLevel is kept for the indent level.
# Every call creates blank output that matches the indent level.
# In addition, with a '-' argument, the indent level
# decrements by one before printing.
# With a '+', the indent level increments after printing.
# This is generally just used by Xecho
#
XmlLevel=0
IndentXml() {
if [ "$1" = '-' -a $XmlLevel != 0 ]; then
XmlLevel=$(($XmlLevel - 1))
fi
local idx=0
while [ "$idx" != "$XmlLevel" ]; do
echo -n ' '
idx=$(($idx + 1))
done
if [ "$1" = '+' ]; then
XmlLevel=$(($XmlLevel + 1))
fi
}
# Xecho [ - | + ] ...
# echoes arguments (like) echo, except that the output
# is indented for XML first. If +, the indentation changes
# after printing, if -, the indentation changes before printing.
#
Xecho()
{
local xarg=
if [ "$1" = '-' -o "$1" = '+' ]; then
xarg="$1"
shift
fi
IndentXml $xarg
echo "$@"
}
# SlashCount(PATH)
# Returns the number of slashes in its argument
# Note, we are relying on some advanced
# features of bash shell substitution
#
SlashCount()
{
local allslash=`echo "$1" | sed -e 's:[^/]*::g'`
echo "${#allslash}"
}
# ProcessDirTransition(PREVDIR, NEXTDIR)
# Used by ProcessFeatures to create the parts
# of an WiX <Directory> heirarchy (on stdout) needed to
# transition from directory PREVDIR to NEXTDIR.
# This may include any needed </Directory> entries as well.
# For example, ProcessDirTransition /Bin/Stuff /Bin/Foo/Bar
# produces:
# </Directory> ...to go up one from 'Stuff'
# <Directory Foo>
# <Directory Bar>
#
ProcessDirTransition() {
local p="$1"
local n="$2"
if [ "$p" = '' ]; then p=/; fi
if [ "$n" = '' ]; then n=/; fi
local nextdir="$2"
# The number of slashes in $p is the current directory level.
XmlLevel=$(($(SlashCount $p) + 4))
while [ "$p" != / ]; do
if [ "${n#${p}}" != "$n" ]; then
break
fi
# go up one level, and keep $p terminated with a /
p=`dirname $p`
case "$p" in
*/ ) ;;
* ) p=$p/;;
esac
Xecho - "</Directory>"
done
n=${n#${p}}
while [ "$n" != '' ]; do
local dirname=`echo $n | sed -e 's:/.*::'`
local cleanname=`CleanFileName "$dirname"`
local shortname=`GetShortName "$cleanname"`
local dirid=`NextId`
local larg=""
if [ "${shortname}" != "${dirname}" ]; then
larg="LongName=\"${dirname}\""
fi
Xecho + "<Directory Id=\"${cleanname}Dir.$dirid\" Name=\"${shortname}\" $larg>"
n=`echo $n | sed -e 's:^[^/]*/::'`
done
Xecho "WIX_DB_SET_CURDIR($nextdir)" # Tell the m4 macro what the current dir is
}
# SetupErrorLog()
# Given the global variable ERRORLOG for the name of the
# error output file, do any setup required to make that happen.
#
SetupErrorLog() {
# Before we start to use ERRORLOG, we get a full pathname,
# since the caller may change directories at times.
case "$ERRORLOG" in
/* ) ;;
*) ERRORLOG=`pwd`"/$ERRORLOG" ;;
esac
rm -f $ERRORLOG
# File descriptor tricks.
# Duplicate current stderr to 15, as we'll occasionally
# need to report progress to it. Then, redirect all
# stderr from now on to the ERRORLOG.
#
exec 15>&2
exec 2>>$ERRORLOG
}
# RequireCygwin
# Cygwin does not install certain needed components by default.
# Check to make sure that everything needed by the script
# and functions is here.
#
RequireCygwin() {
Progress -minor "checking for Cygwin..."
RequireFileInPath PATH "$PATH" m4
RequireFileInPath PATH "$PATH" gcc
RequireFileInPath PATH "$PATH" make
RequireFileInPath PATH "$PATH" unzip
RequireFileInPath PATH "$PATH" bc
RequireFileInPath PATH "$PATH" openssl # needed for MD5 hashing
}
# RequireJava()
# A java SDK (with include files) must be installed
#
RequireJava() {
Progress -minor "checking for Java..."
RequireFileInPath INCLUDE "$INCLUDE" jni.h
RequireFileInPath INCLUDE "$INCLUDE" jni_md.h
RequireFileInPath PATH "$PATH" jar.exe
RequireFileInPath PATH "$PATH" javac.exe
}
# RequireTcl()
# A Tcl SDK (with compatible .lib files) must be installed
#
RequireTcl() {
Progress -minor "checking for Tcl..."
RequireFileInPath INCLUDE "$INCLUDE" tcl.h
RequireFileInPath LIB "$LIB" tcl84g.lib
RequireFileInPath LIB "$LIB" tcl84.lib
}
# RequireWix()
# WiX must be installed
#
RequireWix() {
Progress -minor "checking for WiX..."
RequireFileInPath PATH "$PATH" candle.exe
RequireFileInPath PATH "$PATH" light.exe
RequireFileInPath PATH "$PATH" tallow.exe
}
# RequirePerl()
# Perl must be installed
#
RequirePerl() {
Progress -minor "checking for Perl..."
RequireFileInPath PATH "$PATH" perl.exe
}
# RequirePython()
# Python (and include files) must be installed
#
RequirePython() {
Progress -minor "checking for Python..."
RequireFileInPath INCLUDE "$INCLUDE" Python.h
RequireFileInPath PATH "$PATH" python.exe
}
# CreateDbPerl()
# Build Perl interface (for Berkeley DB only).
#
CreateDbPerl() {
# First build Berkeley DB using cygwin, as that version is
# needed for the Perl build
local here=`pwd`
Progress "building using Cygwin tools (needed for perl)"
cd "${PRODUCT_DBBUILDDIR}"
insdir="${PRODUCT_STAGE}/install_unix"
../dist/configure --prefix="$insdir" >>$ERRORLOG || exit 1
make install >>$ERRORLOG || exit 1
Progress "building perl"
cd ../perl/BerkeleyDB
BERKELEYDB_INCLUDE="$insdir/installed_include" BERKELEYDB_LIB="$insdir/lib" \
perl Makefile.PL >>$ERRORLOG || exit 1
make >>$ERRORLOG
cd $here
}
# CreateWindowsSystem()
# Copy Window system files
#
CreateWindowsSystem() {
local here=`pwd`
Progress "Copy Window system files..."
cd "${PRODUCT_SUB_BLDDIR}"
cp -f $SYSTEMROOT/system32/msvcr71.dll build_windows/Release/ || exit 1
cp -f $SYSTEMROOT/system32/msvcp71.dll build_windows/Release/ || exit 1
cp -f $SYSTEMROOT/system32/msvcr71d.dll build_windows/Debug/ || exit 1
cp -f $SYSTEMROOT/system32/msvcp71d.dll build_windows/Debug/ || exit 1
cd $here
}
# CreateInclude(DIR, FILES)
# Create an include directory populated with the files given
#
CreateInclude() {
local incdir="$1"
shift
Progress "creating the "$incdir" directory..."
rm -rf "$incdir"
mkdir "$incdir" || exit 1
cp -r "$@" "$incdir"
}
# CreateWindowsBuild()
# Do the windows build as defined by the winbuild.bat file
#
CreateWindowsBuild() {
local here=`pwd`
Progress "building using Windows tools..."
cd "${PRODUCT_SUB_BLDDIR}" || exit 1
# Before starting, copy any installer tools here.
# This makes building these tools straightforward
# and the results are left in the build directory.
#
cp -r ${PRODUCT_SHARED_WINMSIDIR}/instenv .
# We create a wbuild.bat file, which is essentially
# identical, except it has the carriage returns added.
# This allows us to use our favorite editors on winbuild.bat .
#
sed -e 's/$//' < ${PRODUCT_STAGE}/../winbuild.bat | tr '\001' '\015' > wbuild.bat
# TODO: Needed?
rm -f build_windows/Berkeley_DB.sln
rm -f winbld.out winbld.err
touch winbld.out winbld.err
echo "Build output and errors are collected in" >> $ERRORLOG
echo " winbld.{out,err} until the build has completed." >> $ERRORLOG
cmd.exe /x /c call wbuild.bat
status=$?
cat winbld.out >> $ERRORLOG
if [ -s winbld.err -o "$status" != 0 ]; then
cat winbld.err >> $ERRORLOG
Error "Errors during windows build"
exit 1
fi
cd $here
}
# CreateSources(SOURCESDIR,DOCDIR...)
# Create the sources directory, ignoring things in the docdirs
#
CreateSources() {
local sources="$1"
Progress "creating the Sources directory in $sources..."
rm -rf "$sources"
cp -r ${PRODUCT_SRCDIR} "$sources" || exit 1
}
# Usage()
# Show the usage for this script.
#
Usage()
{
echo "Usage: s_winmsi [ options ]" >&2
echo "Options: " >&2
echo " -input file use file rather than ${PRODUCT_ZIP_FILEFMT}" >&2
echo " where X.Y.Z is defined by ../RELEASE" >&2
echo " -output file use file rather than ${PRODUCT_MSI_FILEFMT}" >&2
echo " where X.Y.Z is defined by ../RELEASE" >&2
echo " -usebuild DIR use DIR for exes, DLLs, etc. " >&2
echo " rather than building from scratch" >&2
echo " -preserve preserve the winmsi/msi_staging directory" >&2
echo " -skipgen skip generating m4 include files" >&2
}
# SetupOptions()
# Parse command line options and set global variables as indicated below.
#
SetupOptions() {
OPT_USEBUILD=
OPT_PRESERVE=false
OPT_INFILE=
OPT_OUTFILE=
OPT_SKIPGEN=false
while [ "$#" -gt 0 ]; do
arg="$1"; shift
case "$arg" in
-usebuild ) OPT_USEBUILD="$1"; shift ;;
-skipgen ) OPT_SKIPGEN=true ;;
-preserve ) OPT_PRESERVE=true;;
-input ) OPT_INFILE="$1"; shift ;;
-output ) OPT_OUTFILE="$1"; shift ;;
* )
echo "ERROR: Unknown argument '$arg' to s_winmsi" >&2
Usage
exit 1
;;
esac
done
if [ "$OPT_INFILE" = '' -o ! -f "$OPT_INFILE" ]; then
echo "$OPT_INFILE: not found"
exit 1
fi
}
# CreateStage()
# Create the staging area
#
CreateStage() {
Progress "creating staging area..."
if [ "$PRODUCT_STAGE" = '' ]; then
Error "PRODUCT_STAGE not set"
exit 1
fi
if ! $OPT_PRESERVE; then
trap 'rm -rf ${PRODUCT_STAGE} ; exit 0' 0 1 2 3 13 15
fi
rm -rf ${PRODUCT_STAGE} || exit 1
mkdir ${PRODUCT_STAGE} || exit 1
cd ${PRODUCT_STAGE}
Progress "extracting $OPT_INFILE..."
unzip -q ../../$OPT_INFILE || exit 1
if [ ! -d $PRODUCT_LICENSEDIR ]; then
Error "$OPT_INFILE: no top level $PRODUCT_LICENSEDIR directory"
exit 1
fi
}
# CreateLicenseRtf(LICENSEIN, LICENSERTF)
# From a text LICENSE file, create the equivalent in .rtf format.
#
CreateLicenseRtf() {
local licensein="$1"
local licensertf="$2"
if [ ! -f "$licensein" ]; then
Error "License file $licensein: does not exist"
exit 1
fi
Progress "creating ${licensertf}..."
# Build a list of references to components ids (i.e. directories)
# that are listed in the .wxs file. This is needed to refer to
# all of the source (sadly it appears there is no better way!)
#
if ! grep '^=-=-=-=' $licensein > /dev/null; then
Error "LICENSE has changed format, this script must be adapted"
exit 1
fi
sed -e '1,/^=-=-=-=-=/d' < $licensein | MakeRtf > $licensertf
}
# CreateMsi(INFILE,WXSFILE,MSIFILE)
# Do the final creation of the output .MSI file.
# It is assumed that all *.wixinc files are now in place.
# INFILE is an absolute name of the m4 input WiX file.
# WXSFILE is a short (basename) of the postprocessed WiX file,
# after macro expansion, it will be left in staging directory.
# MSIFILE is a short (basename) of the output .MSI name
#
CreateMsi() {
local infile="$1"
local wxs="$2"
local msifile="$3"
local o=`echo "$wxs" | sed -e 's/[.]wxs$//' -e 's/$/.wixobj/'`
rm -f $o $wxs
# Preprocess the ${PROD}wix.in file, adding the things we need
#
Progress "Running m4 to create $wxs..."
RunM4 < "$infile" > "$PRODUCT_STAGE/$wxs" || Error "m4 failed" || exit 1
local here=`pwd`
cd "$PRODUCT_STAGE"
rm -f "$o" "$msifile"
Progress "compiling $wxs..."
candle -w0 $wxs >> $ERRORLOG || Error "candle (compiler) failed" || exit 1
Progress "linking .msi file..."
light -o "$msifile" $o >> $ERRORLOG || Error "light (linker) failed" || exit 1
(rm -f "../../$msifile" && mv "$msifile" ../..) >> $ERRORLOG || exit 1
cd $here
}
# CreateWixIncludeFiles()
# Do all processing of input files to produce
# the include files that we need to process the Wix input file.
#
CreateWixIncludeFiles() {
local here=`pwd`
cd "$PRODUCT_STAGE"
# Touch all the wix include files in case any end up empty.
touch directory.wixinc features.wixinc envprops.wixinc \
envset.wixinc envshow.wixinc links.wixinc
Progress "tagging the installer..."
ProcessTagProperties envprops.wixinc
Progress "processing environment..."
ProcessEnv ../environment.in ../dbvarsbat.in envprops.wixinc envset.wixinc envshow.wixinc
Progress "processing features and files..."
ProcessFeatures ../files.in ../features.in ../environment.in \
directory.wixinc features.wixinc \
envset.wixinc
Progress "processing links..."
ProcessLinks ../links.in features.wixinc > links.wixinc
cd $here
}