Commit: 7ec0ccb963f6940059592ce24d7c6bc667fd2718 - rpypkgs (git)

Nix flake for RPython interpreters

Commit MetaInfo

• Revisão: 7ec0ccb963f6940059592ce24d7c6bc667fd2718 (tree)
• Hora: 2024-04-30 15:44:34
• Autor: Corbin <cds@corb...>
• Commiter: Corbin

Mensagem de Log

regiux: Split parser.

Mudança Sumário

• modified: regiux/main.py
• add: regiux/parser.py

Diff

--- a/regiux/main.py
+++ b/regiux/main.py
@@ -1,360 +1,6 @@
 import sys
 
-from rpython.rlib.objectmodel import we_are_translated
-from rpython.rlib.rsre import rsre_core
-from rpython.rlib.rsre.rpy import get_code
-
-import rply
-from rply.token import BaseBox
-
-lg = rply.LexerGenerator()
-
-KEYWORDS = "IF THEN ELSE ASSERT WITH LET REC INHERIT OR IN".split()
-for kw in KEYWORDS: lg.add(kw, kw.lower())
-
-lg.add("ELLIPSIS", "\.\.\.")
-lg.add("EQ", "\=\=")
-lg.add("NEQ", "\!\=")
-lg.add("LEQ", "\<\=")
-lg.add("LE", "\<")
-lg.add("GEQ", "\>\=")
-lg.add("GE", "\>")
-lg.add("AND", "\&\&")
-lg.add("OR_OP", "\|\|")
-lg.add("IMPL", "\-\>")
-lg.add("UPDATE", "\/\/")
-lg.add("CONCAT", "\+\+")
-lg.add("PLUS", "\+")
-lg.add("MINUS", "-")
-lg.add("MUL", "\*")
-lg.add("DIV", "\/")
-lg.add("NOT", "!")
-lg.add("HAS", "\?")
-
-lg.add("COLON", ":")
-lg.add("SEMI", ";")
-lg.add("OPEN_BRACE", "\{")
-lg.add("CLOSE_BRACE", "\}")
-lg.add("OPEN_BRACK", "\[")
-lg.add("CLOSE_BRACK", "\]")
-lg.add("OPEN_PAREN", "\(")
-lg.add("CLOSE_PAREN", "\)")
-lg.add("DOT", "\.")
-lg.add("COMMA", ",")
-lg.add("AT", "@")
-lg.add("EQUALS", "\=")
-
-PATH_CHAR = "[a-zA-Z0-9\.\_\-\+]"
-lg.add("URI", "[a-zA-Z][a-zA-Z0-9\+\-\.]*\:[a-zA-Z0-9\%\/\?\:\@\&\=\+\$\,\-\_\.\!\~\*\']+")
-lg.add("ID", "[a-zA-Z\_][a-zA-Z0-9\_\'\-]*")
-lg.add("INT", "[0-9]+")
-lg.add("FLOAT", "(([1-9][0-9]*\.[0-9]*)|(0?\.[0-9]+))([Ee][+-]?[0-9]+)?")
-lg.add("PATH_CHAR", PATH_CHAR)
-lg.add("PATH", "{0}*(\/{0}+)+\/?".format(PATH_CHAR))
-lg.add("PATH_SEG", "{0}*\/".format(PATH_CHAR))
-lg.add("HPATH", "\~(\/{0}+)+\/?".format(PATH_CHAR))
-lg.add("HPATH_START", "\~\/")
-lg.add("SPATH", "\<{0}+(\/{0}+)*\>".format(PATH_CHAR))
-
-lg.ignore("[ \t\r\n]+")
-lg.ignore("#[^\r\n]*")
-lg.ignore("\/\*([^*]|\*+[^*/])*\*+\/")
-
-lexer = lg.build()
-
-# Syntactic classes:
-# * exprs
-# * formal params
-# * attrs
-
-class FormalBox(BaseBox):
-    def __init__(self, name, default):
-        self.name = name
-        self.default = default
-    def pretty(self):
-        if self.default is None:
-            return self.name
-        else:
-            return "%s ? %s" % (self.name, self.default.pretty())
-
-class BindsBox(BaseBox):
-    def __init__(self, binds): self.binds = binds
-    def pretty(self):
-        binds = [bind.pretty() for bind in self.binds]
-        return "{ %s }" % " ".join(binds)
-    def getbinds(self): return self.binds
-
-class BindExprBox(BaseBox):
-    def __init__(self, path, expr):
-        self.path = path
-        self.expr = expr
-    def pretty(self): return "%s = %s;" % (self.path.pretty(), self.expr.pretty())
-
-class BindInheritBox(BaseBox):
-    def __init__(self, attrs, scope):
-        self.attrs = attrs
-        self.scope = scope
-    def pretty(self):
-        if self.scope:
-            return "inherit (%s) %s;" % (self.scope.pretty(), self.attrs.pretty())
-        else: return "inherit %s;" % self.attrs.pretty()
-
-class FormalsBox(BaseBox):
-    def __init__(self, params, hasEllipsis):
-        self.params = params
-        self.hasEllipsis = hasEllipsis
-    def pretty(self):
-        params = [param.pretty() for param in self.params]
-        if self.hasEllipsis: params.append("...")
-        return "{ %s }" % ", ".join(params)
-    def getparams(self): return self.params
-    def getellipsis(self): return self.hasEllipsis
-
-class VarBox(BaseBox):
-    def __init__(self, name): self.name = name
-    def pretty(self): return self.name
-
-class AttrPathBox(BaseBox):
-    def __init__(self, attrs): self.attrs = attrs
-    def pretty(self): return ".".join([attr.pretty() for attr in self.attrs])
-    def getattrs(self): return self.attrs
-
-class AttrsBox(BaseBox):
-    def __init__(self, attrs): self.attrs = attrs
-    def pretty(self): return " ".join([attr.pretty() for attr in self.attrs])
-    def getattrs(self): return self.attrs
-
-class ListBox(BaseBox):
-    def __init__(self, exprs): self.exprs = exprs
-    def pretty(self):
-        return "[ %s ]" % " ".join([expr.pretty() for expr in self.exprs])
-    def getexprs(self): return self.exprs
-
-class IntBox(BaseBox):
-    def __init__(self, value): self.value = value
-    def pretty(self): return str(self.value)
-
-class StrBox(BaseBox):
-    def __init__(self, value): self.value = value
-    def pretty(self): return '"%s"' % self.value
-
-class ExprUnaryBox(BaseBox):
-    def __init__(self, expr, op):
-        self.expr = expr
-        self.op = op.getstr()
-    def pretty(self):
-        return "(%s%s)" % (self.op, self.expr.pretty())
-
-class SelectBox(BaseBox):
-    def __init__(self, expr, path, alt):
-        self.expr = expr
-        self.path = path
-        self.alt = alt
-    def pretty(self):
-        if self.alt is None:
-            return "%s.%s" % (self.expr.pretty(), self.path.pretty())
-        else:
-            return "%s.%s or %s" % (self.expr.pretty(), self.path.pretty(), self.alt.pretty())
-
-class ExprBinaryBox(BaseBox):
-    def __init__(self, left, right, op):
-        self.left = left
-        self.right = right
-        self.op = op.getstr()
-    def pretty(self):
-        return "(%s %s %s)" % (self.left.pretty(), self.op, self.right.pretty())
-
-class HasBox(BaseBox):
-    def __init__(self, value, path):
-        self.value = value
-        self.path = path
-    def pretty(self):
-        return "(%s ? %s)" % (self.value.pretty(), self.path.pretty())
-
-class AssertBox(BaseBox):
-    def __init__(self, cond, expr):
-        self.cond = cond
-        self.expr = expr
-    def pretty(self): return "assert %s; %s" % (self.cond.pretty(), self.expr.pretty())
-
-class WithBox(BaseBox):
-    def __init__(self, scope, expr):
-        self.scope = scope
-        self.expr = expr
-    def pretty(self): return "with %s; %s" % (self.scope.pretty(), self.expr.pretty())
-
-class LambdaBox(BaseBox):
-    def __init__(self, binding, params, body):
-        self.binding = binding
-        self.params = params
-        self.body = body
-    def pretty(self):
-        body = self.body.pretty()
-        if self.binding and self.params:
-            return "%s@%s: %s" % (self.binding.pretty(), self.params.pretty(), body)
-        elif self.binding: return "%s: %s" % (self.binding.pretty(), body)
-        elif self.params: return "%s: %s" % (self.params.pretty(), body)
-        else: return "_: " + body
-
-class AppBox(BaseBox):
-    def __init__(self, func, arg):
-        self.func = func
-        self.arg = arg
-    def pretty(self): return "(%s) (%s)" % (self.func.pretty(), self.arg.pretty())
-
-class IfBox(BaseBox):
-    def __init__(self, cond, seq, alt):
-        self.cond = cond
-        self.seq = seq
-        self.alt = alt
-    def pretty(self):
-        return "if %s then %s else %s" % (
-                self.cond.pretty(), self.seq.pretty(), self.alt.pretty())
-
-pg = rply.ParserGenerator(KEYWORDS + [
-    "ID", "INT", "SPATH", "URI",
-    "AND", "IMPL", "OR_OP",
-    "EQ", "NEQ", "LE", "GE", "LEQ", "GEQ", "HAS",
-    "CONCAT", "UPDATE",
-    "DIV", "MINUS", "MUL", "PLUS",
-    "NEGATE", "NOT",
-    "COLON", "SEMI", "DOT", "COMMA", "AT", "EQUALS", "ELLIPSIS",
-    "OPEN_BRACE", "CLOSE_BRACE", "OPEN_BRACK", "CLOSE_BRACK", "OPEN_PAREN", "CLOSE_PAREN",
-], precedence=[
-    ("right", ["IMPL"]),
-    ("left", ["OR_OP"]),
-    ("left", ["AND"]),
-    ("nonassoc", ["EQ", "NEQ"]),
-    ("nonassoc", ["LE", "GE", "LEQ", "GEQ"]),
-    ("right", ["UPDATE"]),
-    ("left", ["NOT"]),
-    ("left", ["PLUS", "MINUS"]),
-    ("left", ["MUL", "DIV"]),
-    ("right", ["CONCAT"]),
-    ("nonassoc", ["HAS"]),
-    ("nonassoc", ["NEGATE"]),
-])
-
-class ParseError(Exception):
-    def __init__(self, token): self.token = token
-
[e-mail]
-def parseError(token): raise ParseError(token)
-
-def constRule(rule, pb): pg.production(rule)(lambda _: pb)
-def enclosedRule(rule, i): pg.production(rule)(lambda p: p[i])
-def precRule(sup, sub): enclosedRule("expr%s : expr%s" % (sup, sub), 0)
-SPINE = "", "_function", "_if", "_op", "_app", "_select", "_simple"
-for sup, sub in zip(SPINE, SPINE[1:]): precRule(sup, sub)
-
[e-mail]("expr_function : ID COLON expr_function")
-def exprLambda(p): return LambdaBox(VarBox(p[0].getstr()), None, p[2])
-
[e-mail]("expr_function : OPEN_BRACE formals CLOSE_BRACE COLON expr_function")
-def exprLambda(p): return LambdaBox(None, p[1], p[4])
-
[e-mail]("expr_function : OPEN_BRACE formals CLOSE_BRACE AT ID COLON expr_function")
-def exprLambda(p): return LambdaBox(VarBox(p[4].getstr()), p[1], p[6])
-
[e-mail]("expr_function : ID AT OPEN_BRACE formals CLOSE_BRACE COLON expr_function")
-def exprLambda(p): return LambdaBox(VarBox(p[0].getstr()), p[3], p[6])
-
[e-mail]("expr_function : ASSERT expr SEMI expr_function")
-def exprAssert(p): return AssertBox(p[1], p[3])
-
[e-mail]("expr_function : WITH expr SEMI expr_function")
-def exprWith(p): return WithBox(p[1], p[3])
-
[e-mail]("expr_if : IF expr THEN expr ELSE expr")
-def exprIf(p): return IfBox(p[1], p[3], p[5])
-
[e-mail]("expr_op : NEGATE expr_op | NOT expr_op")
-def exprUnary(p): return ExprUnaryBox(p[1], p[0])
-
[e-mail]("expr_op : expr_op AND expr_op")
[e-mail]("expr_op : expr_op CONCAT expr_op")
[e-mail]("expr_op : expr_op DIV expr_op")
[e-mail]("expr_op : expr_op EQ expr_op")
[e-mail]("expr_op : expr_op GE expr_op")
[e-mail]("expr_op : expr_op GEQ expr_op")
[e-mail]("expr_op : expr_op IMPL expr_op")
[e-mail]("expr_op : expr_op LE expr_op")
[e-mail]("expr_op : expr_op LEQ expr_op")
[e-mail]("expr_op : expr_op MINUS expr_op")
[e-mail]("expr_op : expr_op MUL expr_op")
[e-mail]("expr_op : expr_op NEQ expr_op")
[e-mail]("expr_op : expr_op OR_OP expr_op")
[e-mail]("expr_op : expr_op PLUS expr_op")
[e-mail]("expr_op : expr_op UPDATE expr_op")
-def exprBinary(p): return ExprBinaryBox(p[0], p[2], p[1])
-
[e-mail]("expr_op : expr_op HAS attrpath")
-def exprHas(p): return HasBox(p[0], p[2])
-
[e-mail]("expr_app : expr_app expr_select")
-def exprApp(p): return AppBox(p[0], p[1])
-
[e-mail]("expr_select : expr_simple DOT attrpath | expr_simple DOT attrpath OR expr_select")
-def exprSelect(p): return SelectBox(p[0], p[2], p[4] if len(p) == 5 else None)
-
[e-mail]("expr_simple : ID")
-def exprSimpleId(p): return VarBox(p[0].getstr())
-
[e-mail]("expr_simple : INT")
-def exprSimpleInt(p): return IntBox(int(p[0].getstr()))
-
[e-mail]("expr_simple : URI")
-def exprURI(p): return StrBox(p[0].getstr())
-
-enclosedRule("expr_simple : OPEN_BRACE binds CLOSE_BRACE", 1)
-enclosedRule("expr_simple : OPEN_PAREN expr CLOSE_PAREN", 1)
-enclosedRule("expr_simple : OPEN_BRACK expr_list CLOSE_BRACK", 1)
-constRule("expr_list :", ListBox([]))
-
[e-mail]("expr_list : expr_list expr_select")
-def exprListCons(p): return ListBox(p[0].getexprs() + [p[1]])
-
[e-mail]("binds : binds attrpath EQUALS expr SEMI")
-def bindsExpr(p): return BindsBox(p[0].getbinds() + [BindExprBox(p[1], p[3])])
-
[e-mail]("binds : binds INHERIT attrs SEMI")
-def bindsInherit(p):
-    return BindsBox(p[0].getbinds() + [BindInheritBox(p[2], None)])
-
[e-mail]("binds : binds INHERIT OPEN_PAREN expr CLOSE_PAREN attrs SEMI")
-def bindsInherit(p):
-    return BindsBox(p[0].getbinds() + [BindInheritBox(p[5], p[3])])
-
-constRule("binds :", BindsBox([]))
-
[e-mail]("formals : formal COMMA formals")
-def formalsComma(p):
-    return FormalsBox([p[0]] + p[2].getparams(), p[2].getellipsis())
-
[e-mail]("formals : formal")
-def formalsFormal(p): return FormalsBox([p[0]], False)
-
-constRule("formals :", FormalsBox([], False))
-constRule("formals : ELLIPSIS", FormalsBox([], True))
-
[e-mail]("formal : ID | ID HAS expr")
-def formalId(p): return FormalBox(p[0].getstr(), p[2] if len(p) > 1 else None)
-
[e-mail]("attrs : attrs attr")
-def attrsAttr(p): return AttrsBox(p[0].getattrs() + [p[1]])
-
-constRule("attrs :", AttrsBox([]))
-
[e-mail]("attrpath : attrpath DOT attr")
-def attrpathNil(p): return AttrPathBox(p[0].getattrs() + [p[2]])
-
[e-mail]("attrpath : attr")
-def attrpathCons(p): return AttrPathBox(p)
-
[e-mail]("attr : ID")
-def attrId(p): return StrBox(p[0].getstr())
-
-parser = pg.build()
+from parser import parse, ParseError
 
 def entryPoint(argv):
     if len(argv) < 2:
@@ -363,8 +9,7 @@ def entryPoint(argv):
     path = argv[1]
     with open(path, "rb") as handle: expr = handle.read()
     try:
-        ast = parser.parse(lexer.lex(expr))
-        print "Success"
+        ast = parse(expr)
         print "AST:", ast
         print ast.pretty()
         return 0
@@ -380,5 +25,3 @@ def entryPoint(argv):
 def target(*args): return entryPoint, None
 
 if __name__ == "__main__": entryPoint(sys.argv)
-
-# 456 + 293 = 749

--- /dev/null
+++ b/regiux/parser.py
@@ -0,0 +1,358 @@
+import rply
+from rply.token import BaseBox
+
+# A basic Nix parser ported from CppNix.
+# LoC target:
+# 456 (parser.y) + 293 (lexer.l) = 749
+
+lg = rply.LexerGenerator()
+
+KEYWORDS = "IF THEN ELSE ASSERT WITH LET REC INHERIT OR IN".split()
+for kw in KEYWORDS: lg.add(kw, kw.lower())
+
+lg.add("ELLIPSIS", "\.\.\.")
+lg.add("EQ", "\=\=")
+lg.add("NEQ", "\!\=")
+lg.add("LEQ", "\<\=")
+lg.add("LE", "\<")
+lg.add("GEQ", "\>\=")
+lg.add("GE", "\>")
+lg.add("AND", "\&\&")
+lg.add("OR_OP", "\|\|")
+lg.add("IMPL", "\-\>")
+lg.add("UPDATE", "\/\/")
+lg.add("CONCAT", "\+\+")
+lg.add("PLUS", "\+")
+lg.add("MINUS", "-")
+lg.add("MUL", "\*")
+lg.add("DIV", "\/")
+lg.add("NOT", "!")
+lg.add("HAS", "\?")
+
+lg.add("COLON", ":")
+lg.add("SEMI", ";")
+lg.add("OPEN_BRACE", "\{")
+lg.add("CLOSE_BRACE", "\}")
+lg.add("OPEN_BRACK", "\[")
+lg.add("CLOSE_BRACK", "\]")
+lg.add("OPEN_PAREN", "\(")
+lg.add("CLOSE_PAREN", "\)")
+lg.add("DOT", "\.")
+lg.add("COMMA", ",")
+lg.add("AT", "@")
+lg.add("EQUALS", "\=")
+
+PATH_CHAR = "[a-zA-Z0-9\.\_\-\+]"
+lg.add("URI", "[a-zA-Z][a-zA-Z0-9\+\-\.]*\:[a-zA-Z0-9\%\/\?\:\@\&\=\+\$\,\-\_\.\!\~\*\']+")
+lg.add("ID", "[a-zA-Z\_][a-zA-Z0-9\_\'\-]*")
+lg.add("INT", "[0-9]+")
+lg.add("FLOAT", "(([1-9][0-9]*\.[0-9]*)|(0?\.[0-9]+))([Ee][+-]?[0-9]+)?")
+lg.add("PATH_CHAR", PATH_CHAR)
+lg.add("PATH", "{0}*(\/{0}+)+\/?".format(PATH_CHAR))
+lg.add("PATH_SEG", "{0}*\/".format(PATH_CHAR))
+lg.add("HPATH", "\~(\/{0}+)+\/?".format(PATH_CHAR))
+lg.add("HPATH_START", "\~\/")
+lg.add("SPATH", "\<{0}+(\/{0}+)*\>".format(PATH_CHAR))
+
+lg.ignore("[ \t\r\n]+")
+lg.ignore("#[^\r\n]*")
+lg.ignore("\/\*([^*]|\*+[^*/])*\*+\/")
+
+lexer = lg.build()
+
+# Syntactic classes:
+# * exprs
+# * formal params
+# * attrs
+
+class FormalBox(BaseBox):
+    def __init__(self, name, default):
+        self.name = name
+        self.default = default
+    def pretty(self):
+        if self.default is None:
+            return self.name
+        else:
+            return "%s ? %s" % (self.name, self.default.pretty())
+
+class BindsBox(BaseBox):
+    def __init__(self, binds): self.binds = binds
+    def pretty(self):
+        binds = [bind.pretty() for bind in self.binds]
+        return "{ %s }" % " ".join(binds)
+    def getbinds(self): return self.binds
+
+class BindExprBox(BaseBox):
+    def __init__(self, path, expr):
+        self.path = path
+        self.expr = expr
+    def pretty(self): return "%s = %s;" % (self.path.pretty(), self.expr.pretty())
+
+class BindInheritBox(BaseBox):
+    def __init__(self, attrs, scope):
+        self.attrs = attrs
+        self.scope = scope
+    def pretty(self):
+        if self.scope:
+            return "inherit (%s) %s;" % (self.scope.pretty(), self.attrs.pretty())
+        else: return "inherit %s;" % self.attrs.pretty()
+
+class FormalsBox(BaseBox):
+    def __init__(self, params, hasEllipsis):
+        self.params = params
+        self.hasEllipsis = hasEllipsis
+    def pretty(self):
+        params = [param.pretty() for param in self.params]
+        if self.hasEllipsis: params.append("...")
+        return "{ %s }" % ", ".join(params)
+    def getparams(self): return self.params
+    def getellipsis(self): return self.hasEllipsis
+
+class VarBox(BaseBox):
+    def __init__(self, name): self.name = name
+    def pretty(self): return self.name
+
+class AttrPathBox(BaseBox):
+    def __init__(self, attrs): self.attrs = attrs
+    def pretty(self): return ".".join([attr.pretty() for attr in self.attrs])
+    def getattrs(self): return self.attrs
+
+class AttrsBox(BaseBox):
+    def __init__(self, attrs): self.attrs = attrs
+    def pretty(self): return " ".join([attr.pretty() for attr in self.attrs])
+    def getattrs(self): return self.attrs
+
+class ListBox(BaseBox):
+    def __init__(self, exprs): self.exprs = exprs
+    def pretty(self):
+        return "[ %s ]" % " ".join([expr.pretty() for expr in self.exprs])
+    def getexprs(self): return self.exprs
+
+class IntBox(BaseBox):
+    def __init__(self, value): self.value = value
+    def pretty(self): return str(self.value)
+
+class StrBox(BaseBox):
+    def __init__(self, value): self.value = value
+    def pretty(self): return '"%s"' % self.value
+
+class ExprUnaryBox(BaseBox):
+    def __init__(self, expr, op):
+        self.expr = expr
+        self.op = op.getstr()
+    def pretty(self):
+        return "(%s%s)" % (self.op, self.expr.pretty())
+
+class SelectBox(BaseBox):
+    def __init__(self, expr, path, alt):
+        self.expr = expr
+        self.path = path
+        self.alt = alt
+    def pretty(self):
+        if self.alt is None:
+            return "%s.%s" % (self.expr.pretty(), self.path.pretty())
+        else:
+            return "%s.%s or %s" % (self.expr.pretty(), self.path.pretty(), self.alt.pretty())
+
+class ExprBinaryBox(BaseBox):
+    def __init__(self, left, right, op):
+        self.left = left
+        self.right = right
+        self.op = op.getstr()
+    def pretty(self):
+        return "(%s %s %s)" % (self.left.pretty(), self.op, self.right.pretty())
+
+class HasBox(BaseBox):
+    def __init__(self, value, path):
+        self.value = value
+        self.path = path
+    def pretty(self):
+        return "(%s ? %s)" % (self.value.pretty(), self.path.pretty())
+
+class AssertBox(BaseBox):
+    def __init__(self, cond, expr):
+        self.cond = cond
+        self.expr = expr
+    def pretty(self): return "assert %s; %s" % (self.cond.pretty(), self.expr.pretty())
+
+class WithBox(BaseBox):
+    def __init__(self, scope, expr):
+        self.scope = scope
+        self.expr = expr
+    def pretty(self): return "with %s; %s" % (self.scope.pretty(), self.expr.pretty())
+
+class LambdaBox(BaseBox):
+    def __init__(self, binding, params, body):
+        self.binding = binding
+        self.params = params
+        self.body = body
+    def pretty(self):
+        body = self.body.pretty()
+        if self.binding and self.params:
+            return "%s@%s: %s" % (self.binding.pretty(), self.params.pretty(), body)
+        elif self.binding: return "%s: %s" % (self.binding.pretty(), body)
+        elif self.params: return "%s: %s" % (self.params.pretty(), body)
+        else: return "_: " + body
+
+class AppBox(BaseBox):
+    def __init__(self, func, arg):
+        self.func = func
+        self.arg = arg
+    def pretty(self): return "(%s) (%s)" % (self.func.pretty(), self.arg.pretty())
+
+class IfBox(BaseBox):
+    def __init__(self, cond, seq, alt):
+        self.cond = cond
+        self.seq = seq
+        self.alt = alt
+    def pretty(self):
+        return "if %s then %s else %s" % (
+                self.cond.pretty(), self.seq.pretty(), self.alt.pretty())
+
+pg = rply.ParserGenerator(KEYWORDS + [
+    "ID", "INT", "SPATH", "URI",
+    "AND", "IMPL", "OR_OP",
+    "EQ", "NEQ", "LE", "GE", "LEQ", "GEQ", "HAS",
+    "CONCAT", "UPDATE",
+    "DIV", "MINUS", "MUL", "PLUS",
+    "NEGATE", "NOT",
+    "COLON", "SEMI", "DOT", "COMMA", "AT", "EQUALS", "ELLIPSIS",
+    "OPEN_BRACE", "CLOSE_BRACE", "OPEN_BRACK", "CLOSE_BRACK", "OPEN_PAREN", "CLOSE_PAREN",
+], precedence=[
+    ("right", ["IMPL"]),
+    ("left", ["OR_OP"]),
+    ("left", ["AND"]),
+    ("nonassoc", ["EQ", "NEQ"]),
+    ("nonassoc", ["LE", "GE", "LEQ", "GEQ"]),
+    ("right", ["UPDATE"]),
+    ("left", ["NOT"]),
+    ("left", ["PLUS", "MINUS"]),
+    ("left", ["MUL", "DIV"]),
+    ("right", ["CONCAT"]),
+    ("nonassoc", ["HAS"]),
+    ("nonassoc", ["NEGATE"]),
+])
+
+class ParseError(Exception):
+    def __init__(self, token): self.token = token
+
[e-mail]
+def parseError(token): raise ParseError(token)
+
+def constRule(rule, pb): pg.production(rule)(lambda _: pb)
+def enclosedRule(rule, i): pg.production(rule)(lambda p: p[i])
+def precRule(sup, sub): enclosedRule("expr%s : expr%s" % (sup, sub), 0)
+SPINE = "", "_function", "_if", "_op", "_app", "_select", "_simple"
+for sup, sub in zip(SPINE, SPINE[1:]): precRule(sup, sub)
+
[e-mail]("expr_function : ID COLON expr_function")
+def exprLambda(p): return LambdaBox(VarBox(p[0].getstr()), None, p[2])
+
[e-mail]("expr_function : OPEN_BRACE formals CLOSE_BRACE COLON expr_function")
+def exprLambda(p): return LambdaBox(None, p[1], p[4])
+
[e-mail]("expr_function : OPEN_BRACE formals CLOSE_BRACE AT ID COLON expr_function")
+def exprLambda(p): return LambdaBox(VarBox(p[4].getstr()), p[1], p[6])
+
[e-mail]("expr_function : ID AT OPEN_BRACE formals CLOSE_BRACE COLON expr_function")
+def exprLambda(p): return LambdaBox(VarBox(p[0].getstr()), p[3], p[6])
+
[e-mail]("expr_function : ASSERT expr SEMI expr_function")
+def exprAssert(p): return AssertBox(p[1], p[3])
+
[e-mail]("expr_function : WITH expr SEMI expr_function")
+def exprWith(p): return WithBox(p[1], p[3])
+
[e-mail]("expr_if : IF expr THEN expr ELSE expr")
+def exprIf(p): return IfBox(p[1], p[3], p[5])
+
[e-mail]("expr_op : NEGATE expr_op | NOT expr_op")
+def exprUnary(p): return ExprUnaryBox(p[1], p[0])
+
[e-mail]("expr_op : expr_op AND expr_op")
[e-mail]("expr_op : expr_op CONCAT expr_op")
[e-mail]("expr_op : expr_op DIV expr_op")
[e-mail]("expr_op : expr_op EQ expr_op")
[e-mail]("expr_op : expr_op GE expr_op")
[e-mail]("expr_op : expr_op GEQ expr_op")
[e-mail]("expr_op : expr_op IMPL expr_op")
[e-mail]("expr_op : expr_op LE expr_op")
[e-mail]("expr_op : expr_op LEQ expr_op")
[e-mail]("expr_op : expr_op MINUS expr_op")
[e-mail]("expr_op : expr_op MUL expr_op")
[e-mail]("expr_op : expr_op NEQ expr_op")
[e-mail]("expr_op : expr_op OR_OP expr_op")
[e-mail]("expr_op : expr_op PLUS expr_op")
[e-mail]("expr_op : expr_op UPDATE expr_op")
+def exprBinary(p): return ExprBinaryBox(p[0], p[2], p[1])
+
[e-mail]("expr_op : expr_op HAS attrpath")
+def exprHas(p): return HasBox(p[0], p[2])
+
[e-mail]("expr_app : expr_app expr_select")
+def exprApp(p): return AppBox(p[0], p[1])
+
[e-mail]("expr_select : expr_simple DOT attrpath | expr_simple DOT attrpath OR expr_select")
+def exprSelect(p): return SelectBox(p[0], p[2], p[4] if len(p) == 5 else None)
+
[e-mail]("expr_simple : ID")
+def exprSimpleId(p): return VarBox(p[0].getstr())
+
[e-mail]("expr_simple : INT")
+def exprSimpleInt(p): return IntBox(int(p[0].getstr()))
+
[e-mail]("expr_simple : URI")
+def exprURI(p): return StrBox(p[0].getstr())
+
+enclosedRule("expr_simple : OPEN_BRACE binds CLOSE_BRACE", 1)
+enclosedRule("expr_simple : OPEN_PAREN expr CLOSE_PAREN", 1)
+enclosedRule("expr_simple : OPEN_BRACK expr_list CLOSE_BRACK", 1)
+constRule("expr_list :", ListBox([]))
+
[e-mail]("expr_list : expr_list expr_select")
+def exprListCons(p): return ListBox(p[0].getexprs() + [p[1]])
+
[e-mail]("binds : binds attrpath EQUALS expr SEMI")
+def bindsExpr(p): return BindsBox(p[0].getbinds() + [BindExprBox(p[1], p[3])])
+
[e-mail]("binds : binds INHERIT attrs SEMI")
+def bindsInherit(p):
+    return BindsBox(p[0].getbinds() + [BindInheritBox(p[2], None)])
+
[e-mail]("binds : binds INHERIT OPEN_PAREN expr CLOSE_PAREN attrs SEMI")
+def bindsInherit(p):
+    return BindsBox(p[0].getbinds() + [BindInheritBox(p[5], p[3])])
+
+constRule("binds :", BindsBox([]))
+
[e-mail]("formals : formal COMMA formals")
+def formalsComma(p):
+    return FormalsBox([p[0]] + p[2].getparams(), p[2].getellipsis())
+
[e-mail]("formals : formal")
+def formalsFormal(p): return FormalsBox([p[0]], False)
+
+constRule("formals :", FormalsBox([], False))
+constRule("formals : ELLIPSIS", FormalsBox([], True))
+
[e-mail]("formal : ID | ID HAS expr")
+def formalId(p): return FormalBox(p[0].getstr(), p[2] if len(p) > 1 else None)
+
[e-mail]("attrs : attrs attr")
+def attrsAttr(p): return AttrsBox(p[0].getattrs() + [p[1]])
+
+constRule("attrs :", AttrsBox([]))
+
[e-mail]("attrpath : attrpath DOT attr")
+def attrpathNil(p): return AttrPathBox(p[0].getattrs() + [p[2]])
+
[e-mail]("attrpath : attr")
+def attrpathCons(p): return AttrPathBox(p)
+
[e-mail]("attr : ID")
+def attrId(p): return StrBox(p[0].getstr())
+
+parser = pg.build()
+
+# Top-level interface: Lex and parse UTF-8 text.
+def parse(expr): return parser.parse(lexer.lex(expr))