Commit: 10999947ad7b4aefc700339a144555ab8035bdf3 - regiux (git)

A fast implementation of the Nix expression language

Commit MetaInfo

• Revisão: 10999947ad7b4aefc700339a144555ab8035bdf3 (tree)
• Hora: 2024-04-27 16:58:10
• Autor: Corbin <cds@corb...>
• Commiter: Corbin

Mensagem de Log

regiux: Hack out about half of Nix's grammar.

Okay, maybe more like a third. There's a bunch of gnarly regexes that
probably can be ported directly for the lexer, a bunch of implicit
characters that have to be explicitly catalogued and named, and a lot of
boxes to be written for the parser.

I've used as much metaprogramming as I can here, but historically
RPython doesn't like autogeneration of box classes, so they are
handwritten. Yuck.

Mudança Sumário

• modified: main.py

Diff

--- a/main.py
+++ b/main.py
@@ -9,35 +9,182 @@ from rply.token import BaseBox
 
 lg = rply.LexerGenerator()
 
+lg.add("ID", "[a-zA-Z\_][a-zA-Z0-9\_\'\-]*")
 lg.add("INT", "[0-9]+")
+
+KEYWORDS = "IF THEN ELSE ASSERT WITH LET IN REC INHERIT OR".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", "\|\|")
+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.ignore(" +")
+lg.add("COLON", ":")
+lg.add("OPEN_PAREN", "\(")
+lg.add("CLOSE_PAREN", "\)")
+lg.add("DOT", "\.")
+
+lg.ignore("[ \t\r\n]+")
+lg.ignore("#[^\r\n]*")
+lg.ignore("\/\*([^*]|\*+[^*/])*\*+\/")
 
 lexer = lg.build()
 
+class IdBox(BaseBox):
+    def __init__(self, value): self.value = value
+    def pretty(self): return self.value
+
+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 IntBox(BaseBox):
     def __init__(self, value): self.value = value
     def pretty(self): return str(self.value)
 
-class ExprOpBox(BaseBox):
+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 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())
+        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 LambdaBox(BaseBox):
+    def __init__(self, binding, body):
+        self.binding = binding
+        self.body = body
+    def pretty(self): return "%s: %s" % (self.binding.pretty(), self.body.pretty())
+
+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([
-    "INT",
-    "PLUS",
+pg = rply.ParserGenerator(KEYWORDS + [
+    "ID", "INT",
+    "AND", "IMPL", "OR",
+    "EQ", "NEQ", "LE", "GE", "LEQ", "GEQ", "HAS",
+    "CONCAT", "UPDATE",
+    "DIV", "MINUS", "MUL", "PLUS",
+    "NEGATE", "NOT",
+    "COLON", "OPEN_PAREN", "CLOSE_PAREN", "DOT",
+], precedence=[
+    ("right", ["IMPL"]),
+    ("left", ["OR"]),
+    ("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"]),
 ])
 
[e-mail]("expr : expr PLUS expr")
-def exprOp(p): return ExprOpBox(p[0], p[2], p[1])
+class ParseError(Exception):
+    def __init__(self, token): self.token = token
 
[e-mail]("expr : INT")
-def exprSimple(p): return IntBox(int(p[0].getstr()))
[e-mail]
+def parseError(token): raise ParseError(token)
+
+def precRule(sup, sub):
+    pg.production("expr%s : expr%s" % (sup, sub))(lambda p: p[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(p[0], p[2])
+
[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")
[e-mail]("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 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_simple : OPEN_PAREN expr CLOSE_PAREN")
+def exprParens(p): return p[1]
+
[e-mail]("expr_simple : ID")
+def exprSimpleId(p): return IdBox(p[0].getstr())
+
[e-mail]("expr_simple : INT")
+def exprSimpleInt(p): return IntBox(int(p[0].getstr()))
+
[e-mail]("attrpath : attrpath DOT attr")
+def attrpathNil(p): return AttrPathBox(p[0].getattrs() + [p[1]])
+
[e-mail]("attrpath : attr")
+def attrpathCons(p): return AttrPathBox(p)
+
[e-mail]("attr : ID")
+def attrId(p): return p[0]
 
 parser = pg.build()
 
@@ -47,10 +194,23 @@ def entryPoint(argv):
         return 1
     path = argv[1]
     with open(path, "rb") as handle: expr = handle.read()
-    ast = parser.parse(lexer.lex(expr))
-    print ast.pretty()
-    return 0
+    try:
+        ast = parser.parse(lexer.lex(expr))
+        print "Success"
+        print "AST:", ast
+        print ast.pretty()
+        return 0
+    except ParseError as e:
+        print "Error"
+        token = e.token
+        print "Unexpected token:", token.gettokentype(), "(%s)" % token.getstr()
+        pos = token.getsourcepos()
+        if pos is None: print "No position information"
+        else: print "Error at line %d, column %d" % (pos.lineno, pos.colno)
+        return 1
 
 def target(*args): return entryPoint, None
 
 if __name__ == "__main__": entryPoint(sys.argv)
+
+# 456 + 293 = 749