def p_pattern_literal_string(p):
'pattern : STRING'
escaped = p[1].replace('"', '\\"')
p[0] = pat.Lit(escaped, pat.LitKind.String)
def p_pattern_literal_boolean(p):
'pattern : BOOLEAN'
p[0] = pat.Lit(normalizeboolean(p[1]), pat.LitKind.Boolean)
def p_pattern_literal_int(t):
'pattern : INTEGER'
t[0] = pat.Lit(t[1], pat.LitKind.Integer)
def p_pattern_literal_decimal(t):
'pattern : FLOAT'
t[0] = pat.Lit(t[1], pat.LitKind.Float)
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
try:
case = pattern.BuiltInPatKind(prefix).name
return pattern.BuiltInPat(pattern.BuiltInPatKind[case], prefix,
node.sym).copyattributesfrom(node)
except ValueError:
pass
# not nt or builtin-pat, check if there's underscore
if prefix != node.sym:
raise Exception(
'define-language: before underscore must be either a non-terminal or build-in pattern {}'
.format(node.sym))
self.variables.add(node.sym) # for variable-not-defined patterns.
return pattern.Lit(node.sym,
pattern.LitKind.Variable).copyattributesfrom(node)
class Pattern_NtRewriter(NtResolver):
def __init__(self, pattern, ntsyms):
super().__init__(ntsyms)
self.pattern = pattern
def run(self):
return self.transform(self.pattern)
class DefineLanguage_NtRewriter(NtResolver):
def __init__(self, definelanguage, ntsyms):
super().__init__(ntsyms)
self.definelanguage = definelanguage