scripts/generator/build_variables.sh

   1 ##############
   2 #
   3 #  Name   : build variable calculator
   4 #  Author : Chris Koeritz
   5 #
   6 #  Purpose:
   7 #
   8 #    This script sets up all the variables needed by the HOOPLE system for
   9 #  building the source code.  It can either be run as a bash script directly
  10 #  like so:
  11 #
  12 #      bash ~/feisty_meow/scripts/generator/build_variables.sh
  13 #
  14 #  which will establish a new shell containing all the variables, or you can
  15 #  'source' the script like so:
  16 #
  17 #      build_vars=~/feisty_meow/scripts/generator/build_variables.sh
  18 #      source $build_vars $build_vars
  19 #
  20 #  to set all of the variables in your current shell.  The full path is
  21 #  necessary in these commands to allow the script to easily find itself.
  22 #  The 'source' version needs to be fed the actual path to the script
  23 #  because bash 'source' commands cause the first parameter (called $0) to
  24 #  be set to just the path to bash itself.
  25 #
  26 ##############
  27 # Copyright (c) 2004-$now By Author.  This program is free software; you can
  28 # redistribute it and/or modify it under the terms of the GNU General Public
  29 # License as published by the Free Software Foundation; either version 2 of
  30 # the License or (at your option) any later version.  This is online at:
  31 #     http://www.fsf.org/copyleft/gpl.html
  32 # Please send any updates to: fred@gruntose.com
  33 ##############
  34
  35 # here is where we compute the locations for the build's pieces, based on
  36 # where this script is located.  we currently assume that the build scripts
  37 # like this one are at the same height in the hierarchy as the clam scripts
  38 # that are used in the bootstrapping process.
  39
  40 # get the most important bits first; the directory this script lives in and
  41 # the script's name.
  42 PARM_0="$0"
  43 PARM_1="$1"
  44
  45 ##############
  46
  47 # helpful build function zone.
  48
  49 source $FEISTY_MEOW_SCRIPTS/core/functions.sh
  50
  51 ##############
  52
  53 # outer check on whether this already was run or not.
  54 if [ -z "$BUILD_VARS_LOADED" ]; then
  55
  56 # perform some calculations to get the right paths from our parameters.
  57 if [ ! -z "$PARM_1" ]; then
  58   # use the first real parameter since this is probably the 'source' version.
  59   export BUILD_SCRIPTS_DIR="$(dirname "$PARM_1")"
  60   THIS_TOOL_NAME="$(basename "$PARM_1")"
  61 else
  62   # use the zeroth parameter, since we know nothing more about our name.
  63   export BUILD_SCRIPTS_DIR="$(dirname "$PARM_0")"
  64   THIS_TOOL_NAME="$(basename "$PARM_0")"
  65 fi
  66 BUILD_SCRIPTS_DIR="$(cd $(echo $BUILD_SCRIPTS_DIR | tr '\\\\' '/' ); \pwd)"
  67
  68 # figure out the other paths based on where we found this script.
  69 export BUILDING_HIERARCHY="$(echo "$BUILD_SCRIPTS_DIR" | sed -e 's/\(.*\)\/[^\/]*/\1/')"
  70 export CLAM_DIR="$(cd $BUILD_SCRIPTS_DIR/../clam ; \pwd)"
  71 # synonym to make other builds happy.
  72 export BUILDER_DIR="$BUILDING_HIERARCHY"
  73
  74 # guess the current platform.
  75 IS_UNIX=$(uname | grep -i linux)
  76 if [ -z "$IS_UNIX" ]; then IS_UNIX=$(uname | grep -i unix); fi
  77 if [ -z "$IS_UNIX" ]; then IS_UNIX=$(uname | grep -i darwin); fi
  78 IS_DOS=$(uname | grep -i ming)
  79 if [ -z "$IS_DOS" ]; then IS_DOS=$(uname | grep -i cygwin); fi
  80
  81 # set some clam parameters for compilation.  if the script can't guess the
  82 # right configuration, then you will need to set them in the last 'else'
  83 # below.
  84 if [ ! -z "$IS_UNIX" ]; then export OPERATING_SYSTEM=UNIX;
  85 elif [ ! -z "$IS_DOS" ]; then export OPERATING_SYSTEM=WIN32;
  86 else
  87   # the system is unknown, so we give up on guessing.
  88   export OPERATING_SYSTEM=unknown
  89 fi
  90 if [ ! -z "$SHELL_DEBUG" ]; then
  91   echo "[OS is \"$OPERATING_SYSTEM\"]"
  92 fi
  93
  94 if [ ! -z "$SHELL_DEBUG" ]; then
  95   echo "[FEISTY_MEOW_DIR is $FEISTY_MEOW_DIR]"
  96 fi
  97
  98 # new BUILD_TOP variable points at the utter top-most level of any files
  99 # in the building hierarchy.
 100 export BUILD_TOP="$FEISTY_MEOW_DIR"
 101
 102 # this variable points at a folder where we store most of the generated products
 103 # of the build.  these tend to be the things that will be used for packaging into
 104 # different types of products.
 105 export PRODUCTION_DIR="$BUILD_TOP/production"
 106
 107 # we define a log file storage area that can be relied on by the build.
 108 export LOGS_DIR="$PRODUCTION_DIR/logs"
 109 if [ ! -d "$LOGS_DIR" ]; then
 110   mkdir -p "$LOGS_DIR"
 111 fi
 112
 113 ##############
 114
 115 # debugging area where we say what we think we know.
 116
 117 if [ ! -z "$SHELL_DEBUG" ]; then
 118   echo scripts: $BUILD_SCRIPTS_DIR
 119   echo build tools hier: $BUILDING_HIERARCHY
 120   echo this tool: $THIS_TOOL_NAME
 121   echo repository: $FEISTY_MEOW_DIR
 122   echo clam: $CLAM_DIR
 123 fi
 124
 125 ##############
 126
 127 # test out our computed variables to make sure they look right.
 128 pushd / &>/dev/null # jump to the root so relative paths are caught.
 129
 130 # flag for whether any checks have failed.
 131 got_bad=
 132
 133 # first the scripts directory; do we find this script there?
 134 if [ ! -f "$BUILD_SCRIPTS_DIR/$THIS_TOOL_NAME" ]; then
 135   echo "This script cannot locate the proper build folders.  The crucial path"
 136   echo "variable seems to be '$BUILD_SCRIPTS_DIR', which"
 137   echo "does not seem to contain '$THIS_TOOL_NAME' (this"
 138   echo "script's apparent name)."
 139   got_bad=1
 140 fi
 141
 142 # next the clam directory; is the main variables file present there?
 143 if [ -z "$got_bad" -a ! -f "$CLAM_DIR/variables.def" ]; then
 144   echo "The clam directory could not be located under our build tools hierarchy."
 145   echo "Please examine the configuration and make sure that this script is in a"
 146   echo "directory that resides at the same height as the 'clam' directory."
 147   got_bad=1
 148 fi
 149
 150 # now compute some more paths with a bit of "heuristics" for where we can
 151 # find the source code.
 152 export TOOL_SOURCES="$FEISTY_MEOW_DIR/nucleus/tools"
 153 if [ -z "$got_bad" -a ! -d "$TOOL_SOURCES/dependency_tool" -o ! -d "$TOOL_SOURCES/clam_tools" ]; then
 154   echo "This script cannot locate the tool source code folder.  This is where the"
 155   echo "dependency_tool and clam_tools folders are expected to be."
 156   got_bad=1
 157 fi
 158
 159 ############################
 160
 161 # we only run the rest of the script if we know we didn't have some kind of
 162 # bad thing happen earlier.
 163 if [ -z "$got_bad" ]; then
 164
 165   # where we store the binaries used for building the rest of the code base.
 166   export BINARY_DIR="$PRODUCTION_DIR/clam_bin"
 167     # the final destination for the new binaries which provide the hoople
 168     # build with all the apps it needs to get going.
 169   export TARGETS_DIR="$PRODUCTION_DIR/binaries"
 170     # targets directory is meaningful to clam, which will use it for output.
 171   export INTERMEDIATE_EXE_DIR="$TARGETS_DIR"
 172     # where we are building the apps before they get promoted.
 173
 174   export WASTE_DIR="$PRODUCTION_DIR/waste"
 175   if [ ! -d "$WASTE_DIR" ]; then
 176     mkdir -p "$WASTE_DIR"
 177   fi
 178   export TEMPORARIES_DIR="$WASTE_DIR/temporaries"
 179   if [ ! -d "$TEMPORARIES_DIR" ]; then
 180     mkdir -p "$TEMPORARIES_DIR"
 181   fi
 182
 183   # calculate which build ini file to use.
 184   export BUILD_PARAMETER_FILE="$PRODUCTION_DIR/feisty_meow_config.ini"
 185   if [ ! -f "$BUILD_PARAMETER_FILE" ]; then
 186     echo "Cannot find a useful build configuration file."
 187   fi
 188
 189   # pick the executable's file ending based on the platform.
 190   if [ "$OPERATING_SYSTEM" == "UNIX" ]; then export EXE_ENDING=;
 191   elif [ "$OPERATING_SYSTEM" == "WIN32" ]; then export EXE_ENDING=.exe;
 192   else
 193     echo "The OPERATING_SYSTEM variable is unset or unknown.  Bailing out."
 194   fi
 195
 196   # we should have established our internal variables now, so let's try
 197   # using them.
 198   export PATH=$BINARY_DIR:$PATH
 199
 200   # load up the helper variables for visual studio on winders.
 201   if [ "$OPERATING_SYSTEM" == "WIN32" ]; then
 202     source "$BUILD_SCRIPTS_DIR/vis_stu_vars.sh"
 203   else
 204     export LD_LIBRARY_PATH="$TARGETS_DIR"
 205   fi
 206
 207   popd &>/dev/null # checking is over, jump back to the starting point.
 208
 209   ############################
 210
 211   # at this point, all the build related variables should be valid.
 212
 213   if [ -z "$INCLUDED_FROM_BOOTSTRAP" \
 214       -a -z "$PARM_1" ]; then
 215     # we are running as a stand-alone script, so we stay resident with our
 216     # current set of variables.
 217     bash
 218   fi
 219
 220   # sentinel that tells us this script was pulled in.
 221   export BUILD_VARS_LOADED=true
 222
 223 fi
 224
 225 fi  # outer wrapper for already ran build vars check.
 226
 227 ##############
 228
 229 # hook clam into the compilation system.
 230 # this always needs to be defined since functions aren't exported.
 231 function make()
 232 {
 233   /usr/bin/make -I "$CLAM_DIR" $*
 234 }
 235
 236