Help('''
Type 'scons' to build and run all the available test cases.
It will automatically detect your platform and C compiler and
build appropriately.

You can modify the behaviour using following options:
BUILDDIR    Directory to build into (default "build")
CC          Name of C compiler
CXX         Name of C++ compiler
CCFLAGS     Flags to pass to the C compiler
CXXFLAGS    Flags to pass to the C++ compiler
LINK        Name of linker (usually same as CC)
LINKFLAGS   Flags to pass to linker
LINKLIBS    Flags to pass to linker after object files
PROTOC      Path to protoc binary
PROTOCFLAGS Arguments to pass protoc
NODEFARGS   Do not add the default CCFLAGS
NOVALGRIND  Do not use valgrind for memory checks

For example, for a clang build, use:
scons CC=clang CXX=clang++
''')

import os
import platform
env = Environment(ENV = os.environ)

# Allow giving environment flags on command line.
list_vars = ['CCFLAGS', 'CXXFLAGS', 'LINKFLAGS', 'LINKLIBS', 'PROTOCFLAGS']
for var,val in ARGUMENTS.items():
    if var in list_vars:
        env.Append(**{var: val})
    else:
        env.Replace(**{var: val})

env.SetDefault(BUILDDIR = "build")
env.SConsignFile(env['BUILDDIR'] + "/sconsign")
env.Replace(CONFIGUREDIR = env['BUILDDIR'] + "/config")

# If a cross compilation platform is given, apply the environment settings
# from site_scons/platforms/X/X.py
if ARGUMENTS.get('PLATFORM'):
    platform_func = platforms.get(ARGUMENTS.get('PLATFORM'))
    if not platform_func:
        print("Supported platforms: " + str(platforms.keys()))
        raise Exception("Unsupported platform: " + ARGUMENTS.get('PLATFORM'))
    else:
        platform_func(env)

# Load nanopb generator build rules from site_scons/site_tools/nanopb.py
env.Tool("nanopb")

# Limit memory usage. This is to catch problems like issue #338
try:
    import resource
    soft, hard = resource.getrlimit(resourse.RLIMIT_AS)
    resource.setrlimit(resource.RLIMIT_AS, (100*1024*1024, hard))
except:
    pass

# On Mac OS X, gcc is usually alias for clang.
# To avoid problem with default options, use clang directly.
if platform.system() == "Darwin" and 'CC' not in ARGUMENTS:
    env.Replace(CC = "clang", CXX = "clang++")

# Add the builders defined in site_init.py
add_nanopb_builders(env)

# Path to the files shared by tests, and to the nanopb core.
env.Append(CPPPATH = ["#../", "$COMMON"])

# Path for finding nanopb.proto
env.Append(PROTOCPATH = '#../generator')

# Check the compilation environment, unless we are just cleaning up.
if not env.GetOption('clean'):
    def check_ccflags(context, flags, linkflags = ''):
        '''Check if given CCFLAGS are supported'''
        context.Message('Checking support for CCFLAGS="%s"... ' % flags)
        oldflags = context.env['CCFLAGS']
        oldlinkflags = context.env['LINKFLAGS']
        context.env.Append(CCFLAGS = flags)
        context.env.Append(LINKFLAGS = linkflags)
        result = context.TryCompile("int main() {return 0;}", '.c')
        context.env.Replace(CCFLAGS = oldflags)
        context.env.Replace(LINKFLAGS = oldlinkflags)
        context.Result(result)
        return result
    
    def check_protocversion(context):
        context.Display("Checking protoc version... ")
        status, output = context.TryAction('$PROTOC --version > $TARGET')
        if status:
            context.Result(str(output.strip()))
            return str(output.strip())
        else:
            context.Display("error: %s\n" % output.strip())
            context.did_show_result = 1
            context.Result("unknown, assuming 3.6.1")
            return "3.6.1"

    conf = Configure(env, custom_tests =
                     {'CheckCCFLAGS': check_ccflags,
                      'CheckProtocVersion': check_protocversion})

    # If the platform doesn't support C99, use our own header file instead.
    stdbool = conf.CheckCHeader('stdbool.h')
    stdint = conf.CheckCHeader('stdint.h')
    stddef = conf.CheckCHeader('stddef.h')
    string = conf.CheckCHeader('string.h')
    stdlib = conf.CheckCHeader('stdlib.h')
    limits = conf.CheckCHeader('limits.h')
    if not stdbool or not stdint or not stddef or not string or not limits:
        conf.env.Append(CPPDEFINES = {'PB_SYSTEM_HEADER': '\\"pb_syshdr.h\\"'})
        conf.env.Append(CPPPATH = "#../extra")
        conf.env.Append(SYSHDR = '\\"pb_syshdr.h\\"')
        
        if stdbool: conf.env.Append(CPPDEFINES = {'HAVE_STDBOOL_H': 1})
        if stdint: conf.env.Append(CPPDEFINES = {'HAVE_STDINT_H': 1})
        if stddef: conf.env.Append(CPPDEFINES = {'HAVE_STDDEF_H': 1})
        if string: conf.env.Append(CPPDEFINES = {'HAVE_STRING_H': 1})
        if stdlib: conf.env.Append(CPPDEFINES = {'HAVE_STDLIB_H': 1})
        if limits: conf.env.Append(CPPDEFINES = {'HAVE_LIMITS_H': 1})
    
    # Check protoc version
    conf.env['PROTOC_VERSION'] = conf.CheckProtocVersion()

    # Initialize compiler arguments with defaults, unless overridden on
    # command line.
    if not env.get('NODEFARGS'):
        # Check if libmudflap is available (only with GCC)
        if 'gcc' in env['CC']:
            if conf.CheckLib('mudflap'):
                conf.env.Append(CCFLAGS = '-fmudflap')
                conf.env.Append(LINKFLAGS = '-fmudflap')

        # Check if we can use extra strict warning flags (only with GCC)
        extra = '-Wcast-qual -Wlogical-op -Wconversion'
        extra += ' -fstrict-aliasing -Wstrict-aliasing=1'
        extra += ' -Wmissing-prototypes -Wmissing-declarations -Wredundant-decls'
        extra += ' -Wstack-protector '
        if 'gcc' in env['CC']:
            if conf.CheckCCFLAGS(extra):
                conf.env.Append(CORECFLAGS = extra)

        # Check if we can use undefined behaviour sanitizer (only with clang)
        # TODO: Fuzz test triggers the bool sanitizer, figure out whether to
        #       modify the fuzz test or to keep ignoring the check.
        extra = '-fsanitize=undefined,integer -fno-sanitize-recover=undefined,integer '
        if 'clang' in env['CC']:
            if conf.CheckCCFLAGS(extra, linkflags = extra):
                conf.env.Append(CORECFLAGS = extra)
                conf.env.Append(LINKFLAGS = extra)
    
    # End the config stuff
    env = conf.Finish()

if not env.get('NODEFARGS'):
    # Initialize the CCFLAGS according to the compiler
    if 'gcc' in env['CC']:
        # GNU Compiler Collection
        
        # Debug info, warnings as errors
        env.Append(CFLAGS = '-g -Wall -Werror ')
        env.Append(CORECFLAGS = '-Wextra')

        # Pedantic ANSI C. On AVR this doesn't work because we use large
        # enums in some of the tests.
        if env.get("EMBEDDED") != "AVR":
            env.Append(CFLAGS = '-ansi -pedantic')

        # Profiling and coverage
        if not env.get("EMBEDDED"):
            env.Append(CFLAGS = '-fprofile-arcs -ftest-coverage ')
            env.Append(LINKFLAGS = '-g --coverage')


        # We currently need uint64_t anyway, even though ANSI C90 otherwise..
        env.Append(CFLAGS = '-Wno-long-long')
    elif 'clang' in env['CC']:
        # CLang
        env.Append(CFLAGS = '-ansi -g -Wall -Werror')
        env.Append(CORECFLAGS = ' -Wextra -Wcast-qual -Wconversion')
    elif 'cl' in env['CC']:
        # Microsoft Visual C++

        # Debug info on, warning level 2 for tests, warnings as errors
        env.Append(CFLAGS = '/Zi /W2 /WX')
        env.Append(LINKFLAGS = '/DEBUG')

        # More strict checks on the nanopb core
        env.Append(CORECFLAGS = '/W4')

        # Disable warning about sizeof(union{}) construct that is used in
        # message size macros, in e.g. multiple_files testcase. The C construct
        # itself is valid, but quite rare, which causes Visual C++ to give a warning
        # about it.
        env.Append(CFLAGS = '/wd4116')
    elif 'tcc' in env['CC']:
        # Tiny C Compiler
        env.Append(CFLAGS = '-Wall -Werror -g')

    if 'clang' in env['CXX']:
        env.Append(CXXFLAGS = '-g -Wall -Werror -Wextra -Wno-missing-field-initializers')
    elif 'g++' in env['CXX'] or 'gcc' in env['CXX']:
        env.Append(CXXFLAGS = '-g -Wall -Werror -Wextra -Wno-missing-field-initializers')
    elif 'cl' in env['CXX']:
        env.Append(CXXFLAGS = '/Zi /W2 /WX /wd4116 /wd4127')

env.SetDefault(CORECFLAGS = '')

if not env.get("EMBEDDED") and not env.get("NOVALGRIND"):
    valgrind = env.WhereIs('valgrind')
    if valgrind:
        env.SetDefault(VALGRIND = valgrind)

# Make it possible to add commands to the end of linker line
env.SetDefault(LINKLIBS = '')
env.Replace(LINKCOM = env['LINKCOM'] + " $LINKLIBS")

# Place build files under separate folder
import os.path
env['VARIANT_DIR'] = env['BUILDDIR']
env['BUILD'] = '#' + env['VARIANT_DIR']
env['COMMON'] = '#' + env['VARIANT_DIR'] + '/common'

# Include common/SConscript first to make sure its exports are available
# to other SConscripts.
SConscript("common/SConscript", exports = 'env', variant_dir = env['VARIANT_DIR'] + '/common')

# Now include the SConscript files from all subdirectories
for subdir in Glob('*/SConscript') + Glob('regression/*/SConscript'):
    if str(subdir).startswith("common/"): continue
    if str(subdir).startswith("common\\"): continue
    SConscript(subdir, exports = 'env', variant_dir = env['VARIANT_DIR'] + '/' + os.path.dirname(str(subdir)))

