0.36.0

Author: voidwyrm-2

changelog.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.36.0
+
+- Page now (after ***much*** pain) has closures
+- Lists literals now draw items from parent stacks (e.g. `1 2 3 [pop]` is now valid)
+
 ## 0.35.1
 
 - 'ge' was misnamed as 'gt'

examples/closures.pg

@@ -0,0 +1,10 @@
+/fun {
+1 dict begin
+  /a 10 def
+  {a ==}
+end
+} def
+
+fun
+dup ==
+exec

page.nimble

@@ -1,6 +1,6 @@
 # Package
 
-version       = "0.35.1"
+version       = "0.36.0"
 author        = "Nuclear Pasta"
 description   = "A PostScript-like language."
 license       = "Apache-2.0"

src/builtins.nim

@@ -353,6 +353,9 @@ Takes a function P and executes it.
 
   s.check(f.args)
 
+  ps.closure = f.closure
+  defer: ps.closure = nil
+
   if f.ptype == ptLiteral:
     evalValues(s, ps, f.values)
   else:
@@ -1107,7 +1110,7 @@ S -> V
 Retrieves the value bound to a symbol S.
 """, @[("S", tSymbol)]):
   let name = s.pop().strv
-  s.push(s.get(name))
+  s.push(s.get(name, cast[State](ps.closure)))
 
 addS("load?",
 """

src/interpreter.nim

@@ -23,6 +23,7 @@ export value
 type Interpreter* = ref object
   rand: Rand
   state: State
+  closure: ptr ClosureState
 
 
 proc codeEvaler(g: GlobalState, file, text: string): State
@@ -50,12 +51,30 @@ func pstate(self: Interpreter): ProcState =
 
 proc exec*(self: Interpreter, nodes: openArray[Node])
 
+proc runf(self: Interpreter, v: Value) =
+  self.state.check(v.args)
+
+  let
+    prevClos = self.closure
+    ps = self.pstate
+
+  defer:
+    self.closure = prevClos
+
+  ps.closure = v.closure
+  self.closure = cast[ptr ClosureState](v.closure)
+
+  if v.ptype == ptLiteral:
+    evalValues(self.state, ps, v.values)
+  else:
+    v.run(cast[pointer](self.state), ps)
+
 proc runDeferred*(self: Interpreter) =
   self.state.deferred.add(@[])
   defer: discard self.state.deferred.pop()
 
   for p in self.state.deferred[^2]:
-    p.run(cast[pointer](self.state), self.pstate)
+    self.runf(p)
 
 proc exec(self: Interpreter, n: Node) =
   logger.logd("DEFERRED: " & $self.state.deferred)
@@ -76,29 +95,23 @@ proc exec(self: Interpreter, n: Node) =
   of nList:
     var i = newInterpreter(self.state.dicts)
     i.state.g = self.state.g
+    i.state.parent = self.state
     i.exec(n.nodes)
     self.state.push(newList(i.state.stack))
   of nProc:
-    self.state.push(newProcedure(n.nodes))
+    let
+      p = newProcedure(n.nodes)
+      clos = self.state.closure()
+
+    p.closure = cast[pointer](clos)
+
+    self.state.push(p)
   of nWord:
     logger.logdv("Found word with value '" & n.tok.lit & "'")
-    let v = self.state.get(n.tok.lit)
+    let v = self.state.get(n.tok.lit, self.closure.stateFromClosure())
 
     if v.typ == tProcedure:
-      logger.logdv("Word is a function")
-      logger.logdv(fmt"As debug: `{v.debug()}`")
-
-      logger.logdv("Checking function arguments")
-      self.state.check(v.args)
-
-      logger.logdv("Executing function")
-
-      let ps = self.pstate
-
-      if v.ptype == ptLiteral:
-        evalValues(self.state, ps, v.values)
-      else:
-        v.run(cast[pointer](self.state), ps)
+      self.runf(v)
     else:
       logger.logdv("Word is not a function")
       self.state.push(v)
@@ -113,20 +126,17 @@ proc exec(self: Interpreter, n: Node) =
         discard self.state.dend(self.pstate)
 
     if v.typ == tProcedure and not literal:
-      self.state.check(v.args)
-
-      let ps = self.pstate
-
-      if v.ptype == ptLiteral:
-        evalValues(self.state, ps, v.values)
-      else:
-        v.run(cast[pointer](self.state), ps)
+      self.runf(v)
     else:
       self.state.push(v)
 
 proc exec*(self: Interpreter, nodes: openArray[Node]) =
   if self.state.nodeRunner == nil:
-    self.state.nodeRunner = proc(nodes: seq[Node]) = self.exec(nodes)
+    self.state.nodeRunner = proc(nodes: seq[Node], closure: pointer) =
+      let prevClos = self.closure
+      defer: self.closure = prevClos
+      self.closure = cast[ptr ClosureState](closure)
+      self.exec(nodes)
 
   for n in nodes:
     try:

src/state.nim

@@ -26,8 +26,13 @@ type
     importCache*: TableRef[string, ImportCacheEntry]
     cleanup*: seq[proc()]
 
+  ClosureState* = object
+    g*: GlobalState
+    dicts*: seq[Dict]
+
   State* = ref object
     g*: GlobalState
+    parent*: State
     dictMin: int
     dicts: seq[Dict]
     stack: seq[Value]
@@ -50,6 +55,12 @@ func copy*(dict: Dict): Dict =
   for (k, v) in dict.pairs:
     result[k] = v
 
+func pairSeq*(dict: Dict): seq[(string, Value)] =
+  result = newSeqOfCap[(string, Value)](dict.len)
+
+  for p in dict.pairs:
+    result.add(p)
+
 
 func newGlobalState*(exe, file: string, args: seq[string]): GlobalState =
   new result
@@ -59,8 +70,17 @@ func newGlobalState*(exe, file: string, args: seq[string]): GlobalState =
   result.importCache = newTable[string, ImportCacheEntry](0)
 
 
-func newState*(dictMin: int, dicts: varargs[Dict]): State =
+func stateFromClosure*(clos: ptr ClosureState): State =
+  if clos == nil:
+    return nil
+
   new result
+  result.g = clos[].g
+  result.dicts = clos[].dicts
+
+func newState*(dictMin: int, dicts: varargs[Dict], parent: State = nil): State =
+  new result
+  result.parent = parent
   result.dictMin = dictMin
   result.dicts = newSeqOfCap[Dict](varargsLen(dicts))
   result.deferred = newSeqOfCap[seq[Value]](varargsLen(dicts))
@@ -78,6 +98,8 @@ proc doCleanup*(self: State) =
   for f in self.g.cleanup:
     f()
 
+  self.g.cleanup = @[]
+
 func dicts*(self: State): seq[Dict] =
   self.dicts
 
@@ -88,6 +110,18 @@ func dbegin*(self: State, dict: Dict) =
   self.dicts.add(dict)
   self.deferred.add(@[])
 
+proc closure*(self: State): ptr ClosureState =
+  let clos = allocZ(ClosureState)
+  clos[].g = self.g
+  clos[].dicts = newSeqOfCap[Dict](self.dicts.len)
+
+  for d in self.dicts:
+    clos[].dicts.add(d)
+
+  self.g.cleanup.add(proc() = dealloc(clos))
+  
+  clos
+
 func dbegin*(self: State, size: int) =
   self.dbegin(newDict(size))
 
@@ -110,11 +144,14 @@ func has*(self: State, name: string): bool =
 proc set*(self: State, name: string, val: Value) =
   self.dicts[^1][name] = val
 
-proc get*(self: State, name: string): Value =
+proc get*(self: State, name: string, closure: State = nil): Value =
   for d in self.dicts.rev:
     if d.hasKey(name):
       return d[name]
 
+  if closure != nil:
+    return closure.get(name)
+
   raise newPgError(fmt"Undefined symbol '{name}'")
 
 proc unset*(self: State, name: string): bool =
@@ -160,6 +197,9 @@ proc push*(self: State, val: Value) =
 
 func pop*(self: State): Value =
   if self.stack.len == 0:
+    if self.parent != nil:
+      return self.parent.pop()
+
     raise newPgError("stack underflow")
 
   self.stack.pop()
@@ -174,14 +214,38 @@ func peek*(self: State, ind: BackwardsIndex): Value =
   self.peek(self.stack.len - int(ind))
 
 proc check*(self: State, args: ProcArgs) =
-  if self.stack.len < args.len:
-    raise newPgError(fmt"Expected {args.len} items on the stack but found {self.stack.len} items instead")
+  if args.len == 0:
+    return
+
+  var
+    srcState = self
+    ind = args.len - 1
+    stackLen = 0
+    stack = newSeq[Value](args.len)
+
+  while true:
+    if srcState.stack.len > 0:
+      for i in countdown(srcState.stack.len - 1, 0, 1):
+        if ind < 0:
+          break
+
+        stack[ind] = srcState.stack[i]
+        dec ind
+        inc stackLen
+
+    if ind < 0 or srcState.parent == nil:
+      break
+
+    srcState = srcState.parent
+
+  if stackLen < args.len:
+    raise newPgError(fmt"Expected {args.len} items on the stack but found {stackLen} items instead")
 
-  var i = self.stack.len - 1
+  var i = stack.len - 1
 
   for pst in args:
-    if self.stack[i] isnot pst.typ:
-      raise newPgError(fmt"Expected type {pst.typ} for argument {pst.name} at stack position {i + 1}, but found type {self.stack[i].typ} instead")
+    if stack[i] isnot pst.typ:
+      raise newPgError(fmt"Expected type {pst.typ} for argument {pst.name} at stack position {i + 1}, but found type {stack[i].typ} instead")
 
     dec i
 

src/value.nim

@@ -33,12 +33,13 @@ type
     tProcedure = 0b100000000,
     tExtitem   = 0b1000000000
 
-  Runner* = proc(nodes: seq[Node])
+  Runner* = proc(nodes: seq[Node], closure: pointer)
 
   ProcState* = ref object
     r*: Runner
     rand*: Rand
     deferred*: seq[seq[Value]]
+    closure*: pointer
 
   NativeProc* = proc(s: pointer, ps: ProcState)
   ProcArgs* = seq[tuple[name: string, typ: Type]]
@@ -72,6 +73,7 @@ type
     of tProcedure:
       args*: ProcArgs
       lit*: bool
+      closure*: pointer
       case ptype: ProcType
       of ptNative:
         native: NativeProc
@@ -301,7 +303,7 @@ proc run*(self: Value, s: pointer, ps: ProcState) =
     self.native(s, ps)
   elif self.ptype == ptComposite:
     if self.nodes.len > 0:
-      ps.r(self.nodes)
+      ps.r(self.nodes, ps.closure)
   elif self.ptype == ptLiteral:
     panic(fmt"Literal procedures cannot be executed via 'run'")
   else: