| #!/usr/bin/env python |
| import optparse |
| import os |
| import pprint |
| import re |
| import shlex |
| import subprocess |
| import sys |
| import shutil |
| import string |
| |
| CC = os.environ.get('CC', 'cc') |
| CXX = os.environ.get('CXX', 'c++') |
| |
| root_dir = os.path.dirname(__file__) |
| sys.path.insert(0, os.path.join(root_dir, 'tools', 'gyp', 'pylib')) |
| from gyp.common import GetFlavor |
| |
| # imports in tools/configure.d |
| sys.path.insert(0, os.path.join(root_dir, 'tools', 'configure.d')) |
| import nodedownload |
| |
| # parse our options |
| parser = optparse.OptionParser() |
| |
| # 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', |
| help='select the install prefix (defaults to /usr/local)') |
| |
| parser.add_option('--debug', |
| action='store_true', |
| dest='debug', |
| help='also build debug build') |
| |
| parser.add_option('--dest-cpu', |
| action='store', |
| dest='dest_cpu', |
| help='CPU architecture to build for. Valid values are: arm, ia32, x32, x64') |
| |
| parser.add_option('--dest-os', |
| action='store', |
| dest='dest_os', |
| help='operating system to build for. Valid values are: ' |
| 'win, mac, solaris, freebsd, openbsd, linux, android') |
| |
| 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 default compilation environment") |
| |
| parser.add_option("--openssl-no-asm", |
| action="store_true", |
| dest="openssl_no_asm", |
| help="Do not build optimized assembly for OpenSSL") |
| |
| # deprecated |
| parser.add_option('--openssl-includes', |
| action='store', |
| dest='shared_openssl_includes', |
| help=optparse.SUPPRESS_HELP) |
| |
| # deprecated |
| parser.add_option('--openssl-libpath', |
| action='store', |
| dest='shared_openssl_libpath', |
| help=optparse.SUPPRESS_HELP) |
| |
| # deprecated |
| parser.add_option('--openssl-use-sys', |
| action='store_true', |
| dest='shared_openssl', |
| help=optparse.SUPPRESS_HELP) |
| |
| parser.add_option('--shared-http-parser', |
| action='store_true', |
| dest='shared_http_parser', |
| help='link to a shared http_parser DLL instead of static linking') |
| |
| parser.add_option('--shared-http-parser-includes', |
| action='store', |
| dest='shared_http_parser_includes', |
| help='directory containing http_parser header files') |
| |
| parser.add_option('--shared-http-parser-libname', |
| action='store', |
| dest='shared_http_parser_libname', |
| help='alternative lib name to link to (default: \'http_parser\')') |
| |
| parser.add_option('--shared-http-parser-libpath', |
| action='store', |
| dest='shared_http_parser_libpath', |
| help='a directory to search for the shared http_parser DLL') |
| |
| parser.add_option('--shared-libuv', |
| action='store_true', |
| dest='shared_libuv', |
| help='link to a shared libuv DLL instead of static linking') |
| |
| parser.add_option('--shared-libuv-includes', |
| action='store', |
| dest='shared_libuv_includes', |
| help='directory containing libuv header files') |
| |
| parser.add_option('--shared-libuv-libname', |
| action='store', |
| dest='shared_libuv_libname', |
| help='alternative lib name to link to (default: \'uv\')') |
| |
| parser.add_option('--shared-libuv-libpath', |
| action='store', |
| dest='shared_libuv_libpath', |
| help='a directory to search for the shared libuv DLL') |
| |
| parser.add_option('--shared-openssl', |
| action='store_true', |
| dest='shared_openssl', |
| help='link to a shared OpenSSl DLL instead of static linking') |
| |
| parser.add_option('--shared-openssl-includes', |
| action='store', |
| dest='shared_openssl_includes', |
| help='directory containing OpenSSL header files') |
| |
| parser.add_option('--shared-openssl-libname', |
| action='store', |
| dest='shared_openssl_libname', |
| help='alternative lib name to link to (default: \'crypto,ssl\')') |
| |
| parser.add_option('--shared-openssl-libpath', |
| action='store', |
| dest='shared_openssl_libpath', |
| help='a directory to search for the shared OpenSSL DLLs') |
| |
| parser.add_option('--shared-v8', |
| action='store_true', |
| dest='shared_v8', |
| help='link to a shared V8 DLL instead of static linking') |
| |
| parser.add_option('--shared-v8-includes', |
| action='store', |
| dest='shared_v8_includes', |
| help='directory containing V8 header files') |
| |
| parser.add_option('--shared-v8-libname', |
| action='store', |
| dest='shared_v8_libname', |
| help='alternative lib name to link to (default: \'v8\')') |
| |
| parser.add_option('--shared-v8-libpath', |
| action='store', |
| dest='shared_v8_libpath', |
| help='a directory to search for the shared V8 DLL') |
| |
| parser.add_option('--shared-zlib', |
| action='store_true', |
| dest='shared_zlib', |
| help='link to a shared zlib DLL instead of static linking') |
| |
| parser.add_option('--shared-zlib-includes', |
| action='store', |
| dest='shared_zlib_includes', |
| help='directory containing zlib header files') |
| |
| parser.add_option('--shared-zlib-libname', |
| action='store', |
| dest='shared_zlib_libname', |
| help='alternative lib name to link to (default: \'z\')') |
| |
| parser.add_option('--shared-zlib-libpath', |
| action='store', |
| dest='shared_zlib_libpath', |
| help='a directory to search for the shared zlib DLL') |
| |
| # TODO document when we've decided on what the tracing API and its options will |
| # look like |
| parser.add_option('--systemtap-includes', |
| action='store', |
| dest='systemtap_includes', |
| help=optparse.SUPPRESS_HELP) |
| |
| parser.add_option('--tag', |
| action='store', |
| dest='tag', |
| help='custom build tag') |
| |
| 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', |
| help='specifies which floating-point ABI to use. Valid values are: ' |
| 'soft, softfp, hard') |
| |
| parser.add_option('--with-dtrace', |
| action='store_true', |
| dest='with_dtrace', |
| help='build with DTrace (default is true on sunos)') |
| |
| parser.add_option('--with-lttng', |
| action='store_true', |
| dest='with_lttng', |
| help='build with Lttng (Only available to Linux)') |
| |
| parser.add_option('--with-etw', |
| action='store_true', |
| dest='with_etw', |
| help='build with ETW (default is true on Windows)') |
| |
| parser.add_option('--download', |
| action='store', |
| dest='download_list', |
| help=nodedownload.help()) |
| |
| parser.add_option('--with-icu-path', |
| action='store', |
| dest='with_icu_path', |
| help='Path to icu.gyp (ICU i18n, Chromium version only.)') |
| |
| parser.add_option('--with-icu-locales', |
| action='store', |
| dest='with_icu_locales', |
| help='Comma-separated list of locales for "small-icu". Default: "root,en". "root" is assumed.') |
| |
| parser.add_option('--with-intl', |
| action='store', |
| dest='with_intl', |
| help='Intl mode: none, full-icu, small-icu (default is none)') |
| |
| parser.add_option('--with-icu-source', |
| action='store', |
| dest='with_icu_source', |
| help='Intl mode: optional local path to icu/ dir, or path/URL of icu source archive.') |
| |
| parser.add_option('--with-perfctr', |
| action='store_true', |
| dest='with_perfctr', |
| help='build with performance counters (default is true on Windows)') |
| |
| 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='don\'t install the bundled npm package manager') |
| |
| parser.add_option('--without-perfctr', |
| action='store_true', |
| dest='without_perfctr', |
| help='build without performance counters') |
| |
| parser.add_option('--with-snapshot', |
| action='store_true', |
| dest='with_snapshot', |
| help=optparse.SUPPRESS_HELP) |
| |
| # Dummy option for backwards compatibility. |
| parser.add_option('--without-snapshot', |
| action='store_true', |
| dest='unused_without_snapshot', |
| help=optparse.SUPPRESS_HELP) |
| |
| parser.add_option('--without-ssl', |
| action='store_true', |
| dest='without_ssl', |
| help='build without SSL') |
| |
| parser.add_option('--xcode', |
| action='store_true', |
| dest='use_xcode', |
| help='generate build files for use with xcode') |
| |
| (options, args) = parser.parse_args() |
| |
| # set up auto-download list |
| auto_downloads = nodedownload.parse(options.download_list) |
| |
| |
| 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 occured |
| warn.warned = False |
| |
| def b(value): |
| """Returns the string 'true' if value is truthy, 'false' otherwise.""" |
| if value: |
| return 'true' |
| else: |
| return 'false' |
| |
| |
| def pkg_config(pkg): |
| cmd = os.popen('pkg-config --libs %s' % pkg, 'r') |
| libs = cmd.readline().strip() |
| ret = cmd.close() |
| if (ret): return None |
| |
| cmd = os.popen('pkg-config --cflags %s' % pkg, 'r') |
| cflags = cmd.readline().strip() |
| ret = cmd.close() |
| if (ret): return None |
| |
| return (libs, cflags) |
| |
| |
| 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('__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]) |
| |
| return (True, is_clang, clang_version, gcc_version) |
| |
| |
| # 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(): |
| 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.0' if is_clang else gcc_version < '4.8.0': |
| warn('C++ compiler too old, need g++ 4.8 or clang++ 3.4 (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) |
| |
| |
| def cc_macros(): |
| """Checks predefined macros using the CC command.""" |
| |
| try: |
| p = subprocess.Popen(shlex.split(CC) + ['-dM', '-E', '-'], |
| stdin=subprocess.PIPE, |
| stdout=subprocess.PIPE, |
| stderr=subprocess.PIPE) |
| except OSError: |
| print '''Node.js configure 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. |
| ''' |
| 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 |
| return k |
| |
| |
| def is_arch_armv7(): |
| """Check for ARMv7 instructions""" |
| cc_macros_cache = cc_macros() |
| return ('__ARM_ARCH_7__' in cc_macros_cache or |
| '__ARM_ARCH_7A__' in cc_macros_cache or |
| '__ARM_ARCH_7R__' in cc_macros_cache or |
| '__ARM_ARCH_7M__' in cc_macros_cache) |
| |
| |
| def is_arch_armv6(): |
| """Check for ARMv6 instructions""" |
| cc_macros_cache = cc_macros() |
| return ('__ARM_ARCH_6__' in cc_macros_cache or |
| '__ARM_ARCH_6M__' in cc_macros_cache) |
| |
| |
| 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.""" |
| |
| k = cc_macros() |
| |
| matchup = { |
| '__x86_64__' : 'x64', |
| '__i386__' : 'ia32', |
| '__arm__' : 'arm', |
| '__mips__' : 'mips', |
| } |
| |
| rtn = 'ia32' # default |
| |
| for i in matchup: |
| if i in k and k[i] != '0': |
| rtn = matchup[i] |
| break |
| |
| 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' |
| |
| if is_arch_armv7(): |
| o['variables']['arm_fpu'] = 'vfpv3' |
| o['variables']['arm_version'] = '7' |
| else: |
| o['variables']['arm_fpu'] = 'vfpv2' |
| 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 |
| |
| # Print warning when snapshot is enabled and building on armv6 |
| if is_arch_armv6() and options.with_snapshot: |
| warn('when building on ARMv6, don\'t use --with-snapshot') |
| |
| |
| def configure_node(o): |
| if options.dest_os == 'android': |
| o['variables']['OS'] = 'android' |
| o['variables']['node_prefix'] = os.path.expanduser(options.prefix or '') |
| 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 |
| o['variables']['host_arch'] = host_arch |
| o['variables']['target_arch'] = target_arch |
| |
| if target_arch != host_arch and options.with_snapshot: |
| o['variables']['want_separate_host_toolset'] = 1 |
| else: |
| o['variables']['want_separate_host_toolset'] = 0 |
| |
| if target_arch == 'arm': |
| configure_arm(o) |
| |
| 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 we're on illumos based systems wrap the helper library into the |
| # executable |
| if flavor == 'solaris': |
| o['variables']['node_use_mdb'] = 'true' |
| else: |
| o['variables']['node_use_mdb'] = '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'] = '' |
| |
| if options.v8_options: |
| o['variables']['node_v8_options'] = options.v8_options.replace('"', '\\"') |
| |
| |
| def configure_libz(o): |
| o['variables']['node_shared_zlib'] = b(options.shared_zlib) |
| |
| # assume shared_zlib if one of these is set? |
| if options.shared_zlib_libpath: |
| o['libraries'] += ['-L%s' % options.shared_zlib_libpath] |
| if options.shared_zlib_libname: |
| o['libraries'] += ['-l%s' % options.shared_zlib_libname] |
| elif options.shared_zlib: |
| o['libraries'] += ['-lz'] |
| if options.shared_zlib_includes: |
| o['include_dirs'] += [options.shared_zlib_includes] |
| |
| |
| def configure_http_parser(o): |
| o['variables']['node_shared_http_parser'] = b(options.shared_http_parser) |
| |
| # assume shared http_parser if one of these is set? |
| if options.shared_http_parser_libpath: |
| o['libraries'] += ['-L%s' % options.shared_http_parser_libpath] |
| if options.shared_http_parser_libname: |
| o['libraries'] += ['-l%s' % options.shared_http_parser_libname] |
| elif options.shared_http_parser: |
| o['libraries'] += ['-lhttp_parser'] |
| if options.shared_http_parser_includes: |
| o['include_dirs'] += [options.shared_http_parser_includes] |
| |
| |
| def configure_libuv(o): |
| o['variables']['node_shared_libuv'] = b(options.shared_libuv) |
| |
| # assume shared libuv if one of these is set? |
| if options.shared_libuv_libpath: |
| o['libraries'] += ['-L%s' % options.shared_libuv_libpath] |
| else: |
| o['variables']['uv_library'] = 'static_library' |
| |
| if options.shared_libuv_libname: |
| o['libraries'] += ['-l%s' % options.shared_libuv_libname] |
| elif options.shared_libuv: |
| o['libraries'] += ['-luv'] |
| if options.shared_libuv_includes: |
| o['include_dirs'] += [options.shared_libuv_includes] |
| |
| |
| def configure_v8(o): |
| o['variables']['node_shared_v8'] = b(options.shared_v8) |
| 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'] = b(options.with_snapshot) |
| |
| # assume shared_v8 if one of these is set? |
| if options.shared_v8_libpath: |
| o['libraries'] += ['-L%s' % options.shared_v8_libpath] |
| if options.shared_v8_libname: |
| o['libraries'] += ['-l%s' % options.shared_v8_libname] |
| elif options.shared_v8: |
| o['libraries'] += ['-lv8'] |
| if options.shared_v8_includes: |
| o['include_dirs'] += [options.shared_v8_includes] |
| |
| |
| def configure_openssl(o): |
| 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.without_ssl: |
| return |
| |
| if options.shared_openssl: |
| (libs, cflags) = pkg_config('openssl') or ('-lssl -lcrypto', '') |
| |
| if options.shared_openssl_libpath: |
| o['libraries'] += ['-L%s' % options.shared_openssl_libpath] |
| |
| if options.shared_openssl_libname: |
| libnames = options.shared_openssl_libname.split(',') |
| o['libraries'] += ['-l%s' % s for s in libnames] |
| else: |
| o['libraries'] += libs.split() |
| |
| if options.shared_openssl_includes: |
| o['include_dirs'] += [options.shared_openssl_includes] |
| else: |
| o['cflags'] += cflags.split() |
| |
| |
| def configure_fullystatic(o): |
| if options.fully_static: |
| o['libraries'] += ['-static'] |
| if flavor == 'mac': |
| print("Generation of static executable will not work on OSX " |
| "when using default compilation environment") |
| |
| |
| def configure_winsdk(o): |
| if flavor != 'win': |
| return |
| |
| winsdk_dir = os.environ.get('WindowsSdkDir') |
| |
| if winsdk_dir and os.path.isfile(winsdk_dir + '\\bin\\ctrpp.exe'): |
| print('Found ctrpp in WinSDK--will build generated files ' |
| 'into tools/msvs/genfiles.') |
| o['variables']['node_has_winsdk'] = 'true' |
| return |
| |
| print('ctrpp not found in WinSDK path--using pre-gen files ' |
| 'from tools/msvs/genfiles.') |
| |
| def write(filename, data): |
| filename = os.path.join(root_dir, filename) |
| print 'creating ', filename |
| f = open(filename, 'w+') |
| f.write(data) |
| |
| do_not_edit = '# Do not edit. Generated by the configure script.\n' |
| |
| def glob_to_var(dir_base, dir_sub): |
| list = [] |
| dir_all = os.path.join(dir_base, dir_sub) |
| files = os.walk(dir_all) |
| for ent in files: |
| (path, dirs, files) = ent |
| for file in files: |
| if file.endswith('.cpp') or file.endswith('.c') or file.endswith('.h'): |
| list.append('%s/%s' % (dir_sub, file)) |
| break |
| return list |
| |
| def configure_intl(o): |
| icus = [ |
| { |
| 'url': 'http://download.icu-project.org/files/icu4c/54.1/icu4c-54_1-src.zip', |
| # from https://ssl.icu-project.org/files/icu4c/54.1/icu4c-src-54_1.md5: |
| 'md5': '6b89d60e2f0e140898ae4d7f72323bca', |
| }, |
| ] |
| def icu_download(path): |
| # download ICU, if needed |
| for icu in icus: |
| url = icu['url'] |
| md5 = icu['md5'] |
| local = url.split('/')[-1] |
| targetfile = os.path.join(root_dir, 'deps', local) |
| if not os.path.isfile(targetfile): |
| if nodedownload.candownload(auto_downloads, "icu"): |
| nodedownload.retrievefile(url, targetfile) |
| else: |
| print ' Re-using existing %s' % targetfile |
| if os.path.isfile(targetfile): |
| sys.stdout.write(' Checking file integrity with MD5:\r') |
| gotmd5 = nodedownload.md5sum(targetfile) |
| print ' MD5: %s %s' % (gotmd5, targetfile) |
| if (md5 == gotmd5): |
| return targetfile |
| else: |
| print ' Expected: %s *MISMATCH*' % md5 |
| print '\n ** Corrupted ZIP? Delete %s to retry download.\n' % targetfile |
| return None |
| icu_config = { |
| 'variables': {} |
| } |
| icu_config_name = 'icu_config.gypi' |
| def write_config(data, name): |
| return |
| |
| # write an empty file to start with |
| write(icu_config_name, do_not_edit + |
| pprint.pformat(icu_config, indent=2) + '\n') |
| |
| # always set icu_small, node.gyp depends on it being defined. |
| o['variables']['icu_small'] = b(False) |
| |
| with_intl = options.with_intl |
| with_icu_source = options.with_icu_source |
| have_icu_path = bool(options.with_icu_path) |
| if have_icu_path and with_intl: |
| print 'Error: Cannot specify both --with-icu-path and --with-intl' |
| sys.exit(1) |
| elif have_icu_path: |
| # Chromium .gyp mode: --with-icu-path |
| o['variables']['v8_enable_i18n_support'] = 1 |
| # use the .gyp given |
| o['variables']['icu_gyp_path'] = options.with_icu_path |
| return |
| # --with-intl=<with_intl> |
| # set the default |
| if with_intl is None: |
| with_intl = 'none' # The default mode of Intl |
| # sanity check localelist |
| if options.with_icu_locales and (with_intl != 'small-icu'): |
| print 'Error: --with-icu-locales only makes sense with --with-intl=small-icu' |
| sys.exit(1) |
| if with_intl == 'none' or with_intl is None: |
| o['variables']['v8_enable_i18n_support'] = 0 |
| return # no Intl |
| elif with_intl == 'small-icu': |
| # small ICU (English only) |
| o['variables']['v8_enable_i18n_support'] = 1 |
| o['variables']['icu_small'] = b(True) |
| with_icu_locales = options.with_icu_locales |
| if not with_icu_locales: |
| with_icu_locales = 'root,en' |
| locs = set(with_icu_locales.split(',')) |
| locs.add('root') # must have root |
| o['variables']['icu_locales'] = string.join(locs,',') |
| elif with_intl == 'full-icu': |
| # full ICU |
| o['variables']['v8_enable_i18n_support'] = 1 |
| elif with_intl == 'system-icu': |
| # ICU from pkg-config. |
| o['variables']['v8_enable_i18n_support'] = 1 |
| pkgicu = pkg_config('icu-i18n') |
| if not pkgicu: |
| print 'Error: could not load pkg-config data for "icu-i18n".' |
| print 'See above errors or the README.md.' |
| sys.exit(1) |
| (libs, cflags) = pkgicu |
| o['libraries'] += libs.split() |
| o['cflags'] += cflags.split() |
| # use the "system" .gyp |
| o['variables']['icu_gyp_path'] = 'tools/icu/icu-system.gyp' |
| return |
| else: |
| print 'Error: unknown value --with-intl=%s' % with_intl |
| sys.exit(1) |
| # Note: non-ICU implementations could use other 'with_intl' |
| # values. |
| |
| # this is just the 'deps' dir. Used for unpacking. |
| icu_parent_path = os.path.join(root_dir, 'deps') |
| |
| # The full path to the ICU source directory. |
| icu_full_path = os.path.join(icu_parent_path, 'icu') |
| |
| # icu-tmp is used to download and unpack the ICU tarball. |
| icu_tmp_path = os.path.join(icu_parent_path, 'icu-tmp') |
| |
| # --with-icu-source processing |
| # first, check that they didn't pass --with-icu-source=deps/icu |
| if with_icu_source and os.path.abspath(icu_full_path) == os.path.abspath(with_icu_source): |
| print 'Ignoring redundant --with-icu-source=%s' % (with_icu_source) |
| with_icu_source = None |
| # if with_icu_source is still set, try to use it. |
| if with_icu_source: |
| if os.path.isdir(icu_full_path): |
| print 'Deleting old ICU source: %s' % (icu_full_path) |
| shutil.rmtree(icu_full_path) |
| # now, what path was given? |
| if os.path.isdir(with_icu_source): |
| # it's a path. Copy it. |
| print '%s -> %s' % (with_icu_source, icu_full_path) |
| shutil.copytree(with_icu_source, icu_full_path) |
| else: |
| # could be file or URL. |
| # Set up temporary area |
| if os.path.isdir(icu_tmp_path): |
| shutil.rmtree(icu_tmp_path) |
| os.mkdir(icu_tmp_path) |
| icu_tarball = None |
| if os.path.isfile(with_icu_source): |
| # it's a file. Try to unpack it. |
| icu_tarball = with_icu_source |
| else: |
| # Can we download it? |
| local = os.path.join(icu_tmp_path, with_icu_source.split('/')[-1]) # local part |
| icu_tarball = nodedownload.retrievefile(with_icu_source, local) |
| # continue with "icu_tarball" |
| nodedownload.unpack(icu_tarball, icu_tmp_path) |
| # Did it unpack correctly? Should contain 'icu' |
| tmp_icu = os.path.join(icu_tmp_path, 'icu') |
| if os.path.isdir(tmp_icu): |
| os.rename(tmp_icu, icu_full_path) |
| shutil.rmtree(icu_tmp_path) |
| else: |
| print ' Error: --with-icu-source=%s did not result in an "icu" dir.' % with_icu_source |
| shutil.rmtree(icu_tmp_path) |
| sys.exit(1) |
| |
| # ICU mode. (icu-generic.gyp) |
| o['variables']['icu_gyp_path'] = 'tools/icu/icu-generic.gyp' |
| # ICU source dir relative to root |
| o['variables']['icu_path'] = icu_full_path |
| if not os.path.isdir(icu_full_path): |
| print '* ECMA-402 (Intl) support didn\'t find ICU in %s..' % (icu_full_path) |
| # can we download (or find) a zipfile? |
| localzip = icu_download(icu_full_path) |
| if localzip: |
| nodedownload.unpack(localzip, icu_parent_path) |
| if not os.path.isdir(icu_full_path): |
| print ' Cannot build Intl without ICU in %s.' % (icu_full_path) |
| print ' (Fix, or disable with "--with-intl=none" )' |
| sys.exit(1) |
| else: |
| print '* Using ICU in %s' % (icu_full_path) |
| # Now, what version of ICU is it? We just need the "major", such as 54. |
| # uvernum.h contains it as a #define. |
| uvernum_h = os.path.join(icu_full_path, 'source/common/unicode/uvernum.h') |
| if not os.path.isfile(uvernum_h): |
| print ' Error: could not load %s - is ICU installed?' % uvernum_h |
| sys.exit(1) |
| icu_ver_major = None |
| matchVerExp = r'^\s*#define\s+U_ICU_VERSION_SHORT\s+"([^"]*)".*' |
| match_version = re.compile(matchVerExp) |
| for line in open(uvernum_h).readlines(): |
| m = match_version.match(line) |
| if m: |
| icu_ver_major = m.group(1) |
| if not icu_ver_major: |
| print ' Could not read U_ICU_VERSION_SHORT version from %s' % uvernum_h |
| sys.exit(1) |
| icu_endianness = sys.byteorder[0]; # TODO(srl295): EBCDIC should be 'e' |
| o['variables']['icu_ver_major'] = icu_ver_major |
| o['variables']['icu_endianness'] = icu_endianness |
| icu_data_file_l = 'icudt%s%s.dat' % (icu_ver_major, 'l') |
| icu_data_file = 'icudt%s%s.dat' % (icu_ver_major, icu_endianness) |
| # relative to configure |
| icu_data_path = os.path.join(icu_full_path, |
| 'source/data/in', |
| icu_data_file_l) |
| # relative to dep.. |
| icu_data_in = os.path.join('../../deps/icu/source/data/in', icu_data_file_l) |
| if not os.path.isfile(icu_data_path) and icu_endianness != 'l': |
| # use host endianness |
| icu_data_path = os.path.join(icu_full_path, |
| 'source/data/in', |
| icu_data_file) |
| # relative to dep.. |
| icu_data_in = os.path.join('icu/source/data/in', |
| icu_data_file) |
| # this is the input '.dat' file to use .. icudt*.dat |
| # may be little-endian if from a icu-project.org tarball |
| o['variables']['icu_data_in'] = icu_data_in |
| # this is the icudt*.dat file which node will be using (platform endianness) |
| o['variables']['icu_data_file'] = icu_data_file |
| if not os.path.isfile(icu_data_path): |
| print ' Error: ICU prebuilt data file %s does not exist.' % icu_data_path |
| print ' See the README.md.' |
| # .. and we're not about to build it from .gyp! |
| sys.exit(1) |
| # map from variable name to subdirs |
| icu_src = { |
| 'stubdata': 'stubdata', |
| 'common': 'common', |
| 'i18n': 'i18n', |
| 'io': 'io', |
| 'tools': 'tools/toolutil', |
| 'genccode': 'tools/genccode', |
| 'genrb': 'tools/genrb', |
| 'icupkg': 'tools/icupkg', |
| } |
| # this creates a variable icu_src_XXX for each of the subdirs |
| # with a list of the src files to use |
| for i in icu_src: |
| var = 'icu_src_%s' % i |
| path = '../../deps/icu/source/%s' % icu_src[i] |
| icu_config['variables'][var] = glob_to_var('tools/icu', path) |
| # write updated icu_config.gypi with a bunch of paths |
| write(icu_config_name, do_not_edit + |
| pprint.pformat(icu_config, indent=2) + '\n') |
| return # end of configure_intl |
| |
| # Print a warning when the compiler is too old. |
| check_compiler() |
| |
| # determine the "flavor" (operating system) we're building for, |
| # leveraging gyp's GetFlavor function |
| flavor_params = {} |
| if (options.dest_os): |
| flavor_params['flavor'] = options.dest_os |
| flavor = GetFlavor(flavor_params) |
| |
| output = { |
| 'variables': { 'python': sys.executable }, |
| 'include_dirs': [], |
| 'libraries': [], |
| 'defines': [], |
| 'cflags': [], |
| } |
| |
| configure_node(output) |
| configure_libz(output) |
| configure_http_parser(output) |
| configure_libuv(output) |
| configure_v8(output) |
| configure_openssl(output) |
| configure_winsdk(output) |
| configure_intl(output) |
| configure_fullystatic(output) |
| |
| # variables should be a root level element, |
| # move everything else to target_defaults |
| variables = output['variables'] |
| del output['variables'] |
| output = { |
| 'variables': variables, |
| 'target_defaults': output |
| } |
| pprint.pprint(output, indent=2) |
| |
| write('config.gypi', do_not_edit + |
| pprint.pformat(output, indent=2) + '\n') |
| |
| config = { |
| 'BUILDTYPE': 'Debug' if options.debug else 'Release', |
| 'USE_XCODE': str(int(options.use_xcode or 0)), |
| 'PYTHON': sys.executable, |
| } |
| |
| if options.prefix: |
| config['PREFIX'] = options.prefix |
| |
| config = '\n'.join(map('='.join, config.iteritems())) + '\n' |
| |
| write('config.mk', |
| '# Do not edit. Generated by the configure script.\n' + config) |
| |
| gyp_args = [sys.executable, 'tools/gyp_node.py', '--no-parallel'] |
| |
| if options.use_xcode: |
| gyp_args += ['-f', 'xcode'] |
| elif flavor == 'win' and sys.platform != 'msys': |
| gyp_args += ['-f', 'msvs', '-G', 'msvs_version=auto'] |
| else: |
| gyp_args += ['-f', 'make-' + flavor] |
| |
| gyp_args += args |
| |
| if warn.warned: |
| warn('warnings were emitted in the configure phase') |
| |
| sys.exit(subprocess.call(gyp_args)) |