Commit: 3db301521ecd174f759d748e32507c3d3fd2fc0e - rpypkgs (git)

Nix flake for RPython interpreters

Commit MetaInfo

• Revision: 3db301521ecd174f759d748e32507c3d3fd2fc0e (tree)
• Time: 2024-04-28 14:35:39
• Author: Corbin <cds@corb...>
• Commiter: Corbin

Log Message

reguix: More of the parser.

The remaining parts have to do with lexing and parsing of quasiliteral
strings. Parsing these is always...involved. It seems rply doesn't
support the CppNix approach of stateful lexing, so instead we'll have
to carefully lex quasiliterals into pieces and parse the pieces.

Change Summary

• modified: regiux/main.py
• modified: regiux/todo.txt

Incremental Difference

--- a/regiux/main.py
+++ b/regiux/main.py
@@ -9,19 +9,7 @@ from rply.token import BaseBox
 
 lg = rply.LexerGenerator()
 
-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))
-
-KEYWORDS = "IF THEN ELSE ASSERT WITH LET IN REC INHERIT OR".split()
+KEYWORDS = "IF THEN ELSE ASSERT WITH LET REC INHERIT OR IN".split()
 for kw in KEYWORDS: lg.add(kw, kw.lower())
 
 lg.add("ELLIPSIS", "\.\.\.")
@@ -45,11 +33,28 @@ 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]*")
@@ -57,6 +62,54 @@ 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
@@ -66,6 +119,11 @@ class AttrPathBox(BaseBox):
     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):
@@ -126,10 +184,17 @@ class WithBox(BaseBox):
     def pretty(self): return "with %s; %s" % (self.scope.pretty(), self.expr.pretty())
 
 class LambdaBox(BaseBox):
-    def __init__(self, binding, body):
+    def __init__(self, binding, params, body):
         self.binding = binding
+        self.params = params
         self.body = body
-    def pretty(self): return "%s: %s" % (self.binding.pretty(), self.body.pretty())
+    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):
@@ -153,7 +218,8 @@ pg = rply.ParserGenerator(KEYWORDS + [
     "CONCAT", "UPDATE",
     "DIV", "MINUS", "MUL", "PLUS",
     "NEGATE", "NOT",
-    "COLON", "SEMI", "OPEN_BRACK", "CLOSE_BRACK", "OPEN_PAREN", "CLOSE_PAREN", "DOT",
+    "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"]),
@@ -175,13 +241,23 @@ class ParseError(Exception):
 @pg.error
 def parseError(token): raise ParseError(token)
 
-def precRule(sup, sub):
-    pg.production("expr%s : expr%s" % (sup, sub))(lambda p: p[0])
+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)
 
 @pg.production("expr_function : ID COLON expr_function")
-def exprLambda(p): return LambdaBox(VarBox(p[0].getstr()), p[2])
+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])
 
 @pg.production("expr_function : ASSERT expr SEMI expr_function")
 def exprAssert(p): return AssertBox(p[1], p[3])
@@ -192,8 +268,7 @@ def exprWith(p): return WithBox(p[1], p[3])
 @pg.production("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")
[e-mail]("expr_op : NEGATE expr_op | NOT expr_op")
 def exprUnary(p): return ExprUnaryBox(p[1], p[0])
 
 @pg.production("expr_op : expr_op AND expr_op")
@@ -222,9 +297,6 @@ def exprApp(p): return AppBox(p[0], p[1])
 @pg.production("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 : OPEN_PAREN expr CLOSE_PAREN")
-def exprParens(p): return p[1]
-
 @pg.production("expr_simple : ID")
 def exprSimpleId(p): return VarBox(p[0].getstr())
 
@@ -234,17 +306,47 @@ def exprSimpleInt(p): return IntBox(int(p[0].getstr()))
 @pg.production("expr_simple : URI")
 def exprURI(p): return StrBox(p[0].getstr())
 
[e-mail]("expr_simple : OPEN_BRACK expr_list CLOSE_BRACK")
-def exprList(p): return p[1]
-
[e-mail]("expr_list :")
-def exprListNil(p): return ListBox([])
+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([]))
 
 @pg.production("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([]))
+
 @pg.production("attrpath : attrpath DOT attr")
-def attrpathNil(p): return AttrPathBox(p[0].getattrs() + [p[1]])
+def attrpathNil(p): return AttrPathBox(p[0].getattrs() + [p[2]])
 
 @pg.production("attrpath : attr")
 def attrpathCons(p): return AttrPathBox(p)

--- a/regiux/todo.txt
+++ b/regiux/todo.txt
@@ -43,6 +43,7 @@
           * Negation: -x => builtins.sub 0 x
           * Arithmetic: x * y => builtins.mul x y, etc.
         * Scalar comparison: x > y => y < x, x >= y => !(x < y), etc.
+        * Attrset bindings
       * My ideas
         * Eliminate `with`
           * Motivation: It was bugging somebody (Irenes? Xe? Infinisil?)