def CollectAll(operand, Union=None, reduce=None): '''Collect all subterms for which operand succeeds. collect all subterms with user-defined union operator and a skip argument. @param Union: transformation factory which takes two lists and produces a single one and produce a single one. If duplicates must be removed, then this argument should be union, otherwise it defaults to concat. @param reduce: it can be used to reduce the current term before collecting subterms of it. Producing the empty list will result in a complete skip of all subterms. ''' if Union is None: from transf.lib.lists import Concat as Union collect = util.Proxy() crush = Crush(build.nil, Union, collect) if reduce is not None: crush = +reduce * crush collect.subject = build.Cons(operand, crush) + crush #else: #collect.subject = build.Cons(operand, crush) + reduce * collect + crush #collect.subject = build.Cons(operand, crush) + +reduce * crush return collect
def SplitAllAfter(operand, ): splitall = util.Proxy() splitall.subject = (combine.GuardedChoice( SplitAfter(operand), congruent.Cons(base.ident, project.head * splitall), build.List((base.ident, )))) return splitall
def AllTD(operand): '''Apply a transformation to all subterms, but stops recursing as soon as it finds a subterm to which the transformation succeeds. ''' alltd = util.Proxy() alltd.subject = combine.Choice(operand, All(alltd)) return alltd
def Rec(Def): '''Recursive transformation. @param Def: transformation factory whose single argument is its own definition. ''' rec = util.Proxy() rec.subject = Def(rec) return rec
def Foldr(tail, Cons, operand=None): if operand is None: operand = base.ident foldr = util.Proxy() foldr.subject = combine.GuardedChoice( match.nil, tail, Cons(combine.Composition(project.head, operand), combine.Composition(project.tail, foldr))) return foldr
def One(operand): '''Applies a transformation to exactly one direct subterm of a term.''' one = util.Proxy() one.subject = congruent.Subterms( # FIXME: write a non-recursive implementation combine.Choice(congruent.Cons(operand, base.ident), congruent.Cons(base.ident, one)), base.fail) return one
def DownUp(down=None, up=None, stop=None): downup = util.Proxy() downup.subject = All(downup) if stop is not None: downup.subject = combine.Choice(stop, downup.subject) if up is not None: downup.subject = combine.Composition(downup.subject, up) if down is not None: downup.subject = combine.Composition(down, downup.subject) return downup
def Some(operand): '''Applies a transformation to as many direct subterms of a term, but at list one.''' some = util.Proxy() some.subject = congruent.Subterms( # FIXME: write a non-recursive implementation combine.Choice( congruent.Cons(operand, lists.Map(combine.Try(operand))), congruent.Cons(base.ident, some), ), base.fail) return some
def Traverse(Subterms, down=None, up=None, stop=None, Enter=None, Leave=None): '''Generic traversal.''' traverse = util.Proxy() traverse.subject = Subterms(traverse) if Leave is not None: traverse.subject = Leave(traverse.subject) if stop is not None: traverse.subject = combine.Choice(stop, traverse.subject) if up is not None: traverse.subject = combine.Composition(traverse.subject, up) if down is not None: traverse.subject = combine.Composition(down, traverse.subject) if Enter is not None: traverse.subject = Enter(traverse.subject) return traverse
def OneStmt(pre, post=trf.base.ident): stmt = util.Proxy() stmts = trf.lists.One(stmt) stmt.subject = pre**post**Stmt(stmt, stmts, trf.base.fail) return stmt
def AllStmts(**kargs): stmt = util.Proxy() stmts = trf.lists.Map(stmt) stmt.subject = Stmt(stmt, stmts, trf.base.ident, **kargs) return stmt
def CountAll(operand): '''Count the number of occorrences in all subterms.''' count = util.Proxy() count.subject = arith.AddInt(_CountOne(operand), Crush(build.zero, arith.AddInt, count))
def AtSuffixR(operand): atsuffix = util.Proxy() atsuffix.subject = combine.Choice(congruent.Cons(base.ident, atsuffix), operand) return atsuffix
def AllBU(operand): allbu = util.Proxy() allbu.subject = combine.Choice(All(allbu), operand) return allbu
def InnerMost(operand): innermost = util.Proxy() innermost.subject = BottomUp( combine.Try(combine.Composition(operand, innermost))) return innermost