SConstruct

#! /usr/bin/env python

"""
Master of the build system, root of all scons files, The One file.

In this files all necessary helpers are defined, to let me simplify
``SConscript`` files in directories as much as possible.
"""

import atexit
import collections
import colorama
import datetime
import fnmatch
import hashlib
import os
import subprocess
import sys

from functools import partial
from six import iteritems, string_types

DEFAULT_CFLAGS = '-fno-builtin -nostdinc -mllvm -disable-tail-duplicate'
DEFAULT_ASMFLAGS = '-D__DUCKY_PURE_ASM__'


def print_(*args, **kwargs):
  """
  Simple Python3-print-like function.

  CI boxes I use contain `six` package in a version that does not support `flush`
  argument. Replacing system python package with one I'd fetch using `pip` is
  a colosal PITA. Therefore this simple implementation...
  """

  end = kwargs.pop('end', '\n')
  flush = kwargs.pop('flush', False)
  f = kwargs.pop('file', sys.stdout)

  f.write(' '.join([str(arg) for arg in args]) + end)

  if flush is True:
    f.flush()


#
# Our extra options
#
# These have to be first - well, at least --no-color has to be first,
# and it makes no sense to put that one here and the rest somewhere bellow.
#

def generate_build_stamp():
  return subprocess.check_output('git log --date=iso --pretty=format:"%H %cd" -n 1 | cut -d" " -f1,2,3 | tr -d "-" | tr -d ":" | tr " " "-"', shell = True).strip()

AddOption('--define',
          metavar = 'NAME[=VALUE]',
          dest = 'defines',
          action = 'append',
          default = [],
          help = 'Define macro for C and assembly')

AddOption('--no-color',
          dest = 'no_color',
          action = 'store_true',
          default = False,
          help = 'Do not colorize output')

AddOption('--testset-id',
          dest = 'testset_id',
          action = 'store',
          type = int,
          default = os.getpid(),
          metavar = 'ID',
          help = 'Set testset id to this value')

AddOption('--testset-dir',
          dest = 'testset_dir',
          action = 'store',
          metavar = 'NAME',
          help = 'Store test results in this test set')

AddOption('--with-jit',
          dest = 'jit',
          action = 'store_true',
          default = False,
          help = 'Run with JIT enabled')

AddOption('--with-mmap',
          dest = 'mmap',
          action = 'store_true',
          default = False,
          help = 'Run using mmap as binary loading method.')

AddOption('--with-coverage',
          dest = 'coverage',
          action = 'store_true',
          default = False,
          help = 'Run tests with coverage enabled')

AddOption('--with-profiling',
          dest = 'profiling',
          action = 'store_true',
          default = False,
          help = 'Run tests with profiling enabled')

AddOption('--with-debug',
          dest = 'debug',
          action = 'store_true',
          default = False,
          help = 'Run with debugging enabled')

AddOption('--pass-testsuite-output',
          dest = 'pass_testsuite_output',
          action = 'store_true',
          default = False,
          help = 'If set, output of testsuites will be passed directly to stdout/stderr')

AddOption('--hypothesis-profile',
          dest = 'hypothesis_profile',
          action = 'store',
          default = 'Default',
          metavar = 'PROFILE',
          help = 'Set Hypothesis profile to PROFILE')

AddOption('--clean-testsets',
          dest = 'clean_testsets',
          action = 'store_true',
          default = False,
          help = 'Remove testset dirs when building "clean" target.')

AddOption('--repeats',
          dest = 'repeats',
          action = 'append',
          default = [],
          help = 'Specify number of repeats of particular tests')

VARS = Variables(None, ARGUMENTS)
VARS.Add(             'BUILD_STAMP',        'Set to force FORTH kernel build stamp', generate_build_stamp())
VARS.Add(BoolVariable('BOOT_IMAGE',         'Set to true to build boot loader with support for Ducky images', True))
VARS.Add(             'LLVMDIR',            'Path to LLVM tools', None)


#
# Output colorization
#
# Turned on by default, if --no-color is set, declare relevant helpers
# as NOPs.
#
if GetOption('no_color') is False:
  def colorize(fg, bg, s):
    """
    Returns colorized version of input string.
    """

    fg = getattr(colorama.Fore, fg) if fg is not None else ''
    bg = getattr(colorama.Back, bg) if bg is not None else ''

    return '%s%s%s%s' % (fg, bg, s, colorama.Style.RESET_ALL)

  def colorize_fmt(s):
    fgs = [
      ('${GREEN}', colorama.Fore.GREEN),
      ('${BLUE}',  colorama.Fore.BLUE),
      ('${CLR}',   colorama.Style.RESET_ALL),
    ]

    for p, c in fgs:
      s = s.replace(p, c)

    return s

  GREEN  = partial(colorize, 'GREEN',  None)
  YELLOW = partial(colorize, 'YELLOW', None)
  RED    = partial(colorize, 'RED',    None)
  BLUE   = partial(colorize, 'BLUE',   None)

else:
  def colorize(fg, bg, s):
    return s

  def colorize_fmt(s):
    return s

  def BLUE(s):
    return s

  GREEN = YELLOW = RED = BLUE


#
# Extra Environment methods
#
def __is_silent(self):
  """
  Returns ``True`` if ``-s`` option is set.
  """

  return self.GetOption('silent')

def __DEBUG(self, msg):
  if not self.IS_SILENT():
    print_('[DEBUG] %s' % msg)

def __PASS(self, runtime = None):
  msg = 'PASS'

  if self is not None and not self.IS_SILENT():
    msg = '[' + msg + ']'

  if runtime is not None:
    msg += ' (%s)' % str(runtime)

  print_(GREEN(msg))

def __FAIL(self):
  if self.IS_SILENT():
    print_(RED('FAIL'))

  else:
    print_(RED('[FAIL]'))

def __WORK(self, label, target):
  if self.IS_SILENT():
    print_('%s %s ... ' % (YELLOW('[' + label + ']'), target), end = '', flush = True)

  else:
    print_('%s %s' % (YELLOW('[' + label + ']'), target), flush = True)

def __on_clean(self, target):
  if self.GetOption('clean'):
    self.Default(target)

def __pass_var_as_define(self, name, to_boolean = True, ignore_false = True):
  if name not in self:
    return

  if ignore_false and not self[name]:
    return

  if to_boolean:
    value = 'yes' if self[name] else 'no'
  else:
    value = str(self[name])

  self.Append(DEFS = '-D %s=%s' % (name, value))

def __run_something(_env, label, target, runner, *args, **kwargs):
  expected_exit = 0
  if 'expected_exit' in kwargs:
    expected_exit = kwargs['expected_exit']
    del kwargs['expected_exit']

  _env.DEBUG('__run_something: label="%s", target="%s"' % (label, target))
  _env.DEBUG('    runner="%s"' % runner)
  _env.DEBUG('    expected_exit=%d' % expected_exit)
  _env.DEBUG('    args="%s"' % ', '.join(['"%s"' % str(arg) for arg in args]))
  _env.DEBUG('    kwargs="%s"' % ', '.join(['%s="%s"' % (k, v) for k, v in iteritems(kwargs)]))

  _env.WORK(label, target)

  start = datetime.datetime.now()

  def __PASS():
    _env.PASS(runtime = datetime.datetime.now() - start)

    return 0

  def __FAIL(exit_code):
    _env.FAIL()
    return 1

  try:
    runner(*args, **kwargs)

  except subprocess.CalledProcessError as e:
    if e.returncode == expected_exit:
      return __PASS()

    return __FAIL(e.returncode)

  except Exception as e:
    import traceback

    tb = traceback.format_exc()

    _env.FAIL()
    _env.ERROR(str(e))

    for l in tb.split('\n'):
      _env.ERROR(l)

    return 1

  else:
    if expected_exit == 0:
      return __PASS()

    return __FAIL(0)

class DuckyCommand(object):
  def __init__(self, _env, env = None, runner = None, command = None, stdout = None, stderr = None, junit_record = None):
    self.env     = env or {}
    self.runner  = runner if runner is not None else _env['PYTHON']
    self.command = command if command is not None else ''

    self.stdout  = stdout
    self.stderr  = stderr

    self.junit_record = junit_record

  def materialize(self, env):
    env.DEBUG('materialize:')
    env.DEBUG('  runner="%s"' % self.runner)
    env.DEBUG('  command="%s"' % self.command)
    env.DEBUG('  stdout=%s' % self.stdout)
    env.DEBUG('  stderr=%s' % self.stderr)

    cmd = [
      self.runner,
      self.command
    ]

    kwargs = {
      'shell': True,
      'env':   dict(env['ENV'], **self.env)
    }

    if self.stdout is None:
      kwargs['stdout'] = sys.stdout

      if self.stderr is None:
        kwargs['stderr'] = sys.stderr

      else:
        cmd.append('2> %s' % self.stderr)

    else:
      if self.stderr is None:
        cmd.append('> %s' % self.stdout)
        kwargs['stderr'] = sys.stderr

      else:
        if self.stdout == self.stderr:
          cmd.append('&> %s' % self.stdout)

        else:
          cmd.append('> %s' % self.stdout)
          cmd.append('2> %s' % self.stderr)

    return ' '.join(cmd), kwargs

  def run(self, env, label, message, expected_exit = 0):
    cmd, kwargs = self.materialize(env)

    return env.RunSomething(label, message, subprocess.check_call, cmd, expected_exit = expected_exit, **kwargs)

  def wrap_by_coverage(self, env):
    self.env['COVERAGE_FILE'] = env.subst('$COVERAGEDIR/.coverage.' + hashlib.sha256(self.command.replace(' ', '-').replace('/', '-')).hexdigest())
    self.runner = self.runner + ' ' + env.subst('$VIRTUAL_ENV/bin/coverage run --rcfile=$TOPDIR/coveragerc')

  def wrap_by_profiling(self, env):
    self.command += ' ' + env.subst('--profile --profile-dir $PROFILEDIR')

  def wrap_by_debugging(self, env):
    self.command += ' -d'

def __asm_from_c(source, target, env):
  if 'LLVMDIR' not in env:
    env.ERROR('LLVMDIR not set, don\'t know where to find clang')
    env.Exit(1)

  cmd = DuckyCommand(env, runner = '')
  cmd.command = env.subst('$LLVMDIR/bin/clang -cc1 -S $CFLAGS $DEFS {include} -o {target} {inputs}'.format(
    inputs  = ' '.join([str(f) for f in source]),
    include = ' '.join(env['INCLUDE']) if 'INCLUDE' in env else '',
    target  = target[0]))

  return cmd.run(env, 'C => ASM', target[0])

def __object_from_c(source, target, env):
  if 'LLVMDIR' not in env:
    env.ERROR('LLVMDIR not set, don\'t know where to find clang')
    env.Exit(1)

  cmd = DuckyCommand(env, runner = '')
  cmd.command = env.subst('$LLVMDIR/bin/clang -c $CFLAGS $DEFS -fno-integrated-as {include} -o {target} {inputs}'.format(
    inputs  = ' '.join([str(f) for f in source]),
    include = ' '.join(env['INCLUDE']) if 'INCLUDE' in env else '',
    target  = target[0]))

  return cmd.run(env, 'C => OBJ', target[0])

def __compile_ducky_object(source, target, env):
  cmd = DuckyCommand(env)
  cmd.command = env.subst('$VIRTUAL_ENV/bin/ducky-as {inputs} $ASMFLAGS $DEFS {include} -o {target}'.format(
    inputs  = ' '.join(['-i %s' % f for f in source]),
    include = ' '.join(env['INCLUDE']) if 'INCLUDE' in env else '',
    target  = target[0]))

  if 'COVERAGEDIR' in env:
    cmd.wrap_by_coverage(env)

  if GetOption('mmap') is True:
    cmd.command += ' --mmapable-sections'

  if GetOption('debug') is True:
    cmd.wrap_by_debugging(env)

  return cmd.run(env, 'ASM => OBJ', target[0])

def __link_ducky_binary(source, target, env):
  cmd = DuckyCommand(env)
  cmd.command = env.subst('$VIRTUAL_ENV/bin/ducky-ld {inputs} {linker_script} -o {target}'.format(
    inputs = ' '.join(['-i %s' % f for f in source]),
    linker_script = ('--script=%s' % env['LINKER_SCRIPT']) if 'LINKER_SCRIPT' in env else '',
    target  = target[0]))

  if 'COVERAGEDIR' in env:
    cmd.wrap_by_coverage(env)

  if GetOption('debug') is True:
    cmd.wrap_by_debugging(env)

  return cmd.run(env, 'LINK', target[0])

def __archive_from_objs(source, target, env):
  cmd = DuckyCommand(env)
  cmd.command = env.subst('$VIRTUAL_ENV/bin/ducky-ld --archive {inputs} -o {target}'.format(
      inputs = ' '.join(['-i %s' % f for f in source]),
      target  = target[0]))

  if 'COVERAGEDIR' in env:
    cmd.wrap_by_coverage(env)

  if GetOption('debug') is True:
    cmd.wrap_by_debugging(env)

  return cmd.run(env, 'OBJs => ARCH', target[0])

def __run_ducky_binary(self, config, set_options = None, add_options = None, environ = None, expected_exit = 0):
  set_options = set_options or []
  add_options = add_options or []
  environ = environ or {}

  def _run_ducky_binary(target, source, env, cmd = None, expected_exit = 0):
    assert cmd is not None

    return cmd.run(env, 'RUN', target[0], expected_exit = expected_exit)

  config = File(config) if isinstance(config, string_types) else config

  cmdline = self.subst('$VIRTUAL_ENV/bin/ducky-vm --machine-config={machine_config} {set_options} {add_options}'.format(
    machine_config = config.abspath,
    set_options = ' '.join(['--set-option=%s' % option for option in set_options]),
    add_options = ' '.join(['--add-option=%s' % option for option in add_options])))

  cmd = DuckyCommand(self)
  cmd.command = cmdline
  cmd.env.update(environ)

  cmd.env['PYTHONUNBUFFERED'] = 'yes'

  if 'COVERAGEDIR' in self:
    cmd.wrap_by_coverage(self)

  if 'PROFILEDIR' in self:
    cmd.wrap_by_profiling(self)

  if GetOption('debug') is True:
    cmd.wrap_by_debugging(self)

  if GetOption('jit'):
    cmd.env['JIT'] = 'yes'

  return partial(_run_ducky_binary, cmd = cmd, expected_exit = expected_exit)

def __create_ducky_image(self, _target, _source, mode = 'binary', bio = False):
  def _create_ducky_image(target, source, env, cmd = None):
    assert cmd is not None

    return cmd.run(env, 'IMAGE', target[0])

  _source = File(_source) if isinstance(_source, string_types) else _source
  _target = File(_target) if isinstance(_target, string_types) else _target

  cmd = DuckyCommand(self)
  cmd.command = self.subst('$VIRTUAL_ENV/bin/ducky-img {mode} -i {source} -o {target} {bio}'.format(mode = '-b' if mode == 'binary' else '-h', source = _source.abspath, target = _target.abspath, bio = '--bio' if bio else ''))

  if 'COVERAGEDIR' in self:
    cmd.wrap_by_coverage(self)

  if GetOption('debug') is True:
    cmd.wrap_by_debugging(self)

  return partial(_create_ducky_image, cmd = cmd)

def __read_external_deps(self, directory = None):
  directory = Dir(directory) if directory is not None else self.Dir('.')
  deps_file = File(os.path.join(directory.abspath, '.depends')).abspath

  if not os.path.exists(deps_file):
    #self.ERROR('External dependencies expected in %s but file does not exist' % deps_file)
    return

  with open(deps_file, 'r') as f:
    for line in f:
      line = line.strip()
      if not line or line[0] == '#':
        continue

      target, sources = [s.strip() for s in line.split(':')]

      self.Depends(File(self.subst(target.strip())), [self.File(self.subst(name.strip())) for name in sources.split(' ')])

def __parse_repeats(self):
  if hasattr(self, '_repeats'):
    return self._repeats

  repeats = []

  for entry in self.GetOption('repeats'):
    test, count = entry.split(':')
    repeats.append((test.strip(), int(count.strip())))

  self._repeats = repeats
  return repeats

def __clone_env(self, *args, **kwargs):
  clone = self.Clone(*args, **kwargs)

  original_help = clone.Help

  def Help(self, s, **kwargs):
    return original_help(colorize_fmt(s), **kwargs)

  methods = {
    'IS_SILENT': __is_silent,
    'DEBUG':     __DEBUG,
    'INFO':      lambda self, msg: print_('%s %s' % (GREEN('[INFO]'), msg)),
    'WARN':      lambda self, msg: print_('%s %s' % (RED('[WARN]'), msg)),
    'ERROR':     lambda self, msg: print_('%s %s' % (RED('[ERR]'), msg)),
    'FAIL':      __FAIL,
    'PASS':      __PASS,
    'WORK':      __WORK,
    'OnClean':   __on_clean,
    'PassVarAsDefine': __pass_var_as_define,
    'FullClone':       __clone_env,
    'ReadExternalDeps': __read_external_deps,
    'ParseRepeats':     __parse_repeats,

    # Virtual builders
    'RunSomething':    __run_something,
    'DuckyRun':        __run_ducky_binary,
    'DuckyImage':      __create_ducky_image,
    'GetDuckyDefine':  lambda self, *names: [os.path.join(str(ENV['HEADERSDIR']), name + '.hs') for name in names]
  }

  for name, fn in iteritems(methods):
    AddMethod(clone, fn, name)

  clone.AddMethod(Help)

  return clone

def print_info(source, target, env):
  env.INFO('Build stamp:           %s' % env['BUILD_STAMP'])
  env.INFO('SCONS is using Python: %s (%s)' % (ENV['SCONS_PYTHON'], ENV['SCONS_PYTHON_NAME']))
  env.INFO('Default Python:        %s (%s)' % (ENV['PYTHON'], ENV['PYTHON_NAME']))

  if 'LLVMDIR' in env:
    env.INFO('LLVM dir:              %s' % ENV['LLVMDIR'])

  if 'TESTSETDIR' in env:
    env.INFO('Test set dir:          %s' % ENV['TESTSETDIR'])
    env.INFO('Results dir:           %s' % ENV['RESULTSDIR'])
    env.INFO('Log dir:               %s' % ENV['LOGDIR'])
    env.INFO('Tmp dir:               %s' % ENV['TMPDIR'])
    env.INFO('Report dir:            %s' % ENV['REPORTDIR'])

    if 'COVERAGEDIR' in ENV:
      env.INFO('Coverage dir:          %s' % ENV['COVERAGEDIR'])

    if 'PROFILEDIR' in ENV:
      env.INFO('Profile dir:           %s' % ENV['PROFILEDIR'])

  env.INFO('CFLAGS:                %s' % ENV.subst('$CFLAGS $DEFS'))
  env.INFO('ASMFLAGS:              %s' % ENV.subst('$ASMFLAGS $DEFS'))

  for test, count in env.ParseRepeats():
    env.INFO('  Repeat %s %d times' % (test, count))

def build_failure_to_str(bf):
  import SCons.Errors

  if bf is None:
    return 'unknown target'

  if isinstance(bf, SCons.Errors.StopError):
    return str(bf)

  if bf.node:
    return str(bf.node) + ': ' + bf.errstr

  if bf.filename:
    return bf.filename + ': ' + bf.errstr

  return 'unknown failure: ' + bf.errstr

def build_status():
  from SCons.Script import GetBuildFailures

  bf = GetBuildFailures()
  if bf:
    return ('failed', ['Failed building %s' % build_failure_to_str(x) for x in bf if x is not None])

  return ('passed', None)

def display_build_status():
  status, messages = build_status()

  if messages is not None:
    print_('\n'.join([RED(msg) for msg in messages]))

def print_help(env, target, source):
  import SCons
  print_(SCons.Script.help_text)

def run_flake(target, source, env):
  def __find_files(d, pattern):
    files = []

    for root, dirnames, filenames in os.walk(d.abspath):
      if 'vhdl' in root:
        continue
      files += [os.path.join(root, f) for f in os.listdir(root) if fnmatch.fnmatch(f, pattern)]

    return files

  sources  = __find_files(Dir('#ducky'), '*.py')
  sources += __find_files(Dir('#tests'), '*.py')

  cmd = DuckyCommand(env, runner = '')
  cmd.command = 'flake8 --config={config_file} --exclude parsetab.py {files}'.format(
    config_file = File('#flake8.cfg').abspath,
    files = ' '.join(sources)
  )

  return cmd.run(env, 'INFO', 'flake')

def run_pylint(target, source, env):
  cmd = DuckyCommand(env, runner = '')
  cmd.command = 'pylint --rcfile=pylintrc ducky'

  return cmd.run(env, 'INFO', 'pylint')

def run_cloc(target, source, env):
  cmd = DuckyCommand(env, runner = '')
  cmd.command = 'cloc --skip-uniqueness --lang-no-ext=Python boot/ defs/ ducky/ forth/ examples/ tests/'

  return cmd.run(env, 'INFO', 'cloc')

def run_install(target, source, env):
  cmd = DuckyCommand(env)
  cmd.command = 'setup.py install'

  return cmd.run(env, 'INFO', 'install')

def run_local_install(target, source, env):
  cmd = DuckyCommand(env, runner = '')
  cmd.command = 'pip install -e .'

  return cmd.run(env, 'INFO', 'local-install')

def run_publish(target, source, env):
  cmd = DuckyCommand(env)
  cmd.command = 'setup.py sdist upload'

  return cmd.run(env, 'INFO', 'publish')

DuckyAsmFromC   = Builder(action = __asm_from_c)
DuckyObjFromAsm = Builder(action = __compile_ducky_object)
DuckyObjFromC   = Builder(action = __object_from_c)
DuckyObject = Builder(action = __compile_ducky_object)
DuckyBinary = Builder(action = __link_ducky_binary)
DuckyArchFromObjs = Builder(action = __archive_from_objs)


#
# Master Environment
#
# This is a template for all envs that come after it.
#
ENV = Environment(
  variables = VARS,

  # Our special builders for Ducky files
  BUILDERS = {
    'DuckyAsmFromC':   DuckyAsmFromC,
    'DuckyObjFromAsm': DuckyObjFromAsm,
    'DuckyObjFromC':   DuckyObjFromC,
    'DuckyObject': DuckyObject,
    'DuckyBinary': DuckyBinary,
    'DuckyArchFromObjs': DuckyArchFromObjs
  },

  # Initial, quite empty environment
  ENV = {
    'PATH': os.environ['PATH']
  },

  # Directory with Ducky-supplied header files
  HEADERSDIR = Dir('#libducky/include').abspath,
  INCLUDE = ['-I %s' % Dir('#libducky/include').abspath],

  # Predefined macros
  DEFS = '',

  # Initial CFLAGS
  CFLAGS = DEFAULT_CFLAGS,

  # Initial ASMFLAGS
  ASMFLAGS = DEFAULT_ASMFLAGS,

  # Top-level directory of this Ducky repository
  TOPDIR = Dir('#.').abspath,

  # Path do current virtual environment - if any, empty string otherwise
  VIRTUAL_ENV = os.environ.get('VIRTUAL_ENV', ''),

  # Python version running scons
  SCONS_PYTHON = sys.executable,
  SCONS_PYTHON_NAME = sys.version.replace('\n', ' '),
  SCONS_PYTHON_VERSION = sys.version_info,

  # Python version provided by virtualenv
  PYTHON = subprocess.check_output('type python', shell = True).split('\n')[0].split(' ')[2].strip(),
  PYTHON_NAME = subprocess.check_output('python -c "from __future__ import print_function; import sys; print(sys.version)"', shell = True).replace('\n', ' ').strip(),
  PYTHON_VERSION = eval(subprocess.check_output('python -c "from __future__ import print_function; import sys; print(list(sys.version_info))"', shell = True)),

  # Default linker script
  LINKER_SCRIPT = File('#raw.ld').abspath
)

# If LLVMDIR wasn't specified on command line, maybe it exists in environment
if 'LLVMDIR' not in ENV and 'LLVMDIR' in os.environ:
  ENV.Append(LLVMDIR = os.environ['LLVMDIR'])

if 'CFLAGS' in os.environ:
  ENV.Append(CFLAGS = [os.environ['CFLAGS']])

if 'ASMFLAGS' in os.environ:
  ENV.Append(ASMFLAGS = [os.eviron['ASMFLAGS']])

# Import all predefined macros from command-line options
for define in GetOption('defines'):
  ENV.Append(DEFS = ['-D' + define])

# Clone ENV to ENV, to add our methods
ENV = __clone_env(ENV)

# Default target - if user asks for nothing specific, show him help.
ENV.Default(ENV.Command('default', None, print_help))

if COMMAND_LINE_TARGETS:
  targets = COMMAND_LINE_TARGETS

else:
  targets = DEFAULT_TARGETS

if len(targets) != 1:
  ENV.ERROR('Please, specify 1 target only')
  ENV.Exit(1)

ENV.Append(BUILD_TARGET = str(targets[0]))

if ENV['BUILD_TARGET'].startswith('tests'):
  if GetOption('testset_dir') is None:
    ENV.ERROR('For running tests, it is necessary to set --testset-dir option correctly.')
    Exit(1)

  testset_dir = 'tests-%s' % GetOption('testset_dir')
  testset_id = str(GetOption('testset_id'))
  testset_dir = os.path.join(Dir('#' + testset_dir).abspath, testset_id)

  ENV = ENV.FullClone(
    RAW_TESTSETDIR = GetOption('testset_dir'),
    TESTSETDIR  = testset_dir,
    TESTSETID   = testset_id,

    LOGDIR      = os.path.join(testset_dir, 'log'),
    RESULTSDIR  = os.path.join(testset_dir, 'results'),
    TMPDIR      = os.path.join(testset_dir, 'tmp'),
    CONFIGDIR   = os.path.join(testset_dir, 'config'),
    REPORTDIR   = os.path.join(testset_dir, 'report'),
    SNAPSHOTDIR = os.path.join(testset_dir, 'snapshot'),
    EXAMPLESDIR = Dir('examples').abspath,
    LOADERDIR   = Dir('boot').abspath
  )

  if GetOption('coverage') is True:
    ENV.Append(COVERAGEDIR = os.path.join(testset_dir, 'coverage'))

  if GetOption('profiling') is True:
    ENV.Append(PROFILEDIR  = os.path.join(testset_dir, 'profile'))

  ENV['ENV']['TESTSETDIR'] = ENV['TESTSETDIR']
  ENV['ENV']['TMPDIR']     = ENV['TMPDIR']

  print_info(None, None, ENV)

else:
  if GetOption('coverage') is True:
    ENV.Append(COVERAGEDIR = Dir('coverage').abspath)
    ENV.Command(ENV['COVERAGEDIR'], None, Mkdir(ENV['COVERAGEDIR']))

  if GetOption('profiling') is True:
    ENV.Append(PROFILEDIR  = Dir('profile').abspath)
    ENV.Command(ENV['PROFILEDIR'], None, Mkdir(ENV['PROFILEDIR']))


Export('ENV', 'GREEN', 'RED', 'DuckyCommand')

ENV.Help("""
  ${GREEN}Available targets:${CLR}
""")

# Generic info and usefull stuff
ENV.Command('info', None, print_info)
ENV.Help("""     ${BLUE}'scons info'${CLR} to gather information about environment,\n""")

# FORTH
SConscript(os.path.join('forth', 'SConscript'))

# Boot loaders
SConscript(os.path.join('boot', 'SConscript'))

# Ducky library
SConscript(os.path.join('libducky', 'SConscript'))

# Examples
SConscript(os.path.join('examples', 'SConscript'))

# Tests
SConscript(os.path.join('tests', 'SConscript'))

# Utilities
ENV.Alias('flake', ENV.Command('.flake', None, run_flake))
ENV.Alias('pylint', ENV.Command('.pylint', None, run_pylint))
ENV.Alias('cloc', ENV.Command('.cloc', None, run_cloc))

# Install
ENV.Alias('install', ENV.Command('.install', None, run_install))
ENV.Alias('local-install', ENV.Command('.local-install', None, run_local_install))
ENV.Alias('publish', ENV.Command('.publish', None, run_publish))

# Documentation
ENV.Command('docs/introduction.rst', 'README.rst', 'cp README.rst docs/introduction.rst')
ENV.Command('.docs-generate', 'docs/introduction.rst', 'sphinx-apidoc -T -e -o docs/ ducky/')
ENV.AlwaysBuild('.docs-generate')
ENV.Command('.docs-html', '.docs-generate', 'make -C docs/ html')
ENV.AlwaysBuild('.docs-html')
ENV.Alias('docs', '.docs-html')

# And finalize help
ENV.Help("""
  ${GREEN}Utilities:${CLR}
     ${BLUE}'scons flake'${CLR} to run flake8 utility, and check for violations of Python
         style conventions,
     ${BLUE}'scons pylint'${CLR} to run pylint utility, and chack for even more violations
         of Python conventions, and possible errors,
     ${BLUE}'scons cloc'${CLR} to run cloc utility, and count lines of code,
     ${BLUE}'scons docs'${CLR} to generate documentation,

  or ${BLUE}'scons -h'${CLR} to see this help.

  ${GREEN}Available options:${CLR}

    --define=NAME[=VALUE]       Define macro for C/assembly.
    --no-color                  Do not colorize output.
    --testset=NAME              Store test results in this test set.
    --with-coverage             Run tests with coverage enabled.
    --with-profiling            Run tests with profiling enabled.
    --with-jit                  Run with JIT enabled.
    --with-mmap                 Run using mmap as binary loading method.
    --pass-testsuite-output     If set, output of testsuites will be passed
                                    directly to stdout/stderr.
    --hypothesis-profile        Set Hypothesis profile to PROFILE ("Default" by default)
    --clean-testsets            Remove testset dirs when building "clean" target.

  ${GREEN}Available variables:${CLR}
""")

ENV.Help(VARS.GenerateHelpText(ENV))

atexit.register(display_build_status)