+#!/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
# helpful build function zone.
-source $FEISTY_MEOW_SCRIPTS/core/functions.sh
+source "$FEISTY_MEOW_SCRIPTS/core/functions.sh"
##############
# outer check on whether this already was run or not.
if [ -z "$BUILD_VARS_LOADED" ]; then
+#hmmm: make print only in debug mode
+echo recalculating feisty meow build variables.
+echo
+
# 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")"
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")"
fi
-BUILD_SCRIPTS_DIR="$(cd $(echo $BUILD_SCRIPTS_DIR | tr '\\\\' '/' ); \pwd)"
+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)"
+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"
+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
-if [ ! -z "$SHELL_DEBUG" ]; then
+if [ ! -z "$DEBUG_FEISTY_MEOW" ]; then
echo "[FEISTY_MEOW_APEX is $FEISTY_MEOW_APEX]"
fi
-#if [ "$OPERATING_SYSTEM" == "WIN32" ]; then
-# # harsh on the paths and make them use backwards slashes.
-# export SERIOUS_SLASH_TREATMENT=true
-#fi
+# set some extra variables that clam uses.
+
+# CLAM_ON_UNIX or CLAM_ON_DOS might get defined here.
+# we also can set OS_SUBCLASS if we detect darwin.
+if [ $OPERATING_SYSTEM == UNIX ]; then
+ export CLAM_ON_UNIX=$(uname)
+ if [[ $CLAM_ON_UNIX =~ .*[Dd]arwin.* ]]; then
+ # pick the subclass now that we know this is darwin.
+ export CLAM_OS_SUBCLASS=darwin
+ fi
+elif [ $OPERATING_SYSTEM == WIN32 ]; then
+ export CLAM_ON_DOS=$(uname)
+else
+ echo "Unknown operating system--clam will not build well here."
+fi
+
+# CLAM_BASE_CPU is a flag that distinguishes the type of processor, if necessary.
+export CLAM_BASE_CPU="$(uname -m 2>/dev/null || arch 2>/dev/null || echo i686)"
+#ugh, machine gives us an odd answer on macos. machine 2>/dev/null ||
+
+# "FEISTY_MEOW_CPP_HEADERS" are folders where our C and C++ header files can be found.
+# we'll compute the set of folders as best we can below.
+if [ -d "$FEISTY_MEOW_APEX/nucleus" ]; then
+ # just assumes we're at home and know our header locations under the feisty meow hierarchy.
+ export LOCUS_LIBRARY_HEADERS="$FEISTY_MEOW_APEX/nucleus $FEISTY_MEOW_APEX/octopi $FEISTY_MEOW_APEX/graphiq"
+else
+ export LOCUS_LIBRARY_HEADERS=
+fi
+ ####blech! maybe not needed now? was involved above. | tr "\\\\" / | sed -e "s/\([a-zA-Z]\):\/\([^ ]*\)/\/cygdrive\/\1\/\2/g" ')
+export FEISTY_MEOW_CPP_HEADERS=$(find $LOCUS_LIBRARY_HEADERS -mindepth 1 -maxdepth 1 -type d | grep -v "\.settings" )
+
+# the root name of the version file. This is currently irrelevant on
+# non-windoze platforms.
+export CLAM_VERSION_RC_ROOT=$(bash $CLAM_SCRIPTS/cpp/rc_name.sh)
+
+# CLAM_COMPILER is the C/C++ compiler application that builds our code.
+# The variable is mainly used within CLAM itself for determining the proper
+# compiler flags.
+export CLAM_COMPILER
+if [ "$OPERATING_SYSTEM" == UNIX ]; then
+ if [ "$CLAM_OS_SUBCLASS" == darwin ]; then
+ CLAM_COMPILER=GNU_DARWIN
+ else
+ CLAM_COMPILER=GNU_LINUX
+ fi
+elif [ "$OPERATING_SYSTEM" == WIN32 ]; then
+ CLAM_COMPILER=GNU_WINDOWS
+fi
+if [ -z "$CLAM_COMPILER" ]; then
+ # if we get into this case, we have no idea how to set the default compiler.
+ # so... pick a fun default.
+ CLAM_COMPILER=GNU_LINUX
+fi
+
+# "CLAM_COMPILER_ROOT_DIR" is the top-level for the C++ compiler location.
+# it is generally the top of the OS, although some variants may need this
+# modified (e.g., gnu arm linux, but we haven't built on that in a bit).
+export CLAM_COMPILER_ROOT_DIR="/"
+
+# CLAM_COMPILER_VERSION specifies the version of the particular compiler we're using.
+# this is sometimes needed to distinguish how the code is built or where headers/libraries are found.
+export CLAM_COMPILER_VERSION=$(bash $CLAM_SCRIPTS/cpp/get_version.sh $CLAM_COMPILER $CLAM_COMPILER_ROOT_DIR )
# new BUILD_TOP variable points at the utter top-most level of any files
# in the building hierarchy.
# the production directory is the location for all the scripts and setup
# code needed to produce the executables for feisty meow.
-export PRODUCTION_DIR="$BUILD_TOP/production"
+export PRODUCTION_STORE="$BUILD_TOP/production"
## set up the top-level for all build creations and logs and such.
-#export GENERATED_DIR="$TMP/generated-feisty_meow"
-#if [ ! -d "$GENERATED_DIR" ]; then
-# mkdir -p "$GENERATED_DIR"
+#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_DIR="$GENERATED_DIR/temporaries"
-#if [ ! -d "$TEMPORARIES_DIR" ]; then
-# mkdir -p "$TEMPORARIES_DIR"
+#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_DIR="$GENERATED_DIR/runtime"
-if [ ! -d "$RUNTIME_DIR" ]; then
- mkdir -p "$RUNTIME_DIR"
+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="$GENERATED_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
##############
# debugging area where we say what we think we know.
-if [ ! -z "$SHELL_DEBUG" ]; then
- echo scripts: $BUILD_SCRIPTS_DIR
+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_DIR
+ 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."
if [ -z "$got_bad" ]; then
# where we store the binaries used for building the rest of the code base.
- export CLAM_BINARY_DIR="$RUNTIME_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="$RUNTIME_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.
#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=$(dos_to_unix_path $CLAM_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"
+ # moved back to the good path of using gcc, not visual studio.
+#what vars needed?
+#trying just unixy ones, since we're doing cygwin on doze.
+export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$TARGETS_STORE"
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.
# this always needs to be defined since functions aren't exported.
function make()
{
- /usr/bin/make -I "$CLAM_DIR" $*
+ /usr/bin/make -I "$CLAM_SCRIPTS" $*
}
projects / feisty_meow.git / blobdiff