# HG changeset patch # User Christophe Lincoln # Date 1398356197 -7200 # Node ID ba780b0b772eac8f97147275aece6b7de47572df # Parent 9f3a7907cf0cdd0850f1cb20239ba2561e3877af mpg123: up to (1.19.0) with better ARM support diff -r 9f3a7907cf0c -r ba780b0b772e mpg123-dev/receipt --- a/mpg123-dev/receipt Thu Apr 24 15:10:41 2014 +0000 +++ b/mpg123-dev/receipt Thu Apr 24 18:16:37 2014 +0200 @@ -1,7 +1,7 @@ # SliTaz package receipt. PACKAGE="mpg123-dev" -VERSION="1.18.1" +VERSION="1.19.0" CATEGORY="development" SHORT_DESC="mpg123 development files" MAINTAINER="devl547@gmail.com" diff -r 9f3a7907cf0c -r ba780b0b772e mpg123/receipt --- a/mpg123/receipt Thu Apr 24 15:10:41 2014 +0000 +++ b/mpg123/receipt Thu Apr 24 18:16:37 2014 +0200 @@ -1,7 +1,7 @@ # SliTaz package receipt. PACKAGE="mpg123" -VERSION="1.18.1" +VERSION="1.19.0" CATEGORY="multimedia" SHORT_DESC="Command line audio player and streamer" MAINTAINER="pankso@slitaz.org" @@ -25,9 +25,8 @@ { ./configure \ --with-default-audio=alsa \ - --with-audio="alsa" \ $CONFIGURE_ARGS ${ARCH_ARGS} && - make && make install + make CFLAGS="-I/cross/arm/sysroot/usr/include" && make install } # Rules to gen a SliTaz package suitable for Tazpkg. diff -r 9f3a7907cf0c -r ba780b0b772e node/receipt --- a/node/receipt Thu Apr 24 15:10:41 2014 +0000 +++ b/node/receipt Thu Apr 24 18:16:37 2014 +0200 @@ -9,6 +9,7 @@ TARBALL="$PACKAGE-v$VERSION.tar.gz" WEB_SITE="http://nodejs.org/" WGET_URL="http://nodejs.org/dist/v$VERSION/$TARBALL" +#HOST_ARCH="i486 arm" DEPENDS="python libssl" BUILD_DEPENDS="python-dev openssl-dev" @@ -16,7 +17,7 @@ # Rules to configure and make the package. compile_rules() { - cd $src + #patch -p0 < ${stuff}/SConstruct.patch || return 1 ./configure --prefix=/usr && make && make install } diff -r 9f3a7907cf0c -r ba780b0b772e node/stuff/SConstruct --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/node/stuff/SConstruct Thu Apr 24 18:16:37 2014 +0200 @@ -0,0 +1,1636 @@ +# Copyright 2012 the V8 project authors. All rights reserved. +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following +# disclaimer in the documentation and/or other materials provided +# with the distribution. +# * Neither the name of Google Inc. nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +import platform +import re +import subprocess +import sys +import os +from os.path import join, dirname, abspath +from types import DictType, StringTypes +root_dir = dirname(File('SConstruct').rfile().abspath) +src_dir = join(root_dir, 'src') +sys.path.insert(0, join(root_dir, 'tools')) +import js2c, utils + +# ARM_TARGET_LIB is the path to the dynamic library to use on the target +# machine if cross-compiling to an arm machine. You will also need to set +# the additional cross-compiling environment variables to the cross compiler. +ARM_TARGET_LIB = os.environ.get('ARM_TARGET_LIB') +if ARM_TARGET_LIB: + ARM_LINK_FLAGS = ['-Wl,-rpath=' + ARM_TARGET_LIB + '/lib:' + + ARM_TARGET_LIB + '/usr/lib', + '-Wl,--dynamic-linker=' + ARM_TARGET_LIB + + '/lib/ld-linux.so.3'] +else: + ARM_LINK_FLAGS = [] + +GCC_EXTRA_CCFLAGS = [] +GCC_DTOA_EXTRA_CCFLAGS = [] + +LIBRARY_FLAGS = { + 'all': { + 'CPPPATH': [src_dir], + 'regexp:interpreted': { + 'CPPDEFINES': ['V8_INTERPRETED_REGEXP'] + }, + 'mode:debug': { + 'CPPDEFINES': ['V8_ENABLE_CHECKS', 'OBJECT_PRINT', 'VERIFY_HEAP'] + }, + 'objectprint:on': { + 'CPPDEFINES': ['OBJECT_PRINT'], + }, + 'debuggersupport:on': { + 'CPPDEFINES': ['ENABLE_DEBUGGER_SUPPORT'], + }, + 'inspector:on': { + 'CPPDEFINES': ['INSPECTOR'], + }, + 'fasttls:off': { + 'CPPDEFINES': ['V8_NO_FAST_TLS'], + }, + 'liveobjectlist:on': { + 'CPPDEFINES': ['ENABLE_DEBUGGER_SUPPORT', 'INSPECTOR', + 'LIVE_OBJECT_LIST', 'OBJECT_PRINT'], + } + }, + 'gcc': { + 'all': { + 'CCFLAGS': ['$DIALECTFLAGS', '$WARNINGFLAGS', '-march=armv6'], + 'CXXFLAGS': ['-fno-rtti', '-fno-exceptions', '-march=armv6'], + }, + 'visibility:hidden': { + # Use visibility=default to disable this. + 'CXXFLAGS': ['-fvisibility=hidden'] + }, + 'strictaliasing:off': { + 'CCFLAGS': ['-fno-strict-aliasing'] + }, + 'mode:debug': { + 'CCFLAGS': ['-g', '-O0'], + 'CPPDEFINES': ['ENABLE_DISASSEMBLER', 'DEBUG'], + }, + 'mode:release': { + 'CCFLAGS': ['-O3', '-fomit-frame-pointer', '-fdata-sections', + '-ffunction-sections'], + }, + 'os:linux': { + 'CCFLAGS': ['-ansi'] + GCC_EXTRA_CCFLAGS, + 'library:shared': { + 'CPPDEFINES': ['V8_SHARED', 'BUILDING_V8_SHARED'], + 'LIBS': ['pthread'] + } + }, + 'os:macos': { + 'CCFLAGS': ['-ansi', '-mmacosx-version-min=10.4'], + 'library:shared': { + 'CPPDEFINES': ['V8_SHARED', 'BUILDING_V8_SHARED'], + } + }, + 'os:freebsd': { + 'CPPPATH' : [src_dir, '/usr/local/include'], + 'LIBPATH' : ['/usr/local/lib'], + 'CCFLAGS': ['-ansi'], + 'LIBS': ['execinfo'] + }, + 'os:openbsd': { + 'CPPPATH' : [src_dir, '/usr/local/include'], + 'LIBPATH' : ['/usr/local/lib'], + 'CCFLAGS': ['-ansi'], + }, + 'os:solaris': { + # On Solaris, to get isinf, INFINITY, fpclassify and other macros one + # needs to define __C99FEATURES__. + 'CPPDEFINES': ['__C99FEATURES__'], + 'CPPPATH' : [src_dir, '/usr/local/include'], + 'LIBPATH' : ['/usr/local/lib'], + 'CCFLAGS': ['-ansi'], + }, + 'os:netbsd': { + 'CPPPATH' : [src_dir, '/usr/pkg/include'], + 'LIBPATH' : ['/usr/pkg/lib'], + }, + 'os:win32': { + 'CCFLAGS': ['-DWIN32'], + 'CXXFLAGS': ['-DWIN32'], + }, + 'arch:ia32': { + 'CPPDEFINES': ['V8_TARGET_ARCH_IA32'], + 'CCFLAGS': ['-m32'], + 'LINKFLAGS': ['-m32'] + }, + 'arch:arm': { + 'CPPDEFINES': ['V8_TARGET_ARCH_ARM'], + 'unalignedaccesses:on' : { + 'CPPDEFINES' : ['CAN_USE_UNALIGNED_ACCESSES=1'] + }, + 'unalignedaccesses:off' : { + 'CPPDEFINES' : ['CAN_USE_UNALIGNED_ACCESSES=0'] + }, + 'armeabi:soft' : { + 'CPPDEFINES' : ['USE_EABI_HARDFLOAT=0'], + 'simulator:none': { + 'CCFLAGS': ['-mfloat-abi=soft'], + } + }, + 'armeabi:softfp' : { + 'CPPDEFINES' : ['USE_EABI_HARDFLOAT=0'], + 'vfp3:on': { + 'CPPDEFINES' : ['CAN_USE_VFP_INSTRUCTIONS'] + }, + 'simulator:none': { + 'CCFLAGS': ['-mfloat-abi=softfp'], + } + }, + 'armeabi:hard' : { + 'CPPDEFINES' : ['USE_EABI_HARDFLOAT=1'], + 'vfp3:on': { + 'CPPDEFINES' : ['CAN_USE_VFP_INSTRUCTIONS'] + }, + 'simulator:none': { + 'CCFLAGS': ['-mfloat-abi=hard'], + } + } + }, + 'simulator:arm': { + 'CCFLAGS': ['-m32'], + 'LINKFLAGS': ['-m32'], + }, + 'arch:mips': { + 'CPPDEFINES': ['V8_TARGET_ARCH_MIPS'], + 'mips_arch_variant:mips32r2': { + 'CPPDEFINES': ['_MIPS_ARCH_MIPS32R2'] + }, + 'mips_arch_variant:loongson': { + 'CPPDEFINES': ['_MIPS_ARCH_LOONGSON'] + }, + 'simulator:none': { + 'CCFLAGS': ['-EL'], + 'LINKFLAGS': ['-EL'], + 'mips_arch_variant:mips32r2': { + 'CCFLAGS': ['-mips32r2', '-Wa,-mips32r2'] + }, + 'mips_arch_variant:mips32r1': { + 'CCFLAGS': ['-mips32', '-Wa,-mips32'] + }, + 'mips_arch_variant:loongson': { + 'CCFLAGS': ['-march=mips3', '-Wa,-march=mips3'] + }, + 'library:static': { + 'LINKFLAGS': ['-static', '-static-libgcc'] + }, + 'mipsabi:softfloat': { + 'CCFLAGS': ['-msoft-float'], + 'LINKFLAGS': ['-msoft-float'] + }, + 'mipsabi:hardfloat': { + 'CCFLAGS': ['-mhard-float'], + 'LINKFLAGS': ['-mhard-float'] + } + } + }, + 'simulator:mips': { + 'CCFLAGS': ['-m32'], + 'LINKFLAGS': ['-m32'], + 'mipsabi:softfloat': { + 'CPPDEFINES': ['__mips_soft_float=1'], + 'fpu:on': { + 'CPPDEFINES' : ['CAN_USE_FPU_INSTRUCTIONS'] + } + }, + 'mipsabi:hardfloat': { + 'CPPDEFINES': ['__mips_hard_float=1', 'CAN_USE_FPU_INSTRUCTIONS'], + } + }, + 'arch:x64': { + 'CPPDEFINES': ['V8_TARGET_ARCH_X64'], + 'CCFLAGS': ['-m64'], + 'LINKFLAGS': ['-m64'], + }, + 'gdbjit:on': { + 'CPPDEFINES': ['ENABLE_GDB_JIT_INTERFACE'] + }, + 'compress_startup_data:bz2': { + 'CPPDEFINES': ['COMPRESS_STARTUP_DATA_BZ2'] + } + }, + 'msvc': { + 'all': { + 'CCFLAGS': ['$DIALECTFLAGS', '$WARNINGFLAGS'], + 'CXXFLAGS': ['/GR-', '/Gy'], + 'CPPDEFINES': ['WIN32'], + 'LINKFLAGS': ['/INCREMENTAL:NO', '/NXCOMPAT', '/IGNORE:4221'], + 'CCPDBFLAGS': ['/Zi'] + }, + 'verbose:off': { + 'DIALECTFLAGS': ['/nologo'], + 'ARFLAGS': ['/NOLOGO'] + }, + 'arch:ia32': { + 'CPPDEFINES': ['V8_TARGET_ARCH_IA32', '_USE_32BIT_TIME_T'], + 'LINKFLAGS': ['/MACHINE:X86'], + 'ARFLAGS': ['/MACHINE:X86'] + }, + 'arch:x64': { + 'CPPDEFINES': ['V8_TARGET_ARCH_X64'], + 'LINKFLAGS': ['/MACHINE:X64'], + 'ARFLAGS': ['/MACHINE:X64'] + }, + 'mode:debug': { + 'CCFLAGS': ['/Od', '/Gm'], + 'CPPDEFINES': ['_DEBUG', 'ENABLE_DISASSEMBLER', 'DEBUG'], + 'LINKFLAGS': ['/DEBUG'], + 'msvcrt:static': { + 'CCFLAGS': ['/MTd'] + }, + 'msvcrt:shared': { + 'CCFLAGS': ['/MDd'] + } + }, + 'mode:release': { + 'CCFLAGS': ['/O2'], + 'LINKFLAGS': ['/OPT:REF', '/OPT:ICF'], + 'msvcrt:static': { + 'CCFLAGS': ['/MT'] + }, + 'msvcrt:shared': { + 'CCFLAGS': ['/MD'] + }, + 'msvcltcg:on': { + 'CCFLAGS': ['/GL'], + 'ARFLAGS': ['/LTCG'], + 'pgo:off': { + 'LINKFLAGS': ['/LTCG'], + }, + 'pgo:instrument': { + 'LINKFLAGS': ['/LTCG:PGI'] + }, + 'pgo:optimize': { + 'LINKFLAGS': ['/LTCG:PGO'] + } + } + } + } +} + + +V8_EXTRA_FLAGS = { + 'gcc': { + 'all': { + 'WARNINGFLAGS': ['-Wall', + '-Werror', + '-W', + '-Wno-unused-parameter', + '-Woverloaded-virtual', + '-Wnon-virtual-dtor'] + }, + 'os:win32': { + 'WARNINGFLAGS': ['-pedantic', + '-Wno-long-long', + '-Wno-pedantic-ms-format'], + 'library:shared': { + 'LIBS': ['winmm', 'ws2_32'] + } + }, + 'os:linux': { + 'WARNINGFLAGS': ['-pedantic'], + 'library:shared': { + 'soname:on': { + 'LINKFLAGS': ['-Wl,-soname,${SONAME}'] + } + } + }, + 'os:macos': { + 'WARNINGFLAGS': ['-pedantic'] + }, + 'arch:arm': { + # This is to silence warnings about ABI changes that some versions of the + # CodeSourcery G++ tool chain produce for each occurrence of varargs. + 'WARNINGFLAGS': ['-Wno-abi'] + }, + 'disassembler:on': { + 'CPPDEFINES': ['ENABLE_DISASSEMBLER'] + } + }, + 'msvc': { + 'all': { + 'WARNINGFLAGS': ['/W3', '/WX', '/wd4351', '/wd4355', '/wd4800'] + }, + 'library:shared': { + 'CPPDEFINES': ['BUILDING_V8_SHARED'], + 'LIBS': ['winmm', 'ws2_32'] + }, + 'arch:arm': { + 'CPPDEFINES': ['V8_TARGET_ARCH_ARM'], + # /wd4996 is to silence the warning about sscanf + # used by the arm simulator. + 'WARNINGFLAGS': ['/wd4996'] + }, + 'arch:mips': { + 'CPPDEFINES': ['V8_TARGET_ARCH_MIPS'], + 'mips_arch_variant:mips32r2': { + 'CPPDEFINES': ['_MIPS_ARCH_MIPS32R2'] + }, + }, + 'disassembler:on': { + 'CPPDEFINES': ['ENABLE_DISASSEMBLER'] + } + } +} + + +MKSNAPSHOT_EXTRA_FLAGS = { + 'gcc': { + 'os:linux': { + 'LIBS': ['pthread'], + }, + 'os:macos': { + 'LIBS': ['pthread'], + }, + 'os:freebsd': { + 'LIBS': ['execinfo', 'pthread'] + }, + 'os:solaris': { + 'LIBS': ['m', 'pthread', 'socket', 'nsl', 'rt'], + 'LINKFLAGS': ['-mt'] + }, + 'os:openbsd': { + 'LIBS': ['execinfo', 'pthread'] + }, + 'os:win32': { + 'LIBS': ['winmm', 'ws2_32'], + }, + 'os:netbsd': { + 'LIBS': ['execinfo', 'pthread'] + }, + 'compress_startup_data:bz2': { + 'os:linux': { + 'LIBS': ['bz2'] + } + }, + }, + 'msvc': { + 'all': { + 'CPPDEFINES': ['_HAS_EXCEPTIONS=0'], + 'LIBS': ['winmm', 'ws2_32'] + } + } +} + + +DTOA_EXTRA_FLAGS = { + 'gcc': { + 'all': { + 'WARNINGFLAGS': ['-Werror', '-Wno-uninitialized'], + 'CCFLAGS': GCC_DTOA_EXTRA_CCFLAGS + } + }, + 'msvc': { + 'all': { + 'WARNINGFLAGS': ['/WX', '/wd4018', '/wd4244'] + } + } +} + + +CCTEST_EXTRA_FLAGS = { + 'all': { + 'CPPPATH': [src_dir], + 'library:shared': { + 'CPPDEFINES': ['USING_V8_SHARED'] + }, + }, + 'gcc': { + 'all': { + 'LIBPATH': [abspath('.')], + 'CCFLAGS': ['$DIALECTFLAGS', '$WARNINGFLAGS'], + 'CXXFLAGS': ['-fno-rtti', '-fno-exceptions'], + 'LINKFLAGS': ['$CCFLAGS'], + }, + 'os:linux': { + 'LIBS': ['pthread'], + 'CCFLAGS': ['-Wno-unused-but-set-variable'], + }, + 'os:macos': { + 'LIBS': ['pthread'], + }, + 'os:freebsd': { + 'LIBS': ['execinfo', 'pthread'] + }, + 'os:solaris': { + 'LIBS': ['m', 'pthread', 'socket', 'nsl', 'rt'], + 'LINKFLAGS': ['-mt'] + }, + 'os:openbsd': { + 'LIBS': ['execinfo', 'pthread'] + }, + 'os:win32': { + 'LIBS': ['winmm', 'ws2_32'] + }, + 'os:netbsd': { + 'LIBS': ['execinfo', 'pthread'] + }, + 'arch:arm': { + 'LINKFLAGS': ARM_LINK_FLAGS + }, + }, + 'msvc': { + 'all': { + 'CPPDEFINES': ['_HAS_EXCEPTIONS=0'], + 'LIBS': ['winmm', 'ws2_32'] + }, + 'arch:ia32': { + 'CPPDEFINES': ['V8_TARGET_ARCH_IA32'] + }, + 'arch:x64': { + 'CPPDEFINES': ['V8_TARGET_ARCH_X64'], + 'LINKFLAGS': ['/STACK:2097152'] + }, + } +} + + +SAMPLE_FLAGS = { + 'all': { + 'CPPPATH': [join(root_dir, 'include')], + 'library:shared': { + 'CPPDEFINES': ['USING_V8_SHARED'] + }, + }, + 'gcc': { + 'all': { + 'LIBPATH': ['.'], + 'CCFLAGS': ['$DIALECTFLAGS', '$WARNINGFLAGS'], + 'CXXFLAGS': ['-fno-rtti', '-fno-exceptions'], + 'LINKFLAGS': ['$CCFLAGS'], + }, + 'os:linux': { + 'LIBS': ['pthread'], + }, + 'os:macos': { + 'LIBS': ['pthread'], + }, + 'os:freebsd': { + 'LIBPATH' : ['/usr/local/lib'], + 'LIBS': ['execinfo', 'pthread'] + }, + 'os:solaris': { + # On Solaris, to get isinf, INFINITY, fpclassify and other macros one + # needs to define __C99FEATURES__. + 'CPPDEFINES': ['__C99FEATURES__'], + 'LIBPATH' : ['/usr/local/lib'], + 'LIBS': ['m', 'pthread', 'socket', 'nsl', 'rt'], + 'LINKFLAGS': ['-mt'] + }, + 'os:openbsd': { + 'LIBPATH' : ['/usr/local/lib'], + 'LIBS': ['execinfo', 'pthread'] + }, + 'os:win32': { + 'LIBS': ['winmm', 'ws2_32'] + }, + 'os:netbsd': { + 'LIBPATH' : ['/usr/pkg/lib'], + 'LIBS': ['execinfo', 'pthread'] + }, + 'arch:arm': { + 'LINKFLAGS': ARM_LINK_FLAGS, + 'armeabi:soft' : { + 'CPPDEFINES' : ['USE_EABI_HARDFLOAT=0'], + 'simulator:none': { + 'CCFLAGS': ['-mfloat-abi=soft'], + } + }, + 'armeabi:softfp' : { + 'CPPDEFINES' : ['USE_EABI_HARDFLOAT=0'], + 'simulator:none': { + 'CCFLAGS': ['-mfloat-abi=softfp'], + } + }, + 'armeabi:hard' : { + 'CPPDEFINES' : ['USE_EABI_HARDFLOAT=1'], + 'vfp3:on': { + 'CPPDEFINES' : ['CAN_USE_VFP_INSTRUCTIONS'] + }, + 'simulator:none': { + 'CCFLAGS': ['-mfloat-abi=hard'], + } + } + }, + 'arch:ia32': { + 'CCFLAGS': ['-m32'], + 'LINKFLAGS': ['-m32'] + }, + 'arch:x64': { + 'CCFLAGS': ['-m64'], + 'LINKFLAGS': ['-m64'] + }, + 'arch:mips': { + 'CPPDEFINES': ['V8_TARGET_ARCH_MIPS'], + 'mips_arch_variant:mips32r2': { + 'CPPDEFINES': ['_MIPS_ARCH_MIPS32R2'] + }, + 'mips_arch_variant:loongson': { + 'CPPDEFINES': ['_MIPS_ARCH_LOONGSON'] + }, + 'simulator:none': { + 'CCFLAGS': ['-EL'], + 'LINKFLAGS': ['-EL'], + 'mips_arch_variant:mips32r2': { + 'CCFLAGS': ['-mips32r2', '-Wa,-mips32r2'] + }, + 'mips_arch_variant:mips32r1': { + 'CCFLAGS': ['-mips32', '-Wa,-mips32'] + }, + 'mips_arch_variant:loongson': { + 'CCFLAGS': ['-march=mips3', '-Wa,-march=mips3'] + }, + 'library:static': { + 'LINKFLAGS': ['-static', '-static-libgcc'] + }, + 'mipsabi:softfloat': { + 'CCFLAGS': ['-msoft-float'], + 'LINKFLAGS': ['-msoft-float'] + }, + 'mipsabi:hardfloat': { + 'CCFLAGS': ['-mhard-float'], + 'LINKFLAGS': ['-mhard-float'], + 'fpu:on': { + 'CPPDEFINES' : ['CAN_USE_FPU_INSTRUCTIONS'] + } + } + } + }, + 'simulator:arm': { + 'CCFLAGS': ['-m32'], + 'LINKFLAGS': ['-m32'] + }, + 'simulator:mips': { + 'CCFLAGS': ['-m32'], + 'LINKFLAGS': ['-m32'] + }, + 'mode:release': { + 'CCFLAGS': ['-O2'] + }, + 'mode:debug': { + 'CCFLAGS': ['-g', '-O0'], + 'CPPDEFINES': ['DEBUG'] + }, + 'compress_startup_data:bz2': { + 'CPPDEFINES': ['COMPRESS_STARTUP_DATA_BZ2'], + 'os:linux': { + 'LIBS': ['bz2'] + } + }, + }, + 'msvc': { + 'all': { + 'LIBS': ['winmm', 'ws2_32'] + }, + 'verbose:off': { + 'CCFLAGS': ['/nologo'], + 'LINKFLAGS': ['/NOLOGO'] + }, + 'verbose:on': { + 'LINKFLAGS': ['/VERBOSE'] + }, + 'prof:on': { + 'LINKFLAGS': ['/MAP'] + }, + 'mode:release': { + 'CCFLAGS': ['/O2'], + 'LINKFLAGS': ['/OPT:REF', '/OPT:ICF'], + 'msvcrt:static': { + 'CCFLAGS': ['/MT'] + }, + 'msvcrt:shared': { + 'CCFLAGS': ['/MD'] + }, + 'msvcltcg:on': { + 'CCFLAGS': ['/GL'], + 'pgo:off': { + 'LINKFLAGS': ['/LTCG'], + }, + }, + 'pgo:instrument': { + 'LINKFLAGS': ['/LTCG:PGI'] + }, + 'pgo:optimize': { + 'LINKFLAGS': ['/LTCG:PGO'] + } + }, + 'arch:ia32': { + 'CPPDEFINES': ['V8_TARGET_ARCH_IA32', 'WIN32'], + 'LINKFLAGS': ['/MACHINE:X86'] + }, + 'arch:x64': { + 'CPPDEFINES': ['V8_TARGET_ARCH_X64', 'WIN32'], + 'LINKFLAGS': ['/MACHINE:X64', '/STACK:2097152'] + }, + 'mode:debug': { + 'CCFLAGS': ['/Od'], + 'LINKFLAGS': ['/DEBUG'], + 'CPPDEFINES': ['DEBUG'], + 'msvcrt:static': { + 'CCFLAGS': ['/MTd'] + }, + 'msvcrt:shared': { + 'CCFLAGS': ['/MDd'] + } + } + } +} + + +PREPARSER_FLAGS = { + 'all': { + 'CPPPATH': [join(root_dir, 'include'), src_dir], + 'library:shared': { + 'CPPDEFINES': ['USING_V8_SHARED'] + }, + }, + 'gcc': { + 'all': { + 'LIBPATH': ['.'], + 'CCFLAGS': ['$DIALECTFLAGS', '$WARNINGFLAGS'], + 'CXXFLAGS': ['-fno-rtti', '-fno-exceptions'], + 'LINKFLAGS': ['$CCFLAGS'], + }, + 'os:win32': { + 'LIBS': ['winmm', 'ws2_32'] + }, + 'arch:arm': { + 'LINKFLAGS': ARM_LINK_FLAGS, + 'armeabi:soft' : { + 'CPPDEFINES' : ['USE_EABI_HARDFLOAT=0'], + 'simulator:none': { + 'CCFLAGS': ['-mfloat-abi=soft'], + } + }, + 'armeabi:softfp' : { + 'simulator:none': { + 'CCFLAGS': ['-mfloat-abi=softfp'], + } + }, + 'armeabi:hard' : { + 'simulator:none': { + 'CCFLAGS': ['-mfloat-abi=hard'], + } + } + }, + 'arch:ia32': { + 'CCFLAGS': ['-m32'], + 'LINKFLAGS': ['-m32'] + }, + 'arch:x64': { + 'CCFLAGS': ['-m64'], + 'LINKFLAGS': ['-m64'] + }, + 'arch:mips': { + 'CPPDEFINES': ['V8_TARGET_ARCH_MIPS'], + 'mips_arch_variant:mips32r2': { + 'CPPDEFINES': ['_MIPS_ARCH_MIPS32R2'] + }, + 'mips_arch_variant:loongson': { + 'CPPDEFINES': ['_MIPS_ARCH_LOONGSON'] + }, + 'simulator:none': { + 'CCFLAGS': ['-EL'], + 'LINKFLAGS': ['-EL'], + 'mips_arch_variant:mips32r2': { + 'CCFLAGS': ['-mips32r2', '-Wa,-mips32r2'] + }, + 'mips_arch_variant:mips32r1': { + 'CCFLAGS': ['-mips32', '-Wa,-mips32'] + }, + 'mips_arch_variant:loongson': { + 'CCFLAGS': ['-march=mips3', '-Wa,-march=mips3'] + }, + 'library:static': { + 'LINKFLAGS': ['-static', '-static-libgcc'] + }, + 'mipsabi:softfloat': { + 'CCFLAGS': ['-msoft-float'], + 'LINKFLAGS': ['-msoft-float'] + }, + 'mipsabi:hardfloat': { + 'CCFLAGS': ['-mhard-float'], + 'LINKFLAGS': ['-mhard-float'] + } + } + }, + 'simulator:arm': { + 'CCFLAGS': ['-m32'], + 'LINKFLAGS': ['-m32'] + }, + 'simulator:mips': { + 'CCFLAGS': ['-m32'], + 'LINKFLAGS': ['-m32'], + 'mipsabi:softfloat': { + 'CPPDEFINES': ['__mips_soft_float=1'], + }, + 'mipsabi:hardfloat': { + 'CPPDEFINES': ['__mips_hard_float=1'], + } + }, + 'mode:release': { + 'CCFLAGS': ['-O2'] + }, + 'mode:debug': { + 'CCFLAGS': ['-g', '-O0'], + 'CPPDEFINES': ['DEBUG'] + }, + 'os:freebsd': { + 'LIBPATH' : ['/usr/local/lib'], + }, + }, + 'msvc': { + 'all': { + 'LIBS': ['winmm', 'ws2_32'] + }, + 'verbose:off': { + 'CCFLAGS': ['/nologo'], + 'LINKFLAGS': ['/NOLOGO'] + }, + 'verbose:on': { + 'LINKFLAGS': ['/VERBOSE'] + }, + 'prof:on': { + 'LINKFLAGS': ['/MAP'] + }, + 'mode:release': { + 'CCFLAGS': ['/O2'], + 'LINKFLAGS': ['/OPT:REF', '/OPT:ICF'], + 'msvcrt:static': { + 'CCFLAGS': ['/MT'] + }, + 'msvcrt:shared': { + 'CCFLAGS': ['/MD'] + }, + 'msvcltcg:on': { + 'CCFLAGS': ['/GL'], + 'pgo:off': { + 'LINKFLAGS': ['/LTCG'], + }, + }, + 'pgo:instrument': { + 'LINKFLAGS': ['/LTCG:PGI'] + }, + 'pgo:optimize': { + 'LINKFLAGS': ['/LTCG:PGO'] + } + }, + 'arch:ia32': { + 'CPPDEFINES': ['V8_TARGET_ARCH_IA32', 'WIN32'], + 'LINKFLAGS': ['/MACHINE:X86'] + }, + 'arch:x64': { + 'CPPDEFINES': ['V8_TARGET_ARCH_X64', 'WIN32'], + 'LINKFLAGS': ['/MACHINE:X64', '/STACK:2097152'] + }, + 'mode:debug': { + 'CCFLAGS': ['/Od'], + 'LINKFLAGS': ['/DEBUG'], + 'CPPDEFINES': ['DEBUG'], + 'msvcrt:static': { + 'CCFLAGS': ['/MTd'] + }, + 'msvcrt:shared': { + 'CCFLAGS': ['/MDd'] + } + } + } +} + + +D8_FLAGS = { + 'all': { + 'library:shared': { + 'CPPDEFINES': ['V8_SHARED'], + 'LIBS': ['v8'], + 'LIBPATH': ['.'] + }, + }, + 'gcc': { + 'all': { + 'CCFLAGS': ['$DIALECTFLAGS', '$WARNINGFLAGS'], + 'CXXFLAGS': ['-fno-rtti', '-fno-exceptions'], + 'LINKFLAGS': ['$CCFLAGS'], + }, + 'console:readline': { + 'LIBS': ['readline'] + }, + 'os:linux': { + 'LIBS': ['pthread'], + }, + 'os:macos': { + 'LIBS': ['pthread'], + }, + 'os:freebsd': { + 'LIBS': ['pthread'], + }, + 'os:solaris': { + 'LIBS': ['m', 'pthread', 'socket', 'nsl', 'rt'], + 'LINKFLAGS': ['-mt'] + }, + 'os:openbsd': { + 'LIBS': ['pthread'], + }, + 'os:win32': { + 'LIBS': ['winmm', 'ws2_32'], + }, + 'os:netbsd': { + 'LIBS': ['pthread'], + }, + 'arch:arm': { + 'LINKFLAGS': ARM_LINK_FLAGS + }, + 'compress_startup_data:bz2': { + 'CPPDEFINES': ['COMPRESS_STARTUP_DATA_BZ2'], + 'os:linux': { + 'LIBS': ['bz2'] + } + } + }, + 'msvc': { + 'all': { + 'LIBS': ['winmm', 'ws2_32'] + }, + 'verbose:off': { + 'CCFLAGS': ['/nologo'], + 'LINKFLAGS': ['/NOLOGO'] + }, + 'verbose:on': { + 'LINKFLAGS': ['/VERBOSE'] + }, + 'prof:on': { + 'LINKFLAGS': ['/MAP'] + }, + 'mode:release': { + 'CCFLAGS': ['/O2'], + 'LINKFLAGS': ['/OPT:REF', '/OPT:ICF'], + 'msvcrt:static': { + 'CCFLAGS': ['/MT'] + }, + 'msvcrt:shared': { + 'CCFLAGS': ['/MD'] + }, + 'msvcltcg:on': { + 'CCFLAGS': ['/GL'], + 'pgo:off': { + 'LINKFLAGS': ['/LTCG'], + }, + }, + 'pgo:instrument': { + 'LINKFLAGS': ['/LTCG:PGI'] + }, + 'pgo:optimize': { + 'LINKFLAGS': ['/LTCG:PGO'] + } + }, + 'arch:ia32': { + 'CPPDEFINES': ['V8_TARGET_ARCH_IA32', 'WIN32'], + 'LINKFLAGS': ['/MACHINE:X86'] + }, + 'arch:x64': { + 'CPPDEFINES': ['V8_TARGET_ARCH_X64', 'WIN32'], + 'LINKFLAGS': ['/MACHINE:X64', '/STACK:2097152'] + }, + 'mode:debug': { + 'CCFLAGS': ['/Od'], + 'LINKFLAGS': ['/DEBUG'], + 'CPPDEFINES': ['DEBUG'], + 'msvcrt:static': { + 'CCFLAGS': ['/MTd'] + }, + 'msvcrt:shared': { + 'CCFLAGS': ['/MDd'] + } + } + } +} + + +SUFFIXES = { + 'release': '', + 'debug': '_g' +} + + +def Abort(message): + print message + sys.exit(1) + + +def GuessOS(env): + return utils.GuessOS() + + +def GuessArch(env): + return utils.GuessArchitecture() + + +def GuessToolchain(env): + tools = env['TOOLS'] + if 'gcc' in tools: + return 'gcc' + elif 'msvc' in tools: + return 'msvc' + else: + return None + + +def GuessVisibility(env): + os = env['os'] + toolchain = env['toolchain']; + if (os == 'win32' or os == 'cygwin') and toolchain == 'gcc': + # MinGW / Cygwin can't do it. + return 'default' + elif os == 'solaris': + return 'default' + else: + return 'hidden' + + +def GuessStrictAliasing(env): + # There seems to be a problem with gcc 4.5.x. + # See http://code.google.com/p/v8/issues/detail?id=884 + # It can be worked around by disabling strict aliasing. + toolchain = env['toolchain']; + if toolchain == 'gcc': + env = Environment(tools=['gcc']) + # The gcc version should be available in env['CCVERSION'], + # but when scons detects msvc this value is not set. + version = subprocess.Popen([env['CC'], '-dumpversion'], + stdout=subprocess.PIPE).communicate()[0] + if version.find('4.5') == 0: + return 'off' + return 'default' + + +PLATFORM_OPTIONS = { + 'arch': { + 'values': ['arm', 'ia32', 'x64', 'mips'], + 'guess': GuessArch, + 'help': 'the architecture to build for' + }, + 'os': { + 'values': ['freebsd', 'linux', 'macos', 'win32', 'openbsd', 'solaris', 'cygwin', 'netbsd'], + 'guess': GuessOS, + 'help': 'the os to build for' + }, + 'toolchain': { + 'values': ['gcc', 'msvc'], + 'guess': GuessToolchain, + 'help': 'the toolchain to use' + } +} + +SIMPLE_OPTIONS = { + 'regexp': { + 'values': ['native', 'interpreted'], + 'default': 'native', + 'help': 'Whether to use native or interpreted regexp implementation' + }, + 'snapshot': { + 'values': ['on', 'off', 'nobuild'], + 'default': 'off', + 'help': 'build using snapshots for faster start-up' + }, + 'prof': { + 'values': ['on', 'off'], + 'default': 'off', + 'help': 'enable profiling of build target' + }, + 'gdbjit': { + 'values': ['on', 'off'], + 'default': 'off', + 'help': 'enable GDB JIT interface' + }, + 'library': { + 'values': ['static', 'shared'], + 'default': 'static', + 'help': 'the type of library to produce' + }, + 'objectprint': { + 'values': ['on', 'off'], + 'default': 'off', + 'help': 'enable object printing' + }, + 'profilingsupport': { + 'values': ['on', 'off'], + 'default': 'on', + 'help': 'enable profiling of JavaScript code' + }, + 'debuggersupport': { + 'values': ['on', 'off'], + 'default': 'on', + 'help': 'enable debugging of JavaScript code' + }, + 'inspector': { + 'values': ['on', 'off'], + 'default': 'off', + 'help': 'enable inspector features' + }, + 'liveobjectlist': { + 'values': ['on', 'off'], + 'default': 'off', + 'help': 'enable live object list features in the debugger' + }, + 'soname': { + 'values': ['on', 'off'], + 'default': 'off', + 'help': 'turn on setting soname for Linux shared library' + }, + 'msvcrt': { + 'values': ['static', 'shared'], + 'default': 'static', + 'help': 'the type of Microsoft Visual C++ runtime library to use' + }, + 'msvcltcg': { + 'values': ['on', 'off'], + 'default': 'on', + 'help': 'use Microsoft Visual C++ link-time code generation' + }, + 'simulator': { + 'values': ['arm', 'mips', 'none'], + 'default': 'none', + 'help': 'build with simulator' + }, + 'unalignedaccesses': { + 'values': ['default', 'on', 'off'], + 'default': 'default', + 'help': 'set whether the ARM target supports unaligned accesses' + }, + 'disassembler': { + 'values': ['on', 'off'], + 'default': 'off', + 'help': 'enable the disassembler to inspect generated code' + }, + 'fasttls': { + 'values': ['on', 'off'], + 'default': 'on', + 'help': 'enable fast thread local storage support ' + '(if available on the current architecture/platform)' + }, + 'sourcesignatures': { + 'values': ['MD5', 'timestamp'], + 'default': 'MD5', + 'help': 'set how the build system detects file changes' + }, + 'console': { + 'values': ['dumb', 'readline'], + 'default': 'dumb', + 'help': 'the console to use for the d8 shell' + }, + 'verbose': { + 'values': ['on', 'off'], + 'default': 'off', + 'help': 'more output from compiler and linker' + }, + 'visibility': { + 'values': ['default', 'hidden'], + 'guess': GuessVisibility, + 'help': 'shared library symbol visibility' + }, + 'strictaliasing': { + 'values': ['default', 'off'], + 'guess': GuessStrictAliasing, + 'help': 'assume strict aliasing while optimizing' + }, + 'pgo': { + 'values': ['off', 'instrument', 'optimize'], + 'default': 'off', + 'help': 'select profile guided optimization variant', + }, + 'armeabi': { + 'values': ['hard', 'softfp', 'soft'], + 'default': 'softfp', + 'help': 'generate calling conventiont according to selected ARM EABI variant' + }, + 'mipsabi': { + 'values': ['hardfloat', 'softfloat', 'none'], + 'default': 'hardfloat', + 'help': 'generate calling conventiont according to selected mips ABI' + }, + 'mips_arch_variant': { + 'values': ['mips32r2', 'mips32r1', 'loongson'], + 'default': 'mips32r2', + 'help': 'mips variant' + }, + 'compress_startup_data': { + 'values': ['off', 'bz2'], + 'default': 'off', + 'help': 'compress startup data (snapshot) [Linux only]' + }, + 'vfp3': { + 'values': ['on', 'off'], + 'default': 'on', + 'help': 'use vfp3 instructions when building the snapshot [Arm only]' + }, + 'fpu': { + 'values': ['on', 'off'], + 'default': 'on', + 'help': 'use fpu instructions when building the snapshot [MIPS only]' + }, + 'I_know_I_should_build_with_GYP': { + 'values': ['yes', 'no'], + 'default': 'no', + 'help': 'grace period: temporarily override SCons deprecation' + } + +} + +ALL_OPTIONS = dict(PLATFORM_OPTIONS, **SIMPLE_OPTIONS) + + +def AddOptions(options, result): + guess_env = Environment(options=result) + for (name, option) in options.iteritems(): + if 'guess' in option: + # Option has a guess function + guess = option.get('guess') + default = guess(guess_env) + else: + # Option has a fixed default + default = option.get('default') + help = '%s (%s)' % (option.get('help'), ", ".join(option['values'])) + result.Add(name, help, default) + + +def GetOptions(): + result = Options() + result.Add('mode', 'compilation mode (debug, release)', 'release') + result.Add('sample', 'build sample (shell, process, lineprocessor)', '') + result.Add('cache', 'directory to use for scons build cache', '') + result.Add('env', 'override environment settings (NAME0:value0,NAME1:value1,...)', '') + result.Add('importenv', 'import environment settings (NAME0,NAME1,...)', '') + AddOptions(PLATFORM_OPTIONS, result) + AddOptions(SIMPLE_OPTIONS, result) + return result + + +def GetTools(opts): + env = Environment(options=opts) + os = env['os'] + toolchain = env['toolchain'] + if os == 'win32' and toolchain == 'gcc': + return ['mingw'] + elif os == 'win32' and toolchain == 'msvc': + return ['msvc', 'mslink', 'mslib', 'msvs'] + else: + return ['default'] + + +def GetVersionComponents(): + MAJOR_VERSION_PATTERN = re.compile(r"#define\s+MAJOR_VERSION\s+(.*)") + MINOR_VERSION_PATTERN = re.compile(r"#define\s+MINOR_VERSION\s+(.*)") + BUILD_NUMBER_PATTERN = re.compile(r"#define\s+BUILD_NUMBER\s+(.*)") + PATCH_LEVEL_PATTERN = re.compile(r"#define\s+PATCH_LEVEL\s+(.*)") + + patterns = [MAJOR_VERSION_PATTERN, + MINOR_VERSION_PATTERN, + BUILD_NUMBER_PATTERN, + PATCH_LEVEL_PATTERN] + + source = open(join(root_dir, 'src', 'version.cc')).read() + version_components = [] + for pattern in patterns: + match = pattern.search(source) + if match: + version_components.append(match.group(1).strip()) + else: + version_components.append('0') + + return version_components + + +def GetVersion(): + version_components = GetVersionComponents() + + if version_components[len(version_components) - 1] == '0': + version_components.pop() + return '.'.join(version_components) + + +def GetSpecificSONAME(): + SONAME_PATTERN = re.compile(r"#define\s+SONAME\s+\"(.*)\"") + + source = open(join(root_dir, 'src', 'version.cc')).read() + match = SONAME_PATTERN.search(source) + + if match: + return match.group(1).strip() + else: + return '' + + +def SplitList(str): + return [ s for s in str.split(",") if len(s) > 0 ] + + +def IsLegal(env, option, values): + str = env[option] + for s in SplitList(str): + if not s in values: + Abort("Illegal value for option %s '%s'." % (option, s)) + return False + return True + + +def WarnAboutDeprecation(): + print """ + ##################################################################### + # # + # LAST WARNING: Building V8 with SCons is deprecated. # + # # + # This only works because you have overridden the kill switch. # + # # + # MIGRATE TO THE GYP-BASED BUILD NOW! # + # # + # Instructions: http://code.google.com/p/v8/wiki/BuildingWithGYP. # + # # + ##################################################################### + """ + + +def VerifyOptions(env): + if env['I_know_I_should_build_with_GYP'] != 'yes': + Abort("Building V8 with SCons is no longer supported. Please use GYP " + "instead; you can find instructions are at " + "http://code.google.com/p/v8/wiki/BuildingWithGYP.\n\n" + "Quitting.\n\n" + "For a limited grace period, you can specify " + "\"I_know_I_should_build_with_GYP=yes\" to override.") + else: + WarnAboutDeprecation() + import atexit + atexit.register(WarnAboutDeprecation) + + if not IsLegal(env, 'mode', ['debug', 'release']): + return False + if not IsLegal(env, 'sample', ["shell", "process", "lineprocessor"]): + return False + if not IsLegal(env, 'regexp', ["native", "interpreted"]): + return False + if env['os'] == 'win32' and env['library'] == 'shared' and env['prof'] == 'on': + Abort("Profiling on windows only supported for static library.") + if env['gdbjit'] == 'on' and ((env['os'] != 'linux' and env['os'] != 'macos') or (env['arch'] != 'ia32' and env['arch'] != 'x64' and env['arch'] != 'arm')): + Abort("GDBJIT interface is supported only for Intel-compatible (ia32 or x64) Linux/OSX target.") + if env['os'] == 'win32' and env['soname'] == 'on': + Abort("Shared Object soname not applicable for Windows.") + if env['soname'] == 'on' and env['library'] == 'static': + Abort("Shared Object soname not applicable for static library.") + if env['os'] != 'win32' and env['pgo'] != 'off': + Abort("Profile guided optimization only supported on Windows.") + if env['cache'] and not os.path.isdir(env['cache']): + Abort("The specified cache directory does not exist.") + if not (env['arch'] == 'arm' or env['simulator'] == 'arm') and ('unalignedaccesses' in ARGUMENTS): + print env['arch'] + print env['simulator'] + Abort("Option unalignedaccesses only supported for the ARM architecture.") + if env['os'] != 'linux' and env['compress_startup_data'] != 'off': + Abort("Startup data compression is only available on Linux") + for (name, option) in ALL_OPTIONS.iteritems(): + if (not name in env): + message = ("A value for option %s must be specified (%s)." % + (name, ", ".join(option['values']))) + Abort(message) + if not env[name] in option['values']: + message = ("Unknown %s value '%s'. Possible values are (%s)." % + (name, env[name], ", ".join(option['values']))) + Abort(message) + + +class BuildContext(object): + + def __init__(self, options, env_overrides, samples): + self.library_targets = [] + self.mksnapshot_targets = [] + self.cctest_targets = [] + self.sample_targets = [] + self.d8_targets = [] + self.options = options + self.env_overrides = env_overrides + self.samples = samples + self.preparser_targets = [] + self.use_snapshot = (options['snapshot'] != 'off') + self.build_snapshot = (options['snapshot'] == 'on') + self.flags = None + + def AddRelevantFlags(self, initial, flags): + result = initial.copy() + toolchain = self.options['toolchain'] + if toolchain in flags: + self.AppendFlags(result, flags[toolchain].get('all')) + for option in sorted(self.options.keys()): + value = self.options[option] + self.AppendFlags(result, flags[toolchain].get(option + ':' + value)) + self.AppendFlags(result, flags.get('all')) + return result + + def AddRelevantSubFlags(self, options, flags): + self.AppendFlags(options, flags.get('all')) + for option in sorted(self.options.keys()): + value = self.options[option] + self.AppendFlags(options, flags.get(option + ':' + value)) + + def GetRelevantSources(self, source): + result = [] + result += source.get('all', []) + for (name, value) in self.options.iteritems(): + source_value = source.get(name + ':' + value, []) + if type(source_value) == dict: + result += self.GetRelevantSources(source_value) + else: + result += source_value + return sorted(result) + + def AppendFlags(self, options, added): + if not added: + return + for (key, value) in added.iteritems(): + if key.find(':') != -1: + self.AddRelevantSubFlags(options, { key: value }) + else: + if not key in options: + options[key] = value + else: + prefix = options[key] + if isinstance(prefix, StringTypes): prefix = prefix.split() + options[key] = prefix + value + + def ConfigureObject(self, env, input, **kw): + if (kw.has_key('CPPPATH') and env.has_key('CPPPATH')): + kw['CPPPATH'] += env['CPPPATH'] + if self.options['library'] == 'static': + return env.StaticObject(input, **kw) + else: + return env.SharedObject(input, **kw) + + def ApplyEnvOverrides(self, env): + if not self.env_overrides: + return + if type(env['ENV']) == DictType: + env['ENV'].update(**self.env_overrides) + else: + env['ENV'] = self.env_overrides + + +def PostprocessOptions(options, os): + # Adjust architecture if the simulator option has been set + if (options['simulator'] != 'none') and (options['arch'] != options['simulator']): + if 'arch' in ARGUMENTS: + # Print a warning if arch has explicitly been set + print "Warning: forcing architecture to match simulator (%s)" % options['simulator'] + options['arch'] = options['simulator'] + if (options['prof'] != 'off') and (options['profilingsupport'] == 'off'): + # Print a warning if profiling is enabled without profiling support + print "Warning: forcing profilingsupport on when prof is on" + options['profilingsupport'] = 'on' + if os == 'win32' and options['pgo'] != 'off' and options['msvcltcg'] == 'off': + if 'msvcltcg' in ARGUMENTS: + print "Warning: forcing msvcltcg on as it is required for pgo (%s)" % options['pgo'] + options['msvcltcg'] = 'on' + if (options['mipsabi'] != 'none') and (options['arch'] != 'mips') and (options['simulator'] != 'mips'): + options['mipsabi'] = 'none' + if options['liveobjectlist'] == 'on': + if (options['debuggersupport'] != 'on') or (options['mode'] == 'release'): + # Print a warning that liveobjectlist will implicitly enable the debugger + print "Warning: forcing debuggersupport on for liveobjectlist" + options['debuggersupport'] = 'on' + options['inspector'] = 'on' + options['objectprint'] = 'on' + + +def ParseEnvOverrides(arg, imports): + # The environment overrides are in the format NAME0:value0,NAME1:value1,... + # The environment imports are in the format NAME0,NAME1,... + overrides = {} + for var in imports.split(','): + if var in os.environ: + overrides[var] = os.environ[var] + for override in arg.split(','): + pos = override.find(':') + if pos == -1: + continue + overrides[override[:pos].strip()] = override[pos+1:].strip() + return overrides + + +def BuildSpecific(env, mode, env_overrides, tools): + options = {'mode': mode} + for option in ALL_OPTIONS: + options[option] = env[option] + PostprocessOptions(options, env['os']) + + context = BuildContext(options, env_overrides, samples=SplitList(env['sample'])) + + # Remove variables which can't be imported from the user's external + # environment into a construction environment. + user_environ = os.environ.copy() + try: + del user_environ['ENV'] + except KeyError: + pass + + library_flags = context.AddRelevantFlags(user_environ, LIBRARY_FLAGS) + v8_flags = context.AddRelevantFlags(library_flags, V8_EXTRA_FLAGS) + mksnapshot_flags = context.AddRelevantFlags(library_flags, MKSNAPSHOT_EXTRA_FLAGS) + dtoa_flags = context.AddRelevantFlags(library_flags, DTOA_EXTRA_FLAGS) + cctest_flags = context.AddRelevantFlags(v8_flags, CCTEST_EXTRA_FLAGS) + sample_flags = context.AddRelevantFlags(user_environ, SAMPLE_FLAGS) + preparser_flags = context.AddRelevantFlags(user_environ, PREPARSER_FLAGS) + d8_flags = context.AddRelevantFlags(library_flags, D8_FLAGS) + + context.flags = { + 'v8': v8_flags, + 'mksnapshot': mksnapshot_flags, + 'dtoa': dtoa_flags, + 'cctest': cctest_flags, + 'sample': sample_flags, + 'd8': d8_flags, + 'preparser': preparser_flags + } + + # Generate library base name. + target_id = mode + suffix = SUFFIXES[target_id] + library_name = 'v8' + suffix + preparser_library_name = 'v8preparser' + suffix + version = GetVersion() + if context.options['soname'] == 'on': + # When building shared object with SONAME version the library name. + library_name += '-' + version + + # Generate library SONAME if required by the build. + if context.options['soname'] == 'on': + soname = GetSpecificSONAME() + if soname == '': + soname = 'lib' + library_name + '.so' + env['SONAME'] = soname + + # Build the object files by invoking SCons recursively. + d8_env = Environment(tools=tools) + d8_env.Replace(**context.flags['d8']) + (object_files, shell_files, mksnapshot, preparser_files) = env.SConscript( + join('src', 'SConscript'), + build_dir=join('obj', target_id), + exports='context tools d8_env', + duplicate=False + ) + + context.mksnapshot_targets.append(mksnapshot) + + # Link the object files into a library. + env.Replace(**context.flags['v8']) + + context.ApplyEnvOverrides(env) + if context.options['library'] == 'static': + library = env.StaticLibrary(library_name, object_files) + preparser_library = env.StaticLibrary(preparser_library_name, + preparser_files) + else: + # There seems to be a glitch in the way scons decides where to put + # PDB files when compiling using MSVC so we specify it manually. + # This should not affect any other platforms. + pdb_name = library_name + '.dll.pdb' + library = env.SharedLibrary(library_name, object_files, PDB=pdb_name) + preparser_pdb_name = preparser_library_name + '.dll.pdb'; + preparser_soname = 'lib' + preparser_library_name + '.so'; + preparser_library = env.SharedLibrary(preparser_library_name, + preparser_files, + PDB=preparser_pdb_name, + SONAME=preparser_soname) + context.library_targets.append(library) + context.library_targets.append(preparser_library) + + context.ApplyEnvOverrides(d8_env) + if context.options['library'] == 'static': + shell = d8_env.Program('d8' + suffix, object_files + shell_files) + else: + shell = d8_env.Program('d8' + suffix, shell_files) + d8_env.Depends(shell, library) + context.d8_targets.append(shell) + + for sample in context.samples: + sample_env = Environment(tools=tools) + sample_env.Replace(**context.flags['sample']) + sample_env.Prepend(LIBS=[library_name]) + context.ApplyEnvOverrides(sample_env) + sample_object = sample_env.SConscript( + join('samples', 'SConscript'), + build_dir=join('obj', 'sample', sample, target_id), + exports='sample context tools', + duplicate=False + ) + sample_name = sample + suffix + sample_program = sample_env.Program(sample_name, sample_object) + sample_env.Depends(sample_program, library) + context.sample_targets.append(sample_program) + + cctest_env = env.Copy() + cctest_env.Prepend(LIBS=[library_name]) + cctest_program = cctest_env.SConscript( + join('test', 'cctest', 'SConscript'), + build_dir=join('obj', 'test', target_id), + exports='context object_files tools', + duplicate=False + ) + context.cctest_targets.append(cctest_program) + + preparser_env = env.Copy() + preparser_env.Replace(**context.flags['preparser']) + preparser_env.Prepend(LIBS=[preparser_library_name]) + context.ApplyEnvOverrides(preparser_env) + preparser_object = preparser_env.SConscript( + join('preparser', 'SConscript'), + build_dir=join('obj', 'preparser', target_id), + exports='context tools', + duplicate=False + ) + preparser_name = join('obj', 'preparser', target_id, 'preparser') + preparser_program = preparser_env.Program(preparser_name, preparser_object); + preparser_env.Depends(preparser_program, preparser_library) + context.preparser_targets.append(preparser_program) + + return context + + +def Build(): + opts = GetOptions() + tools = GetTools(opts) + env = Environment(options=opts, tools=tools) + + Help(opts.GenerateHelpText(env)) + VerifyOptions(env) + env_overrides = ParseEnvOverrides(env['env'], env['importenv']) + + SourceSignatures(env['sourcesignatures']) + + libraries = [] + mksnapshots = [] + cctests = [] + samples = [] + preparsers = [] + d8s = [] + modes = SplitList(env['mode']) + for mode in modes: + context = BuildSpecific(env.Copy(), mode, env_overrides, tools) + libraries += context.library_targets + mksnapshots += context.mksnapshot_targets + cctests += context.cctest_targets + samples += context.sample_targets + preparsers += context.preparser_targets + d8s += context.d8_targets + + env.Alias('library', libraries) + env.Alias('mksnapshot', mksnapshots) + env.Alias('cctests', cctests) + env.Alias('sample', samples) + env.Alias('d8', d8s) + env.Alias('preparser', preparsers) + + if env['sample']: + env.Default('sample') + else: + env.Default('library') + + if env['cache']: + CacheDir(env['cache']) + +# We disable deprecation warnings because we need to be able to use +# env.Copy without getting warnings for compatibility with older +# version of scons. Also, there's a bug in some revisions that +# doesn't allow this flag to be set, so we swallow any exceptions. +# Lovely. +try: + SetOption('warn', 'no-deprecated') +except: + pass + +Build() diff -r 9f3a7907cf0c -r ba780b0b772e node/stuff/SConstruct.patch --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/node/stuff/SConstruct.patch Thu Apr 24 18:16:37 2014 +0200 @@ -0,0 +1,13 @@ +--- deps/v8/SConstruct ++++ deps/v8/SConstruct +@@ -80,8 +80,8 @@ + }, + 'gcc': { + 'all': { +- 'CCFLAGS': ['$DIALECTFLAGS', '$WARNINGFLAGS'], +- 'CXXFLAGS': ['-fno-rtti', '-fno-exceptions'], ++ 'CCFLAGS': ['$DIALECTFLAGS', '$WARNINGFLAGS', '-march=armv6'], ++ 'CXXFLAGS': ['-fno-rtti', '-fno-exceptions', '-march=armv6'], + }, + 'visibility:hidden': { + # Use visibility=default to disable this.