Page 0.28.0

- Type unions are no longer stored as sets
- Renamed src/std/testing.nps to src/std/testing.pg
- Added the 'os' builtin library with the 'stderr', 'stdout', and 'stdin' symbols
- Added the 'io' builtin library with the 'f-write', 'f-open', 'f-close', and 'f-read' operators
- Added the ExtItem datatype, which represents a pointer to abstract data

Author: voidwyrm-2

page.nimble

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

src/builtinlibs/libhttp.nim

@@ -30,7 +30,7 @@ addF("init", """
 'init'
 UA R ->
 Initializes the HTTP client with the useragent UA and maximum redirects R.
-""", @[("UA", t tString), ("R", t tInteger)]):
+""", @[("UA", tString), ("R", tInteger)]):
   let
     redirects = s.pop().intv
     useragent = s.pop().strv
@@ -42,7 +42,7 @@ addF("req", """
 U B T -> R
 Sends a request of a specified type T with a body B to a url U,
 then returns a response R.
-""", @[("U", t tString), ("B", t tString), ("T", t tSymbol)]):
+""", @[("U", tString), ("B", tString), ("T", tSymbol)]):
   checkClient()
 
   let
@@ -72,26 +72,26 @@ addS("get", """
 'get'
 U -> R
 Sends a GET request to a URL U.
-""", @[("U", t tString)]):
+""", @[("U", tString)]):
   "() /GET req"
 
 addS("post", """
 'post'
 U B -> R
 Sends a POST request to a URL U with a body B.
-""", @[("U", t tString)]):
+""", @[("U", tString)]):
   "/POST req"
 
 addS("put", """
 'put'
 U B -> R
 Sends a PUT request to a URL U with a body B.
-""", @[("U", t tString)]):
+""", @[("U", tString)]):
   "/POST req"
 
 addS("delete", """
 'delete'
 U -> R
 Sends a DELETE request to a URL U.
-""", @[("U", t tString)]):
+""", @[("U", tString)]):
   "() /DELETE req"

src/builtinlibs/libio.nim

@@ -0,0 +1,123 @@
+import std/[
+  strutils,
+  strformat,
+  os
+]
+
+import common
+
+
+let lib* = newDict(0)
+
+template addV(name, doc: string, item: Value) =
+  addV(lib, name, doc, item)
+
+template addF(name, doc: string, args: ProcArgs, body: untyped) =
+  addF(lib, name, doc, args, body)
+
+template addS(name, doc: string, args: ProcArgs, body: string) =
+  addS(lib, "io.pg", name, doc, args, body)
+
+
+func newPgFile*(f: File, path: string): Value =
+  result = newExtitem(cast[pointer](f))
+  
+  let fname = fmt"File object at '{path}'"
+
+  result.id = "File"
+  result.fmtf = func(_: pointer): string = fname
+
+
+addF("f-open",
+"""
+'f-open'
+P M -> F
+Opens a filepath P with the specified mode symbol M and returns its file object F.
+The valid modes are:
+- /r (read); opens the file for reading, throws an error if the file doesn't exist.
+- /w (write); opens the file for writing, throws an error if the file doesn't exist.
+- /rw (readwrite); opens the file for reading and writing, throws an error if the file doesn't exist.
+- /a (append); opens the file for writing and appends to the end of the file when written to, throws an error if the file doesn't exist.
+- /c (create); opens the file for reading and writing, creates the file if it doesn't exist.
+""", @[("P", tString), ("M", tSymbol)]):
+  let
+    modeName = s.pop().strv
+    path = s.pop().strv
+
+  var
+    mode: FileMode
+    f: File
+
+  case modeName
+  of "r":
+    mode = fmRead
+  of "w":
+    mode = fmWrite
+  else:
+    raise newPgError(fmt"Invalid file mode '{modeName}'")
+
+  if not path.fileExists() and mode != fmReadWrite:
+    raise newPgError(fmt"File '{path}' does not exist")
+
+  if not f.open(path, mode):
+    raise newPgError(fmt"File '{path}' could not be opened")
+
+  s.push(f.newPgFile(path.absolutePath()))
+
+addF("f-close",
+"""
+'f-close'
+F ->
+Closes a file object F.
+Trying to use a file object after it was closed is undefined behavior.
+""", @[("F", tExtitem)]):
+  let fobj = s.pop()
+
+  if fobj isnot "File":
+    raise newPgError("Given object is not a File object")
+
+  let f = cast[File](fobj.dat)
+
+  f.close()
+
+addF("f-read",
+"""
+'f-readall'
+F -> S
+Reads everything from a file object F and returns the contents S.
+""", @[("F", tExtitem)]):
+  let fobj = s.pop()
+
+  if fobj isnot "File":
+    raise newPgError("Given object is not a File object")
+
+  let f = cast[File](fobj.dat)
+
+  var content: string
+
+  try:
+    content = f.readAll()
+  except IoError as e:
+    raise newPgError(e.msg)
+
+  s.push(newString(content))
+
+addF("f-write",
+"""
+'f-write'
+F S -> WS
+Writes a string S to a file object F and returns the amount written WS.
+""", @[("F", tExtitem), ("S", tString)]):
+  let
+    str = s.pop().strv
+    fobj = s.pop()
+
+  if fobj isnot "File":
+    raise newPgError("Given object is not a File object")
+
+  let f = cast[File](fobj.dat)
+
+  try:
+    f.write(str)
+  except IoError as e:
+    raise newPgError(e.msg)

src/builtinlibs/libos.nim

@@ -0,0 +1,46 @@
+import
+  common,
+  libio
+
+
+let lib* = newDict(0)
+
+template addV(name, doc: string, item: Value) =
+  addV(lib, name, doc, item)
+
+template addF(name, doc: string, args: ProcArgs, body: untyped) =
+  addF(lib, name, doc, args, body)
+
+template addS(name, doc: string, args: ProcArgs, body: string) =
+  addS(lib, "os.pg", name, doc, args, body)
+
+
+let
+  pgStdin* = stdin.newPgFile("stdin")
+  pgStdout* = stdin.newPgFile("stdout")
+  pgStderr* = stdin.newPgFile("stderr")
+
+
+addV("stdin",
+"""
+'stdin'
+-> F
+Returns the file object for STDIN.
+"""):
+  pgStdin
+
+addV("stdout",
+"""
+'stdout'
+-> F
+Returns the file object for STDOUT.
+"""):
+  pgStdout
+
+addV("stderr",
+"""
+'stderr'
+-> F
+Returns the file object for STDERR.
+"""):
+  pgStderr

src/builtinlibs/libstrings.nim

@@ -23,7 +23,7 @@ addF("chars",
 'chars'
 S -> L
 Separates a string S into a list L of character strings.
-""", @[("S", t tString)]):
+""", @[("S", tString)]):
   let str = s.pop().strv
 
   var chars = newSeq[Value](str.len)
@@ -38,7 +38,7 @@ addF("split",
 'split'
 S D -> L
 Separates a string S into a list L of parts by a delimiter D.
-""", @[("S", t tString), ("D", t tString)]):
+""", @[("S", tString), ("D", tString)]):
   let
     delim = s.pop().strv
     str = s.pop().strv
@@ -55,7 +55,7 @@ addF("replace",
 'replace'
 S Old New -> S'
 Replaces all occurences of Old with New in a string S.
-""", @[("S", t tString), ("Old", t tString), ("New", t tString)]):
+""", @[("S", tString), ("Old", tString), ("New", tString)]):
   let
     new = s.pop().strv
     old = s.pop().strv
@@ -68,7 +68,7 @@ addF("joins",
 'joins'
 L D -> S
 Combines a list of strings L into a single string S, separated by delimiter D.
-""", @[("L", t tList), ("D", t tString)]):
+""", @[("L", tList), ("D", tString)]):
   let
     delim = s.pop().strv
     l = s.pop().listv
@@ -87,14 +87,14 @@ addS("join",
 """
 L -> S
 Joins a list of strings end to end.
-""", @[("L", t tList)]):
+""", @[("L", tList)]):
   "() joins"
 
 addF("lower",
 """
 S -> S'
 Sets all the ASCII letters of a string S to lowercase and returns the resulting string S'.
-""", @[("S", t tString)]):
+""", @[("S", tString)]):
   let str = s.pop().strv
 
   s.push(newString(str.toLowerAscii()))
@@ -103,7 +103,7 @@ addF("upper",
 """
 S -> S'
 Sets all the ASCII letters of a string S to uppercase and returns the resulting string S'.
-""", @[("S", t tString)]):
+""", @[("S", tString)]):
   let str = s.pop().strv
 
   s.push(newString(str.toUpperAscii()))