from __future__ import print_function

import json

import sys

import errno

import optparse

import os

import pipes

import pprint

import re

import shlex

import subprocess

import shutil

import bz2

import io

from distutils.spawn import find_executable as which

from distutils.version import StrictVersion

# If not run from node/, cd to node/.

os.chdir(os.path.dirname(__file__) or '.')

original_argv = sys.argv[1:]

# gcc and g++ as defaults matches what GYP's Makefile generator does,

# except on OS X.

CC = os.environ.get('CC', 'cc' if sys.platform == 'darwin' else 'gcc')

CXX = os.environ.get('CXX', 'c++' if sys.platform == 'darwin' else 'g++')

sys.path.insert(0, os.path.join('tools', 'gyp', 'pylib'))

from gyp.common import GetFlavor

# imports in tools/configure.d

sys.path.insert(0, os.path.join('tools', 'configure.d'))

import nodedownload

# imports in tools/

sys.path.insert(0, 'tools')

import getmoduleversion

import getnapibuildversion

from gyp_node import run_gyp

# imports in deps/v8/tools/node

sys.path.insert(0, os.path.join('deps', 'v8', 'tools', 'node'))

from fetch_deps import FetchDeps

# parse our options

parser = optparse.OptionParser()

valid_os = ('win', 'mac', 'solaris', 'freebsd', 'openbsd', 'linux',

'android', 'aix', 'cloudabi')

valid_arch = ('arm', 'arm64', 'ia32', 'mips', 'mipsel', 'mips64el', 'ppc',

'ppc64', 'x32','x64', 'x86', 'x86_64', 's390x')

valid_arm_float_abi = ('soft', 'softfp', 'hard')

valid_arm_fpu = ('vfp', 'vfpv3', 'vfpv3-d16', 'neon')

valid_mips_arch = ('loongson', 'r1', 'r2', 'r6', 'rx')

valid_mips_fpu = ('fp32', 'fp64', 'fpxx')

valid_mips_float_abi = ('soft', 'hard')

valid_intl_modes = ('none', 'small-icu', 'full-icu', 'system-icu')

with open ('tools/icu/icu_versions.json') as f:

icu_versions = json.load(f)

# create option groups

shared_optgroup = optparse.OptionGroup(parser, "Shared libraries",

"Flags that allows you to control whether you want to build against "

"built-in dependencies or its shared representations. If necessary, "

"provide multiple libraries with comma.")

intl_optgroup = optparse.OptionGroup(parser, "Internationalization",

"Flags that lets you enable i18n features in Node.js as well as which "

"library you want to build against.")

http2_optgroup = optparse.OptionGroup(parser, "HTTP2",

"Flags that allows you to control HTTP2 features in Node.js")

# Options should be in alphabetical order but keep --prefix at the top,

# that's arguably the one people will be looking for most.

parser.add_option('--prefix',

action='store',

dest='prefix',

default='/usr/local',

help='select the install prefix [default: %default]')

parser.add_option('--coverage',

action='store_true',

dest='coverage',

help='Build node with code coverage enabled')

parser.add_option('--debug',

action='store_true',

dest='debug',

help='also build debug build')

parser.add_option('--debug-node',

action='store_true',

dest='debug_node',

help='build the Node.js part of the binary with debugging symbols')

parser.add_option('--dest-cpu',

action='store',

dest='dest_cpu',

choices=valid_arch,

help='CPU architecture to build for ({0})'.format(', '.join(valid_arch)))

parser.add_option('--cross-compiling',

action='store_true',

dest='cross_compiling',

default=None,

help='force build to be considered as cross compiled')

parser.add_option('--no-cross-compiling',

action='store_false',

dest='cross_compiling',

default=None,

help='force build to be considered as NOT cross compiled')

parser.add_option('--dest-os',

action='store',

dest='dest_os',

choices=valid_os,

help='operating system to build for ({0})'.format(', '.join(valid_os)))

parser.add_option('--error-on-warn',

action='store_true',

dest='error_on_warn',

help='Turn compiler warnings into errors for node core sources.')

parser.add_option('--gdb',

action='store_true',

dest='gdb',

help='add gdb support')

parser.add_option('--no-ifaddrs',

action='store_true',

dest='no_ifaddrs',

help='use on deprecated SunOS systems that do not support ifaddrs.h')

parser.add_option("--fully-static",

action="store_true",

dest="fully_static",

help="Generate an executable without external dynamic libraries. This "

"will not work on OSX when using the default compilation environment")

parser.add_option("--partly-static",

action="store_true",

dest="partly_static",

help="Generate an executable with libgcc and libstdc++ libraries. This "

"will not work on OSX when using the default compilation environment")

parser.add_option("--enable-pgo-generate",

action="store_true",

dest="enable_pgo_generate",

help="Enable profiling with pgo of a binary. This feature is only available "

"on linux with gcc and g++ 5.4.1 or newer.")

parser.add_option("--enable-pgo-use",

action="store_true",

dest="enable_pgo_use",

help="Enable use of the profile generated with --enable-pgo-generate. This "

"feature is only available on linux with gcc and g++ 5.4.1 or newer.")

parser.add_option("--enable-lto",

action="store_true",

dest="enable_lto",

help="Enable compiling with lto of a binary. This feature is only available "

"on linux with gcc and g++ 5.4.1 or newer.")

parser.add_option("--link-module",

action="append",

dest="linked_module",

help="Path to a JS file to be bundled in the binary as a builtin. "

"This module will be referenced by path without extension; "

"e.g. /root/x/y.js will be referenced via require('root/x/y'). "

"Can be used multiple times")

parser.add_option('--openssl-default-cipher-list',

action='store',

dest='openssl_default_cipher_list',

help='Use the specified cipher list as the default cipher list')

parser.add_option("--openssl-no-asm",

action="store_true",

dest="openssl_no_asm",

help="Do not build optimized assembly for OpenSSL")

parser.add_option('--openssl-fips',

action='store',

dest='openssl_fips',

help='Build OpenSSL using FIPS canister .o file in supplied folder')

parser.add_option('--openssl-is-fips',

action='store_true',

dest='openssl_is_fips',

help='specifies that the OpenSSL library is FIPS compatible')

parser.add_option('--openssl-use-def-ca-store',

action='store_true',

dest='use_openssl_ca_store',

help='Use OpenSSL supplied CA store instead of compiled-in Mozilla CA copy.')

parser.add_option('--openssl-system-ca-path',

action='store',

dest='openssl_system_ca_path',

help='Use the specified path to system CA (PEM format) in addition to '

'the OpenSSL supplied CA store or compiled-in Mozilla CA copy.')

parser.add_option('--experimental-http-parser',

action='store_true',

dest='experimental_http_parser',

help='(no-op)')

shared_optgroup.add_option('--shared-http-parser',

action='store_true',

dest='shared_http_parser',

help='link to a shared http_parser DLL instead of static linking')

shared_optgroup.add_option('--shared-http-parser-includes',

action='store',

dest='shared_http_parser_includes',

help='directory containing http_parser header files')

shared_optgroup.add_option('--shared-http-parser-libname',

action='store',

dest='shared_http_parser_libname',

default='http_parser',

help='alternative lib name to link to [default: %default]')

shared_optgroup.add_option('--shared-http-parser-libpath',

action='store',

dest='shared_http_parser_libpath',

help='a directory to search for the shared http_parser DLL')

shared_optgroup.add_option('--shared-libuv',

action='store_true',

dest='shared_libuv',

help='link to a shared libuv DLL instead of static linking')

shared_optgroup.add_option('--shared-libuv-includes',

action='store',

dest='shared_libuv_includes',

help='directory containing libuv header files')

shared_optgroup.add_option('--shared-libuv-libname',

action='store',

dest='shared_libuv_libname',

default='uv',

help='alternative lib name to link to [default: %default]')

shared_optgroup.add_option('--shared-libuv-libpath',

action='store',

dest='shared_libuv_libpath',

help='a directory to search for the shared libuv DLL')

shared_optgroup.add_option('--shared-nghttp2',

action='store_true',

dest='shared_nghttp2',

help='link to a shared nghttp2 DLL instead of static linking')

shared_optgroup.add_option('--shared-nghttp2-includes',

action='store',

dest='shared_nghttp2_includes',

help='directory containing nghttp2 header files')

shared_optgroup.add_option('--shared-nghttp2-libname',

action='store',

dest='shared_nghttp2_libname',

default='nghttp2',

help='alternative lib name to link to [default: %default]')

shared_optgroup.add_option('--shared-nghttp2-libpath',

action='store',

dest='shared_nghttp2_libpath',

help='a directory to search for the shared nghttp2 DLLs')

shared_optgroup.add_option('--shared-openssl',

action='store_true',

dest='shared_openssl',

help='link to a shared OpenSSl DLL instead of static linking')

shared_optgroup.add_option('--shared-openssl-includes',

action='store',

dest='shared_openssl_includes',

help='directory containing OpenSSL header files')

shared_optgroup.add_option('--shared-openssl-libname',

action='store',

dest='shared_openssl_libname',

default='crypto,ssl',

help='alternative lib name to link to [default: %default]')

shared_optgroup.add_option('--shared-openssl-libpath',

action='store',

dest='shared_openssl_libpath',

help='a directory to search for the shared OpenSSL DLLs')

shared_optgroup.add_option('--shared-zlib',

action='store_true',

dest='shared_zlib',

help='link to a shared zlib DLL instead of static linking')

shared_optgroup.add_option('--shared-zlib-includes',

action='store',

dest='shared_zlib_includes',

help='directory containing zlib header files')

shared_optgroup.add_option('--shared-zlib-libname',

action='store',

dest='shared_zlib_libname',

default='z',

help='alternative lib name to link to [default: %default]')

shared_optgroup.add_option('--shared-zlib-libpath',

action='store',

dest='shared_zlib_libpath',

help='a directory to search for the shared zlib DLL')

shared_optgroup.add_option('--shared-brotli',

action='store_true',

dest='shared_brotli',

help='link to a shared brotli DLL instead of static linking')

shared_optgroup.add_option('--shared-brotli-includes',

action='store',

dest='shared_brotli_includes',

help='directory containing brotli header files')

shared_optgroup.add_option('--shared-brotli-libname',

action='store',

dest='shared_brotli_libname',

default='brotlidec,brotlienc',

help='alternative lib name to link to [default: %default]')

shared_optgroup.add_option('--shared-brotli-libpath',

action='store',

dest='shared_brotli_libpath',

help='a directory to search for the shared brotli DLL')

shared_optgroup.add_option('--shared-cares',

action='store_true',

dest='shared_cares',

help='link to a shared cares DLL instead of static linking')

shared_optgroup.add_option('--shared-cares-includes',

action='store',

dest='shared_cares_includes',

help='directory containing cares header files')

shared_optgroup.add_option('--shared-cares-libname',

action='store',

dest='shared_cares_libname',

default='cares',

help='alternative lib name to link to [default: %default]')

shared_optgroup.add_option('--shared-cares-libpath',

action='store',

dest='shared_cares_libpath',

help='a directory to search for the shared cares DLL')

parser.add_option_group(shared_optgroup)

parser.add_option('--systemtap-includes',

action='store',

dest='systemtap_includes',

help='directory containing systemtap header files')

parser.add_option('--tag',

action='store',

dest='tag',

help='custom build tag')

parser.add_option('--release-urlbase',

action='store',

dest='release_urlbase',

help='Provide a custom URL prefix for the `process.release` properties '

'`sourceUrl` and `headersUrl`. When compiling a release build, this '

'will default to https://nodejs.org/download/release/')

parser.add_option('--enable-d8',

action='store_true',

dest='enable_d8',

help=optparse.SUPPRESS_HELP) # Unsupported, undocumented.

parser.add_option('--enable-trace-maps',

action='store_true',

dest='trace_maps',

help='Enable the --trace-maps flag in V8 (use at your own risk)')

parser.add_option('--experimental-enable-pointer-compression',

action='store_true',

dest='enable_pointer_compression',

help='[Experimental] Enable V8 pointer compression (limits max heap to 4GB and breaks ABI compatibility)')

parser.add_option('--v8-options',

action='store',

dest='v8_options',

help='v8 options to pass, see `node --v8-options` for examples.')

parser.add_option('--with-arm-float-abi',

action='store',

dest='arm_float_abi',

choices=valid_arm_float_abi,

help='specifies which floating-point ABI to use ({0}).'.format(

', '.join(valid_arm_float_abi)))

parser.add_option('--with-arm-fpu',

action='store',

dest='arm_fpu',

choices=valid_arm_fpu,

help='ARM FPU mode ({0}) [default: %default]'.format(

', '.join(valid_arm_fpu)))

parser.add_option('--with-mips-arch-variant',

action='store',

dest='mips_arch_variant',

default='r2',

choices=valid_mips_arch,

help='MIPS arch variant ({0}) [default: %default]'.format(

', '.join(valid_mips_arch)))

parser.add_option('--with-mips-fpu-mode',

action='store',

dest='mips_fpu_mode',

default='fp32',

choices=valid_mips_fpu,

help='MIPS FPU mode ({0}) [default: %default]'.format(

', '.join(valid_mips_fpu)))

parser.add_option('--with-mips-float-abi',

action='store',

dest='mips_float_abi',

default='hard',

choices=valid_mips_float_abi,

help='MIPS floating-point ABI ({0}) [default: %default]'.format(

', '.join(valid_mips_float_abi)))

parser.add_option('--with-dtrace',

action='store_true',

dest='with_dtrace',

help='build with DTrace (default is true on sunos and darwin)')

parser.add_option('--with-etw',

action='store_true',

dest='with_etw',

help='build with ETW (default is true on Windows)')

parser.add_option('--use-largepages',

action='store_true',

dest='node_use_large_pages',

help='This option has no effect. --use-largepages is now a runtime option.')

parser.add_option('--use-largepages-script-lld',

action='store_true',

dest='node_use_large_pages_script_lld',

help='This option has no effect. --use-largepages is now a runtime option.')

intl_optgroup.add_option('--with-intl',

action='store',

dest='with_intl',

default='full-icu',

choices=valid_intl_modes,

help='Intl mode (valid choices: {0}) [default: %default]'.format(

', '.join(valid_intl_modes)))

intl_optgroup.add_option('--without-intl',

action='store_const',

dest='with_intl',

const='none',

help='Disable Intl, same as --with-intl=none (disables inspector)')

intl_optgroup.add_option('--with-icu-path',

action='store',

dest='with_icu_path',

help='Path to icu.gyp (ICU i18n, Chromium version only.)')

icu_default_locales='root,en'

intl_optgroup.add_option('--with-icu-locales',

action='store',

dest='with_icu_locales',

default=icu_default_locales,

help='Comma-separated list of locales for "small-icu". "root" is assumed. '

'[default: %default]')

intl_optgroup.add_option('--with-icu-source',

action='store',

dest='with_icu_source',

help='Intl mode: optional local path to icu/ dir, or path/URL of '

'the icu4c source archive. '

'v%d.x or later recommended.' % icu_versions['minimum_icu'])

intl_optgroup.add_option('--with-icu-default-data-dir',

action='store',

dest='with_icu_default_data_dir',

help='Path to the icuXXdt{lb}.dat file. If unspecified, ICU data will '

'only be read if the NODE_ICU_DATA environment variable or the '

'--icu-data-dir runtime argument is used. This option has effect '

'only when Node.js is built with --with-intl=small-icu.')

parser.add_option('--with-ltcg',

action='store_true',

dest='with_ltcg',

help='Use Link Time Code Generation. This feature is only available on Windows.')

parser.add_option('--without-node-snapshot',

action='store_true',

dest='without_node_snapshot',

help='Turn off V8 snapshot integration. Currently experimental.')

parser.add_option('--without-node-code-cache',

action='store_true',

dest='without_node_code_cache',

help='Turn off V8 Code cache integration.')

intl_optgroup.add_option('--download',

action='store',

dest='download_list',

help=nodedownload.help())

intl_optgroup.add_option('--download-path',

action='store',

dest='download_path',

default='deps',

help='Download directory [default: %default]')

parser.add_option_group(intl_optgroup)

parser.add_option('--debug-lib',

action='store_true',

dest='node_debug_lib',

help='build lib with DCHECK macros')

http2_optgroup.add_option('--debug-nghttp2',

action='store_true',

dest='debug_nghttp2',

help='build nghttp2 with DEBUGBUILD (default is false)')

parser.add_option_group(http2_optgroup)

parser.add_option('--without-dtrace',

action='store_true',

dest='without_dtrace',

help='build without DTrace')

parser.add_option('--without-etw',

action='store_true',

dest='without_etw',

help='build without ETW')

parser.add_option('--without-npm',

action='store_true',

dest='without_npm',

help='do not install the bundled npm (package manager)')

# Dummy option for backwards compatibility

parser.add_option('--without-report',

action='store_true',

dest='unused_without_report',

help=optparse.SUPPRESS_HELP)

parser.add_option('--with-snapshot',

action='store_true',

dest='unused_with_snapshot',

help=optparse.SUPPRESS_HELP)

parser.add_option('--without-snapshot',

action='store_true',

dest='unused_without_snapshot',

help=optparse.SUPPRESS_HELP)

parser.add_option('--without-siphash',

action='store_true',

dest='without_siphash',

help=optparse.SUPPRESS_HELP)

# End dummy list.

parser.add_option('--without-ssl',

action='store_true',

dest='without_ssl',

help='build without SSL (disables crypto, https, inspector, etc.)')

parser.add_option('--without-node-options',

action='store_true',

dest='without_node_options',

help='build without NODE_OPTIONS support')

parser.add_option('--ninja',

action='store_true',

dest='use_ninja',

help='generate build files for use with Ninja')

parser.add_option('--enable-asan',

action='store_true',

dest='enable_asan',

help='compile for Address Sanitizer to find memory bugs')

parser.add_option('--enable-static',

action='store_true',

dest='enable_static',

help='build as static library')

parser.add_option('--no-browser-globals',

action='store_true',

dest='no_browser_globals',

help='do not export browser globals like setTimeout, console, etc. ' +

'(This mode is not officially supported for regular applications)')

parser.add_option('--without-inspector',

action='store_true',

dest='without_inspector',

help='disable the V8 inspector protocol')

parser.add_option('--shared',

action='store_true',

dest='shared',

help='compile shared library for embedding node in another project. ' +

'(This mode is not officially supported for regular applications)')

parser.add_option('--without-v8-platform',

action='store_true',

dest='without_v8_platform',

default=False,

help='do not initialize v8 platform during node.js startup. ' +

'(This mode is not officially supported for regular applications)')

parser.add_option('--without-bundled-v8',

action='store_true',

dest='without_bundled_v8',

default=False,

help='do not use V8 includes from the bundled deps folder. ' +

'(This mode is not officially supported for regular applications)')

parser.add_option('--build-v8-with-gn',

action='store_true',

dest='build_v8_with_gn',

default=False,

help='build V8 using GN instead of gyp')

parser.add_option('--verbose',

action='store_true',

dest='verbose',

default=False,

help='get more output from this script')

parser.add_option('--v8-non-optimized-debug',

action='store_true',

dest='v8_non_optimized_debug',

default=False,

help='compile V8 with minimal optimizations and with runtime checks')

parser.add_option('--v8-with-dchecks',

action='store_true',

dest='v8_with_dchecks',

default=False,

help='compile V8 with debug checks and runtime debugging features enabled')

parser.add_option('--v8-lite-mode',

action='store_true',

dest='v8_lite_mode',

default=False,

help='compile V8 in lite mode for constrained environments (lowers V8 '+

'memory footprint, but also implies no just-in-time compilation ' +

'support, thus much slower execution)')

parser.add_option('--node-builtin-modules-path',

action='store',

dest='node_builtin_modules_path',

default=False,

help='node will load builtin modules from disk instead of from binary')

# Create compile_commands.json in out/Debug and out/Release.

parser.add_option('-C',

action='store_true',

dest='compile_commands_json',

help=optparse.SUPPRESS_HELP)

(options, args) = parser.parse_args()

# Expand ~ in the install prefix now, it gets written to multiple files.

options.prefix = os.path.expanduser(options.prefix or '')

# set up auto-download list

auto_downloads = nodedownload.parse(options.download_list)

def error(msg):

prefix = '\033[1m\033[31mERROR\033[0m' if os.isatty(1) else 'ERROR'

print('%s: %s' % (prefix, msg))

sys.exit(1)

def warn(msg):

warn.warned = True

prefix = '\033[1m\033[93mWARNING\033[0m' if os.isatty(1) else 'WARNING'

print('%s: %s' % (prefix, msg))

# track if warnings occurred

warn.warned = False

def info(msg):

prefix = '\033[1m\033[32mINFO\033[0m' if os.isatty(1) else 'INFO'

print('%s: %s' % (prefix, msg))

def print_verbose(x):

if not options.verbose:

return

if type(x) is str:

print(x)

else:

pprint.pprint(x, indent=2)

def b(value):

"""Returns the string 'true' if value is truthy, 'false' otherwise."""

return 'true' if value else 'false'

def B(value):

"""Returns 1 if value is truthy, 0 otherwise."""

return 1 if value else 0

def to_utf8(s):

return s if isinstance(s, str) else s.decode("utf-8")

def pkg_config(pkg):

"""Run pkg-config on the specified package

Returns ("-l flags", "-I flags", "-L flags", "version")

otherwise (None, None, None, None)"""

pkg_config = os.environ.get('PKG_CONFIG', 'pkg-config')

args = [] # Print pkg-config warnings on first round.

retval = ()

for flag in ['--libs-only-l', '--cflags-only-I',

'--libs-only-L', '--modversion']:

args += [flag]

if isinstance(pkg, list):

args += pkg

else:

args += [pkg]

try:

proc = subprocess.Popen(shlex.split(pkg_config) + args,

stdout=subprocess.PIPE)

val = to_utf8(proc.communicate()[0]).strip()

except OSError as e:

if e.errno != errno.ENOENT: raise e # Unexpected error.

return (None, None, None, None) # No pkg-config/pkgconf installed.

retval += (val,)

args = ['--silence-errors']

return retval

def try_check_compiler(cc, lang):

try:

proc = subprocess.Popen(shlex.split(cc) + ['-E', '-P', '-x', lang, '-'],

stdin=subprocess.PIPE, stdout=subprocess.PIPE)

except OSError:

return (False, False, '', '')

proc.stdin.write(b'__clang__ __GNUC__ __GNUC_MINOR__ __GNUC_PATCHLEVEL__ '

b'__clang_major__ __clang_minor__ __clang_patchlevel__')

values = (to_utf8(proc.communicate()[0]).split() + ['0'] * 7)[0:7]

is_clang = values[0] == '1'

gcc_version = tuple(map(int, values[1:1+3]))

clang_version = tuple(map(int, values[4:4+3])) if is_clang else None

return (True, is_clang, clang_version, gcc_version)

#

# The version of asm compiler is needed for building openssl asm files.

# See deps/openssl/openssl.gypi for detail.

# Commands and regular expressions to obtain its version number are taken from

# https://github.com/openssl/openssl/blob/OpenSSL_1_0_2-stable/crypto/sha/asm/sha512-x86_64.pl#L112-L129

#

def get_version_helper(cc, regexp):

try:

proc = subprocess.Popen(shlex.split(cc) + ['-v'], stdin=subprocess.PIPE,

stderr=subprocess.PIPE, stdout=subprocess.PIPE)

except OSError:

error('''No acceptable C compiler found!

Please make sure you have a C compiler installed on your system and/or

consider adjusting the CC environment variable if you installed

it in a non-standard prefix.''')

match = re.search(regexp, to_utf8(proc.communicate()[1]))

if match:

return match.group(2)

else:

return '0.0'

def get_nasm_version(asm):

try:

proc = subprocess.Popen(shlex.split(asm) + ['-v'],

stdin=subprocess.PIPE, stderr=subprocess.PIPE,

stdout=subprocess.PIPE)

except OSError:

warn('''No acceptable ASM compiler found!

Please make sure you have installed NASM from https://www.nasm.us

and refer BUILDING.md.''')

return '0.0'

match = re.match(r"NASM version ([2-9]\.[0-9][0-9]+)",

to_utf8(proc.communicate()[0]))

if match:

return match.group(1)

else:

return '0.0'

def get_llvm_version(cc):

return get_version_helper(

cc, r"(^(?:FreeBSD )?clang version|based on LLVM) ([0-9]+\.[0-9]+)")

def get_xcode_version(cc):

return get_version_helper(

cc, r"(^Apple (?:clang|LLVM) version) ([0-9]+\.[0-9]+)")

def get_gas_version(cc):

try:

custom_env = os.environ.copy()

custom_env["LC_ALL"] = "C"

proc = subprocess.Popen(shlex.split(cc) + ['-Wa,-v', '-c', '-o',

'/dev/null', '-x',

'assembler', '/dev/null'],

stdin=subprocess.PIPE, stderr=subprocess.PIPE,

stdout=subprocess.PIPE, env=custom_env)

except OSError:

error('''No acceptable C compiler found!

Please make sure you have a C compiler installed on your system and/or

consider adjusting the CC environment variable if you installed

it in a non-standard prefix.''')

gas_ret = to_utf8(proc.communicate()[1])

match = re.match(r"GNU assembler version ([2-9]\.[0-9]+)", gas_ret)

if match:

return match.group(1)

else:

warn('Could not recognize `gas`: ' + gas_ret)

return '0.0'

# Note: Apple clang self-reports as clang 4.2.0 and gcc 4.2.1. It passes

# the version check more by accident than anything else but a more rigorous

# check involves checking the build number against a whitelist. I'm not

# quite prepared to go that far yet.

def check_compiler(o):

if sys.platform == 'win32':

if not options.openssl_no_asm and options.dest_cpu in ('x86', 'x64'):

nasm_version = get_nasm_version('nasm')

o['variables']['nasm_version'] = nasm_version

if nasm_version == '0.0':

o['variables']['openssl_no_asm'] = 1

return

ok, is_clang, clang_version, gcc_version = try_check_compiler(CXX, 'c++')

version_str = ".".join(map(str, clang_version if is_clang else gcc_version))

print_verbose('Detected %sC++ compiler (CXX=%s) version: %s' %

('clang ' if is_clang else '', CXX, version_str))

if not ok:

warn('failed to autodetect C++ compiler version (CXX=%s)' % CXX)

elif clang_version < (8, 0, 0) if is_clang else gcc_version < (6, 3, 0):

warn('C++ compiler (CXX=%s, %s) too old, need g++ 6.3.0 or clang++ 8.0.0' %

(CXX, version_str))

ok, is_clang, clang_version, gcc_version = try_check_compiler(CC, 'c')

version_str = ".".join(map(str, clang_version if is_clang else gcc_version))

print_verbose('Detected %sC compiler (CC=%s) version: %s' %

('clang ' if is_clang else '', CC, version_str))

if not ok:

warn('failed to autodetect C compiler version (CC=%s)' % CC)

elif not is_clang and gcc_version < (4, 2, 0):

# clang 3.2 is a little white lie because any clang version will probably

# do for the C bits. However, we might as well encourage people to upgrade

# to a version that is not completely ancient.

warn('C compiler (CC=%s, %s) too old, need gcc 4.2 or clang 3.2' %

(CC, version_str))

o['variables']['llvm_version'] = get_llvm_version(CC) if is_clang else '0.0'

# Need xcode_version or gas_version when openssl asm files are compiled.

if options.without_ssl or options.openssl_no_asm or options.shared_openssl:

return

if is_clang:

if sys.platform == 'darwin':

o['variables']['xcode_version'] = get_xcode_version(CC)

else:

o['variables']['gas_version'] = get_gas_version(CC)

def cc_macros(cc=None):

"""Checks predefined macros using the C compiler command."""

try:

p = subprocess.Popen(shlex.split(cc or CC) + ['-dM', '-E', '-'],

stdin=subprocess.PIPE,

stdout=subprocess.PIPE,

stderr=subprocess.PIPE)

except OSError:

error('''No acceptable C compiler found!

Please make sure you have a C compiler installed on your system and/or

consider adjusting the CC environment variable if you installed

it in a non-standard prefix.''')

p.stdin.write(b'\n')

out = to_utf8(p.communicate()[0]).split('\n')

k = {}

for line in out:

lst = shlex.split(line)

if len(lst) > 2:

key = lst[1]

val = lst[2]

k[key] = val

return k

def is_arch_armv7():

"""Check for ARMv7 instructions"""

cc_macros_cache = cc_macros()

return cc_macros_cache.get('__ARM_ARCH') == '7'

def is_arch_armv6():

"""Check for ARMv6 instructions"""

cc_macros_cache = cc_macros()

return cc_macros_cache.get('__ARM_ARCH') == '6'

def is_arm_hard_float_abi():

"""Check for hardfloat or softfloat eabi on ARM"""

# GCC versions 4.6 and above define __ARM_PCS or __ARM_PCS_VFP to specify

# the Floating Point ABI used (PCS stands for Procedure Call Standard).

# We use these as well as a couple of other defines to statically determine

# what FP ABI used.

return '__ARM_PCS_VFP' in cc_macros()

def host_arch_cc():

"""Host architecture check using the CC command."""

if sys.platform.startswith('aix'):

# we only support gcc at this point and the default on AIX

# would be xlc so hard code gcc

k = cc_macros('gcc')

else:

k = cc_macros(os.environ.get('CC_host'))

matchup = {

'__aarch64__' : 'arm64',

'__arm__' : 'arm',

'__i386__' : 'ia32',

'__MIPSEL__' : 'mipsel',

'__mips__' : 'mips',

'__PPC64__' : 'ppc64',

'__PPC__' : 'ppc64',

'__x86_64__' : 'x64',

'__s390x__' : 's390x',

}

rtn = 'ia32' # default

for i in matchup:

if i in k and k[i] != '0':

rtn = matchup[i]

break

if rtn == 'mipsel' and '_LP64' in k:

rtn = 'mips64el'

return rtn

def host_arch_win():

"""Host architecture check using environ vars (better way to do this?)"""

observed_arch = os.environ.get('PROCESSOR_ARCHITECTURE', 'x86')

arch = os.environ.get('PROCESSOR_ARCHITEW6432', observed_arch)

matchup = {

'AMD64' : 'x64',

'x86' : 'ia32',

'arm' : 'arm',

'mips' : 'mips',

}

return matchup.get(arch, 'ia32')

def configure_arm(o):

if options.arm_float_abi:

arm_float_abi = options.arm_float_abi

elif is_arm_hard_float_abi():

arm_float_abi = 'hard'

else:

arm_float_abi = 'default'

arm_fpu = 'vfp'

if is_arch_armv7():

arm_fpu = 'vfpv3'