spitewaste 0.2.01 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ce4494399350d9afb01a0c84aef1ce504da4a24349b33a45de83d6b6f4fa10b
-  data.tar.gz: 330b14a9eb241ff0ac8986956c8f790dd88ce87db4823e08ff19edfc7db0aee1
+  metadata.gz: f039f7e3e393fc05321b8eec880b0596320a5a2bf6edc5bd6690502db221fd25
+  data.tar.gz: d2e137737cf57c865637b0ab44a9fe2546c141e8dec624865c7932553b81ceee
 SHA512:
-  metadata.gz: 04d8acb9a1ed8e1617447407ee511b38b35d2f15a0ef2cc836690138f67f1e036712eb912d3c1dc7331e4d4d2d8694b4fad67be4a0fdefec55515144c9b4a9ce
-  data.tar.gz: 3161a39f4f7b364a5204d4174bbe7f1aa3ac43c530c86d6273b3fe61a04a93eb450688c882d9709f06a105bed35e37479310183cdb39d1509cf90049f2f0fcf7
+  metadata.gz: 34cc5fa69d331f4d227b0c7a4263b64fd87464bc52d5aae87bd41012e8d92b825891e779b7620aa8e885c39178d7f983f4e8dc7beb7b6e23d22e834dba08b8f7
+  data.tar.gz: 92b0baacda3b6030e41f49c8915598bfb3d40e7f7fc13ee204aa0a9c8f2696840cea36e834f765fcba8fcbdaaf872cedf65689f6804580847b6e08cbe6387271

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/emitters/image.rb

@@ -112,7 +112,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/libspw/array.spw

@@ -219,11 +219,10 @@ _sorted_yes: push 1 slide 3 ret
 ; [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

data/lib/spitewaste/libspw/docs.json

@@ -1455,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",
@@ -1699,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",
-      "desc": "",
-      "effect": "prints the character at the top of the stack until terminating zero",
+      "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",
-      "desc": "",
-      "effect": "print with newline",
+      "full": "print with newline\n[0 ... C] => []\n",
+      "desc": "print with newline",
+      "effect": "[0 ... C] => []",
+      "cases": [
+
+      ]
+    },
+    "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": [
 
       ]
     },
     "readall": {
-      "full": "consume stdin until EOF\n",
-      "desc": "",
-      "effect": "consume stdin until EOF",
+      "full": "consume stdin until EOF into the string S\n[] => [S]\n",
+      "desc": "consume stdin until EOF into the string S",
+      "effect": "[] => [S]",
+      "cases": [
+
+      ]
+    },
+    "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": [
 
       ]
@@ -2564,6 +2627,14 @@
     }
   },
   "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)",
@@ -3668,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.",
@@ -4103,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)",
@@ -4314,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",
@@ -5035,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",
@@ -5315,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]",
@@ -5323,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",
@@ -5998,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": [
+
+      ]
     }
   }
 }

data/lib/spitewaste/libspw/fun.spw

@@ -94,3 +94,17 @@ to_roman: push -2,0 store
   $_to_roman("X", 10)   $_to_roman("IX", 9)
   $_to_roman("V", 5)    $_to_roman("IV", 4)
   $_to_roman("I", 1) push 2 sub load ret
+
+; applies the ROT13 "cipher" to the string S
+; [S] => [S']
+;
+; ["gnat"] => ["tang"]
+; ["purely"] => ["cheryl"]
+; ["cat.PNG"] => ["png.CAT"]
+; ["Hello, world."] => ["Uryyb, jbeyq."]
+; ["a123z"] => ["n123m"]
+ROT13:
+  push "AZ" :strexpand push "az" :strexpand :strcat
+  push "NZ" :strexpand push "AM" :strexpand
+  push "nz" :strexpand push "am" :strexpand
+  :strcat :strcat :strcat :strtrans ret

data/lib/spitewaste/libspw/io.spw

@@ -1,6 +1,7 @@
 import string ; strcat, strpack, strrev, strunpack
 
 ; prints the character at the top of the stack until terminating zero
+; [0 ... C] => []
 print: :strunpack
 _print_loop:
   dup jz _print_done
@@ -8,34 +9,35 @@ _print_loop:
 _print_done: pop ret
 
 ; print with newline
+; [0 ... C] => []
 println: :print push 10 ochr ret
 
-;;;
-
 ; reads a line of input onto the top of the stack as a packed string
 ; ! clobbers heap address -1
+; [] => [L]
 getline: push 0 ; terminator for strpack
-
-; read characters onto the stack until newline (10) or EOF (-1)
 _getline_loop:
   push -1 dup ichr load
   dup jn _getline_eof
   dup push 10 sub jz _getline_done
   jump _getline_loop
-
 _getline_eof: pop
 _getline_done: :strpack :strrev ret
 
-;;;
-
+; displays the string S then reads a line of input
+; [S] => [L]
 prompt: :print :getline ret
 
-;;;
-
-; consume stdin until EOF
+; consume stdin until EOF into the string S
+; [] => [S]
 readall: push 0 ; accumulated string
 _readall_loop:
   :getline dup jz _readall_done
   :strcat jump _readall_loop
-
 _readall_done: pop ret
+
+; returns the contents C of the file at path P (a string)
+; NON-STANDARD! This function makes use of the `shell` instruction, which is
+; only(?) available in the Spiceweight Whitespace interpreter.
+; [P] => [C]
+readfile: push "cat " swap :strcat shell ret

data/lib/spitewaste/libspw/random.spw

@@ -1,3 +1,4 @@
+import array  ; sorted?
 import math   ; pow
 import string ; strtoa
 
@@ -32,3 +33,7 @@ _shuffle_loop:
 ; shuffles the characters of the string S, producing a random anagram
 ; [S] => [S']
 strfry: :strtoa :shuffle pop :strpack ret
+
+; sorts the array A if you're lucky
+; [A] => [A']
+bogosort: :shuffle :arydup :sorted? jz bogosort ret

data/lib/spitewaste/libspw/stack.spw

@@ -104,3 +104,14 @@ _ncopy_restore:
   dup push 9 add jz _ncopy_done
   dup load swap push 1 add jump _ncopy_restore
 _ncopy_done: pop ret
+
+; swaps the two arrays at the top of the stack
+; [A B] => [B A]
+;
+; [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]
+swapary:
+  push -10 :aryheap push -11 @-9 sub :aryheap
+  push -10 :heapary push -11 @-9 sub :heapary ret

data/lib/spitewaste/libspw/string.spw

@@ -399,3 +399,25 @@ strtoa: dup :strlen pop :strunpack @-1 $++ ret
 ; ["foobar"] => ["LEEHKX"]
 ; ["LEEHKX"] => ["foobar"]
 memfrob: :strtoa map (push 42 :bxor) pop :strpack ret
+
+; returns 1 if the string S begins with substring T, 0 otherwise
+; [S T] => [0 | 1]
+;
+; ["foobar" "foo"] => [1]
+; ["foobar" "boo"] => [0]
+; ["abc123" "123"] => [0]
+; [" foo" " "] = [1]
+strbegins?:
+  dup :strlen copy 2 swap push 0 swap
+  :strslice :eq slide 1 ret
+
+; returns 1 if the string S ends with substring T, 0 otherwise
+; [S T] => [0 | 1]
+;
+; ["foobar" "bar"] => [1]
+; ["foobar" "foo"] => [0]
+; ["abc123" "abc"] => [0]
+; ["foo " " "] = [1]
+strends?:
+  :strrev dup :strlen copy 2 :strrev swap push 0 swap
+  :strslice :eq slide 1 ret

data/lib/spitewaste/libspw/util.spw

@@ -215,8 +215,8 @@ between?: copy 2 :gte swap copy 2 :lte mul slide 1 ret
 ; a value V to search for and a starting index I, and either returns the first
 ; key associated with that value or loops forever. Probably don't touch.
 ; [V I]
-heap_seeking_missile:
-  $++ dup load copy 2 :eq jz heap_search
+heap-seeking_missile:
+  $++ dup load copy 2 :eq jz heap-seeking_missile
   slide 1 ret
 
 ; converts the #RRGGBB (leading '#' optional) color string S to
@@ -246,3 +246,31 @@ rgb2hex:
   copy 2 push 256 mul add add
   slide 2 :to_hex push 6,48 :rjustc ret
 _rgb2hex_invalid: push "(rgb2hex) invalid RGB" :die!
+
+; stashes the array A in negative heap space starting at index I
+; [A I] => []
+aryheap:
+  $++ dup copy 2 store
+  swap times ($-- swap copy 1 swap store) pop ret
+
+; restores the heaped array starting at index I
+; [I] => [A]
+heapary:
+  $++ dup load swap copy 1 sub swap
+  times (dup load swap $++) load ret
+
+; swaps the elements in the heap at indices I and J
+; ! TODO: make heap effects doctest-able
+; [I J] => []
+heapswap: dup load swap copy 2 load store store ret
+
+; returns the number of nanoseconds N since the Unix epoch
+; [] => [N]
+time: push "date +%s%N" shell :to_i ret
+
+$bench(insns) {
+  #insns :println
+  :time ^0 `insns` :time @0 sub
+  push 10,9 :pow :divmod swap onum
+  push '.' ochr :to_s push 9,48 :rjustc :println
+}

data/lib/spitewaste/parsers/spitewaste.rb

@@ -148,11 +148,13 @@ module Spitewaste
         params, body = @macros[$1]
         raise "no macro function '#$1'" unless body
         map = parse[params].zip(parse[$2]).to_h
-        body.gsub(/`(.+?)`/) { map[$1] }
+        body
+          .gsub(/`(.+?)`/) { map[$1] }
+          .gsub(/#(\S+)/) { "push #{Spitewaste.strpack map[$1]}" }
       }
 
       @src.gsub!(/(\$\S+)\s*=\s*(.+)/) { @macros[$1] ||= $2; '' }
-      @src.gsub!(/(\$\S+)/) { @macros[$1] || raise("no macro '#$1'") }
+      @src.gsub!(/(\$[^)\s]+)/) { @macros[$1] || raise("no macro '#$1'") }
     end
 
     def eliminate_dead_code!

data/lib/spitewaste/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spitewaste
 version: !ruby/object:Gem::Version
-  version: 0.2.01
+  version: 0.2.2
 platform: ruby
 authors:
 - Collided Scope (collidedscope)
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-03 00:00:00.000000000 Z
+date: 2021-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake