+#!/bin/bash
+
##############
#
# Name : build variable calculator
# building the source code. It can either be run as a bash script directly
# like so:
#
-# bash ~/feisty_meow/scripts/generator/build_variables.sh
+# bash $FEISTY_MEOW_APEX/scripts/generator/build_variables.sh
#
# which will establish a new shell containing all the variables, or you can
# 'source' the script like so:
#
-# build_vars=~/feisty_meow/scripts/generator/build_variables.sh
+# build_vars=$FEISTY_MEOW_APEX/scripts/generator/build_variables.sh
# source $build_vars $build_vars
#
# to set all of the variables in your current shell. The full path is
# Please send any updates to: fred@gruntose.com
##############
-# prerequisites for this script:
-#
-# (1) the script should be run with a full path, so that it can decide where
-# it lives with minimal fuss.
-# (2) on windows, the msys bin directory should already be in the path so that
-# tools like dirname are already available.
-
# here is where we compute the locations for the build's pieces, based on
# where this script is located. we currently assume that the build scripts
# like this one are at the same height in the hierarchy as the clam scripts
# helpful build function zone.
-source $FEISTY_MEOW_SCRIPTS/core/functions.sh
- # load msys_to_dos_path and dos_to_msys_path.
-
-#### switches from a /X/path form to an X:/ form.
-###function msys_to_dos_path() {
-### # we always remove dos slashes in favor of forward slashes.
-### echo "$1" | sed -e 's/\\/\//g' | sed -e 's/\/\([a-zA-Z]\)\/\(.*\)/\1:\/\2/'
-###}
-
-#### switches from an X:/ form to an /X/path form.
-###function dos_to_msys_path() {
-### # we always remove dos slashes in favor of forward slashes.
-### echo "$1" | sed -e 's/\\/\//g' | sed -e 's/\([a-zA-Z]\):\/\(.*\)/\/\1\/\2/'
-###}
+source "$FEISTY_MEOW_SCRIPTS/core/functions.sh"
##############
+# outer check on whether this already was run or not.
+if [ -z "$BUILD_VARS_LOADED" ]; then
+
# perform some calculations to get the right paths from our parameters.
if [ ! -z "$PARM_1" ]; then
# use the first real parameter since this is probably the 'source' version.
- export BUILD_SCRIPTS_DIR="$(dirname "$PARM_1")"
+ export BUILD_SCRIPTS_PATH="$(dirname "$PARM_1")"
THIS_TOOL_NAME="$(basename "$PARM_1")"
-echo ==sourced version buildscriptsdir is $BUILD_SCRIPTS_DIR
else
# use the zeroth parameter, since we know nothing more about our name.
- export BUILD_SCRIPTS_DIR="$(dirname "$PARM_0")"
+ export BUILD_SCRIPTS_PATH="$(dirname "$PARM_0")"
THIS_TOOL_NAME="$(basename "$PARM_0")"
-echo ==bashed version buildscriptsdir is $BUILD_SCRIPTS_DIR
fi
-BUILD_SCRIPTS_DIR="$(cd $(echo $BUILD_SCRIPTS_DIR | tr '\\\\' '/' ); \pwd)"
-echo "==buildvars buildscriptsdir is $BUILD_SCRIPTS_DIR"
+BUILD_SCRIPTS_PATH="$(cd $(echo $BUILD_SCRIPTS_PATH | tr '\\\\' '/' ); \pwd)"
# figure out the other paths based on where we found this script.
-export BUILDING_HIERARCHY="$(echo "$BUILD_SCRIPTS_DIR" | sed -e 's/\(.*\)\/[^\/]*/\1/')"
-export CLAM_DIR="$(cd $BUILD_SCRIPTS_DIR/../clam ; \pwd)"
-echo "==buildvars clamdir is $CLAM_DIR"
+export BUILDING_HIERARCHY="$(echo "$BUILD_SCRIPTS_PATH" | sed -e 's/\(.*\)\/[^\/]*/\1/')"
+export CLAM_SCRIPTS="$(cd $BUILD_SCRIPTS_PATH/../clam ; \pwd)"
# synonym to make other builds happy.
-export BUILDER_DIR="$BUILDING_HIERARCHY"
-
-# guess the current platform.
-IS_UNIX=$(uname | grep -i linux)
-if [ -z "$IS_UNIX" ]; then IS_UNIX=$(uname | grep -i unix); fi
-if [ -z "$IS_UNIX" ]; then IS_UNIX=$(uname | grep -i darwin); fi
-IS_DOS=$(uname | grep -i ming)
-if [ -z "$IS_DOS" ]; then IS_DOS=$(uname | grep -i cygwin); fi
+export BUILDER_PATH="$BUILDING_HIERARCHY"
# set some clam parameters for compilation. if the script can't guess the
# right configuration, then you will need to set them in the last 'else'
# the system is unknown, so we give up on guessing.
export OPERATING_SYSTEM=unknown
fi
-if [ ! -z "$SHELL_DEBUG" ]; then
+if [ ! -z "$DEBUG_FEISTY_MEOW" ]; then
echo "[OS is \"$OPERATING_SYSTEM\"]"
fi
-#hmmm: all this stuff is highly questionable value now.
-# we create the variable FEISTY_MEOW_DIR, but we keep the dos form of
-# the path, because otherwise lots of bad things happens when passing the
-# folders around to visual studio commands that don't allow a space after them.
-if [ -d "$BUILDING_HIERARCHY/source" ]; then
- # old style repository is same height as building hierarchy.
- export FEISTY_MEOW_DIR="$BUILDING_HIERARCHY"
-else
- # new style repository is a level above the build hierarchy.
- export FEISTY_MEOW_DIR="$(echo "$BUILDING_HIERARCHY" | sed -e 's/\(.*\)\/[^\/]*/\1/')"
-fi
-
-if [ "$OPERATING_SYSTEM" = "WIN32" ]; then
- # make sure repository dir looks right on windoze.
- export FEISTY_MEOW_DIR="$(msys_to_dos_path "$FEISTY_MEOW_DIR")"
+if [ ! -z "$DEBUG_FEISTY_MEOW" ]; then
+ echo "[FEISTY_MEOW_APEX is $FEISTY_MEOW_APEX]"
fi
-if [ ! -z "$SHELL_DEBUG" ]; then
- echo "[FEISTY_MEOW_DIR is $FEISTY_MEOW_DIR]"
-fi
+#if [ "$OPERATING_SYSTEM" == "WIN32" ]; then
+# # harsh on the paths and make them use backwards slashes.
+# export SERIOUS_SLASH_TREATMENT=true
+#fi
# new BUILD_TOP variable points at the utter top-most level of any files
# in the building hierarchy.
-export BUILD_TOP="$FEISTY_MEOW_DIR"
-
-# this variable points at a folder where we store most of the generated products
-# of the build. these tend to be the things that will be used for packaging into
-# different types of products.
-export PRODUCTION_DIR="$BUILD_TOP/production"
+export BUILD_TOP="$FEISTY_MEOW_APEX"
+
+# the production directory is the location for all the scripts and setup
+# code needed to produce the executables for feisty meow.
+export PRODUCTION_STORE="$BUILD_TOP/production"
+
+## set up the top-level for all build creations and logs and such.
+#export FEISTY_MEOW_GENERATED_STORE="$TMP/generated-feisty_meow"
+#if [ ! -d "$FEISTY_MEOW_GENERATED_STORE" ]; then
+# mkdir -p "$FEISTY_MEOW_GENERATED_STORE"
+#fi
+## set up our effluent outsourcing valves.
+#export TEMPORARIES_PILE="$FEISTY_MEOW_GENERATED_STORE/temporaries"
+#if [ ! -d "$TEMPORARIES_PILE" ]; then
+# mkdir -p "$TEMPORARIES_PILE"
+#fi
+
+# this variable points at a folder where we store the generated products of
+# the build, such as the binaries and installer packages.
+export RUNTIME_PATH="$FEISTY_MEOW_GENERATED_STORE/runtime"
+if [ ! -d "$RUNTIME_PATH" ]; then
+ mkdir -p "$RUNTIME_PATH"
+fi
# we define a log file storage area that can be relied on by the build.
-export LOGS_DIR="$PRODUCTION_DIR/logs"
-if [ ! -d "$LOGS_DIR" ]; then
- mkdir -p "$LOGS_DIR"
+export FEISTY_MEOW_LOGS="$FEISTY_MEOW_GENERATED_STORE/logs"
+if [ ! -d "$FEISTY_MEOW_LOGS" ]; then
+ mkdir -p "$FEISTY_MEOW_LOGS"
fi
-# hook clam into the compilation system.
-function make()
-{
- /usr/bin/make -I "$CLAM_DIR" $*
-}
-
##############
# debugging area where we say what we think we know.
-#echo scripts: $BUILD_SCRIPTS_DIR
-#echo build tools hier: $BUILDING_HIERARCHY
-#echo this tool: $THIS_TOOL_NAME
-#echo repository: $FEISTY_MEOW_DIR
-#echo clam: $CLAM_DIR
-#echo makeflags: $MAKEFLAGS
+if [ ! -z "$DEBUG_FEISTY_MEOW" ]; then
+ echo scripts: $BUILD_SCRIPTS_PATH
+ echo build tools hier: $BUILDING_HIERARCHY
+ echo this tool: $THIS_TOOL_NAME
+ echo repository: $FEISTY_MEOW_APEX
+ echo clam: $CLAM_SCRIPTS
+fi
##############
got_bad=
# first the scripts directory; do we find this script there?
-if [ ! -f "$BUILD_SCRIPTS_DIR/$THIS_TOOL_NAME" ]; then
+if [ ! -f "$BUILD_SCRIPTS_PATH/$THIS_TOOL_NAME" ]; then
echo "This script cannot locate the proper build folders. The crucial path"
- echo "variable seems to be '$BUILD_SCRIPTS_DIR', which"
+ echo "variable seems to be '$BUILD_SCRIPTS_PATH', which"
echo "does not seem to contain '$THIS_TOOL_NAME' (this"
echo "script's apparent name)."
got_bad=1
fi
# next the clam directory; is the main variables file present there?
-if [ -z "$got_bad" -a ! -f "$CLAM_DIR/variables.def" ]; then
+if [ -z "$got_bad" -a ! -f "$CLAM_SCRIPTS/variables.def" ]; then
echo "The clam directory could not be located under our build tools hierarchy."
echo "Please examine the configuration and make sure that this script is in a"
echo "directory that resides at the same height as the 'clam' directory."
# now compute some more paths with a bit of "heuristics" for where we can
# find the source code.
-export TOOL_SOURCES="$FEISTY_MEOW_DIR/nucleus/tools"
-echo "==tool source is $TOOL_SOURCES"
+export TOOL_SOURCES="$FEISTY_MEOW_APEX/nucleus/tools"
if [ -z "$got_bad" -a ! -d "$TOOL_SOURCES/dependency_tool" -o ! -d "$TOOL_SOURCES/clam_tools" ]; then
echo "This script cannot locate the tool source code folder. This is where the"
echo "dependency_tool and clam_tools folders are expected to be."
if [ -z "$got_bad" ]; then
# where we store the binaries used for building the rest of the code base.
- export BINARY_DIR="$PRODUCTION_DIR/clam_bin"
- # the final destination for the new binaries which provide the hoople
- # build with all the apps it needs to get going.
- export TARGETS_DIR="$PRODUCTION_DIR/binaries"
+ export CLAM_BINARIES="$RUNTIME_PATH/clam_bin"
+ # the final destination for the new binaries which provide the
+ # build with all the applications it needs to get going.
+ export TARGETS_STORE="$RUNTIME_PATH/binaries"
# targets directory is meaningful to clam, which will use it for output.
- export INTERMEDIATE_EXE_DIR="$TARGETS_DIR"
- # where we are building the apps before they get promoted.
+ export INTERMEDIATE_STORE="$TARGETS_STORE"
+ # where we are building the applications before they get promoted.
- export WASTE_DIR="$PRODUCTION_DIR/waste"
- if [ ! -d "$WASTE_DIR" ]; then
- mkdir -p "$WASTE_DIR"
- fi
- export TEMPORARIES_DIR="$WASTE_DIR/temporaries"
- if [ ! -d "$TEMPORARIES_DIR" ]; then
- mkdir -p "$TEMPORARIES_DIR"
- fi
-
+#hmmm: could allow override on this if already set.
# calculate which build ini file to use.
- export BUILD_PARAMETER_FILE="$PRODUCTION_DIR/feisty_meow_config.ini"
+ export BUILD_PARAMETER_FILE="$PRODUCTION_STORE/feisty_meow_config.ini"
if [ ! -f "$BUILD_PARAMETER_FILE" ]; then
echo "Cannot find a useful build configuration file."
fi
# we should have established our internal variables now, so let's try
# using them.
- export PATH=$BINARY_DIR:$PATH
+ export PATH=$(dos_to_unix_path $CLAM_BINARIES):$PATH
# load up the helper variables for visual studio on winders.
if [ "$OPERATING_SYSTEM" == "WIN32" ]; then
- source "$BUILD_SCRIPTS_DIR/vis_stu_vars.sh"
+ source "$BUILD_SCRIPTS_PATH/vis_stu_vars.sh"
else
- export LD_LIBRARY_PATH="$TARGETS_DIR"
+ export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$TARGETS_STORE"
fi
popd &>/dev/null # checking is over, jump back to the starting point.
bash
fi
+ # sentinel that tells us this script was pulled in.
+ export BUILD_VARS_LOADED=true
+
fi
+fi # outer wrapper for already ran build vars check.
+
+##############
+
+# hook clam into the compilation system.
+# this always needs to be defined since functions aren't exported.
+function make()
+{
+ /usr/bin/make -I "$CLAM_SCRIPTS" $*
+}
+
+
projects / feisty_meow.git / blobdiff