def p_pattern_sequence(t):
"""
pattern : LPAREN pattern-sequence RPAREN
| LPAREN RPAREN
"""
if len(t) == 3:
t[0] = pat.PatSequence([])
else:
t[0] = pat.PatSequence(t[2])
def transformPatSequence(self, node):
assert isinstance(node, pattern.PatSequence)
variables = {}
seq = []
for pat in node.seq:
npat, npatvariables = self.transform(pat)
seq.append(npat)
variables = self._merge_variable_maps(variables, npatvariables)
return pattern.PatSequence(seq).copyattributesfrom(node), variables
def p_tl_pat(t):
"""
tl-pat : IDENT
| LPAREN tl-pat-ele RPAREN
"""
if len(t) == 2:
t[0] = pat.Nt(t[1], t[1])
else:
t[0] = pat.PatSequence(t[2])
def transformPatSequence(self, node):
assert isinstance(node, pattern.PatSequence)
if len(node.seq) == 0:
return node, {}
nseq = []
npat, syms = self.transform(node.seq[0])
nseq.append(npat)
for pat in node.seq[1:]:
npat, nsyms = self.transform(pat)
nseq.append(npat)
syms, syms2check = self._merge_variable_maps(syms, nsyms)
for sym1, sym2 in syms2check:
nseq.append(pattern.CheckConstraint(sym1, sym2))
return pattern.PatSequence(nseq).copyattributesfrom(node), syms
def transformPatSequence(self, sequence):
assert isinstance(sequence, pattern.PatSequence)
closures = self.closures
# recursively transform patterns first.
tseq = []
for pat in sequence.seq:
tseq.append(self.transform(pat))
nseq = []
partitions = self._partitionseq(tseq)
for contains_ellipsis, partition in partitions:
if contains_ellipsis:
for i in range(len(partition) - 1):
pat1, pat2 = partition[i], partition[i + 1]
if isinstance(pat1, pattern.Repeat):
psc = self.PatternStructuralChecker(closures)
if isinstance(pat2, pattern.Repeat):
p1, p2 = pat1.pat, pat2.pat
else:
p1, p2 = pat1.pat, pat2
if psc.aredifferent(p1, p2):
nrep = pattern.Repeat(
p1, pattern.RepeatMatchMode.Deterministic
).copymetadatafrom(pat1)
nseq.append(nrep)
else:
nseq.append(pat1)
# append the last unprocessed element
last = partition[-1]
if isinstance(last, pattern.Repeat):
if not isinstance(last.pat, pattern.InHole):
last = pattern.Repeat(
last.pat, pattern.RepeatMatchMode.Deterministic
).copymetadatafrom(last)
nseq.append(last)
else:
nseq += partition
return pattern.PatSequence(nseq).copymetadatafrom(sequence)
def __init__(self, name, domain, codomain):
self.name = name
self.domain = pattern.PatSequence(
[pattern.Lit(name, pattern.LitKind.Variable)] +
domain) # we will turn contract into pattern.
self.codomain = codomain
def __init__(self, name, patternsequence, termtemplate):
self.name = name
self.patternsequence = pattern.PatSequence(
[pattern.Lit(name, pattern.LitKind.Variable)] +
patternsequence)
self.termtemplate = termtemplate