spitewaste 0.1.012 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 67ded3120c199b08555950070ea3339978a7a23537b902477c69a87d2fe83469
-  data.tar.gz: 6c49ae6ecb268e39894127bdcf5a0c0ba252b5d218b7c3d582b54461f06e48ca
+  metadata.gz: 84437462681ee4c493843fd0c063456b2a0965a6b2717dfabfc7f21fba5c6f08
+  data.tar.gz: 7d7da5a8ca6a201b411e4ed2b739e356bddc8296a0de881fd54f731e433a2910
 SHA512:
-  metadata.gz: a2900fb2ebb4f6cfbb6503615ceb0b8b65ab729cb10354b626397a348867430256bf6d6f60afe9805fec7893a3e327e62144e1f3edba83af12ea7eaabbeb52ce
-  data.tar.gz: f0b3c878bc133874a16255b94076eb9e7ff8f7fb1d438b368fadf53df9f2fff94c466ed90c94011da1008c5a7249370e3bb995903f2b9135bdb968f7505b8cc7
+  metadata.gz: 45acda5886e57621411c7c29b55dc7d7f3b01a8d3f87fe96bc6f16f2781df255207728f0a58b8adba8143b23742e831e55a0fe61026d13c1d9b89faf965104d3
+  data.tar.gz: 4c9cbc788a8f9d50706dda70d1e3d32152bfe7bfc2821a13ed66ff107e082c20d322fb4106835976ab113caebf54d42247031c610e4174ce165f9f0a2988f63a

data/Rakefile

@@ -15,9 +15,8 @@ task :docs do |t|
 
   Dir.chdir('lib/spitewaste/libspw') do |d|
     Dir['*.spw'].sort.each do |path|
-      next if path['random']
-      lib = File.basename path, '.spw'
-      docs[lib] = extract_docs path
+      mod = File.basename path, '.spw'
+      docs[mod] = extract_docs path
     end
 
     File.open('docs.json', ?w) { |f|

data/lib/spitewaste.rb

@@ -21,6 +21,10 @@ module Spitewaste
     return :whitespace if white > black
     program[/import|[^-\w\s]/] ? :spitewaste : :assembly
   end
+
+  def strpack s
+    s.bytes.zip(0..).sum { |b, e| b * 128 ** e }
+  end
 end
 
 require 'spitewaste/assembler'

data/lib/spitewaste/assembler.rb

@@ -85,7 +85,7 @@ module Spitewaste
       @ip = 0
       while @instructions[@ip]
         next @ip -= 1 if optimize_constant_pow
-        next if optimize_constant_strpack
+        # next if optimize_constant_strpack
         @ip += 1
       end
     end

data/lib/spitewaste/emitters/image.rb

@@ -4,7 +4,8 @@ require 'yaml'
 
 module Spitewaste
   class ImageEmitter < Emitter
-    SCHEMES  = YAML.load_file(File.join __dir__, 'schemes.yaml')['schemes']
+    schemes  = File.read File.join __dir__, 'schemes.yaml'
+    SCHEMES  = YAML.safe_load(schemes, aliases: true)['schemes']
     LINEFEED = ChunkyPNG::Image.from_file File.join __dir__, 'linefeed.png'
     DEFAULTS =  {
       colors: 'gruvbox_dark',
@@ -112,7 +113,7 @@ module Spitewaste
       flow:  %i[jump jz jn ret exit],
       math:  %i[add sub mul div mod],
       heap:  %i[store load],
-      io:    %i[ichr inum ochr onum],
+      io:    %i[ichr inum ochr onum shell],
       calls: %i[call label]
     }.flat_map { |type, insns| insns.map { |i| [i, type] } }.to_h
 

data/lib/spitewaste/emitters/schemes.yaml

@@ -599,6 +599,52 @@ schemes:
       cyan:    '0x99faf2'
       white:   '0xffffff'
 
+  konsole_linux: &konsole_linux
+    primary:
+      foreground: '0xe3e3e3'
+      bright_foreground: '0xffffff'
+      dim_foreground:    '0xe3e3e3'
+      background: '0x1f1f1f'
+      bright_background: '0x686868' # not sure
+      dim_background:    '0x1f1f1f' # not sure
+    cursor:
+      text: '0x191622'
+      cursor: '0xf8f8f2'
+    search:
+      matches:
+        foreground: '0xb2b2b2'
+        background: '0xb26818'
+      focused_match:
+        foreground: CellBackground
+        background: CellForeground
+    normal:
+      black:   '0x000000'
+      red:     '0xb21818'
+      green:   '0x18b218'
+      yellow:  '0xb26818'
+      blue:    '0x1818b2'
+      magenta: '0xb218b2'
+      cyan:    '0x18b2b2'
+      white:   '0xb2b2b2'
+    bright:
+      black:   '0x686868'
+      red:     '0xff5454'
+      green:   '0x54ff54'
+      yellow:  '0xffff54'
+      blue:    '0x5454ff'
+      magenta: '0xff54ff'
+      cyan:    '0x54ffff'
+      white:   '0xffffff'
+    dim:
+      black:   '0x000000'
+      red:     '0xb21818'
+      green:   '0x18b218'
+      yellow:  '0xb26818'
+      blue:    '0x1818b2'
+      magenta: '0xb218b2'
+      cyan:    '0x18b2b2'
+      white:   '0xb2b2b2'
+
   low_contrast: &low_contrast
     primary:
       background: '0x333333'
@@ -717,6 +763,41 @@ schemes:
       cyan:    '0x5fb3b3'
       white:   '0xadb5c0'
 
+  omni: &omni
+    primary:
+      background: '0x191622'
+      foreground: '0xe1e1e6'
+    cursor:
+      text: '0x191622'
+      cursor: '0xf8f8f2'
+    normal:
+      black: '0x000000'
+      red: '0xff5555'
+      green: '0x50fa7b'
+      yellow: '0xeffa78'
+      blue: '0xbd93f9'
+      magenta: '0xff79c6'
+      cyan: '0x8d79ba'
+      white: '0xbfbfbf'
+    bright:
+      black: '0x4d4d4d'
+      red: '0xff6e67'
+      green: '0x5af78e'
+      yellow: '0xeaf08d'
+      blue: '0xcaa9fa'
+      magenta: '0xff92d0'
+      cyan: '0xaa91e3'
+      white: '0xe6e6e6'
+    dim:
+      black: '0x000000'
+      red: '0xa90000'
+      green: '0x049f2b'
+      yellow: '0xa3b106'
+      blue: '0x530aba'
+      magenta: '0xbb006b'
+      cyan: '0x433364'
+      white: '0x5f5f5f'
+
   one_dark: &one_dark
     primary:
       background: '0x1e2127'
@@ -740,6 +821,29 @@ schemes:
       cyan:    '0x56b6c2'
       white:   '0xffffff'
 
+  palenight: &palenight
+    primary:
+      background: '0x292d3e'
+      foreground: '0xd0d0d0'
+    normal:
+      black:   '0x292d3e'
+      red:     '0xf07178'
+      green:   '0xc3e88d'
+      yellow:  '0xffcb6b'
+      blue:    '0x82aaff'
+      magenta: '0xc792ea'
+      cyan:    '0x89ddff'
+      white:   '0xd0d0d0'
+    bright:
+      black:   '0x434758'
+      red:     '0xff8b92'
+      green:   '0xddffa7'
+      yellow:  '0xffe585'
+      blue:    '0x9cc4ff'
+      magenta: '0xe1acff'
+      cyan:    '0xa3f7ff'
+      white:   '0xffffff'
+
   papercolor_light: &papercolor_light
     primary:
       background: '0xeeeeee'
@@ -812,6 +916,29 @@ schemes:
       cyan:    '0x4fb8cc'
       white:   '0xf1f1f1'
 
+  remedy_dark: &remedy_dark
+    primary:
+      background: '0x2c2b2a'
+      foreground: '0xf9e7c4'
+    normal:
+      black:   '0x282a2e'
+      blue:    '0x5f819d'
+      cyan:    '0x5e8d87'
+      green:   '0x8c9440'
+      magenta: '0x85678f'
+      red:     '0xa54242'
+      white:   '0x707880'
+      yellow:  '0xde935f'
+    bright:
+      black:   '0x373b41'
+      blue:    '0x81a2be'
+      cyan:    '0x8abeb7'
+      green:   '0xb5bd68'
+      magenta: '0xb294bb'
+      red:     '0xcc6666'
+      white:   '0xc5c8c6'
+      yellow:  '0xf0c674'
+
   snazzy: &snazzy
     primary:
       background: '0x282a36'

data/lib/spitewaste/libspw/array.spw

@@ -10,6 +10,12 @@ import util  ; dec, die!, eq
 
 $amax = 1000
 
+; prints the array A to stdout in the form [e1,e2,...]
+; [A] => []
+aryprint:
+  map (:to_s) push ',' :strjoinc
+  push '[' ochr :print push ']' ochr ret
+
 ; places an array of N elements E at the top of the stack
 ; [N E] => [A]
 ;
@@ -36,7 +42,23 @@ arysum: reduce (add) ret
 ; [7 50 10 2] => [7 50 10 2 50 10 2]
 arydup:
   dup $++ push -2 copy 1 store
-  times (push -2 load $-- :ncopy) ret
+  times (@-2 $-- :ncopy) ret
+
+; returns 1 if the arrays A1 and A2 have the same length and
+; contain the same elements in the same order, 0 otherwise
+; [A1 A2] => [0 | 1]
+;
+; [1 2 3 3 1 2 3 3] => [1]
+; [1 2 3 3 3 2 1 3] => [0]
+; [1 2 2 1 2 3 3] => [0]
+; [1 2 3 3 1 2 2] => [0]
+; [7 10 2 7 10 2] => [1]
+; [6 1 9 1] => [0]
+aryeq: dup $++ :roll copy 1 copy 1 :eq jz _aryeq_difflen ; length mismatch
+  ^-1 times (@-1 :ncopy :eq jz _aryeq_no)
+  push 1 @-1 :nslide ret
+_aryeq_no: push 0 @-1 @-5 sub $-- :nslide ret ; ! -5 is magic from times()
+_aryeq_difflen: add push 0 swap :nslide ret
 
 ; places the element E at the end of the array A, increasing its length by 1
 ; [A E] => [A']
@@ -72,6 +94,23 @@ aryshift: dup :dig $-- ret
 ; [7 2 8 2 0] => [7 0 2 8 3]
 aryunshift: swap dup times (dup $++ :roll swap) $++ ret
 
+; inserts the element E into array A at index I, increasing its length by 1
+; [A I E] => [A']
+;
+; [9 5 2 3 1 4] => [9 4 5 2 4]
+; [1 1 0 7] => [7 1 2]
+; [3 1 1 7] => [3 7 2]
+; [7 5 2 1 6] => [7 6 5 3]
+aryinsert: swap copy 2 swap sub $++ :bury $++ ret
+
+; removes the element at index I in array A, decreasing its length by 1
+; [A I] => [A']
+;
+; [6 0 9 3 1] => [6 9 2]
+; [7 5 3 1 4 0] => [5 3 1 3]
+; [1 3 5 7 4 3] => [1 3 5 3]
+aryremove: copy 1 swap sub :roll pop $-- ret
+
 ; returns the concatenation of arrays A and B
 ; [A B] => [A+B]
 ;
@@ -82,15 +121,15 @@ arycat: dup $++ :roll add ret
 ;;;
 
 arypack:
-  :arydup reduce (:max) $++ push -1 swap store
-  $-- times (push -1 load mul add)
-  push $amax mul push -1 load add
-  push $amax mul push -10 load add ret
+  :arydup reduce (:max) $++ ^-1
+  $-- times (@-1 mul add)
+  push $amax mul @-1 add
+  push $amax mul @-10 add ret
 
 aryunpack:
-  push $amax :divmod push -2 swap store
-  push $amax :divmod push -1 swap store
-  push -2 load times (push -1 load :divmod swap)
+  push $amax :divmod ^-2
+  push $amax :divmod ^-1
+  @-2 times (@-1 :divmod swap)
   push 2 sub load ret
 
 arylen: push $amax mod ret
@@ -121,6 +160,22 @@ aryat:
 _aryat_neg: copy 1 add dup jn _aryat_oob jump aryat
 _aryat_oob: push "(aryat) index out of bounds!" :die!
 
+; swaps the elements at indices I and J in array A
+; [A I J] => [A']
+;
+; [6 0 8 7 4 1 3] => [6 7 8 0 4]
+; [4 3 2 1 4 0 2] => [2 3 4 1 4]
+; [3 2 1 3 1 1] => [3 2 1 3]
+aryswap: copy 1 copy 1 sub jz _aryswap_noop
+  ^-7 ^-6
+  :arydup @-6 :aryat ^-8
+  :arydup @-7 :aryat ^-9
+  @-6 :aryremove
+  @-7 $-- :aryremove
+  @-6 @-9 :aryinsert
+  @-7 @-8 :aryinsert ret
+_aryswap_noop: pop pop ret
+
 ; returns the minimum and maximum elements of array A
 ; [A] => [min max]
 ;
@@ -128,8 +183,8 @@ _aryat_oob: push "(aryat) index out of bounds!" :die!
 ; [6 8 -3 4 0 5] => [-3 8]
 ; [7 1] => [7 7]
 minmax:
-  :arydup reduce (:max) push -1 swap store
-  reduce (:min) push -1 load ret
+  :arydup reduce (:max) ^-1
+  reduce (:min) @-1 ret
 
 ;;; TODO: make sort not atrociously inefficient
 
@@ -137,22 +192,37 @@ sort: push -3 copy 1 store ; preserve length
 _sort_loop:
   :arydup reduce (:min)
   push -1 copy 1 store copy 1 $++ :bury ; stash minimum element
-  :arydup push -1 load :aryindex
+  :arydup @-1 :aryindex
   copy 1 swap sub :dig $-- ; remove minimum element from array
   push 0 copy 1 sub jn _sort_loop
   push 3 sub load ret
 
+; returns 0 if any of the elements in array A is
+; strictly less than the one before it, 1 otherwise
+; [A] => [0 | 1]
+;
+; [1 2 3 3] => [1]
+; [3 2 1 3] => [0]
+; [1 1 2 2 4] => [1]
+; [1 2 3 4 3 5] => [0]
+sorted?: $--
+_sorted_loop:
+  copy 1 copy 3 sub jn _sorted_no
+  $-- dup jz _sorted_yes
+  slide 1 jump _sorted_loop
+_sorted_no: $++ push 0 swap :nslide ret
+_sorted_yes: push 1 slide 3 ret
+
 ; reverses the array A
 ; [A] => [A']
 ;
 ; [1 2 3 3] => [3 2 1 3]
 ; [7 1] => [7 1]
 ; [5 4 3 2 1 5] => [1 2 3 4 5 5]
-aryrev: push -3 copy 1 store
-_aryrev_loop:
-  swap copy 1 :bury $--
-  push 0 copy 1 sub jn _aryrev_loop
-  push 3 sub load ret
+aryrev:
+  push -10 :aryheap push -10
+  @-9 times (dup load swap $--)
+  pop @-9 ret
 
 ; returns the array A replicated N times
 ; ! N must be greater than 1
@@ -163,4 +233,4 @@ aryrep: push -1 swap push -3 copy 1 store store
 _aryrep_loop:
   push -1 dup :dec load jz _aryrep_done
   :arydup jump _aryrep_loop
-_aryrep_done: push -3 load $-- times (:arycat) ret
+_aryrep_done: @-3 $-- times (:arycat) ret

data/lib/spitewaste/libspw/bits.spw

@@ -12,8 +12,8 @@ $bitfun(op, bit, done) {
 push -2,1,-1,0 store store
 _`op`_loop: push -1
   copy 2 push 2 mod copy 2 push 2 mod `bit`
-  push -1 load swap push -2 load dup push 2 mul
-  push -2 swap store mul add store
+  @-1 swap @-2 dup push 2 mul
+  ^-2 mul add store
   push 2 div swap push 2 div
   dup copy 2 mul jz _`op`_done swap jump _`op`_loop
 _`op`_done: `done` ret
@@ -35,7 +35,7 @@ band: $bitfun(band, mul, mul $-- load)
 ; [61 77] => [125]   [93 65] => [93]
 ; [14 87] => [95]    [71 37] => [103]
 ; [7 19]  => [23]    [38 92] => [126]
-bor: $bitfun(bor, add $++ push 2 div, add push -2 load mul push -1 load add)
+bor: $bitfun(bor, add $++ push 2 div, add @-2 mul @-1 add)
 
 ; returns the bitwise XOR of A and B
 ; [A B] => [A ^ B]
@@ -44,7 +44,7 @@ bor: $bitfun(bor, add $++ push 2 div, add push -2 load mul push -1 load add)
 ; [51 5]  => [54]    [97 77] => [44]
 ; [39 65] => [102]   [12 26] => [22]
 ; [44 36] => [8]     [6 21]  => [19]
-bxor: $bitfun(bxor, :neq, add push -2 load mul push -1 load add)
+bxor: $bitfun(bxor, :neq, add @-2 mul @-1 add)
 
 ; returns the infinite-precision bitwise NOT of N by inverting all of its bits
 ; [N] => [~N]
@@ -71,4 +71,8 @@ _blength_zero: ret
 ;
 ; [0] => [0]   [1] => [1]
 ; [7] => [3]   [8] => [1]
-popcount: push 2 :digits reduce (add) ret
+popcount: push 0
+_popcount_loop:
+  copy 1 push 2 mod add swap push 2 div
+  dup jz _popcount_done swap jump _popcount_loop
+_popcount_done: pop ret

data/lib/spitewaste/libspw/docs.json

@@ -135,6 +135,95 @@
         ]
       ]
     },
+    "aryeq": {
+      "full": "returns 1 if the arrays A1 and A2 have the same length and\ncontain the same elements in the same order, 0 otherwise\n[A1 A2] => [0 | 1]\n\n[1 2 3 3 1 2 3 3] => [1]\n[1 2 3 3 3 2 1 3] => [0]\n[1 2 2 1 2 3 3] => [0]\n[1 2 3 3 1 2 2] => [0]\n[7 10 2 7 10 2] => [1]\n[6 1 9 1] => [0]\n",
+      "desc": "returns 1 if the arrays A1 and A2 have the same length and\ncontain the same elements in the same order, 0 otherwise",
+      "effect": "[A1 A2] => [0 | 1]",
+      "cases": [
+        [
+          [
+            1,
+            2,
+            3,
+            3,
+            1,
+            2,
+            3,
+            3
+          ],
+          [
+            1
+          ]
+        ],
+        [
+          [
+            1,
+            2,
+            3,
+            3,
+            3,
+            2,
+            1,
+            3
+          ],
+          [
+            0
+          ]
+        ],
+        [
+          [
+            1,
+            2,
+            2,
+            1,
+            2,
+            3,
+            3
+          ],
+          [
+            0
+          ]
+        ],
+        [
+          [
+            1,
+            2,
+            3,
+            3,
+            1,
+            2,
+            2
+          ],
+          [
+            0
+          ]
+        ],
+        [
+          [
+            7,
+            10,
+            2,
+            7,
+            10,
+            2
+          ],
+          [
+            1
+          ]
+        ],
+        [
+          [
+            6,
+            1,
+            9,
+            1
+          ],
+          [
+            0
+          ]
+        ]
+      ]
+    },
     "aryfill": {
       "full": "places an array of N elements E at the top of the stack\n[N E] => [A]\n\n[3 0] => [0 0 0 3]\n[5 1] => [1 1 1 1 1 5]\n[4 -2] => [-2 -2 -2 -2 4]\n",
       "desc": "places an array of N elements E at the top of the stack",
@@ -227,6 +316,71 @@
         ]
       ]
     },
+    "aryinsert": {
+      "full": "inserts the element E into array A at index I, increasing its length by 1\n[A I E] => [A']\n\n[9 5 2 3 1 4] => [9 4 5 2 4]\n[1 1 0 7] => [7 1 2]\n[3 1 1 7] => [3 7 2]\n[7 5 2 1 6] => [7 6 5 3]\n",
+      "desc": "inserts the element E into array A at index I, increasing its length by 1",
+      "effect": "[A I E] => [A']",
+      "cases": [
+        [
+          [
+            9,
+            5,
+            2,
+            3,
+            1,
+            4
+          ],
+          [
+            9,
+            4,
+            5,
+            2,
+            4
+          ]
+        ],
+        [
+          [
+            1,
+            1,
+            0,
+            7
+          ],
+          [
+            7,
+            1,
+            2
+          ]
+        ],
+        [
+          [
+            3,
+            1,
+            1,
+            7
+          ],
+          [
+            3,
+            7,
+            2
+          ]
+        ],
+        [
+          [
+            7,
+            5,
+            2,
+            1,
+            6
+          ],
+          [
+            7,
+            6,
+            5,
+            3
+          ]
+        ]
+      ]
+    },
     "arypop": {
       "full": "removes the element at the end of the array A, decreasing its length by 1\n[A] => [A']\n\n[10 1] => [0]\n[1 2 3 4 4] => [1 2 3 3]\n[7 10 20 30 3] => [7 10 20 2]\n",
       "desc": "removes the element at the end of the array A, decreasing its length by 1",
@@ -273,6 +427,14 @@
         ]
       ]
     },
+    "aryprint": {
+      "full": "prints the array A to stdout in the form [e1,e2,...]\n[A] => []\n",
+      "desc": "prints the array A to stdout in the form [e1,e2,...]",
+      "effect": "[A] => []",
+      "cases": [
+
+      ]
+    },
     "arypush": {
       "full": "places the element E at the end of the array A, increasing its length by 1\n[A E] => [A']\n\n[3 2 1 3 7] => [3 2 1 7 4]\n[4 2 2 0] => [4 2 0 3]\n[6 1 9] => [6 9 2]\n[7 5 8 2 4] => [7 5 8 4 3]\n",
       "desc": "places the element E at the end of the array A, increasing its length by 1",
@@ -338,6 +500,59 @@
         ]
       ]
     },
+    "aryremove": {
+      "full": "removes the element at index I in array A, decreasing its length by 1\n[A I] => [A']\n\n[6 0 9 3 1] => [6 9 2]\n[7 5 3 1 4 0] => [5 3 1 3]\n[1 3 5 7 4 3] => [1 3 5 3]\n",
+      "desc": "removes the element at index I in array A, decreasing its length by 1",
+      "effect": "[A I] => [A']",
+      "cases": [
+        [
+          [
+            6,
+            0,
+            9,
+            3,
+            1
+          ],
+          [
+            6,
+            9,
+            2
+          ]
+        ],
+        [
+          [
+            7,
+            5,
+            3,
+            1,
+            4,
+            0
+          ],
+          [
+            5,
+            3,
+            1,
+            3
+          ]
+        ],
+        [
+          [
+            1,
+            3,
+            5,
+            7,
+            4,
+            3
+          ],
+          [
+            1,
+            3,
+            5,
+            3
+          ]
+        ]
+      ]
+    },
     "aryrep": {
       "full": "returns the array A replicated N times\n[A N] => [A']\n\n[3 2 1 3 4] => [3 2 1 3 2 1 3 2 1 3 2 1 12]\n",
       "desc": "returns the array A replicated N times",
@@ -505,6 +720,65 @@
         ]
       ]
     },
+    "aryswap": {
+      "full": "swaps the elements at indices I and J in array A\n[A I J] => [A']\n\n[6 0 8 7 4 1 3] => [6 7 8 0 4]\n[4 3 2 1 4 0 2] => [2 3 4 1 4]\n[3 2 1 3 1 1] => [3 2 1 3]\n",
+      "desc": "swaps the elements at indices I and J in array A",
+      "effect": "[A I J] => [A']",
+      "cases": [
+        [
+          [
+            6,
+            0,
+            8,
+            7,
+            4,
+            1,
+            3
+          ],
+          [
+            6,
+            7,
+            8,
+            0,
+            4
+          ]
+        ],
+        [
+          [
+            4,
+            3,
+            2,
+            1,
+            4,
+            0,
+            2
+          ],
+          [
+            2,
+            3,
+            4,
+            1,
+            4
+          ]
+        ],
+        [
+          [
+            3,
+            2,
+            1,
+            3,
+            1,
+            1
+          ],
+          [
+            3,
+            2,
+            1,
+            3
+          ]
+        ]
+      ]
+    },
     "aryunshift": {
       "full": "places the element E at the beginning of the array A, increasing its length by 1\n[A E] => [A']\n\n[3 2 1 3 7] => [7 3 2 1 4]\n[4 2 0 3 9] => [9 4 2 0 4]\n[11 2 2 10] => [10 11 2 3]\n[7 2 8 2 0] => [7 0 2 8 3]\n",
       "desc": "places the element E at the beginning of the array A, increasing its length by 1",
@@ -617,6 +891,60 @@
           ]
         ]
       ]
+    },
+    "sorted?": {
+      "full": "returns 0 if any of the elements in array A is\nstrictly less than the one before it, 1 otherwise\n[A] => [0 | 1]\n\n[1 2 3 3] => [1]\n[3 2 1 3] => [0]\n[1 1 2 2 4] => [1]\n[1 2 3 4 3 5] => [0]\n",
+      "desc": "returns 0 if any of the elements in array A is\nstrictly less than the one before it, 1 otherwise",
+      "effect": "[A] => [0 | 1]",
+      "cases": [
+        [
+          [
+            1,
+            2,
+            3,
+            3
+          ],
+          [
+            1
+          ]
+        ],
+        [
+          [
+            3,
+            2,
+            1,
+            3
+          ],
+          [
+            0
+          ]
+        ],
+        [
+          [
+            1,
+            1,
+            2,
+            2,
+            4
+          ],
+          [
+            1
+          ]
+        ],
+        [
+          [
+            1,
+            2,
+            3,
+            4,
+            3,
+            5
+          ],
+          [
+            0
+          ]
+        ]
+      ]
     }
   },
   "bits": {
@@ -1127,6 +1455,53 @@
     }
   },
   "fun": {
+    "ROT13": {
+      "full": "applies the ROT13 \"cipher\" to the string S\n[S] => [S']\n\n[\"gnat\"] => [\"tang\"]\n[\"purely\"] => [\"cheryl\"]\n[\"cat.PNG\"] => [\"png.CAT\"]\n[\"Hello, world.\"] => [\"Uryyb, jbeyq.\"]\n[\"a123z\"] => [\"n123m\"]\n",
+      "desc": "applies the ROT13 \"cipher\" to the string S",
+      "effect": "[S] => [S']",
+      "cases": [
+        [
+          [
+            244873063
+          ],
+          [
+            217821428
+          ]
+        ],
+        [
+          [
+            4186733066992
+          ],
+          [
+            3743573177443
+          ]
+        ],
+        [
+          [
+            314962935099619
+          ],
+          [
+            371687373272944
+          ]
+        ],
+        [
+          [
+            905009539406525881141375688
+          ],
+          [
+            906989270706565425435408725
+          ]
+        ],
+        [
+          [
+            32856905953
+          ],
+          [
+            29367245038
+          ]
+        ]
+      ]
+    },
     "anagrams?": {
       "full": "returns whether the strings S and T are composed of the same characters\n[S T] => [0 | 1]\n\n[\"allergy\" \"gallery\"] => [1]\n[\"largely\" \"regally\"] => [1]\n[\"foo\" \"bar\"] => [0]\n",
       "desc": "returns whether the strings S and T are composed of the same characters",
@@ -1228,6 +1603,45 @@
         ]
       ]
     },
+    "collatz_len": {
+      "full": "returns the length L of the Collatz sequence for integer N\n[N] => [L]\n\n[1] => [1]\n[4] => [3]\n[7] => [17]\n[189] => [107]\n",
+      "desc": "returns the length L of the Collatz sequence for integer N",
+      "effect": "[N] => [L]",
+      "cases": [
+        [
+          [
+            1
+          ],
+          [
+            1
+          ]
+        ],
+        [
+          [
+            4
+          ],
+          [
+            3
+          ]
+        ],
+        [
+          [
+            7
+          ],
+          [
+            17
+          ]
+        ],
+        [
+          [
+            189
+          ],
+          [
+            107
+          ]
+        ]
+      ]
+    },
     "isop": {
       "full": "returns the sum of the alphabetical characters in string S where A=1, B=2...\n[S] => [sum]\n\n[\"Math\"] => [42]\n[\"wizards\"] => [100]\n[\"AbCd\"] => [10]\n",
       "desc": "returns the sum of the alphabetical characters in string S where A=1, B=2...",
@@ -1332,33 +1746,49 @@
   },
   "io": {
     "getline": {
-      "full": "reads a line of input onto the top of the stack as a packed string\n",
-      "desc": "",
-      "effect": "reads a line of input onto the top of the stack as a packed string",
+      "full": "reads a line of input onto the top of the stack as a packed string\n[] => [L]\n",
+      "desc": "reads a line of input onto the top of the stack as a packed string",
+      "effect": "[] => [L]",
+      "cases": [
+
+      ]
+    },
+    "print": {
+      "full": "prints the character at the top of the stack until terminating zero\n[0 ... C] => []\n",
+      "desc": "prints the character at the top of the stack until terminating zero",
+      "effect": "[0 ... C] => []",
+      "cases": [
+
+      ]
+    },
+    "println": {
+      "full": "print with newline\n[0 ... C] => []\n",
+      "desc": "print with newline",
+      "effect": "[0 ... C] => []",
       "cases": [
 
       ]
     },
-    "print": {
-      "full": "prints the character at the top of the stack until terminating zero\n",
-      "desc": "",
-      "effect": "prints the character at the top of the stack until terminating zero",
+    "prompt": {
+      "full": "displays the string S then reads a line of input\n[S] => [L]\n",
+      "desc": "displays the string S then reads a line of input",
+      "effect": "[S] => [L]",
       "cases": [
 
       ]
     },
-    "println": {
-      "full": "print with newline\n",
-      "desc": "",
-      "effect": "print with newline",
+    "readall": {
+      "full": "consume stdin until EOF into the string S\n[] => [S]\n",
+      "desc": "consume stdin until EOF into the string S",
+      "effect": "[] => [S]",
       "cases": [
 
       ]
     },
-    "readall": {
-      "full": "consume stdin until EOF\n",
-      "desc": "",
-      "effect": "consume stdin until EOF",
+    "readfile": {
+      "full": "returns the contents C of the file at path P (a string)\nNON-STANDARD! This function makes use of the `shell` instruction, which is\nonly(?) available in the Spiceweight Whitespace interpreter.\n[P] => [C]\n",
+      "desc": "returns the contents C of the file at path P (a string)\nNON-STANDARD! This function makes use of the `shell` instruction, which is\nonly(?) available in the Spiceweight Whitespace interpreter.",
+      "effect": "[P] => [C]",
       "cases": [
 
       ]
@@ -1907,8 +2337,8 @@
       ]
     },
     "pow": {
-      "full": "returns B raised to the power E\n[B E] => [B**E]\n\n[0 0] => [1],   [0 9] => [0],   [9 0] => [1]\n[3 2] => [9],   [2 3] => [8],   [7 4] => [2401]\n[-2 3] => [-8]  [-5 0] => [1]   [-4 4] => [256]\n",
-      "desc": "returns B raised to the power E",
+      "full": "returns B raised to the power E; if E must be negative, use ratpow instead\n[B E] => [B**E]\n\n[0 0] => [1],   [0 9] => [0],   [9 0] => [1]\n[3 2] => [9],   [2 3] => [8],   [7 4] => [2401]\n[-2 3] => [-8]  [-5 0] => [1]   [-4 4] => [256]\n",
+      "desc": "returns B raised to the power E; if E must be negative, use ratpow instead",
       "effect": "[B E] => [B**E]",
       "cases": [
         [
@@ -2196,6 +2626,64 @@
       ]
     }
   },
+  "random": {
+    "bogosort": {
+      "full": "sorts the array A if you're lucky\n[A] => [A']\n",
+      "desc": "sorts the array A if you're lucky",
+      "effect": "[A] => [A']",
+      "cases": [
+
+      ]
+    },
+    "dice": {
+      "full": "returns an array A of N random integers between 1 and D (inclusive)\n[N D] => [A]\n",
+      "desc": "returns an array A of N random integers between 1 and D (inclusive)",
+      "effect": "[N D] => [A]",
+      "cases": [
+
+      ]
+    },
+    "rand": {
+      "full": "returns the next number N in the linear congruential generator (better MINSTD)\n[] => [N]\n",
+      "desc": "returns the next number N in the linear congruential generator (better MINSTD)",
+      "effect": "[] => [N]",
+      "cases": [
+
+      ]
+    },
+    "rand_range": {
+      "full": "returns a random integer I between A and B (inclusive)\n[A B] => [I]\n",
+      "desc": "returns a random integer I between A and B (inclusive)",
+      "effect": "[A B] => [I]",
+      "cases": [
+
+      ]
+    },
+    "shuffle": {
+      "full": "shuffles the array A in-place using the modern Fisher-Yates algorithm\n[A] => [A']\n",
+      "desc": "shuffles the array A in-place using the modern Fisher-Yates algorithm",
+      "effect": "[A] => [A']",
+      "cases": [
+
+      ]
+    },
+    "srand": {
+      "full": "seeds the random number generator with integer S\n[S] => []\n",
+      "desc": "seeds the random number generator with integer S",
+      "effect": "[S] => []",
+      "cases": [
+
+      ]
+    },
+    "strfry": {
+      "full": "shuffles the characters of the string S, producing a random anagram\n[S] => [S']\n",
+      "desc": "shuffles the characters of the string S, producing a random anagram",
+      "effect": "[S] => [S']",
+      "cases": [
+
+      ]
+    }
+  },
   "rational": {
     "from_r": {
       "full": "decomposes the rational number R into its numerator N and denominator D\n[R] => [N D]\n\n[R(22,7)] => [22 7]\n[R(-3,4)] => [-3 4]\n[R(3,-4)] => [-3 4]\n[R(4,8)]  => [4 8]  ; no implicit simplification\n",
@@ -2650,7 +3138,7 @@
       ]
     },
     "ratpow": {
-      "full": "returns the rational R raised to the power E\n[R E] => [R']\n\n[R(4,2) 5] => [R(32,1)]\n[R(-3,7) 0] => [R(1,1)]\n[R(-3,14) 2] => [R(9,196)]\n",
+      "full": "returns the rational R raised to the power E\n[R E] => [R']\n\n[R(4,2) 5] => [R(32,1)]\n[R(-3,7) 0] => [R(1,1)]\n[R(-3,14) 2] => [R(9,196)]\n[R(5,1) -1] => [R(1,5)]\n[R(2,5) -2] => [R(25,4)]\n[R(-3,14) -3] => [R(-2744,27)]\n",
       "desc": "returns the rational R raised to the power E",
       "effect": "[R E] => [R']",
       "cases": [
@@ -2680,6 +3168,33 @@
           [
             38654706057
           ]
+        ],
+        [
+          [
+            21474836483,
+            -1
+          ],
+          [
+            4294967307
+          ]
+        ],
+        [
+          [
+            8589934603,
+            -2
+          ],
+          [
+            107374182409
+          ]
+        ],
+        [
+          [
+            12884901916,
+            -3
+          ],
+          [
+            11785390260278
+          ]
         ]
       ]
     },
@@ -3224,6 +3739,93 @@
         ]
       ]
     },
+    "swapary": {
+      "full": "swaps the two arrays at the top of the stack\n[A B] => [B A]\n\n[1 2 3 3 3 2 1 3] => [3 2 1 3 1 2 3 3]\n[5 6 2 9 7 5 3 1 5] => [9 7 5 3 1 5 5 6 2]\n[0 0 2 4 2 0 3] => [4 2 0 3 0 0 2]\n[1 1 2 1] => [2 1 1 1]\n",
+      "desc": "swaps the two arrays at the top of the stack",
+      "effect": "[A B] => [B A]",
+      "cases": [
+        [
+          [
+            1,
+            2,
+            3,
+            3,
+            3,
+            2,
+            1,
+            3
+          ],
+          [
+            3,
+            2,
+            1,
+            3,
+            1,
+            2,
+            3,
+            3
+          ]
+        ],
+        [
+          [
+            5,
+            6,
+            2,
+            9,
+            7,
+            5,
+            3,
+            1,
+            5
+          ],
+          [
+            9,
+            7,
+            5,
+            3,
+            1,
+            5,
+            5,
+            6,
+            2
+          ]
+        ],
+        [
+          [
+            0,
+            0,
+            2,
+            4,
+            2,
+            0,
+            3
+          ],
+          [
+            4,
+            2,
+            0,
+            3,
+            0,
+            0,
+            2
+          ]
+        ],
+        [
+          [
+            1,
+            1,
+            2,
+            1
+          ],
+          [
+            2,
+            1,
+            1,
+            1
+          ]
+        ]
+      ]
+    },
     "to_a": {
       "full": "pops elements off the stack until it hits the specified sentinel value S,\npushing them to the resulting pseudo-array. It's often more convenient to\nbuild up a collection in reverse order, and we often don't know in advance\nhow many elements we'll meet, but we do know to stop at the sentinel.\n[S En ... E1 S] => [E1 ... En n]\n\n[-1 9 8 7 -1] => [7 8 9 3]\n[0 'c' 'b' 'a' 0] => ['a' 'b' 'c' 3]\n",
       "desc": "pops elements off the stack until it hits the specified sentinel value S,\npushing them to the resulting pseudo-array. It's often more convenient to\nbuild up a collection in reverse order, and we often don't know in advance\nhow many elements we'll meet, but we do know to stop at the sentinel.",
@@ -3659,6 +4261,49 @@
         ]
       ]
     },
+    "strbegins?": {
+      "full": "returns 1 if the string S begins with substring T, 0 otherwise\n[S T] => [0 | 1]\n\n[\"foobar\" \"foo\"] => [1]\n[\"foobar\" \"boo\"] => [0]\n[\"abc123\" \"123\"] => [0]\n[\" foo\" \" \"] = [1]\n",
+      "desc": "returns 1 if the string S begins with substring T, 0 otherwise",
+      "effect": "[S T] => [0 | 1]",
+      "cases": [
+        [
+          [
+            3943255767014,
+            1832934
+          ],
+          [
+            1
+          ]
+        ],
+        [
+          [
+            3943255767014,
+            1832930
+          ],
+          [
+            0
+          ]
+        ],
+        [
+          [
+            1765872824673,
+            842033
+          ],
+          [
+            0
+          ]
+        ],
+        [
+          [
+            234615584,
+            32
+          ],
+          [
+            1
+          ]
+        ]
+      ]
+    },
     "strcat": {
       "full": "takes two packed strings and returns their concatenation (as a packed string)\n[S T] => [S+T]\n\n[\"foo\" \"\"] => [\"foo\"]\n[\"\" \"foo\"] => [\"foo\"]\n[\"foo\" \"bar\"] => [\"foobar\"]\n",
       "desc": "takes two packed strings and returns their concatenation (as a packed string)",
@@ -3870,6 +4515,49 @@
         ]
       ]
     },
+    "strends?": {
+      "full": "returns 1 if the string S ends with substring T, 0 otherwise\n[S T] => [0 | 1]\n\n[\"foobar\" \"bar\"] => [1]\n[\"foobar\" \"foo\"] => [0]\n[\"abc123\" \"abc\"] => [0]\n[\"foo \" \" \"] = [1]\n",
+      "desc": "returns 1 if the string S ends with substring T, 0 otherwise",
+      "effect": "[S T] => [0 | 1]",
+      "cases": [
+        [
+          [
+            3943255767014,
+            1880290
+          ],
+          [
+            1
+          ]
+        ],
+        [
+          [
+            3943255767014,
+            1832934
+          ],
+          [
+            0
+          ]
+        ],
+        [
+          [
+            1765872824673,
+            1634657
+          ],
+          [
+            0
+          ]
+        ],
+        [
+          [
+            68941798,
+            32
+          ],
+          [
+            1
+          ]
+        ]
+      ]
+    },
     "strexpand": {
       "full": "expands the length-2 string S to contain the intervening ASCII characters\n[S] => [S']\n\n[\"CJ\"] => [\"CDEFGHIJ\"]\n[\"DA\"] => [\"DCBA\"]\n[\"af\"] => [\"abcdef\"]\n[\"09\"] => [\"0123456789\"]\n[\"90\"] => [\"9876543210\"]\n[\"(1\"] => [\"()*+,-./01\"]\n",
       "desc": "expands the length-2 string S to contain the intervening ASCII characters",
@@ -4482,6 +5170,25 @@
         ]
       ]
     },
+    "strtoa": {
+      "full": "gets the characters of the string S onto the stack as a pseudo-array, but\nwith a leading 0 on the assumption that it'll eventually be repacked\n\n[\"abc\"] => [0 99 98 97 3]\n",
+      "desc": "gets the characters of the string S onto the stack as a pseudo-array, but",
+      "effect": "with a leading 0 on the assumption that it'll eventually be repacked",
+      "cases": [
+        [
+          [
+            1634657
+          ],
+          [
+            0,
+            99,
+            98,
+            97,
+            3
+          ]
+        ]
+      ]
+    },
     "strtrans": {
       "full": "translates all characters in A to the corresponding characters in B\nin string S, ; similar to the `tr` utility in Unix. A and B must be\nof the same length. TODO: make this smarter (ranges, length mismatch)\n[S A B] => [S']\n\n[\"abcd\" \"abc\" \"xyz\"] => [\"xyzd\"]\n[\"foobar\" \"oba\" \"ele\"] => [\"feeler\"]\n[\"abcdcba\" \"abcd\" \"xyz|\"] => [\"xyz|zyx\"]\n",
       "desc": "translates all characters in A to the corresponding characters in B\nin string S, ; similar to the `tr` utility in Unix. A and B must be\nof the same length. TODO: make this smarter (ranges, length mismatch)",
@@ -4572,6 +5279,14 @@
 
       ]
     },
+    "aryheap": {
+      "full": "stashes the array A in negative heap space starting at index I\n[A I] => []\n",
+      "desc": "stashes the array A in negative heap space starting at index I",
+      "effect": "[A I] => []",
+      "cases": [
+
+      ]
+    },
     "between?": {
       "full": "returns 1 if the number N is between A and B (inclusive), 0 otherwise\n[N A B]\n\n[5 0 10] => [1]\n[11 0 10] => [0]\n[4 0 4] => [1]\n[-1 0 4] => [0]\n[-5 -10 0] => [1]\n[3 4 2] => [0]\n",
       "desc": "returns 1 if the number N is between A and B (inclusive), 0 otherwise",
@@ -4648,9 +5363,9 @@
       ]
     },
     "die!": {
-      "full": "prints the string at the top of the stack and halts execution\n",
-      "desc": "",
-      "effect": "prints the string at the top of the stack and halts execution",
+      "full": "prints the string at the top of the stack and halts execution after pushing\nsomething onto the stack to signal abnormal termination/unclean exit\n[...] => [... 1]\n",
+      "desc": "prints the string at the top of the stack and halts execution after pushing\nsomething onto the stack to signal abnormal termination/unclean exit",
+      "effect": "[...] => [... 1]",
       "cases": [
 
       ]
@@ -4852,7 +5567,7 @@
         ]
       ]
     },
-    "heap_seeking_missile": {
+    "heap-seeking_missile": {
       "full": "Though extremely rare, it's possible that we know a particular value is\nstored in the heap at some key, just not which one. This subroutine takes\na value V to search for and a starting index I, and either returns the first\nkey associated with that value or loops forever. Probably don't touch.\n[V I]\n",
       "desc": "Though extremely rare, it's possible that we know a particular value is\nstored in the heap at some key, just not which one. This subroutine takes\na value V to search for and a starting index I, and either returns the first\nkey associated with that value or loops forever. Probably don't touch.",
       "effect": "[V I]",
@@ -4860,6 +5575,22 @@
 
       ]
     },
+    "heapary": {
+      "full": "restores the heaped array starting at index I\n[I] => [A]\n",
+      "desc": "restores the heaped array starting at index I",
+      "effect": "[I] => [A]",
+      "cases": [
+
+      ]
+    },
+    "heapswap": {
+      "full": "swaps the elements in the heap at indices I and J\n[I J] => []\n",
+      "desc": "swaps the elements in the heap at indices I and J",
+      "effect": "[I J] => []",
+      "cases": [
+
+      ]
+    },
     "hex2rgb": {
       "full": "converts the #RRGGBB (leading '#' optional) color string S to\nits individual RGB components as integers in the range 0-255\n[S] => [R G B]\n\n[\"#000000\"] => [0 0 0]\n[\"ffffff\"]  => [255 255 255]\n[\"#102030\"] => [16 32 48]\n[\"c0ffee\"] => [192 255 238]\n",
       "desc": "converts the #RRGGBB (leading '#' optional) color string S to\nits individual RGB components as integers in the range 0-255",
@@ -5535,6 +6266,14 @@
           ]
         ]
       ]
+    },
+    "time": {
+      "full": "returns the number of nanoseconds N since the Unix epoch\n[] => [N]\n",
+      "desc": "returns the number of nanoseconds N since the Unix epoch",
+      "effect": "[] => [N]",
+      "cases": [
+
+      ]
     }
   }
 }