kBuild/env.sh

   1 #!/bin/sh
   2 # $Id$
   3 ## @file
   4 # Environment setup script.
   5 #
   6
   7 #
   8 # Copyright (c) 2005-2008 knut st. osmundsen <bird-kBuild-spam@anduin.net>
   9 #
  10 # This file is part of kBuild.
  11 #
  12 # kBuild is free software; you can redistribute it and/or modify
  13 # it under the terms of the GNU General Public License as published by
  14 # the Free Software Foundation; either version 2 of the License, or
  15 # (at your option) any later version.
  16 #
  17 # kBuild is distributed in the hope that it will be useful,
  18 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 # GNU General Public License for more details.
  21 #
  22 # You should have received a copy of the GNU General Public License
  23 # along with kBuild; if not, write to the Free Software
  24 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  25 #
  26 #
  27 #set -x
  28
  29 #
  30 # Check if we're in eval mode or not.
  31 #
  32 ERR_REDIR=1
  33 DBG_REDIR=1
  34 EVAL_OPT=
  35 EVAL_EXPORT="export "
  36 DBG_OPT=
  37 QUIET_OPT=
  38 FULL_OPT=
  39 LEGACY_OPT=
  40 VAR_OPT=
  41 VALUE_ONLY_OPT=
  42 EXP_TYPE_OPT=
  43 while test $# -gt 0;
  44 do
  45     case "$1" in
  46         "--debug-script")
  47             DBG_OPT="true"
  48             ;;
  49         "--no-debug-script")
  50             DBG_OPT=
  51             ;;
  52         "--quiet")
  53             QUIET_OPT="true"
  54             ;;
  55         "--verbose")
  56             QUIET_OPT=
  57             ;;
  58         "--full")
  59             FULL_OPT="true"
  60             ;;
  61         "--normal")
  62             FULL_OPT=
  63             ;;
  64         "--legacy")
  65             LEGACY_OPT="true"
  66             ;;
  67         "--no-legacy")
  68             LEGACY_OPT=
  69             ;;
  70         "--eval")
  71             EVAL_OPT="true"
  72             ERR_REDIR=2
  73             DBG_REDIR=2
  74             ;;
  75         "--set")
  76             EVAL_OPT="true"
  77             EVAL_EXPORT=""
  78             ERR_REDIR=2
  79             DBG_REDIR=2
  80             ;;
  81         "--var")
  82             shift
  83             VAR_OPT="${VAR_OPT} $1"
  84             ERR_REDIR=2
  85             DBG_REDIR=2
  86             ;;
  87         "--value-only")
  88             VALUE_ONLY_OPT="true"
  89             ;;
  90         "--name-and-value")
  91             VALUE_ONLY_OPT=
  92             ;;
  93         "--release")
  94             EXP_TYPE_OPT=1
  95             KBUILD_TYPE=release
  96             BUILD_TYPE=
  97             ;;
  98         "--debug")
  99             EXP_TYPE_OPT=1
 100             KBUILD_TYPE=debug
 101             BUILD_TYPE=
 102             ;;
 103         "--profile")
 104             EXP_TYPE_OPT=1
 105             KBUILD_TYPE=profile
 106             BUILD_TYPE=
 107             ;;
 108
 109         "--help")
 110             echo "kBuild Environment Setup Script, v0.1.3"
 111             echo ""
 112             echo "syntax: $0 [options] [command [args]]"
 113             echo "    or: $0 [options] --var <varname>"
 114             echo "    or: $0 [options] --eval"
 115             echo "    or: $0 [options] --eval --var <varname>"
 116             echo ""
 117             echo "The first form will execute the command, or if no command is given start"
 118             echo "an interactive shell."
 119             echo "The second form will print the specfified variable(s)."
 120             echo "The third form will print all exported variables suitable for bourne shell"
 121             echo "evalutation."
 122             echo "The forth form will only print the specified variable(s)."
 123             echo ""
 124             echo "Options:"
 125             echo "  --debug, --release, --profile"
 126             echo "      Alternative way of specifying KBUILD_TYPE."
 127             echo "  --debug-script, --no-debug-script"
 128             echo "      Controls debug output. Default: --no-debug-script"
 129             echo "  --quiet, --verbose"
 130             echo "      Controls informational output. Default: --verbose"
 131             echo "  --full, --normal"
 132             echo "      Controls the variable set. Default: --normal"
 133             echo "  --legacy, --no-legacy"
 134             echo "      Include legacy variables in result. Default: --no-legacy"
 135             echo "  --value-only, --name-and-value"
 136             echo "      Controls what the result of a --var query. Default: --name-and-value"
 137             echo "  --set, --export"
 138             echo "      Whether --eval explicitly export the variables. --set is useful for"
 139             echo "      getting a list of environment vars for a commandline, while --eval"
 140             echo "      is useful for eval `env.sh`. Default: --export"
 141             echo ""
 142             exit 1
 143             ;;
 144         *)
 145             break
 146             ;;
 147     esac
 148     shift
 149 done
 150
 151
 152 #
 153 # Deal with legacy environment variables.
 154 #
 155 if test -n "$PATH_KBUILD"; then
 156     if test -n "$KBUILD_PATH"  -a  "$KBUILD_PATH" != "$PATH_KBUILD"; then
 157         echo "$0: error: KBUILD_PATH ($KBUILD_PATH) and PATH_KBUILD ($PATH_KBUILD) disagree." 1>&${ERR_REDIR}
 158         sleep 1
 159         exit 1
 160     fi
 161     KBUILD_PATH=$PATH_KBUILD
 162 fi
 163 if test -n "$PATH_KBUILD_BIN"; then
 164     if test -n "$KBUILD_BIN_PATH"  -a  "$KBUILD_BIN_PATH" != "$PATH_KBUILD_BIN"; then
 165         echo "$0: error: KBUILD_BIN_PATH ($KBUILD_BIN_PATH) and PATH_KBUILD_BIN ($PATH_KBUILD_BIN) disagree." 1>&${ERR_REDIR}
 166         sleep 1
 167         exit 1
 168     fi
 169     KBUILD_BIN_PATH=$PATH_KBUILD_BIN
 170 fi
 171
 172 if test -n "$BUILD_TYPE"; then
 173     if test -n "$KBUILD_TYPE"  -a  "$KBUILD_TYPE" != "$BUILD_TYPE"; then
 174         echo "$0: error: KBUILD_TYPE ($KBUILD_TYPE) and BUILD_TYPE ($BUILD_TYPE) disagree." 1>&${ERR_REDIR}
 175         sleep 1
 176         exit 1
 177     fi
 178     KBUILD_TYPE=$BUILD_TYPE
 179 fi
 180
 181 if test -n "$BUILD_PLATFORM"; then
 182     if test -n "$KBUILD_HOST"  -a  "$KBUILD_HOST" != "$BUILD_PLATFORM"; then
 183         echo "$0: error: KBUILD_HOST ($KBUILD_HOST) and BUILD_PLATFORM ($BUILD_PLATFORM) disagree." 1>&${ERR_REDIR}
 184         sleep 1
 185         exit 1
 186     fi
 187     KBUILD_HOST=$BUILD_PLATFORM
 188 fi
 189 if test -n "$BUILD_PLATFORM_ARCH"; then
 190     if test -n "$KBUILD_HOST_ARCH"  -a  "$KBUILD_HOST_ARCH" != "$BUILD_PLATFORM_ARCH"; then
 191         echo "$0: error: KBUILD_HOST_ARCH ($KBUILD_HOST_ARCH) and BUILD_PLATFORM_ARCH ($BUILD_PLATFORM_ARCH) disagree." 1>&${ERR_REDIR}
 192         sleep 1
 193         exit 1
 194     fi
 195     KBUILD_HOST_ARCH=$BUILD_PLATFORM_ARCH
 196 fi
 197 if test -n "$BUILD_PLATFORM_CPU"; then
 198     if test -n "$KBUILD_HOST_CPU"  -a  "$KBUILD_HOST_CPU" != "$BUILD_PLATFORM_CPU"; then
 199         echo "$0: error: KBUILD_HOST_CPU ($KBUILD_HOST_CPU) and BUILD_PLATFORM_CPU ($BUILD_PLATFORM_CPU) disagree." 1>&${ERR_REDIR}
 200         sleep 1
 201         exit 1
 202     fi
 203     KBUILD_HOST_CPU=$BUILD_PLATFORM_CPU
 204 fi
 205
 206 if test -n "$BUILD_TARGET"; then
 207     if test -n "$KBUILD_TARGET"  -a  "$KBUILD_TARGET" != "$BUILD_TARGET"; then
 208         echo "$0: error: KBUILD_TARGET ($KBUILD_TARGET) and BUILD_TARGET ($BUILD_TARGET) disagree." 1>&${ERR_REDIR}
 209         sleep 1
 210         exit 1
 211     fi
 212     KBUILD_TARGET=$BUILD_TARGET
 213 fi
 214 if test -n "$BUILD_TARGET_ARCH"; then
 215     if test -n "$KBUILD_TARGET_ARCH"  -a  "$KBUILD_TARGET_ARCH" != "$BUILD_TARGET_ARCH"; then
 216         echo "$0: error: KBUILD_TARGET_ARCH ($KBUILD_TARGET_ARCH) and BUILD_TARGET_ARCH ($BUILD_TARGET_ARCH) disagree." 1>&${ERR_REDIR}
 217         sleep 1
 218         exit 1
 219     fi
 220     KBUILD_TARGET_ARCH=$BUILD_TARGET_ARCH
 221 fi
 222 if test -n "$BUILD_TARGET_CPU"; then
 223     if test -n "$KBUILD_TARGET_CPU"  -a  "$KBUILD_TARGET_CPU" != "$BUILD_TARGET_CPU"; then
 224         echo "$0: error: KBUILD_TARGET_CPU ($KBUILD_TARGET_CPU) and BUILD_TARGET_CPU ($BUILD_TARGET_CPU) disagree." 1>&${ERR_REDIR}
 225         sleep 1
 226         exit 1
 227     fi
 228     KBUILD_TARGET_CPU=$BUILD_TARGET_CPU
 229 fi
 230
 231
 232 #
 233 # Set default build type.
 234 #
 235 if test -z "$KBUILD_TYPE"; then
 236     KBUILD_TYPE=release
 237 fi
 238 test -n "$DBG_OPT" && echo "dbg: KBUILD_TYPE=$KBUILD_TYPE" 1>&${DBG_REDIR}
 239
 240 #
 241 # Determin the host platform.
 242 #
 243 # The CPU isn't important, only the other two are.  But, since the cpu,
 244 # arch and platform (and build type) share a common key space, try make
 245 # sure any new additions are unique. (See header.kmk, KBUILD_OSES/ARCHES.)
 246 #
 247 if test -z "$KBUILD_HOST"; then
 248     KBUILD_HOST=`uname`
 249     case "$KBUILD_HOST" in
 250         Darwin|darwin)
 251             KBUILD_HOST=darwin
 252             ;;
 253
 254         DragonFly)
 255             KBUILD_HOST=dragonfly
 256             ;;
 257
 258         freebsd|FreeBSD|FREEBSD)
 259             KBUILD_HOST=freebsd
 260             ;;
 261
 262         linux|Linux|GNU/Linux|LINUX)
 263             KBUILD_HOST=linux
 264             ;;
 265
 266         netbsd|NetBSD|NETBSD)
 267             KBUILD_HOST=netbsd
 268             ;;
 269
 270         openbsd|OpenBSD|OPENBSD)
 271             KBUILD_HOST=openbsd
 272             ;;
 273
 274         os2|OS/2|OS2)
 275             KBUILD_HOST=os2
 276             ;;
 277
 278         SunOS)
 279             KBUILD_HOST=solaris
 280             ;;
 281
 282         WindowsNT|CYGWIN_NT-*)
 283             KBUILD_HOST=win
 284             ;;
 285
 286         *)
 287             echo "$0: unknown os $KBUILD_HOST" 1>&${ERR_REDIR}
 288             sleep 1
 289             exit 1
 290             ;;
 291     esac
 292 fi
 293 test -n "$DBG_OPT" && echo "dbg: KBUILD_HOST=$KBUILD_HOST" 1>&${DBG_REDIR}
 294
 295 if test -z "$KBUILD_HOST_ARCH"; then
 296     # Try deduce it from the cpu if given.
 297     if test -n "$KBUILD_HOST_CPU"; then
 298         case "$KBUILD_HOST_CPU" in
 299             i[3456789]86)
 300                 KBUILD_HOST_ARCH='x86'
 301                 ;;
 302             k8|k8l|k9|k10)
 303                 KBUILD_HOST_ARCH='amd64'
 304                 ;;
 305         esac
 306     fi
 307 fi
 308 if test -z "$KBUILD_HOST_ARCH"; then
 309     # Use uname -m or isainfo (lots of guesses here, please help clean this up...)
 310     if test "$KBUILD_HOST" = "solaris"; then
 311         KBUILD_HOST_ARCH=`isainfo | cut -f 1 -d ' '`
 312
 313     else
 314         KBUILD_HOST_ARCH=`uname -m`
 315     fi
 316     case "$KBUILD_HOST_ARCH" in
 317         x86_64|AMD64|amd64|k8|k8l|k9|k10)
 318             KBUILD_HOST_ARCH='amd64'
 319             ;;
 320         x86|i86pc|ia32|i[3456789]86)
 321             KBUILD_HOST_ARCH='x86'
 322             ;;
 323         sparc32|sparc)
 324             KBUILD_HOST_ARCH='sparc32'
 325             ;;
 326         sparc64)
 327             KBUILD_HOST_ARCH='sparc64'
 328             ;;
 329         s390)
 330             KBUILD_HOST_ARCH='s390'
 331             ;;
 332         s390x)
 333             KBUILD_HOST_ARCH='s390x'
 334             ;;
 335         ppc32|ppc|powerpc)
 336             KBUILD_HOST_ARCH='ppc32'
 337             ;;
 338         ppc64|powerpc64)
 339             KBUILD_HOST_ARCH='ppc64'
 340             ;;
 341         mips32|mips)
 342             KBUILD_HOST_ARCH='mips32'
 343             ;;
 344         mips64)
 345             KBUILD_HOST_ARCH='mips64'
 346             ;;
 347         ia64)
 348             KBUILD_HOST_ARCH='ia64'
 349             ;;
 350         hppa32|parisc32|parisc)
 351             KBUILD_HOST_ARCH='hppa32'
 352             ;;
 353         hppa64|parisc64)
 354             KBUILD_HOST_ARCH='hppa64'
 355             ;;
 356         arm|armv4l|armv5tel|armv5tejl)
 357             KBUILD_HOST_ARCH='arm'
 358             ;;
 359         alpha)
 360             KBUILD_HOST_ARCH='alpha'
 361             ;;
 362
 363         *)  echo "$0: unknown cpu/arch - $KBUILD_HOST_ARCH" 1>&${ERR_REDIR}
 364             sleep 1
 365             exit 1
 366             ;;
 367     esac
 368
 369 fi
 370 test -n "$DBG_OPT" && echo "dbg: KBUILD_HOST_ARCH=$KBUILD_HOST_ARCH" 1>&${DBG_REDIR}
 371
 372 if test -z "$KBUILD_HOST_CPU"; then
 373     KBUILD_HOST_CPU="blend"
 374 fi
 375 test -n "$DBG_OPT" && echo "dbg: KBUILD_HOST_CPU=$KBUILD_HOST_CPU" 1>&${DBG_REDIR}
 376
 377 #
 378 # The target platform.
 379 # Defaults to the host when not specified.
 380 #
 381 if test -z "$KBUILD_TARGET"; then
 382     KBUILD_TARGET="$KBUILD_HOST"
 383 fi
 384 test -n "$DBG_OPT" && echo "dbg: KBUILD_TARGET=$KBUILD_TARGET" 1>&${DBG_REDIR}
 385
 386 if test -z "$KBUILD_TARGET_ARCH"; then
 387     KBUILD_TARGET_ARCH="$KBUILD_HOST_ARCH"
 388 fi
 389 test -n "$DBG_OPT" && echo "dbg: KBUILD_TARGET_ARCH=$KBUILD_TARGET_ARCH" 1>&${DBG_REDIR}
 390
 391 if test -z "$KBUILD_TARGET_CPU"; then
 392     if test "$KBUILD_TARGET_ARCH" = "$KBUILD_HOST_ARCH"; then
 393         KBUILD_TARGET_CPU="$KBUILD_HOST_CPU"
 394     else
 395         KBUILD_TARGET_CPU="blend"
 396     fi
 397 fi
 398 test -n "$DBG_OPT" && echo "dbg: KBUILD_TARGET_CPU=$KBUILD_TARGET_CPU" 1>&${DBG_REDIR}
 399
 400 #
 401 # Determin executable extension and path separator.
 402 #
 403 _SUFF_EXE=
 404 _PATH_SEP=":"
 405 case "$KBUILD_HOST" in
 406     os2|win|nt)
 407         _SUFF_EXE=".exe"
 408         _PATH_SEP=";"
 409         ;;
 410 esac
 411
 412 #
 413 # Determin KBUILD_PATH from the script location and calc KBUILD_BIN_PATH from there.
 414 #
 415 if test -z "$KBUILD_PATH"; then
 416     KBUILD_PATH=`dirname "$0"`
 417     KBUILD_PATH=`cd "$KBUILD_PATH" ; /bin/pwd`
 418 fi
 419 if test ! -f "$KBUILD_PATH/footer.kmk" -o ! -f "$KBUILD_PATH/header.kmk" -o ! -f "$KBUILD_PATH/rules.kmk"; then
 420     echo "$0: error: KBUILD_PATH ($KBUILD_PATH) is not pointing to a popluated kBuild directory." 1>&${ERR_REDIR}
 421     sleep 1
 422     exit 1
 423 fi
 424 test -n "$DBG_OPT" && echo "dbg: KBUILD_PATH=$KBUILD_PATH" 1>&${DBG_REDIR}
 425
 426 if test -z "$KBUILD_BIN_PATH"; then
 427     KBUILD_BIN_PATH="${KBUILD_PATH}/bin/${KBUILD_HOST}.${KBUILD_HOST_ARCH}"
 428 fi
 429 test -n "$DBG_OPT" && echo "dbg: KBUILD_BIN_PATH=${KBUILD_BIN_PATH}" 1>&${DBG_REDIR}
 430
 431 #
 432 # Add the bin/x.y/ directory to the PATH.
 433 # NOTE! Once bootstrapped this is the only thing that is actually necessary.
 434 #
 435 PATH="${KBUILD_BIN_PATH}${_PATH_SEP}$PATH"
 436 test -n "$DBG_OPT" && echo "dbg: PATH=$PATH" 1>&${DBG_REDIR}
 437
 438 #
 439 # Sanity and x bits.
 440 #
 441 if test ! -d "${KBUILD_BIN_PATH}/"; then
 442     echo "$0: warning: The bin directory for this platform doesn't exist. (${KBUILD_BIN_PATH}/)" 1>&${ERR_REDIR}
 443 else
 444     for prog in kmk kDepPre kDepIDB kmk_append kmk_ash kmk_cat kmk_cp kmk_echo kmk_install kmk_ln kmk_mkdir kmk_mv kmk_rm kmk_rmdir kmk_sed;
 445     do
 446         chmod a+x ${KBUILD_BIN_PATH}/${prog} > /dev/null 2>&1
 447         if test ! -f "${KBUILD_BIN_PATH}/${prog}${_SUFF_EXE}"; then
 448             echo "$0: warning: The ${prog} program doesn't exist for this platform. (${KBUILD_BIN_PATH}/${prog}${_SUFF_EXE})" 1>&${ERR_REDIR}
 449         fi
 450     done
 451 fi
 452
 453 #
 454 # The environment is in place, now take the requested action.
 455 #
 456 MY_RC=0
 457 if test -n "${VAR_OPT}"; then
 458     # Echo variable values or variable export statements.
 459     for var in ${VAR_OPT};
 460     do
 461         val=
 462         case "$var" in
 463             PATH)
 464                 val=$PATH
 465                 ;;
 466             KBUILD_PATH)
 467                 val=$KBUILD_PATH
 468                 ;;
 469             KBUILD_BIN_PATH)
 470                 val=$KBUILD_BIN_PATH
 471                 ;;
 472             KBUILD_HOST)
 473                 val=$KBUILD_HOST
 474                 ;;
 475             KBUILD_HOST_ARCH)
 476                 val=$KBUILD_HOST_ARCH
 477                 ;;
 478             KBUILD_HOST_CPU)
 479                 val=$KBUILD_HOST_CPU
 480                 ;;
 481             KBUILD_TARGET)
 482                 val=$KBUILD_TARGET
 483                 ;;
 484             KBUILD_TARGET_ARCH)
 485                 val=$KBUILD_TARGET_ARCH
 486                 ;;
 487             KBUILD_TARGET_CPU)
 488                 val=$KBUILD_TARGET_CPU
 489                 ;;
 490             KBUILD_TYPE)
 491                 val=$KBUILD_TYPE
 492                 ;;
 493             *)
 494                 echo "$0: error: Unknown variable $var specified in --var request." 1>&${ERR_REDIR}
 495                 sleep 1
 496                 exit 1
 497                 ;;
 498         esac
 499
 500         if test -n "$EVAL_OPT"; then
 501             echo "${EVAL_EXPORT} $var=$val"
 502         else
 503             if test -n "$VALUE_ONLY_OPT"; then
 504                 echo "$val"
 505             else
 506                 echo "$var=$val"
 507             fi
 508         fi
 509     done
 510 else
 511     if test -n "$EVAL_OPT"; then
 512         # Echo statements for the shell to evaluate.
 513         test -n "$DBG_OPT" && echo "dbg: echoing exported variables" 1>&${DBG_REDIR}
 514         echo "${EVAL_EXPORT} PATH=${PATH}"
 515         test -n "${FULL_OPT}" -o "${EXP_TYPE_OPT}" && echo "${EVAL_EXPORT} KBUILD_TYPE=${KBUILD_TYPE}"
 516         if test -n "${FULL_OPT}"; then
 517             echo "${EVAL_EXPORT} KBUILD_PATH=${KBUILD_PATH}"
 518             echo "${EVAL_EXPORT} KBUILD_HOST=${KBUILD_HOST}"
 519             echo "${EVAL_EXPORT} KBUILD_HOST_ARCH=${KBUILD_HOST_ARCH}"
 520             echo "${EVAL_EXPORT} KBUILD_HOST_CPU=${KBUILD_HOST_CPU}"
 521             echo "${EVAL_EXPORT} KBUILD_TARGET=${KBUILD_TARGET}"
 522             echo "${EVAL_EXPORT} KBUILD_TARGET_ARCH=${KBUILD_TARGET_ARCH}"
 523             echo "${EVAL_EXPORT} KBUILD_TARGET_CPU=${KBUILD_TARGET_CPU}"
 524
 525             if test -n "${LEGACY_OPT}"; then
 526                 echo "${EVAL_EXPORT} PATH_KBUILD=${KBUILD_PATH}"
 527                 echo "${EVAL_EXPORT} BUILD_TYPE=${KBUILD_TYPE}"
 528                 echo "${EVAL_EXPORT} BUILD_PLATFORM=${KBUILD_HOST}"
 529                 echo "${EVAL_EXPORT} BUILD_PLATFORM_ARCH=${KBUILD_HOST_ARCH}"
 530                 echo "${EVAL_EXPORT} BUILD_PLATFORM_CPU=${KBUILD_HOST_CPU}"
 531                 echo "${EVAL_EXPORT} BUILD_TARGET=${KBUILD_TARGET}"
 532                 echo "${EVAL_EXPORT} BUILD_TARGET_ARCH=${KBUILD_TARGET_ARCH}"
 533                 echo "${EVAL_EXPORT} BUILD_TARGET_CPU=${KBUILD_TARGET_CPU}"
 534             fi
 535         fi
 536     else
 537         # Export variables.
 538         export PATH
 539         test -n "${FULL_OPT}" -o "${EXP_TYPE_OPT}" && export KBUILD_TYPE
 540         if test -n "${FULL_OPT}"; then
 541             export KBUILD_PATH
 542             export KBUILD_HOST
 543             export KBUILD_HOST_ARCH
 544             export KBUILD_HOST_CPU
 545             export KBUILD_TARGET
 546             export KBUILD_TARGET_ARCH
 547             export KBUILD_TARGET_CPU
 548
 549             if test -n "${LEGACY_OPT}"; then
 550                 export PATH_KBUILD=$KBUILD_PATH
 551                 export BUILD_TYPE=$KBUILD_TYPE
 552                 export BUILD_PLATFORM=$KBUILD_HOST
 553                 export BUILD_PLATFORM_ARCH=$KBUILD_HOST_ARCH
 554                 export BUILD_PLATFORM_CPU=$KBUILD_HOST_CPU
 555                 export BUILD_TARGET=$KBUILD_TARGET
 556                 export BUILD_TARGET_ARCH=$KBUILD_TARGET_ARCH
 557                 export BUILD_TARGET_CPU=$KBUILD_TARGET_CPU
 558             fi
 559         fi
 560
 561         # Execute command or spawn shell.
 562         if test $# -eq 0; then
 563             test -z "${QUIET_OPT}" && echo "$0: info: Spawning work shell..." 1>&${ERR_REDIR}
 564             if test "$TERM" != 'dumb'  -a  -n "$BASH"; then
 565                 export PS1='\[\033[01;32m\]\u@\h \[\033[01;34m\]\W \$ \[\033[00m\]'
 566             fi
 567             $SHELL -i
 568             MY_RC=$?
 569         else
 570             test -z "${QUIET_OPT}" && echo "$0: info: Executing command: $*" 1>&${ERR_REDIR}
 571             $*
 572             MY_RC=$?
 573             test -z "${QUIET_OPT}" -a "$MY_RC" -ne 0 && echo "$0: info: rc=$MY_RC: $*" 1>&${ERR_REDIR}
 574         fi
 575     fi
 576 fi
 577 test -n "$DBG_OPT" && echo "dbg: finished (rc=$MY_RC)" 1>&${DBG_REDIR}
 578 exit $MY_RC
 579