1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
|
# Auxiliary functions for build.sh
# Copyright (c) 2002 Serge van den Boom
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
DEPEND_NAME=make.depend
# Show usage information
usage() {
echo "Main build script"
echo
echo "Syntax:"
echo " ./build.sh [-j[#JOBS]] <target>"
echo " ./build.sh <target> config"
echo " ./build.sh <target> depend"
echo " ./build.sh <target> clean"
echo " ./build.sh [-j[#JOBS]] <target> install"
echo " ./build.sh cleanall"
echo " ./build.sh distclean"
echo
echo "Valid targets:"
for TARGET in $TARGETS; do
echo " $TARGET"
done
echo
}
escape_string() {
$SED -e s,[\\\'\"\`\ \ \$\&\\\*\\\?\#\!],\\\\\&,g << EOF
$1
EOF
}
# Start the configure program.
# $1 = target
build_config() {
set_system
prepare_build_system
config_requirements
prepare_host_system
if [ "$BUILD_SYSTEM" '!=' "$HOST_SYSTEM" ]; then
build_message "Cross-compiling to $HOST_SYSTEM."
fi
eval "${TARGET}_requirements"
eval "${TARGET}_prepare_config"
eval "${TARGET}_load_config"
eval "${TARGET}_do_config"
eval "${TARGET}_save_config"
}
build_reconfig() {
if [ ! -e "$BUILD_WORK/config.state" ]; then
echo "*** Warning: file 'config.state' not found - using defaults."
fi
prepare_build_system
config_requirements
prepare_host_system
if [ "$BUILD_SYSTEM" '!=' "$HOST_SYSTEM" ]; then
build_message "Cross-compiling to $HOST_SYSTEM."
fi
eval "${TARGET}_requirements"
eval "${TARGET}_prepare_config"
eval "${TARGET}_load_config"
build_process_config
echo "Reconfiguring complete..." >&2
}
# Process the configuration information
build_process_config() {
eval "${TARGET}_process_config"
}
# Recursively build dependency index
build_depend() {
local DEPEND_FILE EXTRA_OFILES
echo "Building file dependency index..." >&2
eval mkdir -p "\$BUILD_WORK/\${${BUILD_PROJECT}_OBJS}"
eval DEPEND_FILE="\$BUILD_WORK/\${${BUILD_PROJECT}_OBJS}\$DEPEND_NAME"
# Remove the old dependency file, if it exists.
# The .tmp file is used to detect interrupted dependency builds.
rm -f -- "$DEPEND_FILE".tmp "$DEPEND_FILE"
BUILD_ROOT=./ $SH ./build/unix/build_collect > "$DEPEND_FILE".tmp
mv -f -- "$DEPEND_FILE".tmp "$DEPEND_FILE"
}
# Compile the lot.
# With the depend info set up, we can leave everything to make.
# $1 - additional arguments to pass to make (at the moment just
# an optional -j arg for parallel builds).
build_compile() {
local CFLAGS CXXFLAGS LDFLAGS TARGET_FILE DEPEND_FILE OBJDIR
eval CFLAGS="\${${BUILD_PROJECT}_CFLAGS}"
eval CXXFLAGS="\${${BUILD_PROJECT}_CXXFLAGS}"
eval LDFLAGS="\${${BUILD_PROJECT}_LDFLAGS}"
eval OBJDIR=\""\$BUILD_WORK/\${${BUILD_PROJECT}_OBJS}"\"
eval TARGET_FILE=\""\$BUILD_WORK/\${${BUILD_PROJECT}_NAME}"\"
DEPEND_FILE=$OBJDIR$DEPEND_NAME
eval "${TARGET}_pre_build"
CFLAGS=$CFLAGS CXXFLAGS=$CXXFLAGS LDFLAGS=$LDFLAGS \
OBJDIR=$OBJDIR \
BUILD_ROOT= \
TARGET_FILE=$TARGET_FILE DEPEND_FILE=$DEPEND_FILE \
SED=$SED \
$MAKE $1 -f Makefile.build "$TARGET_FILE"
eval "${TARGET}_post_build"
}
build_clean() {
local DEPEND_FILE
BUILD_ROOT=./ $SH ./build/unix/build_clean
eval DEPEND_FILE="\$BUILD_WORK/\${${BUILD_PROJECT}_OBJS}${DEPEND_NAME}"
rm -f "$DEPEND_FILE" "$BUILD_WORK/build.vars" \
"$BUILD_WORK/uqm-wrapper" \
"$BUILD_WORK/config.state"
eval "${TARGET}_clean"
}
build_cleanall() {
export BUILD_PROJECT
for TARGET in $TARGETS; do
BUILD_PROJECT="$TARGET"
build_clean
done
BUILD_PROJECT=""
}
build_distclean() {
build_cleanall
}
# Description: check if the config files are present and load them.
# If they're not present, remake them.
build_check_config() {
if [ ! -e "$BUILD_WORK/build.vars" ]; then
build_config || exit $?
build_process_config
fi
. "$BUILD_WORK/build.vars"
. "${BUILD_REC_PATH:=./}Makeproject"
}
# Description: check if the necessary depend file is present,
# if not, build it.
build_check_dependencies() {
eval DEPEND_FILE="\$BUILD_WORK/\${${BUILD_PROJECT}_OBJS}${DEPEND_NAME}"
[ ! -e "$DEPEND_FILE" -o -n "$BUILD_RUN_DEPEND" ] || return
build_depend || exit $?
}
# Description: check if the program is compiled, and otherwise compile
# $1 - additional arguments to pass to make (at the moment just
# an optional -j arg for parallel builds).
build_check_compile() {
local NAME
eval NAME="\${${BUILD_PROJECT}_NAME}"
[ ! -e "$NAME" ] || return
build_compile "$1" || exit $?
}
# Make a directory path, with mode and owner specified.
# $1 - name of directory path
# $2 - mode of the directories (may be empty)
# $3 - owner of the directories (may be empty)
mkdirhier() {
local REST DIR MODE OWNER
REST="$1"
MODE="$2"
OWNER="$3"
case "$REST" in
/*)
REST="${REST%/}"
DIR="/"
;;
*)
DIR=""
;;
esac
case "$REST" in
*/)
;;
*)
REST="${REST}/"
;;
esac
while [ -n "$REST" ]; do
DIR="$DIR${REST%%/*}"
REST="${REST#*/}"
if [ ! -d "$DIR" ]; then
mkdir "$DIR"
[ -n "$MODE" ] && chmod "$MODE" "$DIR"
[ -n "$OWNER" ] && chown "$OWNER" "$DIR"
fi
DIR="${DIR}/"
done
}
# Install a file or directory
# $1 - Source file/directory
# $2 - Destination directory/file
# $3 - Mode of destination file/directory
# $4 - Owner of destination file/directory
installsome() {
local SRC DEST MODE OWNDER DESTDIR SRCNAME
SRC="$1"
DEST="$2"
MODE="$3"
OWNDER="$4"
DESTDIR="${DEST%/*}"
if [ ! -d "$DESTDIR" ]; then
mkdirhier "$DESTDIR" 0755
fi
SRCNAME="${SRC##*/}"
cp -pr -- "$SRC" "$DEST"
if [ -n "$MODE" ]; then
if [ -d "$DEST" ]; then
chmod -R "$MODE" "${DEST}${SRCNAME}"
else
chmod "$MODE" "$DEST"
fi
fi
if [ -n "$OWNER" ]; then
if [ -d "$DEST" ]; then
chown -R "$OWNER" "${DEST}${SRCNAME}"
else
chown "$OWNER" "$DEST"
fi
fi
}
# Install the program
build_install() {
eval "${TARGET}_install"
}
# Generic installation routine
generic_install() {
local SRC DEST MODE OWNER
eval "${TARGET}_pre_install"
local LIB LIBS LIBDIR
echo "Installing system-dependent data..." >&2
eval LIBS="\${${BUILD_PROJECT}_INSTALL_LIBS}"
eval LIBDIR="\${${BUILD_PROJECT}_INSTALL_LIBDIR%/}/"
mkdirhier "$LIBDIR" 0755
for LIB in $LIBS; do
eval SRC="\${${BUILD_PROJECT}_INSTALL_LIB_${LIB}_SRC%/}"
eval DEST="\$LIBDIR\${${BUILD_PROJECT}_INSTALL_LIB_${LIB}_DEST}"
eval MODE="\${${BUILD_PROJECT}_INSTALL_LIB_${LIB}_MODE}"
eval OWNER="\${${BUILD_PROJECT}_INSTALL_LIB_${LIB}_OWNER}"
installsome "$SRC" "$DEST" "$MODE" "$OWNER"
done
local SHARE SHARED SHAREDIR
echo "Installing system-independent data..." >&2
eval SHARED="\${${BUILD_PROJECT}_INSTALL_SHARED}"
eval SHAREDIR="\${${BUILD_PROJECT}_INSTALL_SHAREDIR%/}/"
mkdirhier "$SHAREDIR" 0755
for SHARE in $SHARED; do
eval SRC="\${${BUILD_PROJECT}_INSTALL_SHARED_${SHARE}_SRC%/}"
eval DEST="\$SHAREDIR\${${BUILD_PROJECT}_INSTALL_SHARED_${SHARE}_DEST}"
eval MODE="\${${BUILD_PROJECT}_INSTALL_SHARED_${SHARE}_MODE}"
eval OWNER="\${${BUILD_PROJECT}_INSTALL_SHARED_${SHARE}_OWNER}"
installsome "$SRC" "$DEST" "$MODE" "$OWNER"
done
local BINS BINDIR
echo "Installing binaries..." >&2
eval BINS="\${${BUILD_PROJECT}_INSTALL_BINS}"
eval BINDIR="\${${BUILD_PROJECT}_INSTALL_BINDIR%/}/"
mkdirhier "$BINDIR" 0755
for BIN in $BINS; do
eval SRC="\${${BUILD_PROJECT}_INSTALL_BIN_${BIN}_SRC%/}"
eval DEST="\$BINDIR\${${BUILD_PROJECT}_INSTALL_BIN_${BIN}_DEST}"
eval MODE="\${${BUILD_PROJECT}_INSTALL_BIN_${BIN}_MODE}"
eval OWNER="\${${BUILD_PROJECT}_INSTALL_BIN_${BIN}_OWNER}"
installsome "$SRC" "$DEST" "$MODE" "$OWNER"
done
eval "${TARGET}_post_install"
}
|