NPScript 0.23.0

- (Fix) Symbols were being resolved from the oldest dict to the newest dict instead of the other way around
- 'symbols' has been replaced with 'psymbols', 'symbols' now operates differently
- 'langver' has been renamed to 'version'
- Added the 'product', 'bind', 'rsymbols', 'psymbols', and 'prsymbols' builtin operators
- 'get' and 'put' now support negative indexes
- Procedures can now be 'literal', meaning symbols inside of them are pre-resolved

Author: voidwyrm-2

npscript.nimble

@@ -1,6 +1,6 @@
 # Package
 
-version       = "0.22.0"
+version       = "0.23.0"
 author        = "Nuclear Pasta"
 description   = "A PostScript implementation"
 license       = "Apache-2.0"

src/builtinlibs/libstrings.nim

@@ -72,7 +72,7 @@ Combines a list of strings L into a single string S, separated by delimiter D.
   var strs = newSeqOfCap[string](l.len)
 
   for v in l:
-    if v.kind != tString:
+    if v.typ != tString:
       raise newNpsError("List argument for 'joins' must be only strings")
 
     strs.add(v.strv)

src/builtins.nim

@@ -6,14 +6,16 @@ import std/[
   random,
   os,
   sequtils,
-  math
+  math,
+  enumerate
 ]
 
 from system/nimscript import nil
 
 import
   npsenv,
   lexer,
+  parser,
   builtinlibs/[
     common,
     libstrings,
@@ -27,15 +29,28 @@ elif defined(danger):
 else:
   const buildMode = "debug"
 
-const langVersion* = staticRead("../npscript.nimble")
-  .split("\n")
-  .filterIt(it.startsWith("version"))[0]
-  .split("=")[^1]
-  .strip()[1..^2] & (if buildMode != "release": "+" & buildMode else: "")
+const
+  langVersion* = staticRead("../npscript.nimble")
+    .split("\n")
+    .filterIt(it.startsWith("version"))[0]
+    .split("=")[^1]
+    .strip()[1..^2] & (if buildMode != "release": "+" & buildMode else: "")
+
+  product = "NPScript"
+
+  helpMessage = staticRead("data/helpmsg.txt")
+    .strip()
+    .colorize()
+
+  helpMessageExtended = staticRead("data/helpmsgext.txt")
+    .strip()
+    .colorize()
+
 
 static:
   echo "Compiling NPScript ", langVersion, " on ", nimscript.buildOS, "/", nimscript.buildCPU, " for ", hostOS, "/", hostCPU, " in ", buildMode, " mode"
 
+
 let builtins* = newDict(0)
 
 template addV(name, doc: static string, item: Value) =
@@ -129,24 +144,47 @@ proc importFile*(s: State, path: string): Value =
   return substate.get("export")
 
 
+proc literalize(s: State, nodes: seq[Node]): seq[Value] =
+  result = newSeq[Value](nodes.len)
+
+  for (i, node) in enumerate(nodes):
+    case node.typ
+    of nSymbol:
+      result[i] = newSymbol(node.tok.lit)
+    of nString:
+      result[i] = newString(node.tok.lit)
+    of nInteger:
+      let num = parseInt(node.tok.lit)
+      result[i] = newInteger(num)
+    of nReal:
+      let num = parseFloat(node.tok.lit)
+      result[i] = newReal(num)
+    of nList:
+      result[i] = newList(literalize(s, node.nodes))
+    of nProc:
+      result[i] = newProcedure(node.nodes)
+    of nWord:
+      result[i] = s.get(node.tok.lit)
+
+
 # Meta operators
 
-addV("langver",
+addV("version",
 """
-'langver'
--> version
+'version'
+-> string
 Returns the current version of the language as a string.
 """):
   newString(langVersion)
 
-const
-  helpMessage = staticRead("data/helpmsg.txt")
-    .strip()
-    .colorize()
-
-  helpMessageExtended = staticRead("data/helpmsgext.txt")
-    .strip()
-    .colorize()
+addV("product",
+"""
+'product'
+-> string
+Returns the product name.
+This is included for compatibility with other PostScript implementations.
+"""):
+  newString(product)
 
 # ->
 # Prints a help message to assist people with writing the language.
@@ -205,7 +243,7 @@ The returned docstring may be empty.
 # X -> typeof X
 # Returns a symbol that describes the type of a value X.
 addF("type", @[("X", tAny)]):
-  let tstr = $s.pop().kind
+  let tstr = $s.pop().typ
 
   s.push(newSymbol(tstr))
 
@@ -260,14 +298,24 @@ addF("quitn", @[("E", tInteger)]):
 addF("exit", @[]):
   raise NpsExitError()
 
+# F -> F
+# Replaces operator names in F with operator values
+addF("bind", @[("F", tProcedure)]):
+  let f = s.pop()
+
+  s.push(newProcedure(f, literalize(s, f.nodes)))
+
 # F ->
 # Takes a function F and executes it.
 addF("exec", @[("F", tProcedure)]):
   let f = s.pop()
 
   s.check(f.args)
-    
-  f.run(sptr, r)
+
+  if f.ptype == ptLiteral:
+    evalValues(s, r, f.values)
+  else:
+    f.run(sptr, r)
 
 # Stack operators
 
@@ -347,7 +395,8 @@ addMathOp("mod", `%`)
 # Computes the power of X and Y.
 addMathOp("exp", `^`)
 
-addV("pi", """
+addV("pi",
+"""
 -> pi
 Returns the value of Pi.
 """):
@@ -639,21 +688,27 @@ addF("array", @[("S", tInteger)]):
 
 # L I -> L[I]
 # Gets the value at an index I of a list L.
+# Negative indexes will index from the back of the list
 addF("get", @[("L", tList), ("I", tInteger)]):
   let
-    ind = s.pop().intv
+    i = s.pop().intv
     arr = s.pop()
 
+  let ind = if i < 0: arr.len - -i else: i
+
   s.push(arr[ind])
 
 # L I X -> L[I] = X
 # Sets an index I of a list L to a value X.
+# Negative indexes will index from the back of the list
 addF("put", @[("L", tList), ("I", tInteger), ("X", tAny)]):
   let
     val = s.pop()
-    ind = s.pop().intv
+    i = s.pop().intv
     arr = s.pop()
 
+  let ind = if i < 0: arr.len - -i else: i
+
   arr[ind] = val
 
 
@@ -694,6 +749,11 @@ addF("begin", @[("D", tDict)]):
 addF("end", @[]):
   discard s.dend()
 
+# ->
+# Returns the last opened dictionary.
+addF("this", @[]):
+  s.push(newDictionary(s.dicts[^1]))
+
 # D S ->
 # Adds a symbol S from a dictionary D into the current dictionary.
 # If S already exists in it current dictionary, it will be overwritten.
@@ -716,7 +776,6 @@ addF("allfrom", @[("D", tDict)]):
   for k, v in d.pairs:
     s.set(k, v)
 
-
 addS("scoped",
 """
 'scoped'
@@ -742,12 +801,62 @@ begin
   if
 end"""
 
-# ->
-# Shows the symbols inside the last opened dictionary.
+# -> L
+# Returns a list of the symbols inside the last opened dictionary.
 addF("symbols", @[]):
-  for symbol in s.symbols():
-    echo symbol
+  let symbols = s.symbols
+  var l = newSeq[Value](symbols.len)
 
+  for (i, symbol) in enumerate(symbols):
+    l[i] = newSymbol(symbol)
+
+  s.push(newList(l))
+
+# -> L
+# Returns a list of lists of the symbols in each dictionary.
+addF("rsymbols", @[]):
+  let dicts = s.dicts
+  var l = newSeq[Value](dicts.len)
+
+  for (i, dict) in enumerate(dicts):
+    var
+      subl = newSeq[Value](dict.len)
+      j = 0
+
+    for symbol in dict.keys:
+      subl[j] = newSymbol(symbol)
+      inc j
+
+    l[i] = newList(subl)
+
+  s.push(newList(l))
+
+addS("psymbols",
+"""
+'psymbols'
+->
+Shows the symbols inside the last opened dictionary.
+""", @[]):
+  "symbols {=} forall"
+
+addS("prsymbols",
+"""
+'prsymbols'
+->
+# Shows the symbols in each dictionary.
+""", @[]):
+  """
+1 rsymbols 
+{
+  exch dup
+  (%f:\n) printf
+  exch
+
+  {( ) printf =}
+  forall
+  1 add
+} forall
+pop"""
 
 # Misc operators
 
@@ -756,22 +865,28 @@ let
   falseSingleton = newBool(false)
   nullSingleton = newNull()
 
-addV("null", """
+addV("null",
+"""
 'null'
 -> null
-Produces the value of null."""):
+Produces the value of null.
+"""):
   nullSingleton
 
-addV("true", """
+addV("true",
+"""
 'true'
 -> true
-Produces the boolean true value."""):
+Produces the boolean true value.
+"""):
   trueSingleton
 
-addV("false", """
+addV("false",
+"""
 'false'
 -> false
-Produces the boolean false value."""):
+Produces the boolean false value.
+"""):
   falseSingleton
 
 # X -> len of X

src/general.nim

@@ -9,6 +9,10 @@ import std/[
 import pkg/regex
 
 
+func panic*(msg: string) =
+  raise newException(Defect, msg)
+
+
 type
   NpsError* = ref object of CatchableError
     stackTrace: seq[string]
@@ -133,6 +137,11 @@ proc colorize*(str: string): string =
   str.replace(colorFinder, (m, s) => s[m.group(0)].getStyleForName())
 
 
+iterator rev*[T](arr: openArray[T]): T =
+  for i in countdown(arr.len - 1, 0, 1):
+    yield arr[i]
+
+
 macro select*(val, cases: untyped): untyped =
   let
     eq = newTree(nnkAccQuoted, ident"==")

src/interpreter.nim

@@ -63,14 +63,20 @@ proc exec(self: Interpreter, n: Node) =
     logger.logdv("Found word with value '" & n.tok.lit & "'")
     let v = self.state.get(n.tok.lit)
 
-    if v.kind == tProcedure:
+    if v.typ == tProcedure:
       logger.logdv("Word is a function")
 
       logger.logdv("Checking function arguments")
       self.state.check(v.args)
 
       logger.logdv("Executing function")
-      v.run(cast[pointer](self.state), proc(nodes: seq[Node]) = self.exec(nodes))
+
+      let runner = proc(nodes: seq[Node]) = self.exec(nodes)
+
+      if v.ptype == ptLiteral:
+        evalValues(self.state, runner, v.values)
+      else:
+        v.run(cast[pointer](self.state), runner)
     else:
       logger.logdv("Word is not a function")
       self.state.push(v)

src/npsenv.nim

@@ -56,7 +56,7 @@ proc writeStdlib*(force: bool) =
       logger.log fmt"Could not write '{item.path}' to {npsStd}:"
       logger.log " " & e.msg
 
-  echo ""
+  logger.log ""
 
 
 type

src/parser.nim

@@ -29,7 +29,7 @@ type
     toks: seq[Token]
     idx: int
 
-proc dbgLit*(node: Node): string =
+func dbgLit*(node: Node): string =
   case node.typ
     of nWord, nSymbol, nString, nInteger, nReal:
       node.tok.dbgLit