#! /usr/bin/env python
# encoding: utf-8
# WARNING! Do not edit! https://waf.io/book/index.html#_obtaining_the_waf_file

import os, re, sys, tempfile, traceback
from waflib import Utils, Logs, Errors

NOT_RUN = 0
MISSING = 1
CRASHED = 2
EXCEPTION = 3
CANCELED = 4
SKIPPED = 8
SUCCESS = 9
ASK_LATER = -1
SKIP_ME = -2
RUN_ME = -3
CANCEL_ME = -4
COMPILE_TEMPLATE_SHELL = '''
def f(tsk):
	env = tsk.env
	gen = tsk.generator
	bld = gen.bld
	cwdx = tsk.get_cwd()
	p = env.get_flat
	def to_list(xx):
		if isinstance(xx, str): return [xx]
		return xx
	tsk.last_cmd = cmd = \'\'\' %s \'\'\' % s
	return tsk.exec_command(cmd, cwd=cwdx, env=env.env or None)
'''
COMPILE_TEMPLATE_NOSHELL = '''
def f(tsk):
	env = tsk.env
	gen = tsk.generator
	bld = gen.bld
	cwdx = tsk.get_cwd()
	def to_list(xx):
		if isinstance(xx, str): return [xx]
		return xx
	def merge(lst1, lst2):
		if lst1 and lst2:
			return lst1[:-1] + [lst1[-1] + lst2[0]] + lst2[1:]
		return lst1 + lst2
	lst = []
	%s
	if '' in lst:
		lst = [x for x in lst if x]
	tsk.last_cmd = lst
	return tsk.exec_command(lst, cwd=cwdx, env=env.env or None)
'''
COMPILE_TEMPLATE_SIG_VARS = '''
def f(tsk):
	sig = tsk.generator.bld.hash_env_vars(tsk.env, tsk.vars)
	tsk.m.update(sig)
	env = tsk.env
	gen = tsk.generator
	bld = gen.bld
	cwdx = tsk.get_cwd()
	p = env.get_flat
	buf = []
	%s
	tsk.m.update(repr(buf).encode())
'''
classes = {}


class store_task_type(type):
    def __init__(cls, name, bases, dict):
        super(store_task_type, cls).__init__(name, bases, dict)
        name = cls.__name__
        if name != 'evil' and name != 'Task':
            if getattr(cls, 'run_str', None):
                (f, dvars) = compile_fun(cls.run_str, cls.shell)
                cls.hcode = Utils.h_cmd(cls.run_str)
                cls.orig_run_str = cls.run_str
                cls.run_str = None
                cls.run = f
                cls.vars = list(set(cls.vars + dvars))
                cls.vars.sort()
                if cls.vars:
                    fun = compile_sig_vars(cls.vars)
                    if fun:
                        cls.sig_vars = fun
            elif getattr(cls, 'run', None) and not 'hcode' in cls.__dict__:
                cls.hcode = Utils.h_cmd(cls.run)
            getattr(cls, 'register', classes)[name] = cls


evil = store_task_type('evil', (object,), {})


class Task(evil):
    vars = []
    always_run = False
    shell = False
    color = 'GREEN'
    ext_in = []
    ext_out = []
    before = []
    after = []
    hcode = Utils.SIG_NIL
    keep_last_cmd = False
    weight = 0
    tree_weight = 0
    prio_order = 0
    __slots__ = ('hasrun', 'generator', 'env', 'inputs', 'outputs', 'dep_nodes', 'run_after')

    def __init__(self, *k, **kw):
        self.hasrun = NOT_RUN
        try:
            self.generator = kw['generator']
        except KeyError:
            self.generator = self
        self.env = kw['env']
        self.inputs = []
        self.outputs = []
        self.dep_nodes = []
        self.run_after = set()

    def __lt__(self, other):
        return self.priority() > other.priority()

    def __le__(self, other):
        return self.priority() >= other.priority()

    def __gt__(self, other):
        return self.priority() < other.priority()

    def __ge__(self, other):
        return self.priority() <= other.priority()

    def get_cwd(self):
        bld = self.generator.bld
        ret = getattr(self, 'cwd', None) or getattr(bld, 'cwd', bld.bldnode)
        if isinstance(ret, str):
            if os.path.isabs(ret):
                ret = bld.root.make_node(ret)
            else:
                ret = self.generator.path.make_node(ret)
        return ret

    def quote_flag(self, x):
        old = x
        if '\\' in x:
            x = x.replace('\\', '\\\\')
        if '"' in x:
            x = x.replace('"', '\\"')
        if old != x or ' ' in x or '\t' in x or "'" in x:
            x = '"%s"' % x
        return x

    def priority(self):
        return (self.weight + self.prio_order, -getattr(self.generator, 'tg_idx_count', 0))

    def split_argfile(self, cmd):
        return ([cmd[0]], [self.quote_flag(x) for x in cmd[1:]])

    def exec_command(self, cmd, **kw):
        if not 'cwd' in kw:
            kw['cwd'] = self.get_cwd()
        if hasattr(self, 'timeout'):
            kw['timeout'] = self.timeout
        if self.env.PATH:
            env = kw['env'] = dict(kw.get('env') or self.env.env or os.environ)
            env['PATH'] = self.env.PATH if isinstance(self.env.PATH, str) else os.pathsep.join(self.env.PATH)
        if hasattr(self, 'stdout'):
            kw['stdout'] = self.stdout
        if hasattr(self, 'stderr'):
            kw['stderr'] = self.stderr
        if not isinstance(cmd, str):
            if Utils.is_win32:
                too_long = sum([len(arg) for arg in cmd]) + len(cmd) > 8192
            else:
                too_long = len(cmd) > 200000
            if too_long and getattr(self, 'allow_argsfile', True):
                cmd, args = self.split_argfile(cmd)
                try:
                    (fd, tmp) = tempfile.mkstemp()
                    os.write(fd, '\r\n'.join(args).encode())
                    os.close(fd)
                    if Logs.verbose:
                        Logs.debug('argfile: @%r -> %r', tmp, args)
                    return self.generator.bld.exec_command(cmd + ['@' + tmp], **kw)
                finally:
                    try:
                        os.remove(tmp)
                    except OSError:
                        pass
        return self.generator.bld.exec_command(cmd, **kw)

    def process(self):
        try:
            del self.generator.bld.task_sigs[self.uid()]
        except KeyError:
            pass
        try:
            ret = self.run()
        except Exception:
            self.err_msg = traceback.format_exc()
            self.hasrun = EXCEPTION
        else:
            if ret:
                self.err_code = ret
                self.hasrun = CRASHED
            else:
                try:
                    self.post_run()
                except Errors.WafError:
                    pass
                except Exception:
                    self.err_msg = traceback.format_exc()
                    self.hasrun = EXCEPTION
                else:
                    self.hasrun = SUCCESS
        if self.hasrun != SUCCESS and self.scan:
            try:
                del self.generator.bld.imp_sigs[self.uid()]
            except KeyError:
                pass

    def log_display(self, bld):
        if self.generator.bld.progress_bar == 3:
            return
        s = self.display()
        if s:
            if bld.logger:
                logger = bld.logger
            else:
                logger = Logs
            if self.generator.bld.progress_bar == 1:
                c1 = Logs.colors.cursor_off
                c2 = Logs.colors.cursor_on
                logger.info(s, extra={'stream': sys.stderr, 'terminator': '', 'c1': c1, 'c2': c2})
            else:
                logger.info(s, extra={'terminator': '', 'c1': '', 'c2': ''})

    def display(self):
        col1 = Logs.colors(self.color)
        col2 = Logs.colors.NORMAL
        master = self.generator.bld.producer

        def cur():
            return master.processed - master.ready.qsize()

        if self.generator.bld.progress_bar == 1:
            return self.generator.bld.progress_line(cur(), master.total, col1, col2)
        if self.generator.bld.progress_bar == 2:
            ela = str(self.generator.bld.timer)
            try:
                ins = ','.join([n.name for n in self.inputs])
            except AttributeError:
                ins = ''
            try:
                outs = ','.join([n.name for n in self.outputs])
            except AttributeError:
                outs = ''
            return '|Total %s|Current %s|Inputs %s|Outputs %s|Time %s|\n' % (master.total, cur(), ins, outs, ela)
        s = str(self)
        if not s:
            return None
        total = master.total
        n = len(str(total))
        fs = '[%%%dd/%%%dd] %%s%%s%%s%%s\n' % (n, n)
        kw = self.keyword()
        if kw:
            kw += ' '
        return fs % (cur(), total, kw, col1, s, col2)

    def hash_constraints(self):
        return (
            tuple(self.before), tuple(self.after), tuple(self.ext_in), tuple(self.ext_out), self.__class__.__name__,
            self.hcode
        )

    def format_error(self):
        if Logs.verbose:
            msg = ': %r\n%r' % (self, getattr(self, 'last_cmd', ''))
        else:
            msg = ' (run with -v to display more information)'
        name = getattr(self.generator, 'name', '')
        if getattr(self, "err_msg", None):
            return self.err_msg
        elif not self.hasrun:
            return 'task in %r was not executed for some reason: %r' % (name, self)
        elif self.hasrun == CRASHED:
            try:
                return ' -> task in %r failed with exit status %r%s' % (name, self.err_code, msg)
            except AttributeError:
                return ' -> task in %r failed%s' % (name, msg)
        elif self.hasrun == MISSING:
            return ' -> missing files in %r%s' % (name, msg)
        elif self.hasrun == CANCELED:
            return ' -> %r canceled because of missing dependencies' % name
        else:
            return 'invalid status for task in %r: %r' % (name, self.hasrun)

    def colon(self, var1, var2):
        tmp = self.env[var1]
        if not tmp:
            return []
        if isinstance(var2, str):
            it = self.env[var2]
        else:
            it = var2
        if isinstance(tmp, str):
            return [tmp % x for x in it]
        else:
            lst = []
            for y in it:
                lst.extend(tmp)
                lst.append(y)
            return lst

    def __str__(self):
        name = self.__class__.__name__
        if self.outputs:
            if name.endswith(('lib', 'program')) or not self.inputs:
                node = self.outputs[0]
                return node.path_from(node.ctx.launch_node())
        if not (self.inputs or self.outputs):
            return self.__class__.__name__
        if len(self.inputs) == 1:
            node = self.inputs[0]
            return node.path_from(node.ctx.launch_node())
        src_str = ' '.join([a.path_from(a.ctx.launch_node()) for a in self.inputs])
        tgt_str = ' '.join([a.path_from(a.ctx.launch_node()) for a in self.outputs])
        if self.outputs:
            sep = ' -> '
        else:
            sep = ''
        return '%s: %s%s%s' % (self.__class__.__name__, src_str, sep, tgt_str)

    def keyword(self):
        name = self.__class__.__name__
        if name.endswith(('lib', 'program')):
            return 'Linking'
        if len(self.inputs) == 1 and len(self.outputs) == 1:
            return 'Compiling'
        if not self.inputs:
            if self.outputs:
                return 'Creating'
            else:
                return 'Running'
        return 'Processing'

    def __repr__(self):
        try:
            ins = ",".join([x.name for x in self.inputs])
            outs = ",".join([x.name for x in self.outputs])
        except AttributeError:
            ins = ",".join([str(x) for x in self.inputs])
            outs = ",".join([str(x) for x in self.outputs])
        return "".join(['\n\t{task %r: ' % id(self), self.__class__.__name__, " ", ins, " -> ", outs, '}'])

    def uid(self):
        try:
            return self.uid_
        except AttributeError:
            m = Utils.md5(self.__class__.__name__)
            up = m.update
            for x in self.inputs + self.outputs:
                up(x.abspath())
            self.uid_ = m.digest()
            return self.uid_

    def set_inputs(self, inp):
        if isinstance(inp, list):
            self.inputs += inp
        else:
            self.inputs.append(inp)

    def set_outputs(self, out):
        if isinstance(out, list):
            self.outputs += out
        else:
            self.outputs.append(out)

    def set_run_after(self, task):
        assert isinstance(task, Task)
        self.run_after.add(task)

    def signature(self):
        try:
            return self.cache_sig
        except AttributeError:
            pass
        self.m = Utils.md5(self.hcode)
        self.sig_explicit_deps()
        self.sig_vars()
        if self.scan:
            try:
                self.sig_implicit_deps()
            except Errors.TaskRescan:
                return self.signature()
        ret = self.cache_sig = self.m.digest()
        return ret

    def runnable_status(self):
        bld = self.generator.bld
        if bld.is_install < 0:
            return SKIP_ME
        for t in self.run_after:
            if not t.hasrun:
                return ASK_LATER
            elif t.hasrun < SKIPPED:
                return CANCEL_ME
        try:
            new_sig = self.signature()
        except Errors.TaskNotReady:
            return ASK_LATER
        key = self.uid()
        try:
            prev_sig = bld.task_sigs[key]
        except KeyError:
            Logs.debug('task: task %r must run: it was never run before or the task code changed', self)
            return RUN_ME
        if new_sig != prev_sig:
            Logs.debug('task: task %r must run: the task signature changed', self)
            return RUN_ME
        for node in self.outputs:
            sig = bld.node_sigs.get(node)
            if not sig:
                Logs.debug('task: task %r must run: an output node has no signature', self)
                return RUN_ME
            if sig != key:
                Logs.debug('task: task %r must run: an output node was produced by another task', self)
                return RUN_ME
            if not node.exists():
                Logs.debug('task: task %r must run: an output node does not exist', self)
                return RUN_ME
        return (self.always_run and RUN_ME) or SKIP_ME

    def post_run(self):
        bld = self.generator.bld
        for node in self.outputs:
            if not node.exists():
                self.hasrun = MISSING
                self.err_msg = '-> missing file: %r' % node.abspath()
                raise Errors.WafError(self.err_msg)
            bld.node_sigs[node] = self.uid()
        bld.task_sigs[self.uid()] = self.signature()
        if not self.keep_last_cmd:
            try:
                del self.last_cmd
            except AttributeError:
                pass

    def sig_explicit_deps(self):
        bld = self.generator.bld
        upd = self.m.update
        for x in self.inputs + self.dep_nodes:
            upd(x.get_bld_sig())
        if bld.deps_man:
            additional_deps = bld.deps_man
            for x in self.inputs + self.outputs:
                try:
                    d = additional_deps[x]
                except KeyError:
                    continue
                for v in d:
                    try:
                        v = v.get_bld_sig()
                    except AttributeError:
                        if hasattr(v, '__call__'):
                            v = v()
                    upd(v)

    def sig_deep_inputs(self):
        bld = self.generator.bld
        lst = [bld.task_sigs[bld.node_sigs[node]] for node in (self.inputs + self.dep_nodes) if node.is_bld()]
        self.m.update(Utils.h_list(lst))

    def sig_vars(self):
        sig = self.generator.bld.hash_env_vars(self.env, self.vars)
        self.m.update(sig)

    scan = None

    def sig_implicit_deps(self):
        bld = self.generator.bld
        key = self.uid()
        prev = bld.imp_sigs.get(key, [])
        if prev:
            try:
                if prev == self.compute_sig_implicit_deps():
                    return prev
            except Errors.TaskNotReady:
                raise
            except EnvironmentError:
                for x in bld.node_deps.get(self.uid(), []):
                    if not x.is_bld() and not x.exists():
                        try:
                            del x.parent.children[x.name]
                        except KeyError:
                            pass
            del bld.imp_sigs[key]
            raise Errors.TaskRescan('rescan')
        (bld.node_deps[key], bld.raw_deps[key]) = self.scan()
        if Logs.verbose:
            Logs.debug('deps: scanner for %s: %r; unresolved: %r', self, bld.node_deps[key], bld.raw_deps[key])
        try:
            bld.imp_sigs[key] = self.compute_sig_implicit_deps()
        except EnvironmentError:
            for k in bld.node_deps.get(self.uid(), []):
                if not k.exists():
                    Logs.warn(
                        'Dependency %r for %r is missing: check the task declaration and the build order!', k, self
                    )
            raise

    def compute_sig_implicit_deps(self):
        upd = self.m.update
        self.are_implicit_nodes_ready()
        for k in self.generator.bld.node_deps.get(self.uid(), []):
            upd(k.get_bld_sig())
        return self.m.digest()

    def are_implicit_nodes_ready(self):
        bld = self.generator.bld
        try:
            cache = bld.dct_implicit_nodes
        except AttributeError:
            bld.dct_implicit_nodes = cache = {}
        try:
            dct = cache[bld.current_group]
        except KeyError:
            dct = cache[bld.current_group] = {}
            for tsk in bld.cur_tasks:
                for x in tsk.outputs:
                    dct[x] = tsk
        modified = False
        for x in bld.node_deps.get(self.uid(), []):
            if x in dct:
                self.run_after.add(dct[x])
                modified = True
        if modified:
            for tsk in self.run_after:
                if not tsk.hasrun:
                    raise Errors.TaskNotReady('not ready')


if sys.hexversion > 0x3000000:

    def uid(self):
        try:
            return self.uid_
        except AttributeError:
            m = Utils.md5(self.__class__.__name__.encode('latin-1', 'xmlcharrefreplace'))
            up = m.update
            for x in self.inputs + self.outputs:
                up(x.abspath().encode('latin-1', 'xmlcharrefreplace'))
            self.uid_ = m.digest()
            return self.uid_

    uid.__doc__ = Task.uid.__doc__
    Task.uid = uid


def is_before(t1, t2):
    to_list = Utils.to_list
    for k in to_list(t2.ext_in):
        if k in to_list(t1.ext_out):
            return 1
    if t1.__class__.__name__ in to_list(t2.after):
        return 1
    if t2.__class__.__name__ in to_list(t1.before):
        return 1
    return 0


def set_file_constraints(tasks):
    ins = Utils.defaultdict(set)
    outs = Utils.defaultdict(set)
    for x in tasks:
        for a in x.inputs:
            ins[a].add(x)
        for a in x.dep_nodes:
            ins[a].add(x)
        for a in x.outputs:
            outs[a].add(x)
    links = set(ins.keys()).intersection(outs.keys())
    for k in links:
        for a in ins[k]:
            a.run_after.update(outs[k])


class TaskGroup(object):
    def __init__(self, prev, next):
        self.prev = prev
        self.next = next
        self.done = False

    def get_hasrun(self):
        for k in self.prev:
            if not k.hasrun:
                return NOT_RUN
        return SUCCESS

    hasrun = property(get_hasrun, None)


def set_precedence_constraints(tasks):
    cstr_groups = Utils.defaultdict(list)
    for x in tasks:
        h = x.hash_constraints()
        cstr_groups[h].append(x)
    keys = list(cstr_groups.keys())
    maxi = len(keys)
    for i in range(maxi):
        t1 = cstr_groups[keys[i]][0]
        for j in range(i + 1, maxi):
            t2 = cstr_groups[keys[j]][0]
            if is_before(t1, t2):
                a = i
                b = j
            elif is_before(t2, t1):
                a = j
                b = i
            else:
                continue
            a = cstr_groups[keys[a]]
            b = cstr_groups[keys[b]]
            if len(a) < 2 or len(b) < 2:
                for x in b:
                    x.run_after.update(a)
            else:
                group = TaskGroup(set(a), set(b))
                for x in b:
                    x.run_after.add(group)


def funex(c):
    dc = {}
    exec(c, dc)
    return dc['f']


re_cond = re.compile(r'(?P<var>\w+)|(?P<or>\|)|(?P<and>&)')
re_novar = re.compile(r'^(SRC|TGT)\W+.*?$')
reg_act = re.compile(r'(?P<backslash>\\)|(?P<dollar>\$\$)|(?P<subst>\$\{(?P<var>\w+)(?P<code>.*?)\})', re.M)


def compile_fun_shell(line):
    extr = []

    def repl(match):
        g = match.group
        if g('dollar'):
            return "$"
        elif g('backslash'):
            return '\\\\'
        elif g('subst'):
            extr.append((g('var'), g('code')))
            return "%s"
        return None

    line = reg_act.sub(repl, line) or line
    dvars = []

    def add_dvar(x):
        if x not in dvars:
            dvars.append(x)

    def replc(m):
        if m.group('and'):
            return ' and '
        elif m.group('or'):
            return ' or '
        else:
            x = m.group('var')
            add_dvar(x)
            return 'env[%r]' % x

    parm = []
    app = parm.append
    for (var, meth) in extr:
        if var == 'SRC':
            if meth:
                app('tsk.inputs%s' % meth)
            else:
                app('" ".join([a.path_from(cwdx) for a in tsk.inputs])')
        elif var == 'TGT':
            if meth:
                app('tsk.outputs%s' % meth)
            else:
                app('" ".join([a.path_from(cwdx) for a in tsk.outputs])')
        elif meth:
            if meth.startswith(':'):
                add_dvar(var)
                m = meth[1:]
                if m == 'SRC':
                    m = '[a.path_from(cwdx) for a in tsk.inputs]'
                elif m == 'TGT':
                    m = '[a.path_from(cwdx) for a in tsk.outputs]'
                elif re_novar.match(m):
                    m = '[tsk.inputs%s]' % m[3:]
                elif re_novar.match(m):
                    m = '[tsk.outputs%s]' % m[3:]
                else:
                    add_dvar(m)
                    if m[:3] not in ('tsk', 'gen', 'bld'):
                        m = '%r' % m
                app('" ".join(tsk.colon(%r, %s))' % (var, m))
            elif meth.startswith('?'):
                expr = re_cond.sub(replc, meth[1:])
                app('p(%r) if (%s) else ""' % (var, expr))
            else:
                call = '%s%s' % (var, meth)
                add_dvar(call)
                app(call)
        else:
            add_dvar(var)
            app("p('%s')" % var)
    if parm:
        parm = "%% (%s) " % (',\n\t\t'.join(parm))
    else:
        parm = ''
    c = COMPILE_TEMPLATE_SHELL % (line, parm)
    Logs.debug('action: %s', c.strip().splitlines())
    return (funex(c), dvars)


reg_act_noshell = re.compile(
    r"(?P<space>\s+)|(?P<subst>\$\{(?P<var>\w+)(?P<code>.*?)\})|(?P<text>([^$ \t\n\r\f\v]|\$\$)+)", re.M
)


def compile_fun_noshell(line):
    buf = []
    dvars = []
    merge = False
    app = buf.append

    def add_dvar(x):
        if x not in dvars:
            dvars.append(x)

    def replc(m):
        if m.group('and'):
            return ' and '
        elif m.group('or'):
            return ' or '
        else:
            x = m.group('var')
            add_dvar(x)
            return 'env[%r]' % x

    for m in reg_act_noshell.finditer(line):
        if m.group('space'):
            merge = False
            continue
        elif m.group('text'):
            app('[%r]' % m.group('text').replace('$$', '$'))
        elif m.group('subst'):
            var = m.group('var')
            code = m.group('code')
            if var == 'SRC':
                if code:
                    app('[tsk.inputs%s]' % code)
                else:
                    app('[a.path_from(cwdx) for a in tsk.inputs]')
            elif var == 'TGT':
                if code:
                    app('[tsk.outputs%s]' % code)
                else:
                    app('[a.path_from(cwdx) for a in tsk.outputs]')
            elif code:
                if code.startswith(':'):
                    add_dvar(var)
                    m = code[1:]
                    if m == 'SRC':
                        m = '[a.path_from(cwdx) for a in tsk.inputs]'
                    elif m == 'TGT':
                        m = '[a.path_from(cwdx) for a in tsk.outputs]'
                    elif re_novar.match(m):
                        m = '[tsk.inputs%s]' % m[3:]
                    elif re_novar.match(m):
                        m = '[tsk.outputs%s]' % m[3:]
                    else:
                        add_dvar(m)
                        if m[:3] not in ('tsk', 'gen', 'bld'):
                            m = '%r' % m
                    app('tsk.colon(%r, %s)' % (var, m))
                elif code.startswith('?'):
                    expr = re_cond.sub(replc, code[1:])
                    app('to_list(env[%r] if (%s) else [])' % (var, expr))
                else:
                    call = '%s%s' % (var, code)
                    add_dvar(call)
                    app('to_list(%s)' % call)
            else:
                app('to_list(env[%r])' % var)
                add_dvar(var)
        if merge:
            tmp = 'merge(%s, %s)' % (buf[-2], buf[-1])
            del buf[-1]
            buf[-1] = tmp
        merge = True
    buf = ['lst.extend(%s)' % x for x in buf]
    fun = COMPILE_TEMPLATE_NOSHELL % "\n\t".join(buf)
    Logs.debug('action: %s', fun.strip().splitlines())
    return (funex(fun), dvars)


def compile_fun(line, shell=False):
    if isinstance(line, str):
        if line.find('<') > 0 or line.find('>') > 0 or line.find('&&') > 0:
            shell = True
    else:
        dvars_lst = []
        funs_lst = []
        for x in line:
            if isinstance(x, str):
                fun, dvars = compile_fun(x, shell)
                dvars_lst += dvars
                funs_lst.append(fun)
            else:
                funs_lst.append(x)

        def composed_fun(task):
            for x in funs_lst:
                ret = x(task)
                if ret:
                    return ret
            return None

        return composed_fun, dvars_lst
    if shell:
        return compile_fun_shell(line)
    else:
        return compile_fun_noshell(line)


def compile_sig_vars(vars):
    buf = []
    for x in sorted(vars):
        if x[:3] in ('tsk', 'gen', 'bld'):
            buf.append('buf.append(%s)' % x)
    if buf:
        return funex(COMPILE_TEMPLATE_SIG_VARS % '\n\t'.join(buf))
    return None


def task_factory(
    name, func=None, vars=None, color='GREEN', ext_in=[], ext_out=[], before=[], after=[], shell=False, scan=None
):
    params = {
        'vars': vars or [],
        'color': color,
        'name': name,
        'shell': shell,
        'scan': scan,
    }
    if isinstance(func, str) or isinstance(func, tuple):
        params['run_str'] = func
    else:
        params['run'] = func
    cls = type(Task)(name, (Task,), params)
    classes[name] = cls
    if ext_in:
        cls.ext_in = Utils.to_list(ext_in)
    if ext_out:
        cls.ext_out = Utils.to_list(ext_out)
    if before:
        cls.before = Utils.to_list(before)
    if after:
        cls.after = Utils.to_list(after)
    return cls


def deep_inputs(cls):
    def sig_explicit_deps(self):
        Task.sig_explicit_deps(self)
        Task.sig_deep_inputs(self)

    cls.sig_explicit_deps = sig_explicit_deps
    return cls


TaskBase = Task


class TaskSemaphore(object):
    def __init__(self, num):
        self.num = num
        self.locking = set()
        self.waiting = set()

    def is_locked(self):
        return len(self.locking) >= self.num

    def acquire(self, tsk):
        if self.is_locked():
            raise IndexError('Cannot lock more %r' % self.locking)
        self.locking.add(tsk)

    def release(self, tsk):
        self.locking.remove(tsk)