Commit: b90c3acf89fb713f952afc784a3e6a2019e8fa8d - regiux (git)

A fast implementation of the Nix expression language

Commit MetaInfo

• Revisão: b90c3acf89fb713f952afc784a3e6a2019e8fa8d (tree)
• Hora: 2024-06-08 10:38:44
• Autor: Corbin <cds@corb...>
• Commiter: Corbin

Mensagem de Log

regiux: Parse and compile quasiliteral strings.

Requires a RPLY fork, so currently broken.

Mudança Sumário

• modified: heap.py
• modified: parser.py

Diff

--- a/heap.py
+++ b/heap.py
@@ -28,6 +28,12 @@ class HeapObject(object):
     def unwrapInt(self):
         raise WrongType("Heap object type %s isn't an integer" %
                         self.__class__.__name__)
+    def unwrapStr(self):
+        raise WrongType("Heap object type %s isn't a string" %
+                        self.__class__.__name__)
+    def unwrapList(self):
+        raise WrongType("Heap object type %s isn't a list" %
+                        self.__class__.__name__)
 
 class HeapTrue(HeapObject):
     _immutable_ = True
@@ -51,6 +57,7 @@ class HeapStr(HeapObject):
     _immutable_ = True
     def __init__(self, s): self.s = s
     def asStr(self): return self.s
+    def unwrapStr(self): return self.s
 
 # The possibly-cyclic nodes.
 
@@ -107,6 +114,7 @@ class HeapList(MutableObject):
         for obj in self.objs: obj.evaluate()
         return self
     def length(self): return len(self.objs)
+    def unwrapList(self): return self.objs
 
 class HeapSelect(MutableObject):
     def __init__(self, obj, path):
@@ -148,6 +156,8 @@ builtins = HeapAttrSet({
     "mul": HeapBinary(lambda x, y: HeapInt(x.unwrapInt() * y.unwrapInt())),
     "sub": HeapBinary(lambda x, y: HeapInt(x.unwrapInt() - y.unwrapInt())),
     "length": HeapAction(lambda obj: HeapInt(obj.length())),
+    "concatStringsSep": HeapBinary(lambda sep, l:
+        HeapStr(sep.unwrapStr().join([x.unwrapStr() for x in l.unwrapList()]))),
 })
 
 defaultScope = {

--- a/parser.py
+++ b/parser.py
@@ -9,6 +9,20 @@ import heap
 
 lg = rply.LexerGenerator()
 
+# Lexer states for quasiliterals.
+class LexerState(object): pass
+class _StateExpr(LexerState): pass
+STATE_EXPR = _StateExpr()
+class _StateString(LexerState): pass
+STATE_STRING = _StateString()
+
+STRING_CHAR = "([^\$\"\\\\]|\$[^\{\"\\\\])"
+
+lg.add("STRING", "\"%s*\"" % STRING_CHAR)
+lg.add("STRING_INIT", "\"%s*\$\{" % STRING_CHAR, push=[STATE_STRING])
+lg.add("STRING_PIECE", "\}%s*\$\{" % STRING_CHAR, state=STATE_STRING)
+lg.add("STRING_END", "\}%s*\"" % STRING_CHAR, state=STATE_STRING, pop=True)
+
 KEYWORDS = "IF THEN ELSE ASSERT WITH LET REC INHERIT OR IN".split()
 for kw in KEYWORDS: lg.add(kw, kw.lower())
 
@@ -33,8 +47,8 @@ lg.add("HAS", "\?")
 
 lg.add("COLON", ":")
 lg.add("SEMI", ";")
-lg.add("OPEN_BRACE", "\{")
-lg.add("CLOSE_BRACE", "\}")
+lg.add("OPEN_BRACE", "\{", push=[STATE_EXPR])
+lg.add("CLOSE_BRACE", "\}", pop=True)
 lg.add("OPEN_BRACK", "\[")
 lg.add("CLOSE_BRACK", "\]")
 lg.add("OPEN_PAREN", "\(")
@@ -56,9 +70,6 @@ lg.add("HPATH", "\~(\/{0}+)+\/?".format(PATH_CHAR))
 lg.add("HPATH_START", "\~\/")
 lg.add("SPATH", "\<{0}+(\/{0}+)*\>".format(PATH_CHAR))
 
-lg.add("OPEN_QUASI", "\$\{")
-lg.add("STRING", "\"([^\$\"\\\\]|\$[^\{\"\\\\])*\"")
-
 lg.ignore("[ \t\r\n]+")
 lg.ignore("#[^\r\n]*")
 lg.ignore("\/\*([^*]|\*+[^*/])*\*+\/")
@@ -162,6 +173,28 @@ class AppBox(EBox):
     def compile(self, scope):
         return heap.HeapApp(self.func.compile(scope), self.arg.compile(scope))
 
+class StrQLBox(EBox):
+    def __init__(self, init, pairs):
+        self.init = init
+        self.pairs = pairs
+    def pretty(self):
+        rv = [self.init]
+        for expr, piece in self.pairs:
+            rv.append("${ ")
+            rv.append(expr.pretty())
+            rv.append(" }")
+            rv.append(piece)
+        return '"%s"' % "".join(rv)
+    def compile(self, scope):
+        l = [heap.HeapStr(self.init)]
+        for expr, piece in self.pairs:
+            l.append(expr.compile(scope))
+            l.append(heap.HeapStr(piece))
+        return heap.HeapApp(
+                heap.HeapApp(heap.HeapSelect(scope["builtins"], ["concatStringsSep"]),
+                             heap.HeapStr("")),
+                heap.HeapList(l))
+
 class BindBox(RegiuxBox):
     "A box for attrset attributes."
     cls = "attrs"
@@ -269,8 +302,12 @@ class LambdaBox(BaseBox):
         elif self.params: return "%s: %s" % (self.params.pretty(), body)
         else: return "_: " + body
 
+class IncompleteQL(BaseBox):
+    def __init__(self, pairs): self.pairs = pairs
+
 pg = rply.ParserGenerator(KEYWORDS + [
     "ID", "INT", "SPATH", "STRING", "URI",
+    "STRING_INIT", "STRING_PIECE",  "STRING_END",
     "AND", "IMPL", "OR_OP",
     "EQ", "NEQ", "LE", "GE", "LEQ", "GEQ", "HAS",
     "CONCAT", "UPDATE",
@@ -293,6 +330,12 @@ pg = rply.ParserGenerator(KEYWORDS + [
     ("nonassoc", ["NEGATE"]),
 ])
 
+def trimBox(b, start, stop):
+    s = b.getstr()
+    if stop < 0: stop += len(s)
+    assert stop >= 0, "Invariant from lexer regex"
+    return s[start:stop]
+
 class ParseError(Exception):
     def __init__(self, token): self.token = token
 
@@ -369,11 +412,24 @@ def exprSimpleId(p): return VarBox(p[0].getstr())
 def exprSimpleInt(p): return IntBox(int(p[0].getstr()))
 
 @pg.production("expr_simple : STRING")
-def exprQuoted(p):
-    s = p[0].getstr()
-    stop = len(s) - 1
-    assert stop >= 1, "Invariant from lexer regex"
-    return StrBox(s[1:stop])
+def exprQuoted(p): return StrBox(trimBox(p[0], 1, -1))
+
[e-mail]("expr_simple : STRING_INIT string_ql")
+def stringQL(p):
+    s = trimBox(p[0], 1, -2)
+    incomplete = p[1]
+    assert isinstance(incomplete, IncompleteQL)
+    return StrQLBox(s, incomplete.pairs)
+
[e-mail]("string_ql : expr STRING_PIECE string_ql")
+def stringQLPiece(p):
+    incomplete = p[2]
+    assert isinstance(incomplete, IncompleteQL)
+    pairs = [(p[0], trimBox(p[1], 1, -2))] + incomplete.pairs
+    return IncompleteQL(pairs)
+
[e-mail]("string_ql : expr STRING_END")
+def stringQLEnd(p): return IncompleteQL([(p[0], trimBox(p[1], 1, -1))])
 
 @pg.production("expr_simple : URI")
 def exprURI(p): return StrBox(p[0].getstr())