<li><big>Setting environment variables for clam:</big></li>
<small> </small><big> </big><small> </small>
<ol>
- <li><big>FEISTY_MEOW_DIR:</big></li>
+ <li><big>FEISTY_MEOW_APEX:</big></li>
<small> </small><big> </big><small> </small>
<ol>
<small> </small><big> </big><small> </small>
since clam became
part of the YETIcode project (at <a href="http://yeticode.org/">http://yeticode.org</a>).</big></li>
<small> </small>
- <li><big>The default location for clam is under the FEISTY_MEOW_DIR
+ <li><big>The default location for clam is under the FEISTY_MEOW_APEX
in a
folder named clam, although the version of clam shipped with the
HOOPLE
<small> </small><big> </big><small> </small>
<li><big>If the yeti root directory is in $HOME/yeti
already, then the
- default for FEISTY_MEOW_DIR will work and it doesn't need to be
+ default for FEISTY_MEOW_APEX will work and it doesn't need to be
declared.</big></li>
<li><big>Setting the variable:<br>
</big></li>
<ol>
<small> </small><big> </big><small> </small>
<li><big>On Unix (assuming bash as shell): <span style="font-weight: bold;">export
- MAKEFLAGS="-I $FEISTY_MEOW_DIR/clam"</span></big></li>
+ MAKEFLAGS="-I $FEISTY_MEOW_APEX/clam"</span></big></li>
<small> </small><big> </big><small> </small>
<li><big>On win32: <span style="font-weight: bold;">set
- MAKEFLAGS="-I %FEISTY_MEOW_DIR%/clam"</span></big></li>
+ MAKEFLAGS="-I %FEISTY_MEOW_APEX%/clam"</span></big></li>
<small> </small><big> </big><small> </small>
<li><big>This variable also requires forward slashes
instead of
the project's temporary directories will be created based on this
variable.
</big>
- <h4><big>FEISTY_MEOW_DIR</big></h4>
+ <h4><big>FEISTY_MEOW_APEX</big></h4>
<big> Specifies the root directory
for compilation or other building activities. The
repository
<big> This folder is where all generated
files are
to
- be stored. It is usually identical to FEISTY_MEOW_DIR but can be
+ be stored. It is usually identical to FEISTY_MEOW_APEX but can be
overridden
when the targets should be stored elsewhere.<br>
</big>
command
line. For C++ compilation, this is usually an INI file
stored in the
- FEISTY_MEOW_DIR under the build folder.
+ FEISTY_MEOW_APEX under the build folder.
Here is a sample parameter file:
</big>
<blockquote><big><tt><font size="-1"><big>#\</big></font></tt> <br>
these files. If you destroy your life by running one of them, I
will have sympathy, but that's about it.</li>
<li>Some of these shell scripts depend on environment variables.
-The most frequent case of this is FEISTY_MEOW_DIR, which should point to the
+The most frequent case of this is FEISTY_MEOW_APEX, which should point to the
top-level
directory where the Feisty Meow scripts are stored on your
machine. This variable is set by default when the scripts are in
# with spaces.
INPUT = \
- $(FEISTY_MEOW_DIR)/scripts \
- $(FEISTY_MEOW_DIR)/nucleus \
- $(FEISTY_MEOW_DIR)/octopi \
- $(FEISTY_MEOW_DIR)/graphiq \
- $(FEISTY_MEOW_DIR)/kona/src \
+ $(FEISTY_MEOW_APEX)/scripts \
+ $(FEISTY_MEOW_APEX)/nucleus \
+ $(FEISTY_MEOW_APEX)/octopi \
+ $(FEISTY_MEOW_APEX)/graphiq \
+ $(FEISTY_MEOW_APEX)/kona/src \
$(PRODUCTION_DIR)/setup_src
# If the value of the INPUT tag contains directories, you can use the
# Set default locations for the following variables. If the build_variables
# have been sourced in, that takes care of setting these.
-ifeq "$(FEISTY_MEOW_DIR)" ""
- export FEISTY_MEOW_DIR := $(CURRENT_DIR)
+ifeq "$(FEISTY_MEOW_APEX)" ""
+ export FEISTY_MEOW_APEX := $(CURRENT_DIR)
endif
#ifeq "$(PRODUCTION_DIR)" ""
-# export PRODUCTION_DIR = $(FEISTY_MEOW_DIR)/production
+# export PRODUCTION_DIR = $(FEISTY_MEOW_APEX)/production
#endif
ifeq "$(CLAM_DIR)" ""
export CLAM_DIR = $(FEISTY_MEOW_SCRIPTS)/clam
log(time_stamp::notarize(true) + "value_tagger started.", basis::ALWAYS_PRINT);
- astring test_repository = environment::get("FEISTY_MEOW_DIR");
+ astring test_repository = environment::get("FEISTY_MEOW_APEX");
if (!test_repository) {
astring msg = "\
There is a problem with a required build precondition. The following\r\n\
variables must be set before the build is run:\r\n\
\r\n\
- FEISTY_MEOW_DIR This should point at the root of the build tree.\r\n\
+ FEISTY_MEOW_APEX This should point at the root of the build tree.\r\n\
\r\n\
There are also a few variables only required for CLAM-based compilation:\r\n\
\r\n\
- MAKEFLAGS This should be set to \"-I $FEISTY_MEOW_DIR/clam\".\r\n\
+ MAKEFLAGS This should be set to \"-I $FEISTY_MEOW_APEX/clam\".\r\n\
\r\n\
Note that on Win32 platforms, these should be set in the System or User\r\n\
variables before running a build.\r\n";
LOG(astring("Directories to scan..."));
LOG(_dirs.text_form());
- astring rdir = environment::get("FEISTY_MEOW_DIR");
+ astring rdir = environment::get("FEISTY_MEOW_APEX");
astring fname;
astring parmfile = environment::get("BUILD_PARAMETER_FILE");
if (parmfile.t()) fname = parmfile;
byte_filer build_file(fname, "r");
if (!build_file.good()) {
non_continuable_error(class_name(), build_file.name(),
- "Could not find the build configuration; is FEISTY_MEOW_DIR set?");
+ "Could not find the build configuration; is FEISTY_MEOW_APEX set?");
}
byte_array full_config;
build_file.read(full_config, 100000); // a good chance to be big enough.
source_dir_whacks += "Release";
source_dir_whacks += "bin";
source_dir_whacks += "temp_build";
- directory repo_source(environment::get("FEISTY_MEOW_DIR") + "/source");
+ directory repo_source(environment::get("FEISTY_MEOW_APEX") + "/source");
whack_in_subdirs(repo_source, source_file_whacks, source_dir_whacks);
- directory libra_src(environment::get("FEISTY_MEOW_DIR") + "/libraries");
+ directory libra_src(environment::get("FEISTY_MEOW_APEX") + "/libraries");
whack_in_subdirs(libra_src, source_file_whacks, source_dir_whacks);
- directory produ_src(environment::get("FEISTY_MEOW_DIR") + "/products");
+ directory produ_src(environment::get("FEISTY_MEOW_APEX") + "/products");
whack_in_subdirs(produ_src, source_file_whacks, source_dir_whacks);
/* this never helped.
// clean out a variety of bad files in the objects hierarchy.
// currently this is just the generated RES files which we have seen cause
// vsts to think apps and dlls are up to date when they are actually not.
- directory repo_objects(environment::get("FEISTY_MEOW_DIR"));
+ directory repo_objects(environment::get("FEISTY_MEOW_APEX"));
string_array objects_file_whacks;
objects_file_whacks += ".res";
string_array objects_dir_whacks; // none right now.
remove_confusing_files();
- astring repo_dir = environment::get("FEISTY_MEOW_DIR");
+ astring repo_dir = environment::get("FEISTY_MEOW_APEX");
// figure out which build parameter file to use.
global_build_ini = "";
SETUP_CONSOLE_LOGGER; // override the file_logger from app_shell.
// find our build ini file.
- astring repodir = environment::get("FEISTY_MEOW_DIR");
+ astring repodir = environment::get("FEISTY_MEOW_APEX");
// the below code should never be needed for a properly configured build.
#ifdef __WIN32__
# only works when repo dir is at the top of the full builds area.
# we need like a top dir of some sort.
-find $FEISTY_MEOW_DIR -iname "*proj" -exec grep -l OutputPath {} ';' >~/outputpath_mentioners.txt
+find $FEISTY_MEOW_APEX -iname "*proj" -exec grep -l OutputPath {} ';' >~/outputpath_mentioners.txt
DEFINE_API_OUTCOME=1
[directories]
-$FEISTY_MEOW_DIR/nucleus/library/basis
-$FEISTY_MEOW_DIR/octopi/library/sockets
-$FEISTY_MEOW_DIR/octopi/library/cromp
-# $FEISTY_MEOW_DIR/source/lib_src/library/mechanisms
-$FEISTY_MEOW_DIR/nucleus/library/nodes
-$FEISTY_MEOW_DIR/nucleus/library/filesystem
-# $FEISTY_MEOW_DIR/source/lib_src/library/post_office
-$FEISTY_MEOW_DIR/nucleus/library/processes
-# $FEISTY_MEOW_DIR/source/lib_src/library/scheduling
-$FEISTY_MEOW_DIR/nucleus/library
-$FEISTY_MEOW_DIR/octopi/library
-$FEISTY_MEOW_DIR/graphiq/library
-$FEISTY_MEOW_DIR
+$FEISTY_MEOW_APEX/nucleus/library/basis
+$FEISTY_MEOW_APEX/octopi/library/sockets
+$FEISTY_MEOW_APEX/octopi/library/cromp
+# $FEISTY_MEOW_APEX/source/lib_src/library/mechanisms
+$FEISTY_MEOW_APEX/nucleus/library/nodes
+$FEISTY_MEOW_APEX/nucleus/library/filesystem
+# $FEISTY_MEOW_APEX/source/lib_src/library/post_office
+$FEISTY_MEOW_APEX/nucleus/library/processes
+# $FEISTY_MEOW_APEX/source/lib_src/library/scheduling
+$FEISTY_MEOW_APEX/nucleus/library
+$FEISTY_MEOW_APEX/octopi/library
+$FEISTY_MEOW_APEX/graphiq/library
+$FEISTY_MEOW_APEX
[DEFINE_OUTCOME]
first=0
[copy_fortunes_to_tempdir]
source=$UNIX_BIN/cp
-parms="$FEISTY_MEOW_DIR/nucleus/applications/nechung/example.txt" "$SOURCE_TEMP/example.txt"
+parms="$FEISTY_MEOW_APEX/nucleus/applications/nechung/example.txt" "$SOURCE_TEMP/example.txt"
no_pack=true
exec_source=true
; simple file copy to an absolute path.
[wildcard_congelio]
-source=$FEISTY_MEOW_DIR/nucleus/library/test_basis/*
+source=$FEISTY_MEOW_APEX/nucleus/library/test_basis/*
target=$TARGET/muse_files
; wildcards are supported. this will put all the files from that directory
; "test_basis" into the target in a folder called "muse_files".
[wildcard_specific]
-source=$FEISTY_MEOW_DIR/nucleus/library/basis/*.h
+source=$FEISTY_MEOW_APEX/nucleus/library/basis/*.h
target=$TARGET/basis_headers
; this is a more specific wildcard that tests a pattern on the end, rather
; than the "get everything" of a bare asterisk.
[recursing_doodle]
-source=$FEISTY_MEOW_DIR/nucleus
+source=$FEISTY_MEOW_APEX/nucleus
target=$TARGET/srcpack/doodle_src
recurse=1
; this shows a recursive copy of the directory "core" into a new directory
PROJECT = example_bundle
TYPE = hierarchy
FIRST_TARGETS = build_bundle
-CLEANUPS = $(FEISTY_MEOW_DIR)/install/example_bundle$(EXE_END)
+CLEANUPS = $(FEISTY_MEOW_APEX)/install/example_bundle$(EXE_END)
# set the unix bin variable so the bundle finds the apps.
export UNIX_BIN = /bin
keyword=sources
[text_files]
-source=$FEISTY_MEOW_DIR/*.txt
+source=$FEISTY_MEOW_APEX/*.txt
target=$TARGET
keyword=sources
[top_makefile]
-source=$FEISTY_MEOW_DIR/makefile
+source=$FEISTY_MEOW_APEX/makefile
target=$TARGET/makefile
keyword=sources
keyword=sources
[customizing]
-source=$FEISTY_MEOW_DIR/customizing
+source=$FEISTY_MEOW_APEX/customizing
target=$TARGET/customizing
recurse=1
keyword=sources
[database]
-source=$FEISTY_MEOW_DIR/infobase
+source=$FEISTY_MEOW_APEX/infobase
target=$TARGET/infobase
recurse=1
keyword=sources
[docs]
-source=$FEISTY_MEOW_DIR/doc
+source=$FEISTY_MEOW_APEX/doc
target=$TARGET/doc
recurse=1
keyword=sources
[examples]
-source=$FEISTY_MEOW_DIR/examples
+source=$FEISTY_MEOW_APEX/examples
target=$TARGET/examples
recurse=1
keyword=sources
[scripts]
-source=$FEISTY_MEOW_DIR/scripts
+source=$FEISTY_MEOW_APEX/scripts
target=$TARGET/scripts
recurse=1
keyword=sources
[nucleus]
-source=$FEISTY_MEOW_DIR/nucleus
+source=$FEISTY_MEOW_APEX/nucleus
target=$TARGET/nucleus
recurse=1
keyword=sources
[octopi]
-source=$FEISTY_MEOW_DIR/octopi
+source=$FEISTY_MEOW_APEX/octopi
target=$TARGET/octopi
recurse=1
keyword=sources
[graphiq]
-source=$FEISTY_MEOW_DIR/graphiq
+source=$FEISTY_MEOW_APEX/graphiq
target=$TARGET/graphiq
recurse=1
keyword=sources
[huffware]
-source=$FEISTY_MEOW_DIR/huffware
+source=$FEISTY_MEOW_APEX/huffware
target=$TARGET/huffware
recurse=1
keyword=sources
[kona]
-source=$FEISTY_MEOW_DIR/kona
+source=$FEISTY_MEOW_APEX/kona
target=$TARGET/kona
recurse=1
keyword=sources
[webby]
-source=$FEISTY_MEOW_DIR/webby
+source=$FEISTY_MEOW_APEX/webby
target=$TARGET/webby
recurse=1
keyword=sources
# shortcut for the lengthy exclude parameter.
export XC='--exclude='
-parent_dir="$(dirname "$FEISTY_MEOW_DIR")"
-base_dir="$(basename "$FEISTY_MEOW_DIR")"
+parent_dir="$(dirname "$FEISTY_MEOW_APEX")"
+base_dir="$(basename "$FEISTY_MEOW_APEX")"
pushd $parent_dir
#!/bin/bash
-source $FEISTY_MEOW_DIR/bin/seek_all_source.sh
+source $FEISTY_MEOW_APEX/bin/seek_all_source.sh
function strip_file {
file=$1
test_file = ""
if len(self.arguments) > 1:
test_file = self.arguments[1]
- if test_file == "": test_file = os.getenv("FEISTY_MEOW_DIR") + "/nucleus/applications/nechung/nechung.vcxproj"
+ if test_file == "": test_file = os.getenv("FEISTY_MEOW_APEX") + "/nucleus/applications/nechung/nechung.vcxproj"
print("test file is: " + test_file)
guid = self.extract_guid_from_project_file(test_file)
for curr_file in "$instdir"/*.dll; do
base=$(basename "$curr_file")
- if [ -f "$FEISTY_MEOW_DIR/dll/$base" ]; then
- cp -f "$FEISTY_MEOW_DIR/dll/$base" "$curr_file"
+ if [ -f "$FEISTY_MEOW_APEX/dll/$base" ]; then
+ cp -f "$FEISTY_MEOW_APEX/dll/$base" "$curr_file"
if [ $? -ne 0 ]; then
echo "** Error copying $base to $instdir"
exval=1
done
for curr_file in "$instdir"/*.exe; do
base=$(basename "$curr_file")
- if [ -f "$FEISTY_MEOW_DIR/exe/$base" ]; then
- cp -f "$FEISTY_MEOW_DIR/exe/$base" "$curr_file"
+ if [ -f "$FEISTY_MEOW_APEX/exe/$base" ]; then
+ cp -f "$FEISTY_MEOW_APEX/exe/$base" "$curr_file"
if [ $? -ne 0 ]; then
echo "** Error copying $base to $instdir"
exval=1
###############################################################################
#no # set the repository directory if it's still set to the base version.
-#ifeq "$(FEISTY_MEOW_DIR)" ""
+#ifeq "$(FEISTY_MEOW_APEX)" ""
# ifeq "$(OP_SYSTEM)" "UNIX"
-# export FEISTY_MEOW_DIR = $(HOME)/hoople
+# export FEISTY_MEOW_APEX = $(HOME)/hoople
# endif
# ifeq "$(OP_SYSTEM)" "WIN32"
-# export FEISTY_MEOW_DIR = l:
+# export FEISTY_MEOW_APEX = l:
# endif
#endif
# special case when doing arm-linux builds
ifeq "$(COMPILER)" "GNU_ARM_LINUX"
- export TARGETS_DIR = $(FEISTY_MEOW_DIR)/$(CPU_BUILD_DIR)
+ export TARGETS_DIR = $(FEISTY_MEOW_APEX)/$(CPU_BUILD_DIR)
# special output directory for firmware doesn't include CPU name because
# the repository already include the CPU name
BASE_OUTPUT_PATH = $(OUTPUT_ROOT)
ifeq "$(HOOPLE_HEADERS)" ""
#seems like some of this is redundant with earlier 3rdparty exploring.
LOCUS_LIBRARY_HEADERS = $(shell bash -c '\
- if [ -d "$(FEISTY_MEOW_DIR)/nucleus" ]; then \
- echo "$(FEISTY_MEOW_DIR)/nucleus" "$(FEISTY_MEOW_DIR)/octopi" "$(FEISTY_MEOW_DIR)/graphiq" ; \
+ if [ -d "$(FEISTY_MEOW_APEX)/nucleus" ]; then \
+ echo "$(FEISTY_MEOW_APEX)/nucleus" "$(FEISTY_MEOW_APEX)/octopi" "$(FEISTY_MEOW_APEX)/graphiq" ; \
else \
echo ""; \
fi | tr "\\\\" / | sed -e "s/\([a-zA-Z]\):\/\([^ ]*\)/\/cygdrive\/\1\/\2/g" ')
# prepares the project for compilation by creating the appropriate directories.
# make sure the top-level repository exists.
-if [ ! -d $FEISTY_MEOW_DIR ]; then mkdir -p $FEISTY_MEOW_DIR; fi
+if [ ! -d $FEISTY_MEOW_APEX ]; then mkdir -p $FEISTY_MEOW_APEX; fi
# make sure our temp directory is there.
if [ ! -d $CLAM_TMP ]; then mkdir -p $CLAM_TMP; fi
# make sure the generated files have a home.
# define our version of the build parameter file. this should be set
# beforehand so we override the default parameter file for clam.
export PARAMETER_FILE = $(BUILD_PARAMETER_FILE)
-###no: $(FEISTY_MEOW_DIR)/build/identity.ini
+###no: $(FEISTY_MEOW_APEX)/build/identity.ini
endif
ifeq "$(PARAMETER_FILE)" ""
# last ditch attempt to get one that will work.
- export PARAMETER_FILE = $(FEISTY_MEOW_DIR)/build.ini
+ export PARAMETER_FILE = $(FEISTY_MEOW_APEX)/build.ini
endif
###############################################################################
export THIRD_PARTY_DIR
endif
ifeq "$(OP_SYSTEM)" "WIN32"
- export THIRD_PARTY_DIR = $(FEISTY_MEOW_DIR)/3rdparty
+ export THIRD_PARTY_DIR = $(FEISTY_MEOW_APEX)/3rdparty
endif
# "OUTPUT_ROOT" is the root of all output directories for objects and other
#HEADER_SEARCH_PATH =
# "HOOPLE_HEADERS" are locations where the HOOPLE headers can be found.
-HOOPLE_HEADERS := $(shell $(FIND) $(FEISTY_MEOW_DIR)/source/lib_src $(FEISTY_MEOW_DIR)/libraries -mindepth 1 -maxdepth 1 -type d)
+HOOPLE_HEADERS := $(shell $(FIND) $(FEISTY_MEOW_APEX)/source/lib_src $(FEISTY_MEOW_APEX)/libraries -mindepth 1 -maxdepth 1 -type d)
# "LOCAL_HEADERS" are overrides that go first in the header search path.
#LOCAL_HEADERS =
###############################################################################
-# "FEISTY_MEOW_DIR" is the root of the "build" for our compilation oriented
+# "FEISTY_MEOW_APEX" is the root of the "build" for our compilation oriented
# features. All source code and build helper files are usually found there.
# The build targets to be built are usually stored there also, although the
# targets can be located elsewhere if desired. see TARGETS_DIR below.
-export FEISTY_MEOW_DIR
-ifeq "$(FEISTY_MEOW_DIR)" ""
-# FEISTY_MEOW_DIR =
+export FEISTY_MEOW_APEX
+ifeq "$(FEISTY_MEOW_APEX)" ""
+# FEISTY_MEOW_APEX =
#uhhh, use the current location?
#currently we rely on this being set from shell bootstrapping. is that bad?
endif
# be able to find a few things there reliably.
export FEISTY_MEOW_SCRIPTS
ifeq "$(FEISTY_MEOW_SCRIPTS)" ""
- export FEISTY_MEOW_SCRIPTS := $(FEISTY_MEOW_DIR)/scripts
+ export FEISTY_MEOW_SCRIPTS := $(FEISTY_MEOW_APEX)/scripts
endif
# "PRODUCTION_DIR" is where components required for building the code or
#hmmm: is this redundant?
export PRODUCTION_DIR
ifeq "$(PRODUCTION_DIR)" ""
- PRODUCTION_DIR=$(FEISTY_MEOW_DIR)/production
+ PRODUCTION_DIR=$(FEISTY_MEOW_APEX)/production
endif
# "CLAM_DIR" points at where the CLAM source files are located. this is needed
ifeq "$(TARGETS_DIR)" ""
# the default is to generate files into subdirectories that are at the
# top-level of the repository.
- TARGETS_DIR = $(FEISTY_MEOW_DIR)
+ TARGETS_DIR = $(FEISTY_MEOW_APEX)
endif
# "CURRENT_DIR" is the directory where this make was started.
source "$CORE_SCRIPTS_DIR/functions.sh"
#echo originating folder is $ORIGINATING_FOLDER
-export FEISTY_MEOW_DIR="$(/bin/pwd)"
-#echo feisty now is FEISTY_MEOW_DIR=$FEISTY_MEOW_DIR
+export FEISTY_MEOW_APEX="$(/bin/pwd)"
+#echo feisty now is FEISTY_MEOW_APEX=$FEISTY_MEOW_APEX
# repetitive bit stolen from variables. should make a file out of this somehow.
IS_DOS=$(uname | grep -i ming)
if [ -z "$IS_DOS" ]; then IS_DOS=$(uname | grep -i cygwin); fi
# now if we're stuck in DOS, then fix the feisty meow variable name.
if [ ! -z "$IS_DOS" ]; then
- FEISTY_MEOW_DIR="$(cmd /c chdir | tr A-Z a-z | sed -e 's/\\/\//g')"
-echo feisty meow dos is: $FEISTY_MEOW_DIR
- FEISTY_MEOW_DIR="$(dos_to_unix_path "$FEISTY_MEOW_DIR")"
-echo new feisty meow fixed dir is: $FEISTY_MEOW_DIR
+ FEISTY_MEOW_APEX="$(cmd /c chdir | tr A-Z a-z | sed -e 's/\\/\//g')"
+echo feisty meow dos is: $FEISTY_MEOW_APEX
+ FEISTY_MEOW_APEX="$(dos_to_unix_path "$FEISTY_MEOW_APEX")"
+echo new feisty meow fixed dir is: $FEISTY_MEOW_APEX
fi
popd &>/dev/null
-export FEISTY_MEOW_SCRIPTS="$FEISTY_MEOW_DIR/scripts"
+export FEISTY_MEOW_SCRIPTS="$FEISTY_MEOW_APEX/scripts"
# FEISTY_MEOW_LOADING_DOCK is where the generated files feisty_meow uses are located.
export FEISTY_MEOW_LOADING_DOCK="$HOME/.zz_feisty_loading"
fi
# just a variable we use in here to refer to the generated variables file.
-GENERATED_FEISTY_MEOW_VARIABLES="$FEISTY_MEOW_LOADING_DOCK/fmc_variables.sh"
+FEISTY_MEOW_VARIABLES_LOADING_FILE="$FEISTY_MEOW_LOADING_DOCK/fmc_variables.sh"
# create the alias file as totally blank.
-echo -n >"$GENERATED_FEISTY_MEOW_VARIABLES"
-for i in FEISTY_MEOW_DIR FEISTY_MEOW_SCRIPTS FEISTY_MEOW_LOADING_DOCK; do
- echo "export $i=${!i}" >>"$GENERATED_FEISTY_MEOW_VARIABLES"
+echo -n >"$FEISTY_MEOW_VARIABLES_LOADING_FILE"
+for i in FEISTY_MEOW_APEX FEISTY_MEOW_SCRIPTS FEISTY_MEOW_LOADING_DOCK; do
+ echo "export $i=${!i}" >>"$FEISTY_MEOW_VARIABLES_LOADING_FILE"
done
# load our variables so we can run our perl scripts successfully.
if [ ! -z "$SHELL_DEBUG" ]; then
echo established these variables for feisty_meow assets:
echo ==============
- cat "$GENERATED_FEISTY_MEOW_VARIABLES"
+ cat "$FEISTY_MEOW_VARIABLES_LOADING_FILE"
echo ==============
fi
# use our default example user if there was no name provided.
user=fred
fi
- if [ ! -d "$FEISTY_MEOW_DIR/customizing/$user" ]; then
+ if [ ! -d "$FEISTY_MEOW_APEX/customizing/$user" ]; then
echo "The customization folder provided for $user should be:"
- echo " '$FEISTY_MEOW_DIR/customizing/$user'"
+ echo " '$FEISTY_MEOW_APEX/customizing/$user'"
echo "but that folder does not exist. Skipping customization."
return 1
fi
regenerate >/dev/null
pushd "$FEISTY_MEOW_LOADING_DOCK/custom" &>/dev/null
- local incongruous_files="$(bash "$FEISTY_MEOW_SCRIPTS/files/list_non_dupes.sh" "$FEISTY_MEOW_DIR/customizing/$user" "$FEISTY_MEOW_LOADING_DOCK/custom")"
+ local incongruous_files="$(bash "$FEISTY_MEOW_SCRIPTS/files/list_non_dupes.sh" "$FEISTY_MEOW_APEX/customizing/$user" "$FEISTY_MEOW_LOADING_DOCK/custom")"
#echo "the incongruous files list is: $incongruous_files"
# disallow a single character result, since we get "*" as result when nothing exists yet.
popd &>/dev/null
echo "copying custom overrides for $user"
mkdir -p "$FEISTY_MEOW_LOADING_DOCK/custom" 2>/dev/null
- perl "$FEISTY_MEOW_SCRIPTS/text/cpdiff.pl" "$FEISTY_MEOW_DIR/customizing/$user" "$FEISTY_MEOW_LOADING_DOCK/custom"
- if [ -d "$FEISTY_MEOW_DIR/customizing/$user/scripts" ]; then
+ perl "$FEISTY_MEOW_SCRIPTS/text/cpdiff.pl" "$FEISTY_MEOW_APEX/customizing/$user" "$FEISTY_MEOW_LOADING_DOCK/custom"
+ if [ -d "$FEISTY_MEOW_APEX/customizing/$user/scripts" ]; then
echo "copying custom scripts for $user"
- \cp -R "$FEISTY_MEOW_DIR/customizing/$user/scripts" "$FEISTY_MEOW_LOADING_DOCK/custom/"
+ \cp -R "$FEISTY_MEOW_APEX/customizing/$user/scripts" "$FEISTY_MEOW_LOADING_DOCK/custom/"
fi
echo
regenerate
require "filename_helper.pl";
-use Env qw(BINDIR BUILD_TOP FEISTY_MEOW_DIR FEISTY_MEOW_LOADING_DOCK FEISTY_MEOW_SCRIPTS SHELL_DEBUG );
+use Env qw(BINDIR BUILD_TOP FEISTY_MEOW_APEX FEISTY_MEOW_LOADING_DOCK FEISTY_MEOW_SCRIPTS SHELL_DEBUG );
# given a possible aliasable filename, this will decide whether to create a perl
# or bash alias for it. it needs the filename of the possible alias and the
$FEISTY_MEOW_LOADING_DOCK =~ s/\\/\//g;
$FEISTY_MEOW_SCRIPTS =~ s/\\/\//g;
-$FEISTY_MEOW_DIR =~ s/\\/\//g;
+$FEISTY_MEOW_APEX =~ s/\\/\//g;
# create our generated shells directory if it's not already there.
if (! -d $FEISTY_MEOW_LOADING_DOCK) {
#hmmm: the above is kind of a constant. that's not so great.
# make sure our main variables are established.
- GENERATED_FEISTY_MEOW_VARIABLES="$FEISTY_MEOW_LOADING_DOCK/fmc_variables.sh"
- if [ ! -f "$GENERATED_FEISTY_MEOW_VARIABLES" ]; then
+ FEISTY_MEOW_VARIABLES_LOADING_FILE="$FEISTY_MEOW_LOADING_DOCK/fmc_variables.sh"
+ if [ ! -f "$FEISTY_MEOW_VARIABLES_LOADING_FILE" ]; then
echo -e '\n\n'
echo "Feisty meow scripts need initialization via the bootstrap process, e.g.:"
echo " bash $HOME/feisty_meow/scripts/core/bootstrap_shells.sh"
# pull in our generated variables that are the minimal set we need to find
# the rest of our resources.
- source "$GENERATED_FEISTY_MEOW_VARIABLES"
+ source "$FEISTY_MEOW_VARIABLES_LOADING_FILE"
# Set up the temporary directory.
source $FEISTY_MEOW_SCRIPTS/core/create_tempdir.sh
# set the main root directory variable for the feisty meow codebase.
# this is only used for extreme failure modes, when the values were not
# pulled in from our auto-generated config.
- if [ -z "$FEISTY_MEOW_DIR" ]; then
+ if [ -z "$FEISTY_MEOW_APEX" ]; then
if [ -d "$HOME/feisty_meow" ]; then
- define_yeti_variable FEISTY_MEOW_DIR="$HOME/feisty_meow"
+ define_yeti_variable FEISTY_MEOW_APEX="$HOME/feisty_meow"
define_yeti_variable FEISTY_MEOW_SCRIPTS="$FEISTY_MEOW_SCRIPTS"
fi
fi
+ # main declaration of the transients area.
+ if [ -z "$TMP" ]; then
+ define_yeti_variable TMP=$HOME/.tmp
+ fi
+
# set up the top-level for all build creations and logs and such.
if [ -z "$GENERATED_DIR" ]; then
define_yeti_variable GENERATED_DIR="$TMP/generated-feisty_meow"
##############
# set this so nechung can find its data.
- define_yeti_variable NECHUNG=$FEISTY_MEOW_DIR/infobase/fortunes.dat
+ define_yeti_variable NECHUNG=$FEISTY_MEOW_APEX/infobase/fortunes.dat
# ensure we use the right kind of secure shell.
# define_yeti_variable CVS_RSH=$FEISTY_MEOW_SCRIPTS/security/ssh.sh
{
found_build_vars=0
# we need to know the feisty meow directory, or we bail.
- if [ -z "$FEISTY_MEOW_DIR" ]; then return; fi
+ if [ -z "$FEISTY_MEOW_APEX" ]; then return; fi
# pick from our expected generator folder, but make sure it's there...
buildvars="$FEISTY_MEOW_SCRIPTS/generator/build_variables.sh"
if [ -f "$buildvars" ]; then
# translate to dos format if there's a cygdrive in there; otherwise microsoft's tools
# will hose up completely due to unknown paths.
-export FEISTY_MEOW_DIR="$(unix_to_dos_path $FEISTY_MEOW_DIR)"
+export FEISTY_MEOW_APEX="$(unix_to_dos_path $FEISTY_MEOW_APEX)"
# load in build variables based on our deduced paths.
source "$BUILD_SCRIPTS_DIR/build_variables.sh" "$BUILD_SCRIPTS_DIR/build_variables.sh"
mkdir -p "$LOGS_DIR"
echo Now starting a normal build of the repository source code.
- pushd "$FEISTY_MEOW_DIR" &>/dev/null
+ pushd "$FEISTY_MEOW_APEX" &>/dev/null
unset BUILD_DEFAULTS
declare -a BUILD_DEFAULTS=( "BOOT_STRAPPING=" "OPTIMIZE=t" "DEBUG=t" "REBUILD=t" )
make_code
fi
if [ ! -z "$SHELL_DEBUG" ]; then
- echo "[FEISTY_MEOW_DIR is $FEISTY_MEOW_DIR]"
+ echo "[FEISTY_MEOW_APEX is $FEISTY_MEOW_APEX]"
fi
#if [ "$OPERATING_SYSTEM" == "WIN32" ]; then
# new BUILD_TOP variable points at the utter top-most level of any files
# in the building hierarchy.
-export BUILD_TOP="$FEISTY_MEOW_DIR"
+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.
echo scripts: $BUILD_SCRIPTS_DIR
echo build tools hier: $BUILDING_HIERARCHY
echo this tool: $THIS_TOOL_NAME
- echo repository: $FEISTY_MEOW_DIR
+ echo repository: $FEISTY_MEOW_APEX
echo clam: $CLAM_DIR
fi
# 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"
+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."
fi
if [ -z "$PARAMETER_FILE" ]; then
# last ditch attempt to get one that will work.
- PARAMETER_FILE="$FEISTY_MEOW_DIR/build.ini"
+ PARAMETER_FILE="$FEISTY_MEOW_APEX/build.ini"
fi
chmod u+w "$PARAMETER_FILE"
exit 3
fi
-#old export NEW_TMP="$(mktemp -d "$CLEANING_LOCALE/TEMPS.XXXXXX")"
export CRUDFILE="$(mktemp "$TMP/zz_whack_build.XXXXXX")"
echo "" &>"$CRUDFILE"
-# CLEANING_TOP="$CLEANING_LOCALE/production"
-
# echo $(date): " cleaning up the build products..."
# avoid accidentally removing important stuff if our variables have not been previously
# kerzap. the cleanups in production directory remove older locations of generated files.
rm -rf \
- "$FEISTY_MEOW_DIR/generatedJUnitFiles" \
+ "$GENERATED_DIR/clam_bin" \
+ "$GENERATED_DIR/binaries" \
+ "$GENERATED_DIR/install" \
+ "$GENERATED_DIR/logs" \
+ "$GENERATED_DIR/waste" \
+ "$FEISTY_MEOW_APEX/generatedJUnitFiles" \
"$TEMPORARIES_DIR" \
- "$GENERATED_DIR" \
- "$CLEANING_TOP/__build_"*.h \
- "$CLEANING_TOP/manifest.txt" \
+ "$PRODUCTION_DIR/__build_"*.h \
+ "$PRODUCTION_DIR/manifest.txt" \
"$PRODUCTION_DIR/clam_bin" \
"$PRODUCTION_DIR/binaries" \
"$PRODUCTION_DIR/install" \
if [ "$clean_src" == "clean" -o "$clean_src" == "CLEAN" ]; then
echo $(date): " ** aggressive cleaning activated..."
- perl "$FEISTY_MEOW_SCRIPTS/files/zapdirs.pl" "$FEISTY_MEOW_DIR" >>"$CRUDFILE"
+ perl "$FEISTY_MEOW_SCRIPTS/files/zapdirs.pl" "$FEISTY_MEOW_APEX" >>"$CRUDFILE"
fi
echo $(date): "cleaned [$choprepo]."
# clean all known hierarchies of build products...
-whack_single_build_area "$FEISTY_MEOW_DIR"
+whack_single_build_area "$FEISTY_MEOW_APEX"
TARGETS += regenerate
OTHER_CLEANS += clean_generated
# override setting from clam.
-export FEISTY_MEOW_SCRIPTS = $(FEISTY_MEOW_DIR)/scripts
+export FEISTY_MEOW_SCRIPTS = $(FEISTY_MEOW_APEX)/scripts
include rules.def
# tunnels to the khandroma machine for vnc access to the win7 box and for the jenkins
# server.
-soundfile=$FEISTY_MEOW_DIR/infobase/sounds/my_mind_is_going.wav
+soundfile=$FEISTY_MEOW_APEX/infobase/sounds/my_mind_is_going.wav
if [ ! -z "$1" ]; then
soundfile=$1
fi
#hmmm: these variables should be configurable from plug-ins someday.
-TUNNEL_ALERT_SOUND=$FEISTY_MEOW_DIR/infobase/sounds/woouoo.wav
+TUNNEL_ALERT_SOUND=$FEISTY_MEOW_APEX/infobase/sounds/woouoo.wav
if [ ! -z "$1" ]; then
TUNNEL_ALERT_SOUND=$1
fi
#ssh_host=khandroma.cs.virginia.edu
ssh_host=mason.cs.virginia.edu
-soundfile=$FEISTY_MEOW_DIR/infobase/sounds/woouoo.wav
+soundfile=$FEISTY_MEOW_APEX/infobase/sounds/woouoo.wav
if [ ! -z "$1" ]; then
soundfile=$1
fi
require "filename_helper.pl";
-use Env qw(FEISTY_MEOW_DIR);
+use Env qw(FEISTY_MEOW_APEX);
use Text::Diff;
This program needs one directory name to be passed on the command line.
This directory is where the installation's executable files live. Any files
that are in the installation bin directory will be compared against the files
-in the build repository (specified by an environment variable FEISTY_MEOW_DIR).
+in the build repository (specified by an environment variable FEISTY_MEOW_APEX).
If files differ, they will be copied from the repository into the installation
directory.
";
}
# print "install=$install_directory\n";
-# print "repos=$FEISTY_MEOW_DIR\n";
+# print "repos=$FEISTY_MEOW_APEX\n";
# iterate over all the files in the source directory.
opendir CURDIR, $install_directory
|| die("couldn't open $install_directory for reading.\n");
- $compare_directory = "$FEISTY_MEOW_DIR/dll";
+ $compare_directory = "$FEISTY_MEOW_APEX/dll";
foreach $filename (readdir CURDIR) {
if ( ($filename eq ".") || ($filename eq "..") ) { next; }
if (! ($filename =~ /\.dll$/)) { next; }
# repeat for the exe directory.
opendir CURDIR, $install_directory
|| die("couldn't open $install_directory for reading.\n");
- $compare_directory = "$FEISTY_MEOW_DIR/exe";
+ $compare_directory = "$FEISTY_MEOW_APEX/exe";
foreach $filename (readdir CURDIR) {
if ( ($filename eq ".") || ($filename eq "..") ) { next; }
if (! ($filename =~ /\.exe$/)) { next; }
-for i in $FEISTY_MEOW_DIR/binaries/*.exe ; do dumpbin //headers $i | grep -i 8664 ; done
+for i in $FEISTY_MEOW_APEX/binaries/*.exe ; do dumpbin //headers $i | grep -i 8664 ; done
projects / feisty_meow.git / commitdiff