spitewaste 0.2.0 → 0.2.01

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8cd3201a4c8647de4fb29c8529c45fb379c2633cd660a4155e28720931202f94
-  data.tar.gz: 3ba703110341a406d476aa8afa8d89c8a57b9d6e136f319956f28f7d311b16e7
+  metadata.gz: 9ce4494399350d9afb01a0c84aef1ce504da4a24349b33a45de83d6b6f4fa10b
+  data.tar.gz: 330b14a9eb241ff0ac8986956c8f790dd88ce87db4823e08ff19edfc7db0aee1
 SHA512:
-  metadata.gz: d103c80be7025cca6d784127444702460394e4d0f137f124581212b6d92523b80c7e95e15642f9c0036b26545e821dcee206686818d0728dbe57c7b57a388ef0
-  data.tar.gz: 39f473d86a4df1a125a6edae3ff1e29c5a069da2aa72862834097b7151bd11c4fdfe93f8119b60c7009468e4f5c2a05ef60a92d99a9b9198485f79c42411f33d
+  metadata.gz: 04d8acb9a1ed8e1617447407ee511b38b35d2f15a0ef2cc836690138f67f1e036712eb912d3c1dc7331e4d4d2d8694b4fad67be4a0fdefec55515144c9b4a9ce
+  data.tar.gz: 3161a39f4f7b364a5204d4174bbe7f1aa3ac43c530c86d6273b3fe61a04a93eb450688c882d9709f06a105bed35e37479310183cdb39d1509cf90049f2f0fcf7

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/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']
@@ -99,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
@@ -161,8 +183,8 @@ _aryswap_noop: pop pop ret
 ; [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
 
@@ -170,11 +192,27 @@ 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']
 ;
@@ -196,4 +234,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]

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",
@@ -338,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",
@@ -794,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": {
@@ -1405,6 +1556,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...",
@@ -2373,6 +2563,56 @@
       ]
     }
   },
+  "random": {
+    "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",
@@ -4686,6 +4926,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)",
@@ -4852,9 +5111,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": [
 
       ]

data/lib/spitewaste/libspw/fun.spw

@@ -36,6 +36,12 @@ _isop_resume: sub add swap push 128 div jump _isop_loop
 _isop_no: dup jump _isop_resume
 _isop_done: pop ret
 
+$_do_collatz() {
+  dup push 2 mod
+  swap copy 1 push 2 mul $++ mul
+  push 2 copy 2 sub div add
+}
+
 ; returns the elements of the Collatz sequence for integer N as a pseudo-array
 ; ! may run forever on some as-yet-unknown input
 ; [N] => [A]
@@ -48,18 +54,29 @@ _isop_done: pop ret
 collatz: push 1 ; sequence length
 _collatz_loop:
   copy 1 dup push 1 sub jz _collatz_done
-  dup push 2 mod
-  swap copy 1 push 2 mul $++ mul
-  push 2 copy 2 sub div add
-  swap $++ jump _collatz_loop
+  $_do_collatz() swap $++ jump _collatz_loop
 _collatz_done: pop ret
 
+; returns the length L of the Collatz sequence for integer N
+; ! may run forever on some as-yet-unknown input
+; [N] => [L]
+;
+; [1] => [1]
+; [4] => [3]
+; [7] => [17]
+; [189] => [107]
+collatz_len: push 1 swap
+_collatz_len_loop:
+  dup $-- jz _collatz_done
+  $_do_collatz() swap $++ swap jump _collatz_len_loop
+  copy 1 dup push 1 sub jz _collatz_done
+
 ; ruby:
 ;   push "'" :strcat push "ruby -e 'p " swap :strcat shell ret
 
 $_to_roman(r, v) {
   push `v` :divmod swap push `r` swap :strrep
-  push -2 load swap :strcat push -2 swap store
+  @-2 swap :strcat ^-2
 }
 
 ; converts the number N to a string of roman numerals R

data/lib/spitewaste/libspw/math.spw

@@ -51,7 +51,7 @@ ilog: push -1,0 store ; accumulator at -1
 _ilog_loop: ; [n b]
   swap copy 1 div dup jz _ilog_done
   push -1 :inc swap jump _ilog_loop
-_ilog_done: push -1 load slide 2 ret
+_ilog_done: @-1 slide 2 ret
 
 ; returns the greatest common divisor of A and B
 ; [A B] => [gcd(A, B)]
@@ -111,10 +111,7 @@ abs: dup :sign mul ret
 ; [42 6] => [7 0]
 ; [ 1 5] => [0 1]
 ; ! [9 0] => [!!] TODO: find a way to expect exceptions
-divmod:
-  push -1 swap store
-  dup push -1 load div
-  swap push -1 load mod ret
+divmod: ^-1 dup @-1 div swap @-1 mod ret
 
 ; returns whether N is greater than 0
 ; [N] => [N > 0]
@@ -138,11 +135,11 @@ neg?: :sign push -1 :eq ret
 ; [25] => [1 5 25 3] ; no duplicate for perfect squares
 ; [60] => [1 2 3 4 5 6 60 30 20 15 12 10 12]
 divisors: ; [n]
-  dup push -1 swap store ; preserve N because array operations
+  dup ^-1 ; preserve N because array operations
   :isqrt push 1 swap :range dup ; 1..isqrt(N)
-  reject (push -1 load swap mod) :arydup ; get first half of divisors
-  map (push -1 load swap div) :arycat ; map first half to second half
-  push -1 load copy 2 dup mul sub jz _divisors_square ret
+  reject (@-1 swap mod) :arydup ; get first half of divisors
+  map (@-1 swap div) :arycat ; map first half to second half
+  @-1 copy 2 dup mul sub jz _divisors_square ret
 _divisors_square: slide 1 $-- ret ; de-duplicate when N is a perfect square
 
 ; returns the number of ways to choose K elements from a set of N

data/lib/spitewaste/libspw/random.spw

@@ -1,16 +1,34 @@
-import math ; pow
+import math   ; pow
+import string ; strtoa
 
-srand: push $seed swap store ret
+; seeds the random number generator with integer S
+; [S] => []
+srand: ^$seed ret
 
+; returns the next number N in the linear congruential generator (better MINSTD)
+; [] => [N]
 rand:
   push $seed dup dup load
-  push 3,13,10244807 mul mul mul
-  push 2,32 :pow mod
+  push 48271 mul
+  push 2,31 :pow $-- mod
   store load ret
 
-rand_range: ; [a b]
-  copy 1 sub :rand swap mod add ret
+; returns a random integer I between A and B (inclusive)
+; [A B] => [I]
+rand_range:
+  $++ copy 1 sub :rand swap mod add ret
 
-dice:
-  push -2 swap store push 1 :aryfill
-  map (push -2 load :rand_range) ret
+; returns an array A of N random integers between 1 and D (inclusive)
+; [N D] => [A]
+dice: ^-2 dup ^-1 times (push 1 @-2 :rand_range) @-1 ret
+
+; shuffles the array A in-place using the modern Fisher-Yates algorithm
+; [A] => [A']
+shuffle: dup $-- ^-3
+_shuffle_loop:
+  push 0 @-3 :rand_range @-3 :aryswap
+  push -3 :dec @-3 push -1 mul jn _shuffle_loop ret
+
+; shuffles the characters of the string S, producing a random anagram
+; [S] => [S']
+strfry: :strtoa :shuffle pop :strpack ret

data/lib/spitewaste/libspw/rational.spw

@@ -187,9 +187,9 @@ _ratpow_neg: push -1 mul swap :ratinv swap :ratpow ret
 ; [R(355,113) 6] => [3 141592]
 ; [R(8675,309) 10] => [28 744336569] TODO: leading 0 is lost (bug)
 ; [R(2,4) 3] => [0 500]
-to_f: push -2 swap store :from_r :divmod push 0 swap
+to_f: ^-2 :from_r :divmod push 0 swap
 _to_f_loop:
-  push -1 load :divmod  swap
+  @-1 :divmod  swap
   copy 2 push 10 mul add
   swap push 10 mul
   push 2 :dig

data/lib/spitewaste/libspw/stack.spw

@@ -16,15 +16,13 @@ import util ; dec
 ; [1 2 3 4 5 3] => [1 3 4 5 2]
 roll:
   push -10 dup store ; current heap index kept at -10
-_roll_keep: ; [n]
+_roll_keep:
   dup jz _roll_remove
   push -10 :dec
-  swap push -10 load swap store
+  swap @-10 swap store
   push 1 sub jump _roll_keep
-_roll_remove:
-  push 10 sub load
-  swap push -10 swap store
-_roll_restore: ; i
+_roll_remove: push 10 sub load swap ^-10
+_roll_restore:
   dup load swap push 1 add
   dup push 10 add jz _roll_done
   jump _roll_restore
@@ -37,15 +35,15 @@ _roll_done: load ret
 ; [1 2 3 4 5 8 5] => [8 1 2 3 4 5]
 bury:
   push -10 dup store ; current heap index kept at -10
-  swap push -9 swap store ; preserve element to bury
+  swap ^-9 ; preserve element to bury
 _bury_keep: ; [n]
   dup jz _bury_restore
   push -10 :dec
-  swap push -10 load swap store
+  swap @-10 swap store
   push 1 sub jump _bury_keep
 _bury_restore:
   push 9 sub load
-  push -10 load :_roll_restore pop ret
+  @-10 :_roll_restore pop ret
 
 
 ; "digs" out the Ith element of the stack and discards it
@@ -63,14 +61,14 @@ dig: :roll pop ret
 ;
 ; [-1 9 8 7 -1] => [7 8 9 3]
 ; [0 'c' 'b' 'a' 0] => ['a' 'b' 'c' 3]
-to_a: push -1 swap store push -10 dup store
+to_a: ^-1 push -10 dup store
 _to_a_loop:
-  dup push -1 load sub jz _to_a_sentinel
+  dup @-1 sub jz _to_a_sentinel
   push -10 dup :dec load
   swap store jump _to_a_loop
 _to_a_sentinel: pop push -10
 _to_a_restore:
-  dup push -10 load sub jz _to_a_done
+  dup @-10 sub jz _to_a_done
   push 1 sub dup load swap
   jump _to_a_restore
 _to_a_done: push -10 swap sub ret
@@ -88,7 +86,7 @@ _npop_done: pop ret
 ;
 ; [1 2 3 4 5 2] => [1 2 5]
 ; [1 2 3 4 1] => [1 2 4]
-nslide: swap push -1 swap store :npop push -1 load ret
+nslide: swap ^-1 :npop @-1 ret
 
 ; copies the Nth element to the top of the stack; this does exactly what
 ; a `copy N` instruction would do, but we don't always know N in advance

data/lib/spitewaste/libspw/string.spw

@@ -224,13 +224,13 @@ _strchop_empty: ret
 ; ["foo,,bar" ','] => ["foo" "" "bar" 3]
 ; ["/foo/bar/" '/'] => ["" "foo" "bar" "" 4]
 strsplit:
-  push -3 push 1 store ; number of found substrings
-  push -2 swap store ; stash delimiter to allow some stack juggling
+  push -3,1 store ; number of found substrings
+  ^-2 ; stash delimiter to allow some stack juggling
 _strsplit_loop:
-  dup dup push -2 load
+  dup dup @-2
   :strindex dup jn _strsplit_done ; done when index of delimiter is -1
   push 0 swap :strslice
-  swap copy 1 push -3 load
+  swap copy 1 @-3
   swap :strlen
   swap push -3 swap push 1 add store ; update number of found
   push 1 add push 128 swap :pow div ; shrink haystack
@@ -248,11 +248,10 @@ lines: push 10 :strsplit ret
 ; ["foo" "bar" "baz" 3 '--'] => ["foo--bar--baz"]
 ; ["foo" 1 "?!"] => ["foo"]
 strjoinc:
-  dup :strlen pop ; get delimiter length into -1
-  push -2 swap store
-  map (push -2 load :strcat) ; add delimiter to all elements
+  dup :strlen pop ^-2 ; get delimiter length into -1
+  map (@-2 :strcat) ; add delimiter to all elements
   swap push 128 copy 1 :strlen
-  push -2 load :strlen
+  @-2 :strlen
   sub :pow mod swap ; remove delimiter from last and flow into strjoin
 
 ; concatenates the pseudo-array of strings A into string S
@@ -289,9 +288,8 @@ _strcountc_done: swap slide 2 ret
 ; ["eunoia" "aeiou"] => [5]
 ; ["why" "aeiou"] => [0]
 strcount:
-  swap push -2 swap store
-  :strunpack push 0 :to_a
-  map (push -2 load swap :strcountc)
+  swap ^-2 :strunpack push 0 :to_a
+  map (@-2 swap :strcountc)
   reduce (add) ret
 
 ; translates all characters in A to the corresponding characters in B
@@ -303,16 +301,13 @@ strcount:
 ; ["abcd" "abc" "xyz"] => ["xyzd"]
 ; ["foobar" "oba" "ele"] => ["feeler"]
 ; ["abcdcba" "abcd" "xyz|"] => ["xyz|zyx"]
-strtrans:
-  push -3 swap store
-  push -2 swap store
-  dup :strlen push -1 swap store
-  :strunpack push -1 load
+strtrans: ^-3 ^-2
+  dup :strlen ^-1 :strunpack @-1
   map (:_strtrans) pop :strpack ret
 _strtrans:
-  dup push -2 load swap :strindex
+  dup @-2 swap :strindex
   dup jn _strtrans_no
-  push -3 load swap :charat
+  @-3 swap :charat
   slide 1 ret
 _strtrans_no: pop ret
 
@@ -346,8 +341,8 @@ _strsqueeze_skip: pop jump _strsqueeze_loop
 _strsqueeze_done: pop :strpack :strrev ret
 
 $_strdel(cmp) {
-  :strunpack push -1 load :strlen
-  select (push -2 load swap :strindex `cmp`)
+  :strunpack @-1 :strlen
+  select (@-2 swap :strindex `cmp`)
   pop :strpack ret
 }
 
@@ -390,13 +385,17 @@ strrotl: push 128 swap copy 2 :strlen mod :pow :divmod :strcat ret
 ; ["abcd" 1] => ["dabc"]
 ; ["abcd" 5] => ["dabc"]
 ; ["foodbar" 3] => ["barfood"]
-strrotr: push 0 swap sub :strrotl ret
+strrotr: push -1 mul :strrotl ret
+
+; gets the characters of the string S onto the stack as a pseudo-array, but
+; with a leading 0 on the assumption that it'll eventually be repacked
+;
+; ["abc"] => [0 99 98 97 3]
+strtoa: dup :strlen pop :strunpack @-1 $++ ret
 
 ; frobnicates the string S by XORing all its bytes with 42
 ; [S] => [S']
 ;
 ; ["foobar"] => ["LEEHKX"]
 ; ["LEEHKX"] => ["foobar"]
-memfrob:
-  dup :strlen pop :strunpack push -1 load $++
-  map (push 42 :bxor) pop :strpack ret
+memfrob: :strtoa map (push 42 :bxor) pop :strpack ret

data/lib/spitewaste/libspw/test.spw

@@ -8,3 +8,6 @@ assert_eq:
   push ", got " :print onum
   push " for test " swap :strcat :die!
 _assert_eq_yes: pop pop pop ret
+
+assert_nz: jz _assert_nz_no pop ret
+_assert_nz_no: push "expected nonzero for test " swap :strcat :die!

data/lib/spitewaste/libspw/util.spw

@@ -26,7 +26,7 @@ _range_down:
 
 $range_loop(fn, cmp) {
 `fn`:
-  dup copy 2 add push -1 load `cmp` jz _`fn`_done
+  dup copy 2 add @-1 `cmp` jz _`fn`_done
   copy 1 copy 1 add swap jump `fn`
 _`fn`_done: pop ret
 }
@@ -50,8 +50,10 @@ steprange: swap push -1 copy 1 store copy 2 sub
 $range_loop(_steprange_loop, :lte)
 $range_loop(_steprange_down_loop, :gte)
 
-; prints the string at the top of the stack and halts execution
-die!: :println exit
+; prints the string at the top of the stack and halts execution after pushing
+; something onto the stack to signal abnormal termination/unclean exit
+; [...] => [... 1]
+die!: :println push 1 exit
 
 ; for stoi and itos
 alpha: push "0123456789abcdefghijklmnopqrstuvwxyz" ret
@@ -72,7 +74,7 @@ alpha: push "0123456789abcdefghijklmnopqrstuvwxyz" ret
 ; ["-123" 10] => [-123]
 ; ["-ff" 16] => [-255]
 stoi: swap dup :_stoi_sign swap copy 1 :eq
-  push 2 mul $-- push -2 swap store push 0
+  push 2 mul $-- ^-2 push 0
 _stoi_loop: ; [b s a]
   swap dup jz _stoi_done
   swap copy 2 copy 2
@@ -83,8 +85,8 @@ _stoi_loop: ; [b s a]
   mul add swap push 128 div swap
   jump _stoi_loop
 _stoi_sign: dup push 0 :charat push '-' :eq copy 1 :strlen :strslice ret
-_stoi_invalid: pop pop slide 1 swap div push -2 load mul ret
-_stoi_done: swap slide 2 push -2 load mul ret
+_stoi_invalid: pop pop slide 1 swap div @-2 mul ret
+_stoi_done: swap slide 2 @-2 mul ret
 
 ; creature comforts
 
@@ -111,7 +113,7 @@ _itos_loop:
   swap :strcat
   swap copy 2 div
   swap jump _itos_loop
-_itos_done: swap slide 2 push 45,-2 load mul swap :strcat ret
+_itos_done: swap slide 2 push 45 @-2 mul swap :strcat ret
 
 ; creature comforts
 
@@ -129,12 +131,10 @@ to_hex: push 16 :itos ret
 ; [256 16] => [1 0 0 3]
 digits:
   copy 1 jz _digits_zero ; special case
-  push -1 swap store
-  push -1 swap ; sentinel value
+  ^-1 push -1 swap ; sentinel value
 _digits_loop:
   dup jz _digits_done
-  push -1 load :divmod
-  swap jump _digits_loop
+  @-1 :divmod swap jump _digits_loop
 _digits_zero: dup div ret
 _digits_done: push 1 sub :to_a ret
 

data/lib/spitewaste/parsers/spitewaste.rb

@@ -118,9 +118,9 @@ module Spitewaste
       # quick push (`push 1,2,3` desugars to individual pushes)
       @src.gsub!(/push \S+/) { |m| m.split(?,) * ' push ' }
       # quick store (`^2` = `push 2 swap store`)
-      @src.gsub!(/\^(-?\d+)/, 'push \1 swap store')
+      @src.gsub!(/\^(\S+)/, 'push \1 swap store')
       # quick load (`@2` = `push 2 load`)
-      @src.gsub!(/@(-?\d+)/, 'push \1 load')
+      @src.gsub!(/@(\S+)/, 'push \1 load')
     end
 
     def gensym
@@ -141,10 +141,10 @@ module Spitewaste
       parse = -> s { s.split(?,).map &:strip }
 
       # Macro "functions" get handled first.
-      @src.gsub!(/(\$\S+?)\(([^)]+)\)\s*{(.+?)}/m) {
+      @src.gsub!(/(\$\S+?)\(([^)]*)\)\s*{(.+?)}/m) {
         @macros[$1] ||= [$2, $3]; ''
       }
-      @src.gsub!(/(\$\S+?)\(([^)]+)\)/) {
+      @src.gsub!(/(\$\S+?)\(([^)]*)\)/) {
         params, body = @macros[$1]
         raise "no macro function '#$1'" unless body
         map = parse[params].zip(parse[$2]).to_h

data/lib/spitewaste/version.rb

@@ -1,3 +1,3 @@
 module Spitewaste
-  VERSION = '0.2.0'
+  VERSION = '0.2.01'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spitewaste
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.01
 platform: ruby
 authors:
 - Collided Scope (collidedscope)