Commit: 4127f061908401ed22b880862dfb62ba6be22fd7 - regiux (git)

A fast implementation of the Nix expression language

Commit MetaInfo

• Révision: 4127f061908401ed22b880862dfb62ba6be22fd7 (tree)
• l'heure: 2024-05-25 11:28:14
• Auteur: Corbin <cds@corb...>
• Commiter: Corbin

Message de Log

regiux: Implement Booleans and if-expressions.

Change Summary

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

Modification

--- a/heap.py
+++ b/heap.py
@@ -22,18 +22,21 @@ class HeapObject(object):
     def getAttr(self, name):
         raise WrongType("Heap object type %s doesn't have attributes" %
                         self.__class__.__name__)
+    def unwrapBool(self):
+        raise WrongType("Heap object type %s isn't a Boolean" %
+                        self.__class__.__name__)
 
-class MutableObject(HeapObject):
-    loop = False
-    cache = None
-    def evaluate(self):
-        if not self.cache:
-            if self.loop: raise InfiniteLoop()
-            try:
-                self.loop = True
-                self.cache = self.resolve()
-            finally: self.loop = False
-        return self.cache
+class HeapTrue(HeapObject):
+    _immutable_ = True
+    def asStr(self): return "true"
+    def unwrapBool(self): return True
+true = HeapTrue()
+
+class HeapFalse(HeapObject):
+    _immutable_ = True
+    def asStr(self): return "false"
+    def unwrapBool(self): return False
+false = HeapFalse()
 
 class HeapInt(HeapObject):
     _immutable_ = True
@@ -49,11 +52,34 @@ class HeapStr(HeapObject):
 
 class InfiniteLoop(Exception): pass
 
+class MutableObject(HeapObject):
+    loop = False
+    cache = None
+    def evaluate(self):
+        if not self.cache:
+            if self.loop: raise InfiniteLoop()
+            try:
+                self.loop = True
+                self.cache = self.resolve()
+            finally: self.loop = False
+        return self.cache
+
 # XXX currently unused, but ready to go
 # class HeapThunk(MutableObject):
 #     def __init__(self, obj): self.obj = obj
 #     def resolve(self): return self.obj
 
+class HeapCond(MutableObject):
+    def __init__(self, b, cons, alt):
+        self.b = b
+        self.cons = cons
+        self.alt = alt
+    def asStr(self):
+        return "if %s then %s else %s" % (self.b.asStr(), self.cons.asStr(), self.alt.asStr())
+    def resolve(self):
+        rv = self.cons if self.b.unwrapBool() else self.alt
+        return rv.evaluate()
+
 class HeapAttrSet(MutableObject):
     def __init__(self, attrs): self.attrs = attrs
     def asStr(self):
@@ -106,4 +132,5 @@ builtins = HeapAttrSet({
 
 defaultScope = {
     "builtins": builtins,
+    "false": false, "true": true,
 }

--- a/parser.py
+++ b/parser.py
@@ -90,6 +90,18 @@ class StrBox(EBox):
     def pretty(self): return '"%s"' % self.value
     def compile(self, scope): return heap.HeapStr(self.value)
 
+class IfBox(EBox):
+    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())
+    def compile(self, scope):
+        return heap.HeapCond(self.cond.compile(scope), self.seq.compile(scope),
+                             self.alt.compile(scope))
+
 class BindsBox(EBox):
     def __init__(self, binds): self.binds = binds
     def pretty(self):
@@ -249,15 +261,6 @@ class LambdaBox(BaseBox):
         elif self.params: return "%s: %s" % (self.params.pretty(), body)
         else: return "_: " + body
 
-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",