+#!/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
# 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.
# 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.
export PRODUCTION_STORE="$BUILD_TOP/production"
## set up the top-level for all build creations and logs and such.
-#export GENERATED_STORE="$TMP/generated-feisty_meow"
-#if [ ! -d "$GENERATED_STORE" ]; then
-# mkdir -p "$GENERATED_STORE"
+#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="$GENERATED_STORE/temporaries"
+#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="$GENERATED_STORE/runtime"
+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 FEISTY_MEOW_LOGS="$GENERATED_STORE/logs"
+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
+if [ ! -z "$DEBUG_FEISTY_MEOW" ]; then
echo scripts: $BUILD_SCRIPTS_PATH
echo build tools hier: $BUILDING_HIERARCHY
echo this tool: $THIS_TOOL_NAME
# where we store the binaries used for building the rest of the code base.
export CLAM_BINARIES="$RUNTIME_PATH/clam_bin"
- # the final destination for the new binaries which provide the hoople
- # build with all the apps it needs to get going.
+ # 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_STORE="$TARGETS_STORE"
- # where we are building the apps before they get promoted.
+ # 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.
# load up the helper variables for visual studio on winders.
if [ "$OPERATING_SYSTEM" == "WIN32" ]; then
- source "$BUILD_SCRIPTS_PATH/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_STORE"
+ export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$TARGETS_STORE"
fi
popd &>/dev/null # checking is over, jump back to the starting point.
projects / feisty_meow.git / blobdiff