def definition(gen):
box = gen.parse(assign).get_list()
name = box[0].get_token().value
args = [a.get_ast() for a in box[1].get_list()]
body = gen.parse(chain).get_ast()
return ASTBox(Definition(sym(name), args, body))
def tag_pattern(gen):
tag = gen.parse(TAGGED).get_token().value
args = gen.parse(pattern.many()).get_list()
pats = [p.get_ast() for p in args]
return ASTBox(TagPat(sym(tag), pats))
expr_element = alt(chain, definition)
@generate
def expr(gen):
box = gen.parse(alt(definition, chain).many())
elements = [a.get_ast() for a in box.get_list()]
return ASTBox(Sequence(elements))
@generate('pattern')
def pattern(gen):
return gen.parse(alt(var_pattern, tag_pattern, named_pattern, paren_pattern))
paren_pattern = LPAREN.then(pattern).skip(RPAREN)
var_pattern = NAME.map(lambda s: ASTBox(VarPat(sym(s.get_token().value))))
@generate
def tag_pattern(gen):
tag = gen.parse(TAGGED).get_token().value
args = gen.parse(pattern.many()).get_list()
pats = [p.get_ast() for p in args]
return ASTBox(TagPat(sym(tag), pats))
named_pattern = CHECK.map(lambda s: ASTBox(NamedPat(sym(s.get_token().value))))
var = NAME.map(lambda b: ASTBox(Var(sym(b.get_token().value))))
number = INT.map(lambda b: ASTBox(Int(int(b.get_token().value or u''))))
paren = LPAREN.then(expr).skip(RPAREN)
autovar = DOLLAR.map(lambda _: ASTBox(Autovar()))
def tag(name, values):
return Tagged(sym(name), values)
assert False, 'abstract'
def dump_nested(self):
return self.dump()
def matches_tag(self, tag, arity):
return False
def matches_type(self, name):
return False
def is_list(self):
return self.matches_tag(nil_sym, 0) or self.matches_tag(cons_sym, 2)
int_sym = sym(u'int')
class Int(Value):
def __init__(self, value):
self.value = value
def matches_type(self, name):
return name == int_sym
def dump(self):
return unicode(str(self.value))
string_sym = sym(u'str')
else:
return u'(*Token %s %s)' % (tok_name, self.value.value)
class Func(Callable):
def __init__(self, bytecode, arity):
self._arity = arity
self.bytecode = bytecode
def arity(self):
return self._arity
def invoke(self, frame, argv):
frame = frame.rt.make_frame(self.bytecode, self.arity, argv)
frame.rt.push(self.bytecode, frame)
cons_sym = sym(u'cons')
nil_sym = sym(u'nil')
class Tagged(Callable):
def __init__(self, symbol, args):
self.symbol = symbol
self.args = args
def dump(self):
if self.is_list():
return self.inspect_cons_list()
if len(self.args) == 0:
return u'.%s' % self.symbol.name
else:
args = u' '.join([a.dump_nested() for a in self.args])
