l = len(t.split())

if l==5:

return time.strptime(t, '%a %b %d %H:%M:%S %Y')

elif l==3:

return time.strptime(t, '%d %b %Y')

else:

memo = {}

def wrapper(*args):

if args in memo:

return memo[args]

else:

rv = function(*args)

memo[args] = rv

return rv

if Beast.system.platform not in ['Debian', 'Ubuntu']:

return

line = subprocess.check_output('openssl version -b'.split()).strip()

check_line = 'built on: '

if not line.startswith(check_line):

raise Exception("Didn't find any '%s' line in '$ %s'" %

(check_line, 'openssl version -b'))

d = line[len(check_line):]

if 'date unspecified' in d:

words = subprocess.check_output('openssl version'.split()).split()

if len(words)!=5:

raise Exception("Didn't find version date in '$ openssl version'")

d = ' '.join(words[-3:])

build_time = 'Mon Apr 7 20:33:19 UTC 2014'

if parse_time(d) < parse_time(build_time):

raise Exception('Your openSSL was built on %s; '

'rippled needs a version built on or after %s.'

'''Use implicit_cache on some targets to improve build times.

if len(COMMAND_LINE_TARGETS) == 1:

s = COMMAND_LINE_TARGETS[0].split('.')

if len(s) > 1 and 'debug' in s:

'''Imports environment settings into the construction environment'''

def set(keys):

if type(keys) == list:

for key in keys:

set(key)

return

if keys in os.environ:

value = os.environ[keys]

env[keys] = value

set(['GNU_CC', 'GNU_CXX', 'GNU_LINK'])

def is_compiler(comp_from, comp_to):

return comp_from and comp_to in comp_from

def detect_clang(env):

n = sum(x in env for x in ['CLANG_CC', 'CLANG_CXX', 'CLANG_LINK'])

if n > 0:

if n == 3:

return True

raise ValueError('CLANG_CC, CLANG_CXX, and CLANG_LINK must be set together')

cc = env.get('CC')

cxx = env.get('CXX')

link = env.subst(env.get('LINK'))

if (cc and cxx and link and

is_compiler(cc, 'clang') and

is_compiler(cxx, 'clang') and

is_compiler(link, 'clang')):

env['CLANG_CC'] = cc

env['CLANG_CXX'] = cxx

env['CLANG_LINK'] = link

return True

cc = env.WhereIs('clang')

cxx = env.WhereIs('clang++')

link = cxx

if (is_compiler(cc, 'clang') and

is_compiler(cxx, 'clang') and

is_compiler(link, 'clang')):

env['CLANG_CC'] = cc

env['CLANG_CXX'] = cxx

env['CLANG_LINK'] = link

return True

env['CLANG_CC'] = 'clang'

env['CLANG_CXX'] = 'clang++'

env['CLANG_LINK'] = env['LINK']

return False

def detect_gcc(env):

n = sum(x in env for x in ['GNU_CC', 'GNU_CXX', 'GNU_LINK'])

if n > 0:

if n == 3:

return True

raise ValueError('GNU_CC, GNU_CXX, and GNU_LINK must be set together')

cc = env.get('CC')

cxx = env.get('CXX')

link = env.subst(env.get('LINK'))

if (cc and cxx and link and

is_compiler(cc, 'gcc') and

is_compiler(cxx, 'g++') and

is_compiler(link, 'g++')):

env['GNU_CC'] = cc

env['GNU_CXX'] = cxx

env['GNU_LINK'] = link

return True

cc = env.WhereIs('gcc')

cxx = env.WhereIs('g++')

link = cxx

if (is_compiler(cc, 'gcc') and

is_compiler(cxx, 'g++') and

is_compiler(link, 'g++')):

env['GNU_CC'] = cc

env['GNU_CXX'] = cxx

env['GNU_LINK'] = link

return True

env['GNU_CC'] = 'gcc'

env['GNU_CXX'] = 'g++'

env['GNU_LINK'] = env['LINK']

return False

toolchains = []

if detect_clang(env):

toolchains.append('clang')

if detect_gcc(env):

toolchains.append('gcc')

if env.Detect('cl'):

toolchains.append('msvc')

def _iter(base):

for parent, _, files in os.walk(base):

for path in files:

path = os.path.join(parent, path)

yield os.path.normpath(path)

'''Display command line exemplars for an environment'''

print ('Target: ' + Beast.yellow(str(target[0])))

# TODO Add 'PROTOCCOM' to this list and make it work

try:

return "Ubuntu" == subprocess.check_output(['lsb_release', '-si'],

stderr=subprocess.STDOUT).strip()

except:

if os.getenv('RIPPLED_OLD_GCC_ABI'):

return True

gcc_ver = ''

ubuntu_ver = None

try:

if 'gcc' in cc_cmd:

gcc_ver = subprocess.check_output([cc_cmd, '-dumpversion'],

stderr=subprocess.STDOUT).strip()

else:

gcc_ver = '5' # assume gcc 5 for ABI purposes for clang

if is_ubuntu():

ubuntu_ver = float(

subprocess.check_output(['lsb_release', '-sr'],

stderr=subprocess.STDOUT).strip())

except:

print("Unable to determine gcc version. Assuming native ABI.")

return False

if ubuntu_ver and ubuntu_ver < 15.1 and gcc_ver.startswith('5'):

return True

if False:

env.Replace(

CCCOMSTR='Compiling ' + Beast.blue('$SOURCES'),

CXXCOMSTR='Compiling ' + Beast.blue('$SOURCES'),

LINKCOMSTR='Linking ' + Beast.blue('$TARGET'),

)

check_openssl()

env.Append(CPPDEFINES=[

'OPENSSL_NO_SSL2'

,'DEPRECATED_IN_MAC_OS_X_VERSION_10_7_AND_LATER'

,{'HAVE_USLEEP' : '1'}

,{'SOCI_CXX_C11' : '1'}

,'_SILENCE_STDEXT_HASH_DEPRECATION_WARNINGS'

,'BOOST_NO_AUTO_PTR'

])

if Beast.system.windows:

try:

OPENSSL_ROOT = os.path.normpath(os.environ['OPENSSL_ROOT'])

env.Append(CPPPATH=[

os.path.join(OPENSSL_ROOT, 'include'),

])

env.Append(LIBPATH=[

os.path.join(OPENSSL_ROOT, 'lib'),

])

except KeyError:

pass

elif Beast.system.osx:

OSX_OPENSSL_ROOT = '/usr/local/Cellar/openssl/'

most_recent = sorted(os.listdir(OSX_OPENSSL_ROOT))[-1]

openssl = os.path.join(OSX_OPENSSL_ROOT, most_recent)

env.Prepend(CPPPATH='%s/include' % openssl)

env.Prepend(LIBPATH=['%s/lib' % openssl])

# handle command-line arguments

profile_jemalloc = ARGUMENTS.get('profile-jemalloc')

if profile_jemalloc:

env.Append(CPPDEFINES={'PROFILE_JEMALLOC' : profile_jemalloc})

env.Append(LIBS=['jemalloc'])

env.Append(LIBPATH=[os.path.join(profile_jemalloc, 'lib')])

env.Append(CPPPATH=[os.path.join(profile_jemalloc, 'include')])

if not 'HASSTATICLIBS' in env:

env['HASSTATICLIBS'] = True

env.Replace(LINKCOM=env['LINKCOM'] + " -Wl,-Bstatic $STATICLIBS -Wl,-Bdynamic $DYNAMICLIBS")

for k,l in [('STATICLIBS', static_libs or []), ('DYNAMICLIBS', dyn_libs or [])]:

c = env.get(k, '')

for f in l:

c += ' -l' + f

'''Returns a tuple of lists. The first element is the static libs,

always_dynamic = ['dl', 'pthread', 'z', # for ubuntu

'gssapi_krb5', 'krb5', 'com_err', 'k5crypto', # for fedora

]

try:

cmd = ['pkg-config', '--static', '--libs', lib]

libs = subprocess.check_output(cmd,

stderr=subprocess.STDOUT).strip()

all_libs = [l[2:] for l in libs.split() if l.startswith('-l')]

if not static:

return ([], all_libs)

static_libs = []

dynamic_libs = []

for l in all_libs:

if l in always_dynamic:

dynamic_libs.append(l)

else:

static_libs.append(l)

return (static_libs, dynamic_libs)

except Exception as e:

san = GetOption('sanitize')

if not san: return

san_to_lib = {'address': 'asan', 'thread': 'tsan'}

if toolchain not in Split('clang gcc'):

raise Exception("Sanitizers are only supported for gcc and clang")

env.Append(CCFLAGS=['-fsanitize='+san, '-fno-omit-frame-pointer'])

env.Append(LINKFLAGS=['-fsanitize='+san])

add_static_libs(env, [san_to_lib[san]])

def get_environ_value(candidates):

for c in candidates:

try:

return os.environ[c]

except KeyError:

pass

raise KeyError('Environment variable not set')

try:

br_cands = ['CLANG_BOOST_ROOT'] if toolchain == 'clang' else []

br_cands.append('BOOST_ROOT')

BOOST_ROOT = os.path.normpath(get_environ_value(br_cands))

env.Append(LIBPATH=[

os.path.join(BOOST_ROOT, 'stage', 'lib'),

])

env['BOOST_ROOT'] = BOOST_ROOT

if toolchain == 'gcc':

env.Append(CCFLAGS=['-isystem' + env['BOOST_ROOT']])

else:

env.Append(CPPPATH=[

env['BOOST_ROOT'],

])

except KeyError:

pass

try:

pb_cands = ['CLANG_PROTOBUF_ROOT'] if toolchain == 'clang' else []

pb_cands.append('PROTOBUF_ROOT')

PROTOBUF_ROOT = os.path.normpath(get_environ_value(pb_cands))

env.Append(LIBPATH=[PROTOBUF_ROOT + '/src/.libs'])

if not should_link_static() and toolchain in['clang', 'gcc']:

env.Append(LINKFLAGS=['-Wl,-rpath,' + PROTOBUF_ROOT + '/src/.libs'])

env['PROTOBUF_ROOT'] = PROTOBUF_ROOT

env.Append(CPPPATH=[env['PROTOBUF_ROOT'] + '/src',])

except KeyError:

add_boost_and_protobuf(toolchain, env)

if is_debug_variant(variant):

env.Append(CPPDEFINES=['DEBUG', '_DEBUG'])

elif (variant == 'release' or variant == 'profile') and (not enable_asserts()):

env.Append(CPPDEFINES=['NDEBUG'])

if should_link_static() and not Beast.system.linux:

raise Exception("Static linking is only implemented for linux.")

add_sanitizer(toolchain, env)

if toolchain in Split('clang gcc'):

if Beast.system.linux:

link_static = should_link_static()

for l in ['openssl', 'protobuf']:

static, dynamic = get_libs(l, link_static)

if link_static:

add_static_libs(env, static, dynamic)

else:

env.Append(LIBS=dynamic)

env.ParseConfig('pkg-config --static --cflags ' + l)

env.Prepend(CFLAGS=['-Wall'])

env.Prepend(CXXFLAGS=['-Wall'])

env.Append(CCFLAGS=[

'-Wno-sign-compare',

'-Wno-char-subscripts',

'-Wno-format',

'-g' # generate debug symbols

])

env.Append(LINKFLAGS=[

'-rdynamic',

'-g',

])

if variant == 'profile':

env.Append(CCFLAGS=[

'-p',

'-pg',

])

env.Append(LINKFLAGS=[

'-p',

'-pg',

])

if toolchain == 'clang':

env.Append(CCFLAGS=['-Wno-redeclared-class-member'])

env.Append(CPPDEFINES=['BOOST_ASIO_HAS_STD_ARRAY'])

env.Append(CXXFLAGS=[

'-frtti',

'-std=c++14',

'-Wno-invalid-offsetof'])

env.Append(CPPDEFINES=['_FILE_OFFSET_BITS=64'])

if Beast.system.osx:

env.Append(CPPDEFINES={

'BEAST_COMPILE_OBJECTIVE_CPP': 1,

})

# These should be the same regardless of platform...

if Beast.system.osx:

env.Append(CCFLAGS=[

'-Wno-deprecated',

'-Wno-deprecated-declarations',

'-Wno-unused-variable',

'-Wno-unused-function',

])

else:

if should_link_static():

env.Append(LINKFLAGS=[

'-static-libstdc++',

])

if use_gcc4_abi(env['CC'] if 'CC' in env else 'gcc'):

env.Append(CPPDEFINES={

'-D_GLIBCXX_USE_CXX11_ABI' : 0

})

if toolchain == 'gcc':

env.Append(CCFLAGS=[

'-Wno-unused-but-set-variable',

'-Wno-deprecated',

])

boost_libs = [

'boost_coroutine',

'boost_context',

'boost_date_time',

'boost_filesystem',

'boost_program_options',

'boost_regex',

'boost_system',

'boost_thread'

]

env.Append(LIBS=['dl'])

if should_link_static():

add_static_libs(env, boost_libs)

else:

# We prefer static libraries for boost

if env.get('BOOST_ROOT'):

static_libs = ['%s/stage/lib/lib%s.a' % (env['BOOST_ROOT'], l) for

l in boost_libs]

if all(os.path.exists(f) for f in static_libs):

boost_libs = [File(f) for f in static_libs]

env.Append(LIBS=boost_libs)

if Beast.system.osx:

env.Append(LIBS=[

'crypto',

'protobuf',

'ssl',

])

env.Append(FRAMEWORKS=[

'AppKit',

'Foundation'

])

else:

env.Append(LIBS=['rt'])

if variant == 'release':

env.Append(CCFLAGS=[

'-O3',

'-fno-strict-aliasing'

])

if variant == 'coverage':

env.Append(CXXFLAGS=[

'-fprofile-arcs', '-ftest-coverage'])

env.Append(LINKFLAGS=[

'-fprofile-arcs', '-ftest-coverage'])

if toolchain == 'clang':

if Beast.system.osx:

env.Replace(CC='clang', CXX='clang++', LINK='clang++')

elif 'CLANG_CC' in env and 'CLANG_CXX' in env and 'CLANG_LINK' in env:

env.Replace(CC=env['CLANG_CC'],

CXX=env['CLANG_CXX'],

LINK=env['CLANG_LINK'])

# C and C++

# Add '-Wshorten-64-to-32'

env.Append(CCFLAGS=[])

# C++ only

env.Append(CXXFLAGS=[

'-Wno-mismatched-tags',

'-Wno-deprecated-register',

'-Wno-unused-local-typedefs',

'-Wno-unknown-warning-option',

])

elif toolchain == 'gcc':

if 'GNU_CC' in env and 'GNU_CXX' in env and 'GNU_LINK' in env:

env.Replace(CC=env['GNU_CC'],

CXX=env['GNU_CXX'],

LINK=env['GNU_LINK'])

# Why is this only for gcc?!

env.Append(CCFLAGS=['-Wno-unused-local-typedefs'])

# If we are in debug mode, use GCC-specific functionality to add

# extra error checking into the code (e.g. std::vector will throw

# for out-of-bounds conditions)

if is_debug_variant(variant):

env.Append(CPPDEFINES={

'_FORTIFY_SOURCE': 2

})

env.Append(CCFLAGS=[

'-O0'

])

elif toolchain == 'msvc':

env.Append (CPPPATH=[

os.path.join('src', 'protobuf', 'src'),

os.path.join('src', 'protobuf', 'vsprojects'),

])

env.Append(CCFLAGS=[

'/bigobj', # Increase object file max size

'/EHa', # ExceptionHandling all

'/fp:precise', # Floating point behavior

'/Gd', # __cdecl calling convention

'/Gm-', # Minimal rebuild: disabled

'/GR', # Enable RTTI

'/Gy-', # Function level linking: disabled

'/FS',

'/MP', # Multiprocessor compilation

'/openmp-', # pragma omp: disabled

'/Zc:forScope', # Language extension: for scope

'/Zi', # Generate complete debug info

'/errorReport:none', # No error reporting to Internet

'/nologo', # Suppress login banner

#'/Fd${TARGET}.pdb', # Path: Program Database (.pdb)

'/W3', # Warning level 3

'/WX-', # Disable warnings as errors

'/wd"4018"',

'/wd"4244"',

'/wd"4267"',

'/wd"4800"', # Disable C4800 (int to bool performance)

])

env.Append(CPPDEFINES={

'_WIN32_WINNT' : '0x6000',

})

env.Append(CPPDEFINES=[

'_SCL_SECURE_NO_WARNINGS',

'_CRT_SECURE_NO_WARNINGS',

'WIN32_CONSOLE',

'NOMINMAX'

])

if variant == 'debug':

env.Append(LIBS=[

'VC/static/ssleay32MTd.lib',

'VC/static/libeay32MTd.lib',

])

else:

env.Append(LIBS=[

'VC/static/ssleay32MT.lib',

'VC/static/libeay32MT.lib',

])

env.Append(LIBS=[

'legacy_stdio_definitions.lib',

'Shlwapi.lib',

'kernel32.lib',

'user32.lib',

'gdi32.lib',

'winspool.lib',

'comdlg32.lib',

'advapi32.lib',

'shell32.lib',

'ole32.lib',

'oleaut32.lib',

'uuid.lib',

'odbc32.lib',

'odbccp32.lib',

])

env.Append(LINKFLAGS=[

'/DEBUG',

'/DYNAMICBASE',

'/ERRORREPORT:NONE',

#'/INCREMENTAL',

'/MACHINE:X64',

'/MANIFEST',

#'''/MANIFESTUAC:"level='asInvoker' uiAccess='false'"''',

'/nologo',

'/NXCOMPAT',

'/SUBSYSTEM:CONSOLE',

'/TLBID:1',

])

if variant == 'debug':

env.Append(CCFLAGS=[

'/GS', # Buffers security check: enable

'/MTd', # Language: Multi-threaded Debug CRT

'/Od', # Optimization: Disabled

'/RTC1', # Run-time error checks:

])

env.Append(CPPDEFINES=[

'_CRTDBG_MAP_ALLOC'

])

else:

env.Append(CCFLAGS=[

'/MT', # Language: Multi-threaded CRT

'/Ox', # Optimization: Full

])

else:

toolpath=[os.path.join ('src', 'ripple', 'beast', 'site_scons', 'site_tools')],

tools=['default', 'Protoc', 'VSProject'],

ENV=os.environ,

def __init__(self, env, variant_dirs):

self.env = env

self.variant_dirs = variant_dirs

self.objects = []

self.child_envs = []

def add_source_files(self, *filenames, **kwds):

for filename in filenames:

env = self.env

if kwds:

env = env.Clone()

env.Prepend(**kwds)

self.child_envs.append(env)

o = env.Object(Beast.variantFile(filename, self.variant_dirs))

def _iter(base):

for parent, dirs, files in os.walk(base):

files = [f for f in files if not f[0] == '.']

dirs[:] = [d for d in dirs if not d[0] == '.']

for path in files:

path = os.path.join(parent, path)

r = os.path.splitext(path)

if r[1] and r[1] in suffixes:

yield os.path.normpath(path)

result = []

cpp_path = [

'src/soci/src/core',

'src/soci/include/private',

'src/sqlite', ]

append_sources(result,

'src/ripple/unity/soci.cpp',

CPPPATH=cpp_path)

if style == 'unity':

append_sources(result,

'src/ripple/unity/soci_ripple.cpp',

CPPPATH=cpp_path)

'''

if toolchain != 'clang':

return False

if use_shp.cache is None:

try:

ver = subprocess.check_output(

['clang', '--version'], stderr=subprocess.STDOUT).strip()

use_shp.cache = 'version 3.4' not in ver and 'version 3.0' not in ver

except:

use_shp.cache = False

result = []

if toolchain == 'msvc':

warning_flags = {}

else:

warning_flags = {'CCFLAGS': ['-Wno-unused-function']}

append_sources(

result,

'src/ripple/unity/secp256k1.cpp',

CPPPATH=['src/secp256k1'],

**warning_flags)

result = []

append_sources(

result,

*list_sources('src/ripple/core', '.cpp'),

CPPPATH=[

'src/soci/src/core',

'src/sqlite']

)

append_sources(result, *list_sources('src/ripple/beast/clock', '.cpp'))

append_sources(result, *list_sources('src/ripple/beast/container', '.cpp'))

append_sources(result, *list_sources('src/ripple/beast/insight', '.cpp'))

append_sources(result, *list_sources('src/ripple/beast/net', '.cpp'))

append_sources(result, *list_sources('src/ripple/beast/nudb', '.cpp'))

append_sources(result, *list_sources('src/ripple/beast/utility', '.cpp'))

append_sources(result, *list_sources('src/ripple/app', '.cpp'))

append_sources(result, *list_sources('src/ripple/basics', '.cpp'))

append_sources(result, *list_sources('src/ripple/crypto', '.cpp'))

append_sources(result, *list_sources('src/ripple/json', '.cpp'))

append_sources(result, *list_sources('src/ripple/ledger', '.cpp'))

append_sources(result, *list_sources('src/ripple/legacy', '.cpp'))

append_sources(result, *list_sources('src/ripple/net', '.cpp'))

append_sources(result, *list_sources('src/ripple/overlay', '.cpp'))

append_sources(result, *list_sources('src/ripple/peerfinder', '.cpp'))

append_sources(result, *list_sources('src/ripple/protocol', '.cpp'))

append_sources(result, *list_sources('src/ripple/rpc', '.cpp'))

append_sources(result, *list_sources('src/ripple/shamap', '.cpp'))

append_sources(result, *list_sources('src/ripple/server', '.cpp'))

append_sources(result, *list_sources('src/ripple/test', '.cpp'))

if use_shp(toolchain):

cc_flags = {'CCFLAGS': ['--system-header-prefix=rocksdb2']}

else:

cc_flags = {}

append_sources(

result,

*list_sources('src/ripple/nodestore', '.cpp'),

CPPPATH=[

'src/rocksdb2/include',

'src/snappy/snappy',

'src/snappy/config',

],

**cc_flags)

result += get_soci_sources('classic')

result += get_common_sources(toolchain)

result = []

append_sources(

result,

'src/ripple/beast/unity/beast_clock_unity.cpp',

'src/ripple/beast/unity/beast_container_unity.cpp',

'src/ripple/beast/unity/beast_insight_unity.cpp',

'src/ripple/beast/unity/beast_net_unity.cpp',

'src/ripple/beast/unity/beast_nudb_unity.cpp',

'src/ripple/beast/unity/beast_utility_unity.cpp',

'src/ripple/unity/app_ledger.cpp',

'src/ripple/unity/app_main.cpp',

'src/ripple/unity/app_misc.cpp',

'src/ripple/unity/app_paths.cpp',

'src/ripple/unity/app_tests.cpp',

'src/ripple/unity/app_tx.cpp',

'src/ripple/unity/core.cpp',

'src/ripple/unity/basics.cpp',

'src/ripple/unity/crypto.cpp',

'src/ripple/unity/ledger.cpp',

'src/ripple/unity/net.cpp',

'src/ripple/unity/overlay.cpp',

'src/ripple/unity/peerfinder.cpp',

'src/ripple/unity/json.cpp',

'src/ripple/unity/protocol.cpp',

'src/ripple/unity/rpcx.cpp',

'src/ripple/unity/shamap.cpp',

'src/ripple/unity/server.cpp',

'src/ripple/unity/test.cpp',

)

if use_shp(toolchain):

cc_flags = {'CCFLAGS': ['--system-header-prefix=rocksdb2']}

else:

cc_flags = {}

append_sources(

result,

'src/ripple/unity/nodestore.cpp',

CPPPATH=[

'src/rocksdb2/include',

'src/snappy/snappy',

'src/snappy/config',

],

**cc_flags)

result += get_soci_sources('unity')

result += get_common_sources(toolchain)