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

if value:

return 'true'

else:

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

retval = ()

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

try:

proc = subprocess.Popen(

shlex.split(pkg_config) + ['--silence-errors', flag, pkg],

stdout=subprocess.PIPE)

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

except OSError as e:

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

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

retval += (val,)

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('__clang__ __GNUC__ __GNUC_MINOR__ __GNUC_PATCHLEVEL__ '

'__clang_major__ __clang_minor__ __clang_patchlevel__')

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

is_clang = values[0] == '1'

gcc_version = '%s.%s.%s' % tuple(values[1:1+3])

clang_version = '%s.%s.%s' % tuple(values[4:4+3])

try:

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

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

except OSError:

print('''Node.js configure error: No acceptable C compiler found!

''')

sys.exit()

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

if match:

return match.group(2)

else:

try:

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)

except OSError:

print('''Node.js configure error: No acceptable C compiler found!

''')

sys.exit()

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

proc.communicate()[1])

if match:

return match.group(1)

else:

if sys.platform == 'win32':

return

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

if not ok:

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

elif clang_version < '3.4.2' if is_clang else gcc_version < '4.8.0':

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

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

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 too old, need gcc 4.2 or clang 3.2 (CC=%s)' % CC)

# Need llvm_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:

o['variables']['llvm_version'] = get_llvm_version(CC)

if sys.platform == 'darwin':

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

else:

"""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:

print('''Node.js configure error: No acceptable C compiler found!

''')

sys.exit()

p.stdin.write('\n')

out = p.communicate()[0]

out = str(out).split('\n')

k = {}

for line in out:

lst = shlex.split(line)

if len(lst) > 2:

key = lst[1]

val = lst[2]

k[key] = val

"""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.

"""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',

'__s390__' : 's390',

'__s390x__' : 's390x',

}

rtn = 'ia32' # default

for i in matchup:

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

rtn = matchup[i]

if rtn != 's390':

break

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

rtn = 'mips64el'

"""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',

}

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'

o['variables']['arm_version'] = '7'

else:

o['variables']['arm_version'] = '6' if is_arch_armv6() else 'default'

o['variables']['arm_thumb'] = 0 # -marm

o['variables']['arm_float_abi'] = arm_float_abi

if options.dest_os == 'android':

arm_fpu = 'vfpv3'

o['variables']['arm_version'] = '7'

can_use_fpu_instructions = (options.mips_float_abi != 'soft')

o['variables']['v8_can_use_fpu_instructions'] = b(can_use_fpu_instructions)

o['variables']['v8_use_mips_abi_hardfloat'] = b(can_use_fpu_instructions)

o['variables']['mips_arch_variant'] = options.mips_arch_variant

if options.dest_os == 'android':

o['variables']['OS'] = 'android'

o['variables']['node_prefix'] = options.prefix

o['variables']['node_install_npm'] = b(not options.without_npm)

o['default_configuration'] = 'Debug' if options.debug else 'Release'

host_arch = host_arch_win() if os.name == 'nt' else host_arch_cc()

target_arch = options.dest_cpu or host_arch

# ia32 is preferred by the build tools (GYP) over x86 even if we prefer the latter

# the Makefile resets this to x86 afterward

if target_arch == 'x86':

target_arch = 'ia32'

o['variables']['host_arch'] = host_arch

o['variables']['target_arch'] = target_arch

o['variables']['node_byteorder'] = sys.byteorder

cross_compiling = (options.cross_compiling

if options.cross_compiling is not None

else target_arch != host_arch)

want_snapshots = not options.without_snapshot

o['variables']['want_separate_host_toolset'] = int(

cross_compiling and want_snapshots)

o['variables']['want_separate_host_toolset_mkpeephole'] = int(

cross_compiling)

if target_arch == 'arm':

configure_arm(o)

elif target_arch in ('mips', 'mipsel', 'mips64el'):

configure_mips(o)

if flavor == 'aix':

o['variables']['node_core_target_name'] = 'node_base'

o['variables']['node_target_type'] = 'static_library'

if target_arch in ('x86', 'x64', 'ia32', 'x32'):

o['variables']['node_enable_v8_vtunejit'] = b(options.enable_vtune_profiling)

elif options.enable_vtune_profiling:

raise Exception(

'The VTune profiler for JavaScript is only supported on x32, x86 and x64 '

'architectures.')

else:

o['variables']['node_enable_v8_vtunejit'] = 'false'

if flavor in ('solaris', 'mac', 'linux', 'freebsd'):

use_dtrace = not options.without_dtrace

# Don't enable by default on linux and freebsd

if flavor in ('linux', 'freebsd'):

use_dtrace = options.with_dtrace

if flavor == 'linux':

if options.systemtap_includes:

o['include_dirs'] += [options.systemtap_includes]

o['variables']['node_use_dtrace'] = b(use_dtrace)

o['variables']['uv_use_dtrace'] = b(use_dtrace)

o['variables']['uv_parent_path'] = '/deps/uv/'

elif options.with_dtrace:

raise Exception(

'DTrace is currently only supported on SunOS, MacOS or Linux systems.')

else:

o['variables']['node_use_dtrace'] = 'false'

# Enable Lttng if --with-lttng was defined. Use logic similar to

# ETW for windows. Lttng is only available on the Linux platform.

if flavor == 'linux':

o['variables']['node_use_lttng'] = b(options.with_lttng)

elif options.with_lttng:

raise Exception('lttng is only supported on Linux.')

else:

o['variables']['node_use_lttng'] = 'false'

if options.no_ifaddrs:

o['defines'] += ['SUNOS_NO_IFADDRS']

# By default, enable ETW on Windows.

if flavor == 'win':

o['variables']['node_use_etw'] = b(not options.without_etw)

elif options.with_etw:

raise Exception('ETW is only supported on Windows.')

else:

o['variables']['node_use_etw'] = 'false'

# By default, enable Performance counters on Windows.

if flavor == 'win':

o['variables']['node_use_perfctr'] = b(not options.without_perfctr)

elif options.with_perfctr:

raise Exception('Performance counter is only supported on Windows.')

else:

o['variables']['node_use_perfctr'] = 'false'

if options.tag:

o['variables']['node_tag'] = '-' + options.tag

else:

o['variables']['node_tag'] = ''

o['variables']['node_release_urlbase'] = options.release_urlbase or ''

if options.v8_options:

o['variables']['node_v8_options'] = options.v8_options.replace('"', '\\"')

if options.enable_static:

o['variables']['node_target_type'] = 'static_library'

o['variables']['node_no_browser_globals'] = b(options.no_browser_globals)

o['variables']['node_shared'] = b(options.shared)

node_module_version = getmoduleversion.get_version()

if sys.platform == 'darwin':

shlib_suffix = '%s.dylib'

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

shlib_suffix = '%s.a'

else:

shlib_suffix = 'so.%s'

shlib_suffix %= node_module_version

o['variables']['node_module_version'] = int(node_module_version)

o['variables']['shlib_suffix'] = shlib_suffix

if options.linked_module:

o['variables']['library_files'] = options.linked_module

o['variables']['asan'] = int(options.enable_asan or 0)

o['variables']['debug_devtools'] = 'node'

if options.use_xcode and options.use_ninja:

raise Exception('--xcode and --ninja cannot be used together.')

if options.coverage:

o['variables']['coverage'] = 'true'

else:

shared_lib = 'shared_' + lib

output['variables']['node_' + shared_lib] = b(getattr(options, shared_lib))

if getattr(options, shared_lib):

(pkg_libs, pkg_cflags, pkg_libpath) = pkg_config(lib)

if options.__dict__[shared_lib + '_includes']:

output['include_dirs'] += [options.__dict__[shared_lib + '_includes']]

elif pkg_cflags:

output['include_dirs'] += (

filter(None, map(str.strip, pkg_cflags.split('-I'))))

# libpath needs to be provided ahead libraries

if options.__dict__[shared_lib + '_libpath']:

output['libraries'] += [

'-L%s' % options.__dict__[shared_lib + '_libpath']]

elif pkg_libpath:

output['libraries'] += [pkg_libpath]

default_libs = getattr(options, shared_lib + '_libname')

default_libs = map('-l{0}'.format, default_libs.split(','))

if default_libs:

output['libraries'] += default_libs

elif pkg_libs:

o['variables']['v8_enable_gdbjit'] = 1 if options.gdb else 0

o['variables']['v8_no_strict_aliasing'] = 1 # Work around compiler bugs.

o['variables']['v8_optimized_debug'] = 0 # Compile with -O0 in debug builds.

o['variables']['v8_random_seed'] = 0 # Use a random seed for hash tables.

o['variables']['v8_use_snapshot'] = 'false' if options.without_snapshot else 'true'

o['variables']['node_use_v8_platform'] = b(not options.without_v8_platform)

o['variables']['node_use_bundled_v8'] = b(not options.without_bundled_v8)

o['variables']['force_dynamic_crt'] = 1 if options.shared else 0

o['variables']['node_enable_d8'] = b(options.enable_d8)

if options.enable_d8:

o['variables']['test_isolation_mode'] = 'noop' # Needed by d8.gyp.

if options.without_bundled_v8 and options.enable_d8:

o['variables']['node_use_openssl'] = b(not options.without_ssl)

o['variables']['node_shared_openssl'] = b(options.shared_openssl)

o['variables']['openssl_no_asm'] = 1 if options.openssl_no_asm else 0

if options.use_openssl_ca_store:

o['defines'] += ['NODE_OPENSSL_CERT_STORE']

if options.openssl_fips:

o['variables']['openssl_fips'] = options.openssl_fips

fips_dir = os.path.join(root_dir, 'deps', 'openssl', 'fips')

fips_ld = os.path.abspath(os.path.join(fips_dir, 'fipsld'))

o['make_fips_settings'] = [

['LINK', fips_ld + ' <(openssl_fips)/bin/fipsld'],

]

else:

o['variables']['openssl_fips'] = ''

if options.without_ssl:

def without_ssl_error(option):

print('Error: --without-ssl is incompatible with %s' % option)

exit(1)

if options.shared_openssl:

without_ssl_error('--shared-openssl')

if options.openssl_no_asm:

without_ssl_error('--openssl-no-asm')

if options.openssl_fips:

without_ssl_error('--openssl-fips')

return

if options.fully_static or options.partly_static:

if flavor == 'mac':

print("Generation of static executable will not work on OSX "

"when using the default compilation environment")

return

if options.fully_static: