from __future__ import print_function

import json

import sys

import errno

import argparse

import os

import pipes

import pprint

import re

import shlex

import subprocess

import shutil

import bz2

import io

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

import getsharedopensslhasquic

from gyp_node import run_gyp

from utils import SearchFiles

# parse our options

parser = argparse.ArgumentParser()

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

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

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

'ppc64', 'x64', 'x86', 'x86_64', 's390x', 'riscv64', 'loong64')

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)

shareable_builtins = {'cjs_module_lexer/lexer': 'deps/cjs-module-lexer/lexer.js',

'cjs_module_lexer/dist/lexer': 'deps/cjs-module-lexer/dist/lexer.js',

'undici/undici': 'deps/undici/undici.js'

}

# create option groups

shared_optgroup = parser.add_argument_group("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.")

static_optgroup = parser.add_argument_group("Static libraries",

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

"additional static libraries.")

intl_optgroup = parser.add_argument_group("Internationalization",

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

"library you want to build against.")

http2_optgroup = parser.add_argument_group("HTTP2",

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

shared_builtin_optgroup = parser.add_argument_group("Shared builtins",

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

"internal builtins or shared files.")

# 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_argument('--prefix',

action='store',

dest='prefix',

default='/usr/local',

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

parser.add_argument('--coverage',

action='store_true',

dest='coverage',

default=None,

help='Build node with code coverage enabled')

parser.add_argument('--debug',

action='store_true',

dest='debug',

default=None,

help='also build debug build')

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

action='store_true',

dest='debug_node',

default=None,

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

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

action='store',

dest='dest_cpu',

choices=valid_arch,

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

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

action='store_true',

dest='cross_compiling',

default=None,

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

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

action='store_false',

dest='cross_compiling',

default=None,

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

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

action='store',

dest='dest_os',

choices=valid_os,

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

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

action='store_true',

dest='error_on_warn',

default=None,

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

parser.add_argument('--gdb',

action='store_true',

dest='gdb',

default=None,

help='add gdb support')

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

action='store_true',

dest='no_ifaddrs',

default=None,

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

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

action="store_true",

dest="fully_static",

default=None,

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

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

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

action="store_true",

dest="partly_static",

default=None,

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

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

parser.add_argument("--enable-vtune-profiling",

action="store_true",

dest="enable_vtune_profiling",

help="Enable profiling support for Intel VTune profiler to profile "

"JavaScript code executed in Node.js. This feature is only available "

"for x32, x86, and x64 architectures.")

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

action="store_true",

dest="enable_pgo_generate",

default=None,

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_argument("--enable-pgo-use",

action="store_true",

dest="enable_pgo_use",

default=None,

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_argument("--enable-lto",

action="store_true",

dest="enable_lto",

default=None,

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

"with gcc 5.4.1+ or clang 3.9.1+.")

parser.add_argument("--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_argument("--openssl-conf-name",

action="store",

dest="openssl_conf_name",

default='nodejs_conf',

help="The OpenSSL config appname (config section name) used by Node.js")

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

action='store',

dest='openssl_default_cipher_list',

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

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

action="store_true",

dest="openssl_no_asm",

default=None,

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

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

action='store_true',

dest='openssl_is_fips',

default=None,

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

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

action='store_true',

dest='use_openssl_ca_store',

default=None,

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

parser.add_argument('--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_argument('--experimental-http-parser',

action='store_true',

dest='experimental_http_parser',

default=None,

help='(no-op)')

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

action='store_true',

dest='shared_http_parser',

default=None,

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

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

action='store',

dest='shared_http_parser_includes',

help='directory containing http_parser header files')

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

action='store',

dest='shared_http_parser_libname',

default='http_parser',

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

shared_optgroup.add_argument('--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_argument('--shared-libuv',

action='store_true',

dest='shared_libuv',

default=None,

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

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

action='store',

dest='shared_libuv_includes',

help='directory containing libuv header files')

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

action='store',

dest='shared_libuv_libname',

default='uv',

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

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

action='store',

dest='shared_libuv_libpath',

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

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

action='store_true',

dest='shared_nghttp2',

default=None,

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

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

action='store',

dest='shared_nghttp2_includes',

help='directory containing nghttp2 header files')

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

action='store',

dest='shared_nghttp2_libname',

default='nghttp2',

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

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

action='store',

dest='shared_nghttp2_libpath',

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

shared_optgroup.add_argument('--shared-nghttp3',

action='store_true',

dest='shared_nghttp3',

default=None,

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

shared_optgroup.add_argument('--shared-nghttp3-includes',

action='store',

dest='shared_nghttp3_includes',

help='directory containing nghttp3 header files')

shared_optgroup.add_argument('--shared-nghttp3-libname',

action='store',

dest='shared_nghttp3_libname',

default='nghttp3',

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

shared_optgroup.add_argument('--shared-nghttp3-libpath',

action='store',

dest='shared_nghttp3_libpath',

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

shared_optgroup.add_argument('--shared-ngtcp2',

action='store_true',

dest='shared_ngtcp2',

default=None,

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

shared_optgroup.add_argument('--shared-ngtcp2-includes',

action='store',

dest='shared_ngtcp2_includes',

help='directory containing ngtcp2 header files')

shared_optgroup.add_argument('--shared-ngtcp2-libname',

action='store',

dest='shared_ngtcp2_libname',

default='ngtcp2',

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

shared_optgroup.add_argument('--shared-ngtcp2-libpath',

action='store',

dest='shared_ngtcp2_libpath',

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

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

action='store_true',

dest='shared_openssl',

default=None,

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

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

action='store',

dest='shared_openssl_includes',

help='directory containing OpenSSL header files')

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

action='store',

dest='shared_openssl_libname',

default='crypto,ssl',

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

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

action='store',

dest='shared_openssl_libpath',

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

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

action='store_true',

dest='shared_zlib',

default=None,

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

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

action='store',

dest='shared_zlib_includes',

help='directory containing zlib header files')

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

action='store',

dest='shared_zlib_libname',

default='z',

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

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

action='store',

dest='shared_zlib_libpath',

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

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

action='store_true',

dest='shared_brotli',

default=None,

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

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

action='store',

dest='shared_brotli_includes',

help='directory containing brotli header files')

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

action='store',

dest='shared_brotli_libname',

default='brotlidec,brotlienc',

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

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

action='store',

dest='shared_brotli_libpath',

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

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

action='store_true',

dest='shared_cares',

default=None,

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

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

action='store',

dest='shared_cares_includes',

help='directory containing cares header files')

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

action='store',

dest='shared_cares_libname',

default='cares',

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

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

action='store',

dest='shared_cares_libpath',

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

parser.add_argument_group(shared_optgroup)

for builtin in shareable_builtins:

builtin_id = 'shared_builtin_' + builtin + '_path'

shared_builtin_optgroup.add_argument('--shared-builtin-' + builtin + '-path',

action='store',

dest='node_shared_builtin_' + builtin.replace('/', '_') + '_path',

help='Path to shared file for ' + builtin + ' builtin. '

'Will be used instead of bundled version at runtime')

parser.add_argument_group(shared_builtin_optgroup)

static_optgroup.add_argument('--static-zoslib-gyp',

action='store',

dest='static_zoslib_gyp',

help='path to zoslib.gyp file for includes and to link to static zoslib libray')

parser.add_argument_group(static_optgroup)

parser.add_argument('--tag',

action='store',

dest='tag',

help='custom build tag')

parser.add_argument('--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_argument('--enable-d8',

action='store_true',

dest='enable_d8',

default=None,

help=argparse.SUPPRESS) # Unsupported, undocumented.

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

action='store_true',

dest='trace_maps',

default=None,

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

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

action='store_true',

dest='enable_pointer_compression',

default=None,

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

parser.add_argument('--disable-shared-readonly-heap',

action='store_true',

dest='disable_shared_ro_heap',

default=None,

help='Disable the shared read-only heap feature in V8')

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

action='store',

dest='v8_options',

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

parser.add_argument('--with-ossfuzz',

action='store_true',

dest='ossfuzz',

default=None,

help='Enables building of fuzzers. This command should be run in an OSS-Fuzz Docker image.')

parser.add_argument('--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_argument('--with-arm-fpu',

action='store',

dest='arm_fpu',

choices=valid_arm_fpu,

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

', '.join(valid_arm_fpu)))

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

action='store',

dest='mips_arch_variant',

default='r2',

choices=valid_mips_arch,

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

', '.join(valid_mips_arch)))

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

action='store',

dest='mips_fpu_mode',

default='fp32',

choices=valid_mips_fpu,

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

', '.join(valid_mips_fpu)))

parser.add_argument('--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)s]'.format(

', '.join(valid_mips_float_abi)))

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

action='store_true',

dest='node_use_large_pages',

default=None,

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

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

action='store_true',

dest='node_use_large_pages_script_lld',

default=None,

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

parser.add_argument('--use-section-ordering-file',

action='store',

dest='node_section_ordering_info',

default='',

help='Pass a section ordering file to the linker. This requires that ' +

'Node.js be linked using the gold linker. The gold linker must have ' +

'version 1.2 or greater.')

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

action='store',

dest='with_intl',

default='full-icu',

choices=valid_intl_modes,

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

', '.join(valid_intl_modes)))

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

action='store_const',

dest='with_intl',

const='none',

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

intl_optgroup.add_argument('--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_argument('--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)s]')

intl_optgroup.add_argument('--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_argument('--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_argument('--with-ltcg',

action='store_true',

dest='with_ltcg',

default=None,

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

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

action='store_true',

dest='without_node_snapshot',

default=None,

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

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

action='store_true',

dest='without_node_code_cache',

default=None,

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

intl_optgroup.add_argument('--download',

action='store',

dest='download_list',

help=nodedownload.help())

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

action='store',

dest='download_path',

default='deps',

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

parser.add_argument_group(intl_optgroup)

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

action='store_true',

dest='node_debug_lib',

default=None,

help='build lib with DCHECK macros')

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

action='store_true',

dest='debug_nghttp2',

default=None,

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

parser.add_argument_group(http2_optgroup)

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

action='store_true',

dest='without_npm',

default=None,

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

parser.add_argument('--without-corepack',

action='store_true',

dest='without_corepack',

default=None,

help='do not install the bundled Corepack')

# Dummy option for backwards compatibility

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

action='store_true',

dest='unused_without_report',

default=None,

help=argparse.SUPPRESS)

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

action='store_true',

dest='unused_with_snapshot',

default=None,

help=argparse.SUPPRESS)

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

action='store_true',

dest='unused_without_snapshot',

default=None,

help=argparse.SUPPRESS)

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

action='store_true',

dest='without_siphash',

default=None,

help=argparse.SUPPRESS)

# End dummy list.

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

action='store_true',

dest='without_ssl',

default=None,

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

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

action='store_true',

dest='without_node_options',

default=None,

help='build without NODE_OPTIONS support')

parser.add_argument('--ninja',

action='store_true',

dest='use_ninja',

default=None,

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

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

action='store_true',

dest='enable_asan',

default=None,

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

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

action='store_true',

dest='enable_static',

default=None,

help='build as static library')

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

action='store_true',

dest='no_browser_globals',

default=None,

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

'(This mode is deprecated and not officially supported for regular ' +

'applications)')

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

action='store_true',

dest='without_inspector',

default=None,

help='disable the V8 inspector protocol')

parser.add_argument('--shared',

action='store_true',

dest='shared',

default=None,

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

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

parser.add_argument('--libdir',

action='store',

dest='libdir',

default='lib',

help='a directory to install the shared library into relative to the '

'prefix. This is a no-op if --shared is not specified. ' +

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

parser.add_argument('--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_argument('--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_argument('--verbose',

action='store_true',

dest='verbose',

default=False,

help='get more output from this script')

parser.add_argument('--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_argument('--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_argument('--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_argument('--v8-enable-object-print',

action='store_true',

dest='v8_enable_object_print',

default=True,

help='compile V8 with auxiliary functions for native debuggers')

parser.add_argument('--v8-disable-object-print',

action='store_true',

dest='v8_disable_object_print',

default=False,

help='disable the V8 auxiliary functions for native debuggers')

parser.add_argument('--v8-enable-hugepage',

action='store_true',

dest='v8_enable_hugepage',

default=None,

help='Enable V8 transparent hugepage support. This feature is only '+

'available on Linux platform.')

parser.add_argument('--v8-enable-short-builtin-calls',

action='store_true',

dest='v8_enable_short_builtin_calls',

default=None,

help='Enable V8 short builtin calls support. This feature is enabled '+

'on x86_64 platform by default.')

parser.add_argument('--v8-enable-snapshot-compression',

action='store_true',

dest='v8_enable_snapshot_compression',

default=None,

help='Enable the built-in snapshot compression in V8.')

parser.add_argument('--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')

parser.add_argument('--node-snapshot-main',

action='store',

dest='node_snapshot_main',

default=None,

help='Run a file when building the embedded snapshot. Currently ' +

'experimental.')

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

parser.add_argument('-C',

action='store_true',

dest='compile_commands_json',

default=None,

help=argparse.SUPPRESS)

(options, args) = parser.parse_known_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.append(val)

args = ['--silence-errors']

return tuple(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__')

if sys.platform == 'zos':

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

else:

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"(^(?:.+ )?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])