configure - third_party/rust - Git at Google

 #!/bin/sh

 msg() {
     echo "configure: $1"
 }

 step_msg() {
     msg
     msg "$1"
     msg
 }

 warn() {
     echo "configure: WARNING: $1"
 }

 err() {
     echo "configure: error: $1"
     exit 1
 }

 need_ok() {
     if [ $? -ne 0 ]
     then
         err $1
     fi
 }

 need_cmd() {
     if which $1 >/dev/null 2>&1
     then msg "found $1"
     else err "need $1"
     fi
 }

 make_dir() {
     if [ ! -d $1 ]
     then
         msg "mkdir -p $1"
         mkdir -p $1
     fi
 }

 copy() {
     msg "cp $1 $2"
     cp $1 $2
 }

 putvar() {
     local T
     eval T=\$$1
     eval TLEN=\${#$1}
     if [ $TLEN -gt 35 ]
     then
         printf "configure: %-20s := %.35s ...\n" $1 "$T"
     else
         printf "configure: %-20s := %s\n" $1 "$T"
     fi
     printf "%-20s := %s\n" $1 "$T" >>config.mk
 }

 probe() {
     local V=$1
     shift
     local P
     local T
     for P
     do
         T=$(which $P 2>&1)
         if [ $? -eq 0 ]
         then
             break
         else
             T=""
         fi
     done
     eval $V=\$T
     putvar $V
 }

 probe_need() {
     local V=$1
     probe $*
     eval VV=\$$V
     if [ -z "$VV" ]
     then
         err "needed, but unable to find any of: $*"
     fi
 }

 valopt() {
     local OP=$1
     local DEFAULT=$2
     shift
     shift
     local DOC="$*"
     if [ $HELP -eq 0 ]
     then
         local UOP=$(echo $OP | tr '[:lower:]' '[:upper:]' | tr '\-' '\_')
         local V="CFG_${UOP}"
         eval $V="$DEFAULT"
         for arg in $CFG_CONFIGURE_ARGS
         do
             if echo "$arg" | grep -q -- "--$OP="
             then
                 val=$(echo "$arg" | cut -f2 -d=)
                 eval $V=$val
             fi
         done
         putvar $V
     else
         if [ -z "$DEFAULT" ]
         then
             DEFAULT="<none>"
         fi
         OP="${OP}=[${DEFAULT}]"
         printf "    --%-30s %s\n" "$OP" "$DOC"
     fi
 }

 opt() {
     local OP=$1
     local DEFAULT=$2
     shift
     shift
     local DOC="$*"
     local FLAG=""

     if [ $DEFAULT -eq 0 ]
     then
         FLAG="enable"
     else
         FLAG="disable"
         DOC="don't $DOC"
     fi

     if [ $HELP -eq 0 ]
     then
         for arg in $CFG_CONFIGURE_ARGS
         do
             if [ "$arg" = "--${FLAG}-${OP}" ]
             then
                 OP=$(echo $OP | tr 'a-z-' 'A-Z_')
                 FLAG=$(echo $FLAG | tr 'a-z' 'A-Z')
                 local V="CFG_${FLAG}_${OP}"
                 eval $V=1
                 putvar $V
             fi
         done
     else
         if [ ! -z "$META" ]
         then
             OP="$OP=<$META>"
         fi
         printf "    --%-30s %s\n" "$FLAG-$OP" "$DOC"
      fi
 }


 msg "looking for configure programs"
 need_cmd mkdir
 need_cmd printf
 need_cmd cut
 need_cmd grep
 need_cmd xargs
 need_cmd cp
 need_cmd find
 need_cmd uname
 need_cmd date
 need_cmd tr
 need_cmd sed


 msg "inspecting environment"

 CFG_OSTYPE=$(uname -s)
 CFG_CPUTYPE=$(uname -m)

 if [ $CFG_OSTYPE = Darwin -a $CFG_CPUTYPE = i386 ]
 then
     # Darwin's `uname -s` lies and always returns i386. We have to use sysctl
     # instead.
     if sysctl hw.optional.x86_64 | grep ': 1'
     then
         CFG_CPUTYPE=x86_64
     fi
 fi

 # The goal here is to come up with the same triple as LLVM would,
 # at least for the subset of platforms we're willing to target.

 case $CFG_OSTYPE in

     Linux)
         CFG_OSTYPE=unknown-linux-gnu
         ;;

     FreeBSD)
         CFG_OSTYPE=unknown-freebsd
         ;;

     Darwin)
         CFG_OSTYPE=apple-darwin
         ;;

     MINGW32*)
         CFG_OSTYPE=pc-mingw32
         ;;

     *)
         err "unknown OS type: $CFG_OSTYPE"
         ;;
 esac


 case $CFG_CPUTYPE in

     i386 | i486 | i686 | i786 | x86)
         CFG_CPUTYPE=i686
         ;;

     xscale | arm)
         CFG_CPUTYPE=arm
         ;;

     x86_64 | x86-64 | x64 | amd64)
         CFG_CPUTYPE=x86_64
         ;;

     *)
         err "unknown CPU type: $CFG_CPUTYPE"
 esac

 DEFAULT_HOST_TRIPLE="${CFG_CPUTYPE}-${CFG_OSTYPE}"

 CFG_SELF=$(echo $0 | tr '\\' '/')
 CFG_SRC_DIR=${CFG_SELF%${CFG_SELF##*/}}
 CFG_BUILD_DIR=$(echo $PWD | tr '\\' '/')
 CFG_CONFIGURE_ARGS="$@"

 OPTIONS=""
 HELP=0
 if [ "$1" = "--help" ]
 then
     HELP=1
     shift
     echo ""
     echo "Usage: $CFG_SELF [options]"
     echo ""
     echo "Options:"
     echo ""
 else
     msg "recreating config.mk"
     echo '' >config.mk

     step_msg "processing $CFG_SELF args"
 fi

 opt sharedstd 1 "build libstd as a shared library"
 opt valgrind 1 "run tests with valgrind"
 opt docs     1 "build documentation"
 opt optimize 1 "build optimized rust code"
 opt optimize-cxx 1 "build optimized C++ code"
 opt optimize-llvm 1 "build optimized LLVM"
 opt manage-submodules 1 "let the build manage the git submodules"
 opt mingw-cross 0 "cross-compile for win32 using mingw"
 opt clang 0 "prefer clang to gcc for building the runtime"
 valopt prefix "/usr/local" "set installation prefix"
 valopt llvm-root "" "set LLVM root"
 valopt host-triple "$DEFAULT_HOST_TRIPLE" "primary LLVM host triple"
 valopt target-triples "" "LLVM target triples (defaults to host if unset)"

 if [ $HELP -eq 1 ]
 then
     echo ""
     exit 0
 fi


 step_msg "looking for build programs"

 probe_need CFG_PERL         perl
 probe_need CFG_PYTHON       python python2.6 python2 python3
 probe_need CFG_CURL         curl

 probe CFG_GIT              git
 probe CFG_CLANG            clang++
 probe CFG_GCC              gcc
 probe CFG_LLVM_CONFIG      llvm-config
 probe CFG_VALGRIND         valgrind
 probe CFG_PERF             perf
 probe CFG_MAKENSIS         makensis
 probe CFG_NATURALDOCS      NaturalDocs naturaldocs
 probe CFG_LLNEXTGEN        LLnextgen
 probe CFG_PANDOC           pandoc
 probe CFG_PDFLATEX         pdflatex
 probe CFG_XETEX            xetex
 probe CFG_LUATEX           luatex
 probe CFG_NODE             nodejs node


 if [ ! -z "$CFG_PANDOC" ]
 then
     PV=$(pandoc --version | awk '/^pandoc/ {print $2}')
     if [ "$PV" \< "1.8" ]
     then
 	step_msg "pandoc $PV is too old. disabling"
 	BAD_PANDOC=1
     fi
 fi

 if [ -z "$CFG_ENABLE_CLANG" -a -z "$CFG_GCC" ]
 then
     err "either clang or gcc is required"
 fi

 if [ ! -z "$CFG_LLVM_ROOT" -a -e "$CFG_LLVM_ROOT/bin/llvm-config" ]
 then
     step_msg "using custom LLVM at $CFG_LLVM_ROOT"

     LLVM_CONFIG="$CFG_LLVM_ROOT/bin/llvm-config"
     LLVM_VERSION=$($LLVM_CONFIG --version)

     case $LLVM_VERSION in
 	(3.1svn)
 	    msg "found ok version of LLVM: $LLVM_VERSION"
 	    ;;
 	(*)
 	    err "bad LLVM version: $LLVM_VERSION, need >=3.0svn"
 	    ;;
     esac
 fi

 if [ ! -z "$CFG_ENABLE_CLANG" ]
 then
     if [ -z "$CFG_CLANG" ]
     then
 	err "clang requested but not found"
     fi
     CFG_CLANG_VERSION=$("$CFG_CLANG" \
                       --version \
                       | grep version \
                       | cut -d ' ' -f 3)

     case $CFG_CLANG_VERSION in
         (3.0svn | 3.0 | 3.1)
         step_msg "found ok version of CLANG: $CFG_CLANG_VERSION"
         CFG_C_COMPILER="clang"
         ;;
         (*)
         err "bad CLANG version: $CFG_CLANG_VERSION, need >=3.0svn"
         ;;
     esac
 else
     CFG_C_COMPILER="gcc"
 fi

 if [ -z "$CFG_PREFIX" ]
 then
     CFG_PREFIX=/usr/local
 fi

 if [ -z "$CFG_HOST_TRIPLE" ]
 then
     CFG_HOST_TRIPLE="$DEFAULT_HOST_TRIPLE"
 fi

 if [ -z "$CFG_TARGET_TRIPLES" ]
 then
     CFG_TARGET_TRIPLES="${CFG_HOST_TRIPLE}"
 else
     CFG_TARGET_TRIPLES="$(echo $CFG_TARGET_TRIPLES | tr ',' ' ')"
 fi

 case $CFG_TARGET_TRIPLES in
     (*$CFG_HOST_TRIPLE*) ;;
     (*) err "Host triple is not among the target triples." ;;
 esac

 if [ -z "$CFG_ENABLE_CLANG" -a -z "$CFG_GCC" ]
 then
     err "either clang or gcc is required"
 fi

 if [ ! -z "$CFG_PERF" ]
 then
     HAVE_PERF_LOGFD=`$CFG_PERF stat --log-fd 2>&1 | grep 'unknown option'`
     if [ -z "$HAVE_PERF_LOGFD" ];
     then
         CFG_PERF_WITH_LOGFD=1
         putvar CFG_PERF_WITH_LOGFD
     fi
 fi

 step_msg "making directories"

 for i in \
     doc doc/core doc/std \
     nd nd/core nd/std \
     dl tmp
 do
     make_dir $i
 done

 make_dir llvm
 for t in $CFG_TARGET_TRIPLES
 do
     make_dir llvm/$t
 done

 make_dir rustllvm
 for t in $CFG_TARGET_TRIPLES
 do
     make_dir rustllvm/$t
 done

 make_dir rt
 for t in $CFG_TARGET_TRIPLES
 do
   make_dir rt/$t
   for i in                                          \
     isaac bigint sync test arch/i386 arch/x86_64    \
     libuv libuv/src/ares libuv/src/eio libuv/src/ev
   do
     make_dir rt/$t/$i
   done
 done

 # On windows we just store the libraries in the bin directory because
 # there's no rpath
 CFG_LIBDIR=lib
 if [ "$CFG_OSTYPE" = "pc-mingw32" ]
 then
     CFG_LIBDIR=bin
 fi

 for h in $CFG_TARGET_TRIPLES
 do
     for t in $CFG_TARGET_TRIPLES
     do
         for i in 0 1 2 3
         do
             # host bin dir
             make_dir $h/stage$i/bin

             # host lib dir
             make_dir $h/stage$i/$CFG_LIBDIR

             # target bin dir
             make_dir $h/stage$i/$CFG_LIBDIR/rustc/$t/bin

             # target lib dir
             make_dir $h/stage$i/$CFG_LIBDIR/rustc/$t/$CFG_LIBDIR
         done
     done

     make_dir $h/test/run-pass
     make_dir $h/test/run-fail
     make_dir $h/test/compile-fail
     make_dir $h/test/bench
     make_dir $h/test/perf
     make_dir $h/test/pretty
 done

 # Configure submodules
 step_msg "configuring submodules"

 # If we have no git directory then we are probably a tarball distribution
 # and shouldn't attempt to load submodules
 if [ ! -e ${CFG_SRC_DIR}.git ]
 then
     msg "git: no git directory. disabling submodules"
     CFG_DISABLE_MANAGE_SUBMODULES=1
 fi

 # Have to be in the top of src directory for this
 cd ${CFG_SRC_DIR}

 if [ -z $CFG_DISABLE_MANAGE_SUBMODULES ]
 then
 SUBMODULE_STATUS=$("${CFG_GIT}" submodule status)
 NEED_INIT_COUNT=$(echo "$SUBMODULE_STATUS" | grep -c "^-")
 NEED_UPDATE_COUNT=$(echo "$SUBMODULE_STATUS" | grep -c "^+")
 NEED_INIT=$(test $NEED_INIT_COUNT -gt 0)$?
 NEED_UPDATE=$(test "($NEED_INIT)" -o "$NEED_UPDATE_COUNT" -gt 0)$?
 else
 NEED_INIT=
 NEED_UPDATE=
 fi

 if [ $NEED_INIT ]
 then
     msg "git: submodule init"
     "${CFG_GIT}" submodule init --quiet
     need_ok "git failed"
 fi

 if [ $NEED_UPDATE ]
 then
     msg "git: submodule update"
     "${CFG_GIT}" submodule update --quiet
     need_ok "git failed"
 fi

 cd ${CFG_BUILD_DIR}


 # Configure llvm. Here we go...
 CFG_LLVM_SRC_DIR=${CFG_SRC_DIR}src/llvm

 for t in $CFG_TARGET_TRIPLES
 do
     if [ -z $CFG_LLVM_ROOT ]
     then
 	step_msg "configuring LLVM for $t"

 	LLVM_BUILD_DIR=$CFG_BUILD_DIR/llvm/$t

 	LLVM_TARGETS="--enable-targets=x86,x86_64"
 	LLVM_BUILD="--build=$t"
 	LLVM_HOST="--host=$t"
 	LLVM_TARGET="--target=$t"

     if [ ! -z "$CFG_DISABLE_OPTIMIZE_LLVM" ]
     then
         LLVM_DBG_OPTS=""
         # Just use LLVM straight from its build directory to
         # avoid 'make install' time
 	    LLVM_INST_DIR=$LLVM_BUILD_DIR/Debug+Asserts
     else
         LLVM_DBG_OPTS="--enable-optimized"
 	    LLVM_INST_DIR=$LLVM_BUILD_DIR/Release+Asserts
     fi
 	# Disable unused LLVM features
 	LLVM_OPTS="$LLVM_DBG_OPTS --disable-docs --disable-jit --enable-bindings=none --disable-threads --disable-pthreads"

 	LLVM_CXX_32="g++ -m32"
 	LLVM_CC_32="gcc -m32"
 	LLVM_CFLAGS_32="-m32"
 	LLVM_CXXFLAGS_32="-m32"
 	LLVM_LDFLAGS_32="-m32"

 	LLVM_CXX_64="g++"
 	LLVM_CC_64="gcc"
 	LLVM_CFLAGS_64=""
 	LLVM_CXXFLAGS_64=""
 	LLVM_LDFLAGS_64=""

 	if echo $t | grep x86_64
 	then
 	    LLVM_CXX=$LLVM_CXX_64
 	    LLVM_CC=$LLVM_CC_64
 	    LLVM_CFLAGS=$LLVM_CFLAGS_64
 	    LLVM_CXXFLAGS=$LLVM_CXXFLAGS_64
 	    LLVM_LDFLAGS=$LLVM_LDFLAGS_64
 	else
 	    LLVM_CXX=$LLVM_CXX_32
 	    LLVM_CC=$LLVM_CC_32
 	    LLVM_CFLAGS=$LLVM_CFLAGS_32
 	    LLVM_CXXFLAGS=$LLVM_CXXFLAGS_32
 	    LLVM_LDFLAGS=$LLVM_LDFLAGS_32
 	fi

 	CXX=$LLVM_CXX
 	CC=$LLVM_CC
 	CFLAGS=$LLVM_CFLAGS
 	CXXFLAGS=$LLVM_CXXFLAGS
 	LDFLAGS=$LLVM_LDFLAGS

 	LLVM_FLAGS="$LLVM_TARGETS $LLVM_OPTS $LLVM_BUILD $LLVM_HOST $LLVM_TARGET"

 	msg "configuring LLVM with:"
 	msg "$LLVM_FLAGS"

 	export CXX
 	export CC
 	export CFLAGS
 	export CXXFLAGS
 	export LDFLAGS

 	cd $LLVM_BUILD_DIR
 	case $CFG_SRC_DIR in
 	    /* | [a-z]:* | [A-Z]:*)
 		${CFG_LLVM_SRC_DIR}/configure $LLVM_FLAGS
 		;;
 	    *)
 		${CFG_BUILD_DIR}/${CFG_LLVM_SRC_DIR}/configure $LLVM_FLAGS
 		;;
 	esac
     need_ok "LLVM configure failed"
 	cd $CFG_BUILD_DIR
     else
 	LLVM_BUILD_DIR=
         # The user is using their own LLVM
 	LLVM_INST_DIR=$CFG_LLVM_ROOT
     fi

     # Construct variables for LLVM build and install directories for
     # each target. These will be named
     # CFG_LLVM_BUILD_DIR_${target_triple} but all the hyphens in
     # target_triple will be converted to underscore, because bash
     # variables can't contain hyphens. The makefile will then have to
     # convert back.
     CFG_LLVM_BUILD_DIR=$(echo CFG_LLVM_BUILD_DIR_${t} | tr - _)
     CFG_LLVM_INST_DIR=$(echo CFG_LLVM_INST_DIR_${t} | tr - _)
     eval ${CFG_LLVM_BUILD_DIR}="'$LLVM_BUILD_DIR'"
     eval ${CFG_LLVM_INST_DIR}="'$LLVM_INST_DIR'"
 done


 step_msg "writing configuration"

 putvar CFG_SRC_DIR
 putvar CFG_BUILD_DIR
 putvar CFG_OSTYPE
 putvar CFG_CPUTYPE
 putvar CFG_CONFIGURE_ARGS
 putvar CFG_HOST_TRIPLE
 putvar CFG_TARGET_TRIPLES
 putvar CFG_C_COMPILER
 putvar CFG_PREFIX
 putvar CFG_LIBDIR

 # Setting this again because it may have been changed
 if [ $CFG_DISABLE_MANAGE_SUBMODULES ]
 then
     putvar CFG_DISABLE_MANAGE_SUBMODULES
 fi

 # Ditto for pandoc
 if [ ! -z $BAD_PANDOC ]
 then
     CFG_PANDOC=
     putvar CFG_PANDOC
 fi

 if head -n 1 ${CFG_SRC_DIR}src/snapshots.txt | grep -q '^T'
 then
     CFG_IN_TRANSITION=1
     putvar CFG_IN_TRANSITION
 fi

 # Valgrind is only reliable on Linux. On Windows it doesn't work at all, and
 # on the Mac the dynamic linker causes Valgrind to emit a huge stream of
 # errors.
 if [ $CFG_OSTYPE != unknown-linux-gnu ] && [ $CFG_OSTYPE != apple-darwin ]
 then
     CFG_BAD_VALGRIND=1
     putvar CFG_BAD_VALGRIND
 fi

 putvar CFG_LLVM_ROOT
 putvar CFG_LLVM_SRC_DIR

 for t in $CFG_TARGET_TRIPLES
 do
     CFG_LLVM_BUILD_DIR=$(echo CFG_LLVM_BUILD_DIR_${t} | tr - _)
     CFG_LLVM_INST_DIR=$(echo CFG_LLVM_INST_DIR_${t} | tr - _)
     putvar $CFG_LLVM_BUILD_DIR
     putvar $CFG_LLVM_INST_DIR
 done


 # Munge any paths that appear in config.mk back to posix-y
 perl -i.bak -p -e 's@ ([a-zA-Z]):[/\\]@ /\1/@go;' \
                -e 's@\\@/@go;' config.mk
 rm -f config.mk.bak

 msg
 copy ${CFG_SRC_DIR}Makefile.in ./Makefile

 step_msg "complete"
	#!/bin/sh

	msg() {
	echo "configure: $1"
	}

	step_msg() {
	msg
	msg "$1"
	msg
	}

	warn() {
	echo "configure: WARNING: $1"
	}

	err() {
	echo "configure: error: $1"
	exit 1
	}

	need_ok() {
	if [ $? -ne 0 ]
	then
	err $1
	fi
	}

	need_cmd() {
	if which $1 >/dev/null 2>&1
	then msg "found $1"
	else err "need $1"
	fi
	}

	make_dir() {
	if [ ! -d $1 ]
	then
	msg "mkdir -p $1"
	mkdir -p $1
	fi
	}

	copy() {
	msg "cp $1 $2"
	cp $1 $2
	}

	putvar() {
	local T
	eval T=\$$1
	eval TLEN=\${#$1}
	if [ $TLEN -gt 35 ]
	then
	printf "configure: %-20s := %.35s ...\n" $1 "$T"
	else
	printf "configure: %-20s := %s\n" $1 "$T"
	fi
	printf "%-20s := %s\n" $1 "$T" >>config.mk
	}

	probe() {
	local V=$1
	shift
	local P
	local T
	for P
	do
	T=$(which $P 2>&1)
	if [ $? -eq 0 ]
	then
	break
	else
	T=""
	fi
	done
	eval $V=\$T
	putvar $V
	}

	probe_need() {
	local V=$1
	probe $*
	eval VV=\$$V
	if [ -z "$VV" ]
	then
	err "needed, but unable to find any of: $*"
	fi
	}

	valopt() {
	local OP=$1
	local DEFAULT=$2
	shift
	shift
	local DOC="$*"
	if [ $HELP -eq 0 ]
	then
	local UOP=$(echo $OP \| tr '[:lower:]' '[:upper:]' \| tr '\-' '\_')
	local V="CFG_${UOP}"
	eval $V="$DEFAULT"
	for arg in $CFG_CONFIGURE_ARGS
	do
	if echo "$arg" \| grep -q -- "--$OP="
	then
	val=$(echo "$arg" \| cut -f2 -d=)
	eval $V=$val
	fi
	done
	putvar $V
	else
	if [ -z "$DEFAULT" ]
	then
	DEFAULT="<none>"
	fi
	OP="${OP}=[${DEFAULT}]"
	printf " --%-30s %s\n" "$OP" "$DOC"
	fi
	}

	opt() {
	local OP=$1
	local DEFAULT=$2
	shift
	shift
	local DOC="$*"
	local FLAG=""

	if [ $DEFAULT -eq 0 ]
	then
	FLAG="enable"
	else
	FLAG="disable"
	DOC="don't $DOC"
	fi

	if [ $HELP -eq 0 ]
	then
	for arg in $CFG_CONFIGURE_ARGS
	do
	if [ "$arg" = "--${FLAG}-${OP}" ]
	then
	OP=$(echo $OP \| tr 'a-z-' 'A-Z_')
	FLAG=$(echo $FLAG \| tr 'a-z' 'A-Z')
	local V="CFG_${FLAG}_${OP}"
	eval $V=1
	putvar $V
	fi
	done
	else
	if [ ! -z "$META" ]
	then
	OP="$OP=<$META>"
	fi
	printf " --%-30s %s\n" "$FLAG-$OP" "$DOC"
	fi
	}


	msg "looking for configure programs"
	need_cmd mkdir
	need_cmd printf
	need_cmd cut
	need_cmd grep
	need_cmd xargs
	need_cmd cp
	need_cmd find
	need_cmd uname
	need_cmd date
	need_cmd tr
	need_cmd sed


	msg "inspecting environment"

	CFG_OSTYPE=$(uname -s)
	CFG_CPUTYPE=$(uname -m)

	if [ $CFG_OSTYPE = Darwin -a $CFG_CPUTYPE = i386 ]
	then
	# Darwin's `uname -s` lies and always returns i386. We have to use sysctl
	# instead.
	if sysctl hw.optional.x86_64 \| grep ': 1'
	then
	CFG_CPUTYPE=x86_64
	fi
	fi

	# The goal here is to come up with the same triple as LLVM would,
	# at least for the subset of platforms we're willing to target.

	case $CFG_OSTYPE in

	Linux)
	CFG_OSTYPE=unknown-linux-gnu
	;;

	FreeBSD)
	CFG_OSTYPE=unknown-freebsd
	;;

	Darwin)
	CFG_OSTYPE=apple-darwin
	;;

	MINGW32*)
	CFG_OSTYPE=pc-mingw32
	;;

	*)
	err "unknown OS type: $CFG_OSTYPE"
	;;
	esac


	case $CFG_CPUTYPE in

	i386 \| i486 \| i686 \| i786 \| x86)
	CFG_CPUTYPE=i686
	;;

	xscale \| arm)
	CFG_CPUTYPE=arm
	;;

	x86_64 \| x86-64 \| x64 \| amd64)
	CFG_CPUTYPE=x86_64
	;;

	*)
	err "unknown CPU type: $CFG_CPUTYPE"
	esac

	DEFAULT_HOST_TRIPLE="${CFG_CPUTYPE}-${CFG_OSTYPE}"

	CFG_SELF=$(echo $0 \| tr '\\' '/')
	CFG_SRC_DIR=${CFG_SELF%${CFG_SELF##*/}}
	CFG_BUILD_DIR=$(echo $PWD \| tr '\\' '/')
	CFG_CONFIGURE_ARGS="$@"

	OPTIONS=""
	HELP=0
	if [ "$1" = "--help" ]
	then
	HELP=1
	shift
	echo ""
	echo "Usage: $CFG_SELF [options]"
	echo ""
	echo "Options:"
	echo ""
	else
	msg "recreating config.mk"
	echo '' >config.mk

	step_msg "processing $CFG_SELF args"
	fi

	opt sharedstd 1 "build libstd as a shared library"
	opt valgrind 1 "run tests with valgrind"
	opt docs 1 "build documentation"
	opt optimize 1 "build optimized rust code"
	opt optimize-cxx 1 "build optimized C++ code"
	opt optimize-llvm 1 "build optimized LLVM"
	opt manage-submodules 1 "let the build manage the git submodules"
	opt mingw-cross 0 "cross-compile for win32 using mingw"
	opt clang 0 "prefer clang to gcc for building the runtime"
	valopt prefix "/usr/local" "set installation prefix"
	valopt llvm-root "" "set LLVM root"
	valopt host-triple "$DEFAULT_HOST_TRIPLE" "primary LLVM host triple"
	valopt target-triples "" "LLVM target triples (defaults to host if unset)"

	if [ $HELP -eq 1 ]
	then
	echo ""
	exit 0
	fi


	step_msg "looking for build programs"

	probe_need CFG_PERL perl
	probe_need CFG_PYTHON python python2.6 python2 python3
	probe_need CFG_CURL curl

	probe CFG_GIT git
	probe CFG_CLANG clang++
	probe CFG_GCC gcc
	probe CFG_LLVM_CONFIG llvm-config
	probe CFG_VALGRIND valgrind
	probe CFG_PERF perf
	probe CFG_MAKENSIS makensis
	probe CFG_NATURALDOCS NaturalDocs naturaldocs
	probe CFG_LLNEXTGEN LLnextgen
	probe CFG_PANDOC pandoc
	probe CFG_PDFLATEX pdflatex
	probe CFG_XETEX xetex
	probe CFG_LUATEX luatex
	probe CFG_NODE nodejs node


	if [ ! -z "$CFG_PANDOC" ]
	then
	PV=$(pandoc --version \| awk '/^pandoc/ {print $2}')
	if [ "$PV" \< "1.8" ]
	then
	step_msg "pandoc $PV is too old. disabling"
	BAD_PANDOC=1
	fi
	fi

	if [ -z "$CFG_ENABLE_CLANG" -a -z "$CFG_GCC" ]
	then
	err "either clang or gcc is required"
	fi

	if [ ! -z "$CFG_LLVM_ROOT" -a -e "$CFG_LLVM_ROOT/bin/llvm-config" ]
	then
	step_msg "using custom LLVM at $CFG_LLVM_ROOT"

	LLVM_CONFIG="$CFG_LLVM_ROOT/bin/llvm-config"
	LLVM_VERSION=$($LLVM_CONFIG --version)

	case $LLVM_VERSION in
	(3.1svn)
	msg "found ok version of LLVM: $LLVM_VERSION"
	;;
	(*)
	err "bad LLVM version: $LLVM_VERSION, need >=3.0svn"
	;;
	esac
	fi

	if [ ! -z "$CFG_ENABLE_CLANG" ]
	then
	if [ -z "$CFG_CLANG" ]
	then
	err "clang requested but not found"
	fi
	CFG_CLANG_VERSION=$("$CFG_CLANG" \
	--version \
	\| grep version \
	\| cut -d ' ' -f 3)

	case $CFG_CLANG_VERSION in
	(3.0svn \| 3.0 \| 3.1)
	step_msg "found ok version of CLANG: $CFG_CLANG_VERSION"
	CFG_C_COMPILER="clang"
	;;
	(*)
	err "bad CLANG version: $CFG_CLANG_VERSION, need >=3.0svn"
	;;
	esac
	else
	CFG_C_COMPILER="gcc"
	fi

	if [ -z "$CFG_PREFIX" ]
	then
	CFG_PREFIX=/usr/local
	fi

	if [ -z "$CFG_HOST_TRIPLE" ]
	then
	CFG_HOST_TRIPLE="$DEFAULT_HOST_TRIPLE"
	fi

	if [ -z "$CFG_TARGET_TRIPLES" ]
	then
	CFG_TARGET_TRIPLES="${CFG_HOST_TRIPLE}"
	else
	CFG_TARGET_TRIPLES="$(echo $CFG_TARGET_TRIPLES \| tr ',' ' ')"
	fi

	case $CFG_TARGET_TRIPLES in
	($CFG_HOST_TRIPLE) ;;
	(*) err "Host triple is not among the target triples." ;;
	esac

	if [ -z "$CFG_ENABLE_CLANG" -a -z "$CFG_GCC" ]
	then
	err "either clang or gcc is required"
	fi

	if [ ! -z "$CFG_PERF" ]
	then
	HAVE_PERF_LOGFD=`$CFG_PERF stat --log-fd 2>&1 \| grep 'unknown option'`
	if [ -z "$HAVE_PERF_LOGFD" ];
	then
	CFG_PERF_WITH_LOGFD=1
	putvar CFG_PERF_WITH_LOGFD
	fi
	fi

	step_msg "making directories"

	for i in \
	doc doc/core doc/std \
	nd nd/core nd/std \
	dl tmp
	do
	make_dir $i
	done

	make_dir llvm
	for t in $CFG_TARGET_TRIPLES
	do
	make_dir llvm/$t
	done

	make_dir rustllvm
	for t in $CFG_TARGET_TRIPLES
	do
	make_dir rustllvm/$t
	done

	make_dir rt
	for t in $CFG_TARGET_TRIPLES
	do
	make_dir rt/$t
	for i in \
	isaac bigint sync test arch/i386 arch/x86_64 \
	libuv libuv/src/ares libuv/src/eio libuv/src/ev
	do
	make_dir rt/$t/$i
	done
	done

	# On windows we just store the libraries in the bin directory because
	# there's no rpath
	CFG_LIBDIR=lib
	if [ "$CFG_OSTYPE" = "pc-mingw32" ]
	then
	CFG_LIBDIR=bin
	fi

	for h in $CFG_TARGET_TRIPLES
	do
	for t in $CFG_TARGET_TRIPLES
	do
	for i in 0 1 2 3
	do
	# host bin dir
	make_dir $h/stage$i/bin

	# host lib dir
	make_dir $h/stage$i/$CFG_LIBDIR

	# target bin dir
	make_dir $h/stage$i/$CFG_LIBDIR/rustc/$t/bin

	# target lib dir
	make_dir $h/stage$i/$CFG_LIBDIR/rustc/$t/$CFG_LIBDIR
	done
	done

	make_dir $h/test/run-pass
	make_dir $h/test/run-fail
	make_dir $h/test/compile-fail
	make_dir $h/test/bench
	make_dir $h/test/perf
	make_dir $h/test/pretty
	done

	# Configure submodules
	step_msg "configuring submodules"

	# If we have no git directory then we are probably a tarball distribution
	# and shouldn't attempt to load submodules
	if [ ! -e ${CFG_SRC_DIR}.git ]
	then
	msg "git: no git directory. disabling submodules"
	CFG_DISABLE_MANAGE_SUBMODULES=1
	fi

	# Have to be in the top of src directory for this
	cd ${CFG_SRC_DIR}

	if [ -z $CFG_DISABLE_MANAGE_SUBMODULES ]
	then
	SUBMODULE_STATUS=$("${CFG_GIT}" submodule status)
	NEED_INIT_COUNT=$(echo "$SUBMODULE_STATUS" \| grep -c "^-")
	NEED_UPDATE_COUNT=$(echo "$SUBMODULE_STATUS" \| grep -c "^+")
	NEED_INIT=$(test $NEED_INIT_COUNT -gt 0)$?
	NEED_UPDATE=$(test "($NEED_INIT)" -o "$NEED_UPDATE_COUNT" -gt 0)$?
	else
	NEED_INIT=
	NEED_UPDATE=
	fi

	if [ $NEED_INIT ]
	then
	msg "git: submodule init"
	"${CFG_GIT}" submodule init --quiet
	need_ok "git failed"
	fi

	if [ $NEED_UPDATE ]
	then
	msg "git: submodule update"
	"${CFG_GIT}" submodule update --quiet
	need_ok "git failed"
	fi

	cd ${CFG_BUILD_DIR}


	# Configure llvm. Here we go...
	CFG_LLVM_SRC_DIR=${CFG_SRC_DIR}src/llvm

	for t in $CFG_TARGET_TRIPLES
	do
	if [ -z $CFG_LLVM_ROOT ]
	then
	step_msg "configuring LLVM for $t"

	LLVM_BUILD_DIR=$CFG_BUILD_DIR/llvm/$t

	LLVM_TARGETS="--enable-targets=x86,x86_64"
	LLVM_BUILD="--build=$t"
	LLVM_HOST="--host=$t"
	LLVM_TARGET="--target=$t"

	if [ ! -z "$CFG_DISABLE_OPTIMIZE_LLVM" ]
	then
	LLVM_DBG_OPTS=""
	# Just use LLVM straight from its build directory to
	# avoid 'make install' time
	LLVM_INST_DIR=$LLVM_BUILD_DIR/Debug+Asserts
	else
	LLVM_DBG_OPTS="--enable-optimized"
	LLVM_INST_DIR=$LLVM_BUILD_DIR/Release+Asserts
	fi
	# Disable unused LLVM features
	LLVM_OPTS="$LLVM_DBG_OPTS --disable-docs --disable-jit --enable-bindings=none --disable-threads --disable-pthreads"

	LLVM_CXX_32="g++ -m32"
	LLVM_CC_32="gcc -m32"
	LLVM_CFLAGS_32="-m32"
	LLVM_CXXFLAGS_32="-m32"
	LLVM_LDFLAGS_32="-m32"

	LLVM_CXX_64="g++"
	LLVM_CC_64="gcc"
	LLVM_CFLAGS_64=""
	LLVM_CXXFLAGS_64=""
	LLVM_LDFLAGS_64=""

	if echo $t \| grep x86_64
	then
	LLVM_CXX=$LLVM_CXX_64
	LLVM_CC=$LLVM_CC_64
	LLVM_CFLAGS=$LLVM_CFLAGS_64
	LLVM_CXXFLAGS=$LLVM_CXXFLAGS_64
	LLVM_LDFLAGS=$LLVM_LDFLAGS_64
	else
	LLVM_CXX=$LLVM_CXX_32
	LLVM_CC=$LLVM_CC_32
	LLVM_CFLAGS=$LLVM_CFLAGS_32
	LLVM_CXXFLAGS=$LLVM_CXXFLAGS_32
	LLVM_LDFLAGS=$LLVM_LDFLAGS_32
	fi

	CXX=$LLVM_CXX
	CC=$LLVM_CC
	CFLAGS=$LLVM_CFLAGS
	CXXFLAGS=$LLVM_CXXFLAGS
	LDFLAGS=$LLVM_LDFLAGS

	LLVM_FLAGS="$LLVM_TARGETS $LLVM_OPTS $LLVM_BUILD $LLVM_HOST $LLVM_TARGET"

	msg "configuring LLVM with:"
	msg "$LLVM_FLAGS"

	export CXX
	export CC
	export CFLAGS
	export CXXFLAGS
	export LDFLAGS

	cd $LLVM_BUILD_DIR
	case $CFG_SRC_DIR in
	/* \| [a-z]:* \| [A-Z]:*)
	${CFG_LLVM_SRC_DIR}/configure $LLVM_FLAGS
	;;
	*)
	${CFG_BUILD_DIR}/${CFG_LLVM_SRC_DIR}/configure $LLVM_FLAGS
	;;
	esac
	need_ok "LLVM configure failed"
	cd $CFG_BUILD_DIR
	else
	LLVM_BUILD_DIR=
	# The user is using their own LLVM
	LLVM_INST_DIR=$CFG_LLVM_ROOT
	fi

	# Construct variables for LLVM build and install directories for
	# each target. These will be named
	# CFG_LLVM_BUILD_DIR_${target_triple} but all the hyphens in
	# target_triple will be converted to underscore, because bash
	# variables can't contain hyphens. The makefile will then have to
	# convert back.
	CFG_LLVM_BUILD_DIR=$(echo CFG_LLVM_BUILD_DIR_${t} \| tr - _)
	CFG_LLVM_INST_DIR=$(echo CFG_LLVM_INST_DIR_${t} \| tr - _)
	eval ${CFG_LLVM_BUILD_DIR}="'$LLVM_BUILD_DIR'"
	eval ${CFG_LLVM_INST_DIR}="'$LLVM_INST_DIR'"
	done


	step_msg "writing configuration"

	putvar CFG_SRC_DIR
	putvar CFG_BUILD_DIR
	putvar CFG_OSTYPE
	putvar CFG_CPUTYPE
	putvar CFG_CONFIGURE_ARGS
	putvar CFG_HOST_TRIPLE
	putvar CFG_TARGET_TRIPLES
	putvar CFG_C_COMPILER
	putvar CFG_PREFIX
	putvar CFG_LIBDIR

	# Setting this again because it may have been changed
	if [ $CFG_DISABLE_MANAGE_SUBMODULES ]
	then
	putvar CFG_DISABLE_MANAGE_SUBMODULES
	fi

	# Ditto for pandoc
	if [ ! -z $BAD_PANDOC ]
	then
	CFG_PANDOC=
	putvar CFG_PANDOC
	fi

	if head -n 1 ${CFG_SRC_DIR}src/snapshots.txt \| grep -q '^T'
	then
	CFG_IN_TRANSITION=1
	putvar CFG_IN_TRANSITION
	fi

	# Valgrind is only reliable on Linux. On Windows it doesn't work at all, and
	# on the Mac the dynamic linker causes Valgrind to emit a huge stream of
	# errors.
	if [ $CFG_OSTYPE != unknown-linux-gnu ] && [ $CFG_OSTYPE != apple-darwin ]
	then
	CFG_BAD_VALGRIND=1
	putvar CFG_BAD_VALGRIND
	fi

	putvar CFG_LLVM_ROOT
	putvar CFG_LLVM_SRC_DIR

	for t in $CFG_TARGET_TRIPLES
	do
	CFG_LLVM_BUILD_DIR=$(echo CFG_LLVM_BUILD_DIR_${t} \| tr - _)
	CFG_LLVM_INST_DIR=$(echo CFG_LLVM_INST_DIR_${t} \| tr - _)
	putvar $CFG_LLVM_BUILD_DIR
	putvar $CFG_LLVM_INST_DIR
	done


	# Munge any paths that appear in config.mk back to posix-y
	perl -i.bak -p -e 's@ ([a-zA-Z]):[/\\]@ /\1/@go;' \
	-e 's@\\@/@go;' config.mk
	rm -f config.mk.bak

	msg
	copy ${CFG_SRC_DIR}Makefile.in ./Makefile

	step_msg "complete"