from peak.util.assembler import *
from codegen import *
from criteria import *
from predicates import *
from core import *
from token import NAME
from ast_builder import build

__all__ = ['Bind', 'match_predicate', 'match_sequence']

nodetype()
def Bind(name, code=None):
    if code is None:
        return name,
    raise TypeError("Can't compile Bind expression")

def match_predicate(pattern, expr, binds):
    """Return predicate matching pattern to expr, updating binds w/bindings"""
    return Test(Comparison(expr), Inequality('==', pattern))

when(match_predicate, (type(None),))
def match_none(pattern, expr, binds):
    return Test(Identity(expr), IsObject(pattern))

when(match_predicate, (Bind,))
def match_bind(pattern, expr, binds):
    if pattern.name != '_':
        vals = binds.setdefault(pattern.name, [])
        if expr not in vals:
            vals.append(expr)
            for old in vals[-2:-1]:
                return Test(Truth(Compare(expr, (('==', old),))), True)
    return True

class SyntaxBuilder(ExprBuilder):
    def Backquote(self, expr):
        while len(expr)==2: expr, expr = expr
        if expr[0]==NAME:
            return Bind(expr[1])
        raise SyntaxError("backquotes may only be used around an indentifier")

def match(expr, pattern):
    """Match `expr` against inline pattern `pattern`

    This function can only be called inside a rule string; the second argument
    is treated as a syntactic match pattern, which can include backquoted
    locals to be used as bind patterns."""
    raise NotImplementedError(
        "Use match_predicate() to match compiled patterns outside a rule"
    )

def build_pattern(builder, node):
    old = builder.__class__
    builder.__class__ = SyntaxBuilder
    try:
        return build(builder, node)
    finally:
        builder.__class__ = old

meta_function(match, pattern=build_pattern)
def compile_match(__builder__, expr, pattern):
    binds = {}
    pred = match_predicate(pattern, expr, binds)
    __builder__.bind(dict([(k, list(v)[0]) for k, v in binds.items()]))
    return pred

















when(match_predicate, (istype(list),))
when(match_predicate, (istype(tuple),))
def match_sequence(pattern, expr, binds):
   pred = Test(Comparison(Call(Const(len), (expr,))), Value(len(pattern)))
   for pos, item in enumerate(pattern):
       pred = intersect(
           pred, match_predicate(item, Getitem(expr, Const(pos)), binds)
       )
   return pred

when(match_predicate, (Node,))
def match_node(pattern, expr, binds):
   pred = Test(IsInstance(expr), istype(type(pattern)))
   for pos, item in enumerate(pattern):
       if pos:
           pred = intersect(
               pred, match_predicate(item, Getitem(expr, Const(pos)), binds)
           )
   return pred






















