5 # Name : build variable calculator
6 # Author : Chris Koeritz
10 # This script sets up all the variables needed by the HOOPLE system for
11 # building the source code. It can either be run as a bash script directly
14 # bash $FEISTY_MEOW_APEX/scripts/generator/build_variables.sh
16 # which will establish a new shell containing all the variables, or you can
17 # 'source' the script like so:
19 # build_vars=$FEISTY_MEOW_APEX/scripts/generator/build_variables.sh
20 # source $build_vars $build_vars
22 # to set all of the variables in your current shell. The full path is
23 # necessary in these commands to allow the script to easily find itself.
24 # The 'source' version needs to be fed the actual path to the script
25 # because bash 'source' commands cause the first parameter (called $0) to
26 # be set to just the path to bash itself.
29 # Copyright (c) 2004-$now By Author. This program is free software; you can
30 # redistribute it and/or modify it under the terms of the GNU General Public
31 # License as published by the Free Software Foundation; either version 2 of
32 # the License or (at your option) any later version. This is online at:
33 # http://www.fsf.org/copyleft/gpl.html
34 # Please send any updates to: fred@gruntose.com
37 # here is where we compute the locations for the build's pieces, based on
38 # where this script is located. we currently assume that the build scripts
39 # like this one are at the same height in the hierarchy as the clam scripts
40 # that are used in the bootstrapping process.
42 # get the most important bits first; the directory this script lives in and
49 # helpful build function zone.
51 source "$FEISTY_MEOW_SCRIPTS/core/functions.sh"
55 # outer check on whether this already was run or not.
56 if [ -z "$BUILD_VARS_LOADED" ]; then
58 #hmmm: make print only in debug mode
59 echo recalculating feisty meow build variables.
62 # perform some calculations to get the right paths from our parameters.
63 if [ ! -z "$PARM_1" ]; then
64 # use the first real parameter since this is probably the 'source' version.
65 export BUILD_SCRIPTS_PATH="$(dirname "$PARM_1")"
66 THIS_TOOL_NAME="$(basename "$PARM_1")"
68 # use the zeroth parameter, since we know nothing more about our name.
69 export BUILD_SCRIPTS_PATH="$(dirname "$PARM_0")"
70 THIS_TOOL_NAME="$(basename "$PARM_0")"
72 BUILD_SCRIPTS_PATH="$(cd $(echo $BUILD_SCRIPTS_PATH | tr '\\\\' '/' ); \pwd)"
74 # figure out the other paths based on where we found this script.
75 export BUILDING_HIERARCHY="$(echo "$BUILD_SCRIPTS_PATH" | sed -e 's/\(.*\)\/[^\/]*/\1/')"
76 export CLAM_SCRIPTS="$(cd $BUILD_SCRIPTS_PATH/../clam ; \pwd)"
77 # synonym to make other builds happy.
78 export BUILDER_PATH="$BUILDING_HIERARCHY"
80 # set some clam parameters for compilation. if the script can't guess the
81 # right configuration, then you will need to set them in the last 'else'
83 if [ ! -z "$IS_UNIX" ]; then export OPERATING_SYSTEM=UNIX;
84 elif [ ! -z "$IS_DOS" ]; then export OPERATING_SYSTEM=WIN32;
86 # the system is unknown, so we give up on guessing.
87 export OPERATING_SYSTEM=unknown
89 if [ ! -z "$DEBUG_FEISTY_MEOW" ]; then
90 echo "[OS is \"$OPERATING_SYSTEM\"]"
93 if [ ! -z "$DEBUG_FEISTY_MEOW" ]; then
94 echo "[FEISTY_MEOW_APEX is $FEISTY_MEOW_APEX]"
97 # set some extra variables that clam uses.
99 # CLAM_ON_UNIX or CLAM_ON_DOS might get defined here.
100 # we also can set OS_SUBCLASS if we detect darwin.
101 if [ $OPERATING_SYSTEM == UNIX ]; then
102 export CLAM_ON_UNIX=$(uname)
103 if [[ $CLAM_ON_UNIX =~ .*[Dd]arwin.* ]]; then
104 # pick the subclass now that we know this is darwin.
105 export CLAM_OS_SUBCLASS=darwin
107 elif [ $OPERATING_SYSTEM == WIN32 ]; then
108 export CLAM_ON_DOS=$(uname)
110 echo "Unknown operating system--clam will not build well here."
113 # CLAM_BASE_CPU is a flag that distinguishes the type of processor, if necessary.
114 export CLAM_BASE_CPU="$(uname -m 2>/dev/null || arch 2>/dev/null || echo i686)"
115 #ugh, machine gives us an odd answer on macos. machine 2>/dev/null ||
117 # "FEISTY_MEOW_CPP_HEADERS" are folders where our C and C++ header files can be found.
118 # we'll compute the set of folders as best we can below.
119 if [ -d "$FEISTY_MEOW_APEX/nucleus" ]; then
120 # just assumes we're at home and know our header locations under the feisty meow hierarchy.
121 export LOCUS_LIBRARY_HEADERS="$FEISTY_MEOW_APEX/nucleus $FEISTY_MEOW_APEX/octopi $FEISTY_MEOW_APEX/graphiq"
123 export LOCUS_LIBRARY_HEADERS=
125 ####blech! maybe not needed now? was involved above. | tr "\\\\" / | sed -e "s/\([a-zA-Z]\):\/\([^ ]*\)/\/cygdrive\/\1\/\2/g" ')
126 export FEISTY_MEOW_CPP_HEADERS=$(find $LOCUS_LIBRARY_HEADERS -mindepth 1 -maxdepth 1 -type d | grep -v "\.settings" )
128 # the root name of the version file. This is currently irrelevant on
129 # non-windoze platforms.
130 export CLAM_VERSION_RC_ROOT=$(bash $CLAM_SCRIPTS/cpp/rc_name.sh)
132 # CLAM_COMPILER is the C/C++ compiler application that builds our code.
133 # The variable is mainly used within CLAM itself for determining the proper
136 if [ "$OPERATING_SYSTEM" == UNIX ]; then
137 if [ "$CLAM_OS_SUBCLASS" == darwin ]; then
138 CLAM_COMPILER=GNU_DARWIN
140 CLAM_COMPILER=GNU_LINUX
142 elif [ "$OPERATING_SYSTEM" == WIN32 ]; then
143 CLAM_COMPILER=GNU_WINDOWS
145 if [ -z "$CLAM_COMPILER" ]; then
146 # if we get into this case, we have no idea how to set the default compiler.
147 # so... pick a fun default.
148 CLAM_COMPILER=GNU_LINUX
151 # "CLAM_COMPILER_ROOT_DIR" is the top-level for the C++ compiler location.
152 # it is generally the top of the OS, although some variants may need this
153 # modified (e.g., gnu arm linux, but we haven't built on that in a bit).
154 export CLAM_COMPILER_ROOT_DIR="/"
156 # CLAM_COMPILER_VERSION specifies the version of the particular compiler we're using.
157 # this is sometimes needed to distinguish how the code is built or where headers/libraries are found.
158 export CLAM_COMPILER_VERSION=$(bash $CLAM_SCRIPTS/cpp/get_version.sh $CLAM_COMPILER $CLAM_COMPILER_ROOT_DIR )
160 # new BUILD_TOP variable points at the utter top-most level of any files
161 # in the building hierarchy.
162 export BUILD_TOP="$FEISTY_MEOW_APEX"
164 # the production directory is the location for all the scripts and setup
165 # code needed to produce the executables for feisty meow.
166 export PRODUCTION_STORE="$BUILD_TOP/production"
168 ## set up the top-level for all build creations and logs and such.
169 #export FEISTY_MEOW_GENERATED_STORE="$TMP/generated-feisty_meow"
170 #if [ ! -d "$FEISTY_MEOW_GENERATED_STORE" ]; then
171 # mkdir -p "$FEISTY_MEOW_GENERATED_STORE"
173 ## set up our effluent outsourcing valves.
174 #export TEMPORARIES_PILE="$FEISTY_MEOW_GENERATED_STORE/temporaries"
175 #if [ ! -d "$TEMPORARIES_PILE" ]; then
176 # mkdir -p "$TEMPORARIES_PILE"
179 # this variable points at a folder where we store the generated products of
180 # the build, such as the binaries and installer packages.
181 export RUNTIME_PATH="$FEISTY_MEOW_GENERATED_STORE/runtime"
182 if [ ! -d "$RUNTIME_PATH" ]; then
183 mkdir -p "$RUNTIME_PATH"
186 # we define a log file storage area that can be relied on by the build.
187 export FEISTY_MEOW_LOGS="$FEISTY_MEOW_GENERATED_STORE/logs"
188 if [ ! -d "$FEISTY_MEOW_LOGS" ]; then
189 mkdir -p "$FEISTY_MEOW_LOGS"
194 # debugging area where we say what we think we know.
196 if [ ! -z "$DEBUG_FEISTY_MEOW" ]; then
197 echo scripts: $BUILD_SCRIPTS_PATH
198 echo build tools hier: $BUILDING_HIERARCHY
199 echo this tool: $THIS_TOOL_NAME
200 echo repository: $FEISTY_MEOW_APEX
201 echo clam: $CLAM_SCRIPTS
206 # test out our computed variables to make sure they look right.
207 pushd / &>/dev/null # jump to the root so relative paths are caught.
209 # flag for whether any checks have failed.
212 # first the scripts directory; do we find this script there?
213 if [ ! -f "$BUILD_SCRIPTS_PATH/$THIS_TOOL_NAME" ]; then
214 echo "This script cannot locate the proper build folders. The crucial path"
215 echo "variable seems to be '$BUILD_SCRIPTS_PATH', which"
216 echo "does not seem to contain '$THIS_TOOL_NAME' (this"
217 echo "script's apparent name)."
221 # next the clam directory; is the main variables file present there?
222 if [ -z "$got_bad" -a ! -f "$CLAM_SCRIPTS/variables.def" ]; then
223 echo "The clam directory could not be located under our build tools hierarchy."
224 echo "Please examine the configuration and make sure that this script is in a"
225 echo "directory that resides at the same height as the 'clam' directory."
229 # now compute some more paths with a bit of "heuristics" for where we can
230 # find the source code.
231 export TOOL_SOURCES="$FEISTY_MEOW_APEX/nucleus/tools"
232 if [ -z "$got_bad" -a ! -d "$TOOL_SOURCES/dependency_tool" -o ! -d "$TOOL_SOURCES/clam_tools" ]; then
233 echo "This script cannot locate the tool source code folder. This is where the"
234 echo "dependency_tool and clam_tools folders are expected to be."
238 ############################
240 # we only run the rest of the script if we know we didn't have some kind of
241 # bad thing happen earlier.
242 if [ -z "$got_bad" ]; then
244 # where we store the binaries used for building the rest of the code base.
245 export CLAM_BINARIES="$RUNTIME_PATH/clam_bin"
246 # the final destination for the new binaries which provide the
247 # build with all the applications it needs to get going.
248 export TARGETS_STORE="$RUNTIME_PATH/binaries"
249 # targets directory is meaningful to clam, which will use it for output.
250 export INTERMEDIATE_STORE="$TARGETS_STORE"
251 # where we are building the applications before they get promoted.
253 #hmmm: could allow override on this if already set.
254 # calculate which build ini file to use.
255 export BUILD_PARAMETER_FILE="$PRODUCTION_STORE/feisty_meow_config.ini"
256 if [ ! -f "$BUILD_PARAMETER_FILE" ]; then
257 echo "Cannot find a useful build configuration file."
260 # pick the executable's file ending based on the platform.
261 if [ "$OPERATING_SYSTEM" == "UNIX" ]; then export EXE_ENDING=;
262 elif [ "$OPERATING_SYSTEM" == "WIN32" ]; then export EXE_ENDING=.exe;
264 echo "The OPERATING_SYSTEM variable is unset or unknown. Bailing out."
267 # we should have established our internal variables now, so let's try
269 export PATH=$(dos_to_unix_path $CLAM_BINARIES):$PATH
271 # load up the helper variables for visual studio on winders.
272 if [ "$OPERATING_SYSTEM" == "WIN32" ]; then
273 # moved back to the good path of using gcc, not visual studio.
275 #trying just unixy ones, since we're doing cygwin on doze.
276 export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$TARGETS_STORE"
278 export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$TARGETS_STORE"
281 popd &>/dev/null # checking is over, jump back to the starting point.
283 ############################
285 # at this point, all the build related variables should be valid.
287 if [ -z "$INCLUDED_FROM_BOOTSTRAP" \
288 -a -z "$PARM_1" ]; then
289 # we are running as a stand-alone script, so we stay resident with our
290 # current set of variables.
294 # sentinel that tells us this script was pulled in.
295 export BUILD_VARS_LOADED=true
299 fi # outer wrapper for already ran build vars check.
303 # hook clam into the compilation system.
304 # this always needs to be defined since functions aren't exported.
307 /usr/bin/make -I "$CLAM_SCRIPTS" $*