| #!/usr/bin/env bash |
| # ################################################################################################ # |
| # MetaStack Solutions Ltd. # |
| # ################################################################################################ # |
| # Microsoft C Compiler Environment Detection Script # |
| # ################################################################################################ # |
| # Copyright (c) 2016, 2017, 2018, 2019, 2020 MetaStack Solutions Ltd. # |
| # ################################################################################################ # |
| # Author: David Allsopp # |
| # 16-Feb-2016 # |
| # ################################################################################################ # |
| # Redistribution and use in source and binary forms, with or without modification, are permitted # |
| # provided that the following two conditions are met: # |
| # 1. Redistributions of source code must retain the above copyright notice, this list of # |
| # conditions and the following disclaimer. # |
| # 2. Neither the name of MetaStack Solutions Ltd. nor the names of its contributors may be # |
| # used to endorse or promote products derived from this software without specific prior # |
| # written permission. # |
| # # |
| # This software is provided by the Copyright Holder 'as is' and any express or implied warranties # |
| # including, but not limited to, the implied warranties of merchantability and fitness for a # |
| # particular purpose are disclaimed. In no event shall the Copyright Holder be liable for any # |
| # direct, indirect, incidental, special, exemplary, or consequential damages (including, but not # |
| # limited to, procurement of substitute goods or services; loss of use, data, or profits; or # |
| # business interruption) however caused and on any theory of liability, whether in contract, # |
| # strict liability, or tort (including negligence or otherwise) arising in any way out of the use # |
| # of this software, even if advised of the possibility of such damage. # |
| # ################################################################################################ # |
| |
| VERSION=0.4.1 |
| |
| # debug [level=2] message |
| debug () |
| { |
| if [[ -z ${2+x} ]] ; then |
| DEBUG_LEVEL=2 |
| else |
| DEBUG_LEVEL=$1 |
| shift |
| fi |
| |
| if [[ $DEBUG -ge $DEBUG_LEVEL ]] ; then |
| echo "$1">&2 |
| fi |
| } |
| |
| # warning message |
| warning () |
| { |
| if [[ $DEBUG -gt 0 ]] ; then |
| echo "Warning: $1">&2 |
| fi |
| } |
| |
| # reg_string key value |
| # Retrieves a REG_SZ value from the registry (redirected on WOW64) |
| reg_string () |
| { |
| reg query "$1" /v "$2" 2>/dev/null | tr -d '\r' | sed -ne "s/ *$2 *REG_SZ *//p" |
| } |
| |
| # reg64_string key value |
| # As reg_string, but without WOW64 redirection (i.e. guaranteed access to 64-bit registry) |
| reg64_string () |
| { |
| $REG64 query "$1" /v "$2" 2>/dev/null | tr -d '\r' | sed -ne "s/ *$2 *REG_SZ *//p" |
| } |
| |
| # find_in list file |
| # Increments $RET if file does not exist in any of the directories in the *-separated list |
| find_in () |
| { |
| debug 4 "Looking for $2 in $1" |
| if [[ -z $1 ]] ; then |
| STATUS=1 |
| else |
| IFS=* |
| STATUS=1 |
| for f in $1; do |
| if [[ -e "$f/$2" ]] ; then |
| STATUS=0 |
| break |
| fi |
| done |
| unset IFS |
| fi |
| if [[ $STATUS -eq 1 ]] ; then |
| debug 4 "$2 not found" |
| fi |
| ((RET+=STATUS)) |
| } |
| |
| # check_environment PATH INC LIB name arch |
| # By checking for the presence of various files, verifies that PATH, INC and LIB provide a complete |
| # compiler and indicates this in its return status. RET is assumed to be zero on entry. $ASSEMBLER |
| # will contain the name of assembler for this compiler series (ml.exe or ml64.exe). |
| # The following files are checked: |
| # cl.exe PATH Microsoft C compiler |
| # kernel32.lib LIB Implies Windows SDK present |
| # link.exe PATH Microsoft Linker |
| # ml[64].exe PATH Microsoft Assembler (ml.exe or ml64.exe) |
| # msvcrt.lib LIB Implies C Runtime Libraries present |
| # mt.exe PATH Microsoft Manifest Tool |
| # oldnames.lib LIB Implies C Runtime Libraries present |
| # rc.exe PATH Microsoft Resource Compiler (implies tools present) |
| # stdlib.h INC Implies Microsoft C Runtime Libraries present |
| # windows.h INC Implies Windows SDK present |
| # oldnames.lib is included, because certain SDKs and older versions don't correctly install the |
| # entire runtime if only some options (e.g. Dynamic Runtime and not Static) are selected. |
| check_environment () |
| { |
| debug 4 "Checking $4 ($5)" |
| for tool in cl rc link ; do |
| find_in "$1" $tool.exe |
| done |
| |
| if [[ $RET -gt 0 ]] ; then |
| warning "Microsoft C Compiler tools not all found - $4 ($5) excluded" |
| return 1 |
| fi |
| |
| RET=0 |
| find_in "$2" windows.h |
| find_in "$3" kernel32.lib |
| if [[ $RET -gt 0 ]] ; then |
| warning "Windows SDK not all found - $4 ($5) excluded" |
| return 1 |
| fi |
| |
| RET=0 |
| find_in "$2" stdlib.h |
| find_in "$3" msvcrt.lib |
| find_in "$3" oldnames.lib |
| if [[ $RET -gt 0 ]] ; then |
| warning "Microsoft C runtime library not all found - $4 ($5) excluded" |
| return 1 |
| fi |
| |
| ASSEMBLER=ml${5#x} |
| ASSEMBLER=${ASSEMBLER%86}.exe |
| if [[ $ML_REQUIRED -eq 1 ]] ; then |
| RET=0 |
| find_in "$1" $ASSEMBLER |
| if [[ $RET -gt 0 ]] ; then |
| warning "Microsoft Assembler ($ASSEMBLER) not found - $4 ($5)" |
| return 1 |
| fi |
| fi |
| |
| if [[ $MT_REQUIRED -eq 1 ]] ; then |
| RET=0 |
| find_in "$1" mt.exe |
| if [[ $RET -gt 0 ]] ; then |
| warning "Microsoft Manifest Tool not found - $4 ($5)" |
| return 1 |
| fi |
| fi |
| |
| return 0 |
| } |
| |
| # output VAR value arch |
| # Outputs a command for setting VAR to value based on $OUTPUT. If $ENV_ARCH is arch, then an empty |
| # value (i.e. no change) is output. |
| output () |
| { |
| if [[ $3 = $ENV_ARCH ]] ; then |
| VALUE= |
| else |
| VALUE=$2 |
| fi |
| case "$OUTPUT" in |
| 0) |
| echo "$1='${VALUE//\'/\'\"\'\"\'}'";; |
| 1) |
| VALUE=${VALUE//#/\\\#} |
| echo "$1=${VALUE//\$/\$\$}";; |
| esac |
| } |
| |
| # DEBUG Debugging level |
| # MODE Operation mode |
| # 0 - Normal |
| # 1 - --all |
| # 2 - --help |
| # 3 - --version |
| # OUTPUT --output option |
| # 0 - =shell |
| # 1 - =make |
| # MT_REQUIRED --with-mt |
| # ML_REQUIRED --with-assembler |
| # TARGET_ARCH Normalised --arch (x86, x64 or blank for both) |
| # LEFT_ARCH \ If $TARGET_ARCH is blank, these will be x86 and x64 respectively, otherwise they |
| # RIGHT_ARCH / equal $TARGET_ARCH |
| # SCAN_ENV Controls from parsing whether the environment should be queried for a compiler |
| DEBUG=0 |
| MODE=0 |
| OUTPUT=0 |
| MT_REQUIRED=0 |
| ML_REQUIRED=0 |
| TARGET_ARCH= |
| SCAN_ENV=0 |
| |
| # Various PATH messing around means it's sensible to know where tools are now |
| WHICH=$(which which) |
| |
| if [[ $(uname --operating-system 2>/dev/null) = "Msys" ]] ; then |
| # Prevent MSYS from translating command line switches to paths |
| SWITCH_PREFIX='//' |
| else |
| SWITCH_PREFIX='/' |
| fi |
| |
| # Parse command-line. At the moment, the short option which usefully combines with anything is -d, |
| # so for the time being, combining short options is not permitted, as the loop becomes even less |
| # clear with getopts. GNU getopt isn't installed by default on Cygwin... |
| if [[ $@ != "" ]] ; then |
| while true ; do |
| case "$1" in |
| # Mode settings ($MODE) |
| -a|--all) |
| MODE=1 |
| shift 1;; |
| -h|--help) |
| MODE=2 |
| shift;; |
| -v|--version) |
| MODE=3 |
| shift;; |
| |
| # Simple flags ($MT_REQUIRED and $ML_REQUIRED) |
| --with-mt) |
| MT_REQUIRED=1 |
| shift;; |
| --with-assembler) |
| ML_REQUIRED=1 |
| shift;; |
| |
| # -o, --output ($OUTPUT) |
| -o|--output) |
| case "$2" in |
| shell) |
| ;; |
| make) |
| OUTPUT=1;; |
| *) |
| echo "$0: unrecognised option for $1: '$2'">&2 |
| exit 2;; |
| esac |
| shift 2;; |
| -oshell|--output=shell) |
| shift;; |
| -omake|--output=make) |
| OUTPUT=1 |
| shift;; |
| -o*) |
| echo "$0: unrecognised option for -o: '${1#-o}'">&2 |
| exit 2;; |
| --output=*) |
| echo "$0: unrecognised option for --output: '${1#--output=}'">&2 |
| exit 2;; |
| |
| # -x, --arch ($TARGET_ARCH) |
| -x|--arch) |
| case "$2" in |
| 86|x86) |
| TARGET_ARCH=x86;; |
| 64|x64) |
| TARGET_ARCH=x64;; |
| *) |
| echo "$0: unrecognised option for $1: '$2'">&2 |
| exit 2 |
| esac |
| shift 2;; |
| -x86|-xx86|--arch=x86|--arch=86) |
| TARGET_ARCH=x86 |
| shift;; |
| -x64|-xx64|--arch=x64|--arch=64) |
| TARGET_ARCH=x64 |
| shift;; |
| -x*) |
| echo "$0: unrecognised option for -x: '${1#-x}'">&2 |
| exit 2;; |
| --arch=*) |
| echo "$0: unrecognised option for --arch: '${1#--arch}'">&2 |
| exit 2;; |
| |
| # -d, --debug ($DEBUG) |
| -d*) |
| DEBUG=${1#-d} |
| if [[ -z $DEBUG ]] ; then |
| DEBUG=1 |
| fi |
| shift;; |
| --debug=*) |
| DEBUG=${1#*=} |
| shift;; |
| --debug) |
| DEBUG=1 |
| shift;; |
| |
| # End of option marker |
| --) |
| shift |
| break;; |
| |
| # Invalid options |
| --*) |
| echo "$0: unrecognised option: '${1%%=*}'">&2 |
| exit 2;; |
| -*) |
| echo "$0: unrecognised option: '${1:1:1}'">&2 |
| exit 2;; |
| |
| # MSVS_PREFERENCE (without end-of-option marker) |
| *) |
| break;; |
| esac |
| done |
| |
| if [[ -n ${1+x} ]] ; then |
| if [[ $MODE -eq 1 ]] ; then |
| echo "$0: cannot specify MSVS_PREFERENCE and --all">&2 |
| exit 2 |
| else |
| MSVS_PREFERENCE="$@" |
| fi |
| fi |
| fi |
| |
| # Options sanitising |
| if [[ $MODE -eq 1 ]] ; then |
| if [[ -n $TARGET_ARCH ]] ; then |
| echo "$0: --all and --arch are mutually exclusive">&2 |
| exit 2 |
| fi |
| MSVS_PREFERENCE= |
| SCAN_ENV=1 |
| elif [[ -z ${MSVS_PREFERENCE+x} ]] ; then |
| MSVS_PREFERENCE='@;VS16.*;VS15.*;VS14.0;VS12.0;VS11.0;10.0;9.0;8.0;7.1;7.0' |
| fi |
| |
| MSVS_PREFERENCE=${MSVS_PREFERENCE//;/ } |
| |
| if [[ -z $TARGET_ARCH ]] ; then |
| LEFT_ARCH=x86 |
| RIGHT_ARCH=x64 |
| else |
| LEFT_ARCH=$TARGET_ARCH |
| RIGHT_ARCH=$TARGET_ARCH |
| fi |
| |
| # Command line parsing complete (MSVS_PREFERENCE pending) |
| |
| NAME="Microsoft C Compiler Environment Detection Script" |
| case $MODE in |
| 2) |
| echo "$NAME" |
| echo "Queries the environment and registry to locate Visual Studio / Windows SDK" |
| echo "installations and uses their initialisation scripts (SetEnv.cmd, vcvarsall.bat," |
| echo "etc.) to determine INCLUDE, LIB and PATH alterations." |
| echo |
| echo "Usage:" |
| echo " $0 [OPTIONS] [--] [MSVS_PREFERENCE]" |
| echo |
| echo "Options:" |
| echo " -a, --all Display all available compiler packages" |
| echo " -x, --arch=ARCH Only consider packages for ARCH (x86 or x64). Default is" |
| echo " to return packages containing both architectures" |
| echo " -d, --debug[=LEVEL] Set debug messages level" |
| echo " -h, --help Display this help screen" |
| echo " -o, --output=OUTPUT Set final output. Default is shell. Valid values:" |
| echo " shell - shell assignments, for use with eval" |
| echo " make - make assignments, for inclusion in a Makefile" |
| echo " -v, --version Display the version" |
| echo " --with-mt Only consider packages including the Manifest Tool" |
| echo " --with-assembler Only consider packages including an assembler" |
| echo |
| echo "If MSVS_PREFERENCE is not given, then the environment variable MSVS_PREFERENCE" |
| echo "is read. MSVS_PREFERENCE is a semicolon separated list of preferred versions." |
| echo "Three kinds of version notation are supported:" |
| echo " 1. @ - which refers to the C compiler found in PATH (if it can be identified)" |
| echo " (this allows the C compiler corresponding to the opposite architecture to" |
| echo " be selected, if possible)." |
| echo " 2. mm.n - which refers to a Visual Studio version (e.g. 14.0, 7.1) but which" |
| echo " also allows an SDK to provide the compiler (e.g. Windows SDK 7.1 provides" |
| echo " 10.0). Visual Studio packages are always preferred ahead of SDKs." |
| echo " 3. SPEC - an actual package specification. Visual Studio packages are VSmm.n" |
| echo " (e.g. VS14.0, VS7.1) and SDK packages are SDKm.n (e.g. SDK7.1)." |
| echo " Any Visual Studio 2017 update can be selected with VS15.*" |
| echo "The default behaviour is to match the environment compiler followed by the most" |
| echo "recent version of the compiler." |
| exit 0;; |
| 3) |
| echo "$NAME" |
| echo "Version $VERSION" |
| exit 0;; |
| esac |
| |
| # Known compiler packages. Visual Studio .NET 2002 onwards. Detection is in place for Visual Studio |
| # 2005 Express, but because it doesn't include a Windows SDK, it can only ever be detected if the |
| # script has been launched from within a Platform SDK command prompt (this provides the Windows |
| # Headers and Libraries which allows this script to detect the rest). |
| # Each element is either a Visual Studio or SDK package and the value is the syntax for a bash |
| # associative array to be eval'd. Each of these contains the following properties: |
| # NAME - the friendly name of the package |
| # ENV - (VS only) the version-specific portion of the VSCOMNTOOLS environment variable |
| # VERSION - (VS only) version number of the package |
| # ARCH - Lists the architectures available in this version |
| # ARCH_SWITCHES - The script is assumed to accept x86 and x64 to indicate architecture. This key |
| # contains another eval'd associative array allowing alternate values to be given |
| # SETENV_RELEASE - (SDK only) script switch necessary to select release than debugging versions |
| # EXPRESS - (VS only) the prefix to the registry key to detect the Express edition |
| # EXPRESS_ARCH - (VS only) overrides ARCH if Express edition is detected |
| # EXPRESS_ARCH_SWITCHES - (VS only) overrides ARCH_SWITCHES if Express edition is detected |
| # VC_VER - (SDK only) specifies the version of the C Compilers included in the SDK (SDK |
| # equivalent of the VERSION key) |
| # REG_KEY - (SDK only) registry key to open to identify this package installation |
| # REG_VALUE - (SDK only) registry value to query to identify this package installation |
| # VSWHERE - (VS 2017+) is 1 if the compiler can only be detected using vswhere |
| # For a while, Windows SDKs followed a standard pattern which is stored in the SDK element and |
| # copied to the appropriate version. SDKs after 7.1 do not include compilers, and so are not |
| # captured (as of Visual Studio 2015, the Windows SDK is official part of Visual Studio). |
| declare -A COMPILERS |
| SDK52_KEY='HKLM\SOFTWARE\Microsoft\MicrosoftSDK\InstalledSDKs\8F9E5EF3-A9A5-491B-A889-C58EFFECE8B3' |
| COMPILERS=( |
| ["VS7.0"]='( |
| ["NAME"]="Visual Studio .NET 2002" |
| ["ENV"]="" |
| ["VERSION"]="7.0" |
| ["ARCH"]="x86")' |
| ["VS7.1"]='( |
| ["NAME"]="Visual Studio .NET 2003" |
| ["ENV"]="71" |
| ["VERSION"]="7.1" |
| ["ARCH"]="x86")' |
| ["VS8.0"]='( |
| ["NAME"]="Visual Studio 2005" |
| ["ENV"]="80" |
| ["VERSION"]="8.0" |
| ["EXPRESS"]="VC" |
| ["ARCH"]="x86 x64" |
| ["EXPRESS_ARCH"]="x86")' |
| ["VS9.0"]='( |
| ["NAME"]="Visual Studio 2008" |
| ["ENV"]="90" |
| ["VERSION"]="9.0" |
| ["EXPRESS"]="VC" |
| ["ARCH"]="x86 x64" |
| ["EXPRESS_ARCH"]="x86")' |
| ["VS10.0"]='( |
| ["NAME"]="Visual Studio 2010" |
| ["ENV"]="100" |
| ["VERSION"]="10.0" |
| ["EXPRESS"]="VC" |
| ["ARCH"]="x86 x64" |
| ["EXPRESS_ARCH"]="x86")' |
| ["VS11.0"]='( |
| ["NAME"]="Visual Studio 2012" |
| ["ENV"]="110" |
| ["VERSION"]="11.0" |
| ["EXPRESS"]="WD" |
| ["ARCH"]="x86 x64" |
| ["EXPRESS_ARCH_SWITCHES"]="([\"x64\"]=\"x86_amd64\")")' |
| ["VS12.0"]='( |
| ["NAME"]="Visual Studio 2013" |
| ["ENV"]="120" |
| ["VERSION"]="12.0" |
| ["EXPRESS"]="WD" |
| ["ARCH"]="x86 x64" |
| ["EXPRESS_ARCH_SWITCHES"]="([\"x64\"]=\"x86_amd64\")")' |
| ["VS14.0"]='( |
| ["NAME"]="Visual Studio 2015" |
| ["ENV"]="140" |
| ["VERSION"]="14.0" |
| ["ARCH"]="x86 x64")' |
| ["VS15.*"]='( |
| ["NAME"]="Visual Studio 2017" |
| ["VSWHERE"]="1")' |
| ["VS16.*"]='( |
| ["NAME"]="Visual Studio 2019" |
| ["VSWHERE"]="1")' |
| ["SDK5.2"]='( |
| ["NAME"]="Windows Server 2003 SP1 SDK" |
| ["VC_VER"]="8.0" |
| ["REG_KEY"]="$SDK52_KEY" |
| ["REG_VALUE"]="Install Dir" |
| ["SETENV_RELEASE"]="/RETAIL" |
| ["ARCH"]="x64" |
| ["ARCH_SWITCHES"]="([\"x64\"]=\"/X64\")")' |
| ["SDK"]='( |
| ["NAME"]="Generalised Windows SDK" |
| ["SETENV_RELEASE"]="/Release" |
| ["ARCH"]="x86 x64" |
| ["ARCH_SWITCHES"]="([\"x86\"]=\"/x86\" [\"x64\"]=\"/x64\")")' |
| ["SDK6.1"]='( |
| ["NAME"]="Windows Server 2008 with .NET 3.5 SDK" |
| ["VC_VER"]="9.0")' |
| ["SDK7.0"]='( |
| ["NAME"]="Windows 7 with .NET 3.5 SP1 SDK" |
| ["VC_VER"]="9.0")' |
| ["SDK7.1"]='( |
| ["NAME"]="Windows 7 with .NET 4 SDK" |
| ["VC_VER"]="10.0")' |
| ) |
| |
| # FOUND is ultimately an associative array containing installed compiler packages. It's |
| # hijacked here as part of MSVS_PREFERENCE validation. |
| # Ultimately, it contains a copy of the value from COMPILERS with the following extra keys: |
| # IS_EXPRESS - (VS only) indicates whether the Express edition was located |
| # SETENV - (SDK only) the full location of the SetEnv.cmd script |
| # ASSEMBLER - the name of the assembler (ml or ml64) |
| # MSVS_PATH \ |
| # MSVS_INC > prefix values for PATH, INCLUDE and LIB determined by running the scripts. |
| # MSVS_LIB / |
| declare -A FOUND |
| |
| # Check that MSVS_PREFERENCE is valid and contains no repetitions. |
| for v in $MSVS_PREFERENCE ; do |
| if [[ -n ${FOUND[$v]+x} ]] ; then |
| echo "$0: corrupt MSVS_PREFERENCE: repeated '$v'">&2 |
| exit 2 |
| fi |
| if [[ $v != "@" ]] ; then |
| if [[ -z ${COMPILERS[$v]+x} && -z ${COMPILERS["VS$v"]+x} && -z ${COMPILERS[${v%.*}.*]+x} ]] ; then |
| echo "$0: corrupt MSVS_PREFERENCE: unknown compiler '$v'">&2 |
| exit 2 |
| fi |
| else |
| SCAN_ENV=1 |
| fi |
| FOUND["$v"]="" |
| done |
| |
| # Reset FOUND for later use. |
| FOUND=() |
| |
| # Scan the environment for a C compiler, and check that it's valid. Throughout the rest of the |
| # script, it is assumed that if ENV_ARCH is set then there is a valid environment compiler. |
| if [[ $SCAN_ENV -eq 1 ]] ; then |
| if "$WHICH" cl >/dev/null 2>&1 ; then |
| # Determine its architecture from the Microsoft Logo line. |
| ENV_ARCH=$(cl 2>&1 | head -1 | tr -d '\r') |
| case "${ENV_ARCH#* for }" in |
| x64|AMD64) |
| ENV_ARCH=x64;; |
| 80x86|x86) |
| ENV_ARCH=x86;; |
| *) |
| echo "Unable to identify C compiler architecture from '${ENV_ARCH#* for }'">&2 |
| echo "Environment C compiler discarded">&2 |
| unset ENV_ARCH;; |
| esac |
| |
| # Environment variable names are a bit of a nightmare on Windows - they are actually case |
| # sensitive (at the kernel level) but not at the user level! To compound the misery is that SDKs |
| # use Include and Lib where vcvars32 tends to use INCLUDE and LIB. Windows versions also contain |
| # a mix of Path and PATH, but fortunately Cygwin normalises that to PATH for us! For this |
| # reason, use env to determine the actual case of the LIB and INCLUDE variables. |
| if [[ -n ${ENV_ARCH+x} ]] ; then |
| RET=0 |
| ENV_INC=$(env | sed -ne 's/^\(INCLUDE\)=.*/\1/pi') |
| ENV_LIB=$(env | sed -ne 's/^\(LIB\)=.*/\1/pi') |
| if [[ -z $ENV_INC || -z $ENV_LIB ]] ; then |
| warning "Microsoft C Compiler Include and/or Lib not set - Environment C compiler ($ENV_ARCH) excluded" |
| unset ENV_ARCH |
| else |
| if check_environment "${PATH//:/*}" \ |
| "${!ENV_INC//;/*}" \ |
| "${!ENV_LIB//;/*}" \ |
| "Environment C compiler" \ |
| "$ENV_ARCH" ; then |
| ENV_CL=$("$WHICH" cl) |
| ENV_cl=${ENV_CL,,} |
| ENV_cl=${ENV_cl/bin\/*_/bin\/} |
| debug "Environment appears to include a compiler at $ENV_CL" |
| if [[ -n $TARGET_ARCH && $TARGET_ARCH != $ENV_ARCH ]] ; then |
| debug "But architecture doesn't match required value" |
| unset ENV_ARCH |
| fi |
| else |
| unset ENV_ARCH |
| fi |
| fi |
| fi |
| fi |
| fi |
| |
| # Even if launched from a 64-bit Command Prompt, Cygwin is usually 32-bit and so the scripts |
| # executed will inherit that fact. This is a problem when querying the registry, but fortunately |
| # WOW64 provides a mechanism to break out of the 32-bit environment by mapping $WINDIR/sysnative to |
| # the real 64-bit programs. |
| # Thus: |
| # MS_ROOT is the 32-bit Microsoft Registry key (all Visual Studio keys are located there) |
| # REG64 is the processor native version of the reg utility (allowing 64-bit keys to be read for |
| # the SDKs) |
| if [[ -n ${PROCESSOR_ARCHITEW6432+x} ]] ; then |
| debug "WOW64 detected" |
| MS_ROOT='HKLM\SOFTWARE\Microsoft' |
| REG64=$WINDIR/sysnative/reg |
| else |
| MS_ROOT='HKLM\SOFTWARE\Wow6432Node\Microsoft' |
| REG64=reg |
| fi |
| |
| # COMPILER contains each eval'd element from COMPILERS |
| declare -A COMPILER |
| |
| # Scan the registry for compiler package (vswhere is later) |
| for i in "${!COMPILERS[@]}" ; do |
| eval COMPILER=${COMPILERS[$i]} |
| |
| if [[ -n ${COMPILER["ENV"]+x} ]] ; then |
| # Visual Studio package - test for its environment variable |
| ENV=VS${COMPILER["ENV"]}COMNTOOLS |
| if [[ -n ${!ENV+x} ]] ; then |
| debug "$ENV is a candidate" |
| TEST_PATH=${!ENV%\"} |
| TEST_PATH=$(cygpath -u -f - <<< ${TEST_PATH#\"}) |
| if [[ -e $TEST_PATH/vsvars32.bat ]] ; then |
| debug "Directory pointed to by $ENV contains vsvars32.bat" |
| EXPRESS=0 |
| # Check for the primary Visual Studio registry value indicating installation |
| INSTALL_DIR=$(reg_string "$MS_ROOT\\VisualStudio\\${COMPILER["VERSION"]}" InstallDir) |
| if [[ -z $INSTALL_DIR ]] ; then |
| if [[ -n ${COMPILER["EXPRESS"]+x} ]] ; then |
| TEST_KEY="$MS_ROOT\\${COMPILER["EXPRESS"]}Express\\${COMPILER["VERSION"]}" |
| INSTALL_DIR=$(reg_string "$TEST_KEY" InstallDir) |
| # Exception for Visual Studio 2005 Express, which doesn't set the registry correctly, so |
| # set INSTALL_DIR to a fake value to pass the next test. |
| if [[ ${COMPILER["VERSION"]} = "8.0" ]] ; then |
| INSTALL_DIR=$(cygpath -w "$TEST_PATH") |
| EXPRESS=1 |
| else |
| if [[ -z $INSTALL_DIR ]] ; then |
| warning "vsvars32.bat found, but registry value not located (Exp or Pro)" |
| else |
| EXPRESS=1 |
| fi |
| fi |
| else |
| warning "vsvars32.bat found, but registry value not located" |
| fi |
| fi |
| |
| if [[ -n $INSTALL_DIR ]] ; then |
| if [[ ${TEST_PATH%/} = $(cygpath -u "$INSTALL_DIR\\..\\Tools") ]] ; then |
| RESULT=${COMPILERS[$i]%)} |
| DISPLAY=${COMPILER["NAME"]} |
| if [[ $EXPRESS -eq 1 ]] ; then |
| DISPLAY="$DISPLAY Express" |
| fi |
| FOUND+=(["$i"]="$RESULT [\"DISPLAY\"]=\"$DISPLAY\" [\"IS_EXPRESS\"]=\"$EXPRESS\")") |
| debug "${COMPILER["NAME"]} accepted for further detection" |
| else |
| warning "$ENV doesn't agree with registry" |
| fi |
| else |
| warning "vsvars32.bat found, but registry settings not found" |
| fi |
| else |
| warning "$ENV set, but vsvars32.bat not found" |
| fi |
| fi |
| elif [[ -n ${COMPILER["REG_KEY"]+x} ]] ; then |
| # SDK with explicit registry detection value |
| INSTALL_DIR=$(reg64_string "${COMPILER["REG_KEY"]}" "${COMPILER["REG_VALUE"]}") |
| if [[ -n $INSTALL_DIR ]] ; then |
| TEST_PATH=$(cygpath -u "$INSTALL_DIR") |
| if [[ -e $TEST_PATH/SetEnv.cmd ]] ; then |
| RESULT=${COMPILERS[$i]%)} |
| FOUND+=(["$i"]="$RESULT [\"DISPLAY\"]=\"${COMPILER["NAME"]}\" [\"SETENV\"]=\"$INSTALL_DIR\\SetEnv.cmd\")") |
| debug "${COMPILER["NAME"]} accepted for further detection" |
| else |
| warning "Registry set for Windows Server 2003 SDK, but SetEnv.cmd not found" |
| fi |
| fi |
| fi |
| done |
| |
| # Now enumerate installed SDKs for v6.0+ |
| SDK_ROOT='HKLM\SOFTWARE\Microsoft\Microsoft SDKs\Windows' |
| for i in $(reg query "$SDK_ROOT" 2>/dev/null | tr -d '\r' | sed -ne '/Windows\\v/s/.*\\//p') ; do |
| debug "Analysing SDK key $SDK_ROOT\\$i" |
| INSTALL_DIR=$(reg_string "$SDK_ROOT\\$i" InstallationFolder) |
| if [[ -n $INSTALL_DIR ]] ; then |
| TEST_PATH=$(cygpath -u "$INSTALL_DIR") |
| if [[ -e $TEST_PATH/Bin/SetEnv.cmd ]] ; then |
| if [[ -z ${COMPILERS["SDK${i#v}"]+x} ]] ; then |
| warning "SDK $i is not known to this script - assuming compatibility" |
| DISPLAY="Windows SDK $i" |
| else |
| eval COMPILER=${COMPILERS["SDK${i#v}"]} |
| DISPLAY=${COMPILER['NAME']} |
| fi |
| RESULT=${COMPILERS['SDK']%)} |
| FOUND+=(["SDK${i/v/}"]="$RESULT [\"DISPLAY\"]=\"$DISPLAY\" [\"SETENV\"]=\"$INSTALL_DIR\\Bin\\SetEnv.cmd\")") |
| else |
| if [[ -n ${COMPILERS["SDK${i#v}"]+x} ]] ; then |
| warning "Registry set for Windows SDK $i, but SetEnv.cmd not found" |
| fi |
| fi |
| else |
| warning "Registry key for Windows SDK $i doesn't contain expected InstallationFolder value" |
| fi |
| done |
| |
| # Now enumerate Visual Studio 2017+ instances |
| VSWHERE=$(dirname $(realpath $0))/vswhere.exe |
| if [[ ! -x $VSWHERE ]] ; then |
| VSWHERE="$(printenv 'ProgramFiles(x86)')\\Microsoft Visual Studio\\Installer\\vswhere.exe" |
| VSWHERE=$(echo $VSWHERE| cygpath -f -) |
| fi |
| if [[ -x $VSWHERE ]] ; then |
| debug "$VSWHERE found" |
| while IFS= read -r line; do |
| case ${line%: *} in |
| instanceId) |
| INSTANCE=${line#*: };; |
| installationPath) |
| INSTANCE_PATH=${line#*: };; |
| installationVersion) |
| INSTANCE_VER=${line#*: } |
| INSTANCE_VER=${INSTANCE_VER%.*} |
| INSTANCE_VER=${INSTANCE_VER%.*};; |
| displayName) |
| INSTANCE_NAME=${line#*: } |
| debug "Looking at $INSTANCE in $INSTANCE_PATH ($INSTANCE_VER $INSTANCE_NAME)" |
| if [[ -e "$(echo $INSTANCE_PATH| cygpath -f -)/VC/Auxiliary/Build/vcvarsall.bat" ]] ; then |
| debug "vcvarsall.bat found" |
| FOUND+=(["VS$INSTANCE_VER"]="([\"DISPLAY\"]=\"$INSTANCE_NAME\" [\"ARCH\"]=\"x86 x64\" [\"SETENV\"]=\"$INSTANCE_PATH\\VC\\Auxiliary\\Build\\vcvarsall.bat\" [\"SETENV_RELEASE\"]=\"\")") |
| else |
| warning "vcvarsall.bat not found for $INSTANCE" |
| fi;; |
| esac |
| done < <("$VSWHERE" -all -nologo | tr -d '\r') |
| fi |
| |
| if [[ $DEBUG -gt 1 ]] ; then |
| for i in "${!FOUND[@]}" ; do |
| echo "Inspect $i">&2 |
| done |
| fi |
| |
| # Basic scanning is complete, now interrogate the packages which seem to be installed and ensure |
| # that they pass the check_environment tests. |
| |
| # CANDIDATES is a hash table of the keys of FOUND. The result of the next piece of processing is to |
| # derive two arrays PREFERENCE and TEST. TEST will contain a list of the keys of FOUND in the order |
| # in which they should be evaluated. PREFERENCE contains a parsed version of MSVS_PREFERENCE but |
| # filtered on the basis of the compiler packages already identified. The current "hoped for" |
| # preference is stored in $pref (the index into PREFERENCE) and $PREF (which is |
| # ${PREFERENCE[$pref]}). These two arrays together allow testing to complete quickly if the desired |
| # version is found (note that often this won't be possible as the @ environment option requires all |
| # packages to be tested in order to be sure that the environment compiler is not ambiguous). |
| declare -A CANDIDATES |
| for i in "${!FOUND[@]}" ; do |
| CANDIDATES[$i]=""; |
| done |
| |
| # For --all, act as though MSVS_PREFERENCE were "@" because this causes all packages to be tested. |
| if [[ $MODE -eq 1 ]] ; then |
| PREFER_ENV=1 |
| PREFERENCE=("@") |
| else |
| PREFER_ENV=0 |
| PREFERENCE=() |
| fi |
| |
| TEST=() |
| for i in $MSVS_PREFERENCE ; do |
| if [[ $i = "@" ]] ; then |
| if [[ -n ${ENV_ARCH+x} ]] ; then |
| PREFERENCE+=("@") |
| PREFER_ENV=1 |
| else |
| debug "Preference @ ignored since no environment compiler selected" |
| fi |
| else |
| if [[ -n ${COMPILERS[$i]+x} || -n ${COMPILERS[${i%.*}.*]+x} ]] ; then |
| if [[ -n ${CANDIDATES[$i]+x} ]] ; then |
| unset CANDIDATES[$i] |
| TEST+=($i) |
| PREFERENCE+=($i) |
| elif [[ ${i#*.} = "*" ]] ; then |
| INSTANCES= |
| for j in "${!CANDIDATES[@]}" ; do |
| if [[ "${j%.*}.*" = $i ]] ; then |
| unset CANDIDATES[$j] |
| INSTANCES="$INSTANCES $j" |
| fi |
| done |
| INSTANCES="$(sort -r <<< "${INSTANCES// /$'\n'}")" |
| eval TEST+=($INSTANCES) |
| eval PREFERENCE+=($INSTANCES) |
| fi |
| else |
| if [[ -n ${CANDIDATES["VS$i"]+x} ]] ; then |
| unset CANDIDATES["VS$i"] |
| TEST+=("VS$i") |
| PREFERENCE+=("VS$i") |
| fi |
| SDKS= |
| for j in "${!COMPILERS[@]}" ; do |
| eval COMPILER=${COMPILERS[$j]} |
| if [[ -n ${COMPILER["VC_VER"]+x} ]] ; then |
| if [[ $i = ${COMPILER["VC_VER"]} && -n ${CANDIDATES[$j]+x} ]] ; then |
| unset CANDIDATES[$j] |
| SDKS="$j $SDKS" |
| fi |
| fi |
| done |
| SDKS=${SDKS% } |
| SDKS="$(sort -r <<< "${SDKS// /$'\n'}")" |
| SDKS=${SDKS//$'\n'/ } |
| eval TEST+=($SDKS) |
| eval PREFERENCE+=($SDKS) |
| fi |
| fi |
| done |
| |
| # If MSVS_PREFERENCE includes @, add any remaining items from CANDIDATES to TEST, otherwise remove |
| # them from FOUND so that they don't accidentally get reported on later. |
| for i in "${!CANDIDATES[@]}" ; do |
| if [[ $PREFER_ENV -eq 1 ]] ; then |
| TEST+=($i) |
| else |
| unset FOUND[$i] |
| fi |
| done |
| |
| # Initialise pref and PREF to ${PREFERENCE[0]} |
| pref=0 |
| PREF=${PREFERENCE[0]} |
| |
| if [[ $DEBUG -gt 1 ]] ; then |
| for i in "${!TEST[@]}" ; do |
| echo "Test ${TEST[$i]}">&2 |
| done |
| fi |
| |
| |
| # Now run each compiler's environment script and then test whether it is suitable. During this loop, |
| # attempt to identify the environment C compiler (if one was found). The environment C compiler is |
| # strongly identified if the full location of cl matches the one in PATH and both LIB and INCLUDE |
| # contain the strings returned by the script in an otherwise empty environment (if one or both of |
| # the LIB and INCLUDE variables do not contain the string returned, then the compiler is weakly |
| # identified). If the environment compiler is strongly identified by more than one package, then it |
| # is not identified at all; if it is strongly identified by no packages but weakly identified by |
| # exactly 1, then we grudgingly accept that that's probably the one. |
| ENV_COMPILER= |
| WEAK_ENV= |
| |
| # ARCHINFO contains the appropriate ARCH_SWITCHES associative array for each compiler. |
| declare -A ARCHINFO |
| |
| for i in "${TEST[@]}" ; do |
| CURRENT=${FOUND[$i]} |
| eval COMPILER=$CURRENT |
| # At the end of this process, the keys of FOUND will be augmented with the architecture found in |
| # each case (so if "VS14.0" was in FOUND from the scan and both the x86 and x64 compilers are |
| # valid, then at the end of this loop FOUND will contain "VS14.0-x86" and "VS14.0-x64"). |
| unset FOUND[$i] |
| |
| if [[ ${COMPILER["IS_EXPRESS"]}0 -gt 0 && -n ${COMPILER["EXPRESS_ARCH_SWITCHES"]+x} ]] ; then |
| eval ARCHINFO=${COMPILER["EXPRESS_ARCH_SWITCHES"]} |
| elif [[ -n ${COMPILER["ARCH_SWITCHES"]+x} ]] ; then |
| eval ARCHINFO=${COMPILER["ARCH_SWITCHES"]} |
| else |
| ARCHINFO=() |
| fi |
| |
| # Determine the script to be executed and any non-architecture specific switches needed. |
| # $ENV is will contain the value of the environment variable for the compiler (empty for an SDK) |
| # which is required for Visual Studio 7.x shim later. |
| if [[ -n ${COMPILER["ENV"]+x} ]] ; then |
| ENV=VS${COMPILER["ENV"]}COMNTOOLS |
| ENV=${!ENV%\"} |
| ENV=${ENV#\"} |
| if [[ ${COMPILER["ENV"]}0 -ge 800 ]] ; then |
| SCRIPT="$(cygpath -d -f - <<< $ENV)\\..\\..\\VC\\vcvarsall.bat" |
| SCRIPT_SWITCHES= |
| else |
| SCRIPT="$(cygpath -d -f - <<< $ENV)\\vsvars32.bat" |
| SCRIPT_SWITCHES= |
| fi |
| else |
| ENV= |
| SCRIPT=${COMPILER["SETENV"]} |
| SCRIPT_SWITCHES=${COMPILER["SETENV_RELEASE"]} |
| fi |
| # For reasons of escaping, the script is executed using its basename so the directory needs |
| # prepending to PATH. |
| DIR=$(dirname "$SCRIPT" | cygpath -u -f -) |
| |
| if [[ ${COMPILER["IS_EXPRESS"]} -gt 0 && -n ${COMPILER["EXPRESS_ARCH"]+x} ]] ; then |
| ARCHS=${COMPILER["EXPRESS_ARCH"]} |
| else |
| ARCHS=${COMPILER["ARCH"]} |
| fi |
| |
| for arch in $ARCHS ; do |
| # Determine the command line switch for this architecture |
| if [[ -n ${ARCHINFO[$arch]+x} ]] ; then |
| ARCH_SWITCHES=${ARCHINFO[$arch]} |
| else |
| ARCH_SWITCHES=$arch |
| fi |
| |
| # Run the script in order to determine changes made to PATH, INCLUDE and LIB. These scripts |
| # always prepend changes to the environment variables. |
| MSVS_PATH= |
| MSVS_LIB= |
| MSVS_INC= |
| |
| COMMAND='%EXEC_SCRIPT% && echo XMARKER && echo !PATH! && echo !LIB! && echo !INCLUDE!' |
| |
| # Note that EXEC_SCRIPT must have ARCH_SWITCHES first for older Platform SDKs (newer ones parse |
| # arguments properly) |
| if [[ $DEBUG -gt 3 ]] ; then |
| printf "Scanning %s... " "$(basename "$SCRIPT") $ARCH_SWITCHES $SCRIPT_SWITCHES">&2 |
| fi |
| num=0 |
| while IFS= read -r line; do |
| case $num in |
| 0) |
| MSVS_PATH=${line%% };; |
| 1) |
| MSVS_LIB=${line%% };; |
| 2) |
| MSVS_INC=${line%% };; |
| esac |
| ((num++)) |
| done < <(INCLUDE='' LIB='' PATH="?msvs-detect?:$DIR:$PATH" ORIGINALPATH='' \ |
| EXEC_SCRIPT="$(basename "$SCRIPT") $ARCH_SWITCHES $SCRIPT_SWITCHES" \ |
| $(cygpath "$COMSPEC") ${SWITCH_PREFIX}v:on ${SWITCH_PREFIX}c $COMMAND 2>/dev/null | grep -F XMARKER -A 3 | tr -d '\015' | tail -3) |
| if [[ $DEBUG -gt 3 ]] ; then |
| echo done>&2 |
| fi |
| |
| if [[ -n $MSVS_PATH ]] ; then |
| # Translate MSVS_PATH back to Cygwin notation (/cygdrive, etc. and colon-separated) |
| MSVS_PATH=$(cygpath "$MSVS_PATH" -p) |
| # Remove any trailing / from elements of MSVS_PATH |
| MSVS_PATH=$(echo "$MSVS_PATH" | sed -e 's|\([^:]\)/\+\(:\|$\)|\1\2|g;s/?msvs-detect?.*//') |
| # Guarantee that MSVS_PATH ends with a single : |
| MSVS_PATH="${MSVS_PATH%%:}:" |
| fi |
| # Ensure that both variables end with a semi-colon (it doesn't matter if for some erroneous |
| # reason they have come back blank, because check_environment will shortly fail) |
| MSVS_LIB="${MSVS_LIB%%;};" |
| MSVS_INC="${MSVS_INC%%;};" |
| |
| # Visual Studio .NET 2002 and 2003 do not include mt in PATH, for not entirely clear reasons. |
| # This shim detects that scenario and adds the winnt folder to MSVS_PATH. |
| RET=0 |
| if [[ ${i/.*/} = "VS7" ]] ; then |
| find_in "${MSVS_PATH//:/*}" mt.exe |
| if [[ $RET -eq 1 ]] ; then |
| MSVS_PATH="$MSVS_PATH$(cygpath -u -f - <<< $ENV\\Bin\\winnt):" |
| RET=0 |
| fi |
| fi |
| |
| # Ensure that these derived values give a valid compiler. |
| if check_environment "${MSVS_PATH//:/*}" "${MSVS_INC//;/*}" "${MSVS_LIB//;/*}" "$i" $arch ; then |
| # Put the package back into FOUND, but augmented with the architecture name and with the |
| # derived values. |
| FOUND["$i-$arch"]="${CURRENT%)} [\"MSVS_PATH\"]=\"$MSVS_PATH\" \ |
| [\"MSVS_INC\"]=\"$MSVS_INC\" \ |
| [\"MSVS_LIB\"]=\"$MSVS_LIB\" \ |
| [\"ASSEMBLER\"]=\"$ASSEMBLER\")" #"# fixes vim syn match error |
| |
| # Check to see if this is a match for the environment C compiler. |
| if [[ -n ${ENV_ARCH+x} ]] ; then |
| TEST_cl=$(PATH="$MSVS_PATH:$PATH" "$WHICH" cl) |
| TEST_cl=${TEST_cl,,} |
| TEST_cl=${TEST_cl/bin\/*_/bin\/} |
| if [[ $TEST_cl = $ENV_cl ]] ; then |
| if [[ ${!ENV_INC/"$MSVS_INC"/} != "${!ENV_INC}" && \ |
| ${!ENV_LIB/"$MSVS_LIB"/} != "${!ENV_LIB}" ]] ; then |
| debug "$i-$arch is a strong candidate for the Environment C compiler" |
| if [[ -n ${ENV_COMPILER+x} ]] ; then |
| if [[ -z ${ENV_COMPILER} ]] ; then |
| ENV_COMPILER=$i-$arch |
| unset WEAK_ENV |
| else |
| # More than one strong candidate - no fall back available |
| unset ENV_COMPILER |
| unset WEAK_ENV |
| fi |
| fi |
| else |
| debug "$i-$arch is a weak candidate for the Environment C compiler" |
| if [[ -n ${WEAK_ENV+x} ]] ; then |
| if [[ -z ${WEAK_ENV} ]] ; then |
| WEAK_ENV=$i-$arch |
| else |
| # More than one weak candidate - no fall back available |
| unset WEAK_ENV |
| fi |
| fi |
| fi |
| fi |
| fi |
| fi |
| done |
| |
| # Does this package match the current preference? Note that PREFERENCE and TEST are constructed in |
| # a cunning (and hopefully not too "You are not expected to understand this" way) such that $PREF |
| # will always equal $i, unless $PREF = "@". |
| if [[ $PREF = $i ]] ; then |
| # In which case, check that the architecture(s)s were found |
| if [[ -n ${FOUND["$i-$LEFT_ARCH"]+x} && -n ${FOUND["$i-$RIGHT_ARCH"]+x} ]] ; then |
| debug "Solved TARGET_ARCH=$TARGET_ARCH with $i" |
| SOLUTION=$i |
| break |
| fi |
| fi |
| |
| if [[ $PREF != "@" ]] ; then |
| ((pref++)) |
| PREF=${PREFERENCE[$pref]} |
| fi |
| done |
| |
| # If we got this far, then either we failed to find a compiler at all, or we were looking for the |
| # environment compiler (or --all was specified). |
| |
| # Adopt a weak match for the environment compiler, if that's the best we can do. |
| if [[ -n ${ENV_COMPILER+x} && -z ${ENV_COMPILER} && -n ${WEAK_ENV} ]] ; then |
| warning "Assuming Environment C compiler is $WEAK_ENV" |
| ENV_COMPILER=$WEAK_ENV |
| fi |
| |
| declare -A FLIP |
| FLIP=(["x86"]="x64" ["x64"]="x86") |
| |
| if [[ $MODE -eq 0 ]] ; then |
| if [[ $PREF = "@" && -n ${ENV_COMPILER} ]] ; then |
| SOLUTION=${ENV_COMPILER%-$ENV_ARCH} |
| # If --arch wasn't specified, then ensure that the other architecture was also found. If --arch |
| # was specified, then validate that the compiler was valid. This should always happen, unless |
| # something went wrong running the script to get MSVS_PATH, MSVS_LIB and MSVS_INC. |
| if [[ -n ${FOUND["$SOLUTION-${FLIP[$ENV_ARCH]}"]+x} || |
| -n ${FOUND["$SOLUTION-$TARGET_ARCH"]+x} ]] ; then |
| debug "Solved with $SOLUTION" |
| else |
| unset SOLUTION |
| unset ENV_ARCH |
| fi |
| fi |
| |
| if [[ -z ${SOLUTION+x} ]] ; then |
| ((pref++)) |
| debug "Search remaining: ${PREFERENCE[*]}" |
| TEST_ARCH=$TARGET_ARCH |
| for i in "${PREFERENCE[@]:$pref}" ; do |
| if [[ -n ${FOUND["$i-$LEFT_ARCH"]+x} && -n ${FOUND["$i-$RIGHT_ARCH"]+x} ]] ; then |
| debug "Solved TARGET_ARCH='$TARGET_ARCH' with $i" |
| SOLUTION=$i |
| break |
| fi |
| done |
| fi |
| fi |
| |
| debug "Solution: $SOLUTION" |
| |
| if [[ -n ${ENV_COMPILER} && $MODE -eq 1 ]] ; then |
| echo "Identified Environment C compiler as $ENV_COMPILER" |
| fi |
| |
| if [[ $MODE -eq 1 ]] ; then |
| echo "Installed and usable packages:" |
| for i in "${!FOUND[@]}" ; do |
| echo " $i" |
| done | sort |
| exit 0 |
| fi |
| |
| if [[ -n $SOLUTION ]] ; then |
| eval COMPILER=${FOUND[$SOLUTION-$LEFT_ARCH]} |
| output MSVS_NAME "${COMPILER["DISPLAY"]}" $LEFT_ARCH |
| output MSVS_PATH "${COMPILER["MSVS_PATH"]}" $LEFT_ARCH |
| output MSVS_INC "${COMPILER["MSVS_INC"]}" $LEFT_ARCH |
| output MSVS_LIB "${COMPILER["MSVS_LIB"]}" $LEFT_ARCH |
| if [[ $ML_REQUIRED -eq 1 ]] ; then |
| output MSVS_ML "${COMPILER["ASSEMBLER"]%.exe}" always |
| fi |
| if [[ -z $TARGET_ARCH ]] ; then |
| eval COMPILER=${FOUND[$SOLUTION-$RIGHT_ARCH]} |
| output MSVS64_PATH "${COMPILER["MSVS_PATH"]}" $RIGHT_ARCH |
| output MSVS64_INC "${COMPILER["MSVS_INC"]}" $RIGHT_ARCH |
| output MSVS64_LIB "${COMPILER["MSVS_LIB"]}" $RIGHT_ARCH |
| if [[ $ML_REQUIRED -eq 1 ]] ; then |
| output MSVS64_ML "${COMPILER["ASSEMBLER"]%.exe}" always |
| fi |
| fi |
| exit 0 |
| else |
| exit 1 |
| fi |
