spitewaste 0.1.005 → 0.1.010

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e31b372173f7c653a34f8c084bc2398c5152c5180bb8ab070ea5f56e74f0943
-  data.tar.gz: 49ca4f1cd8972c0d946350f7c84b5b36daf7158797022ed225cb1623b53b6e25
+  metadata.gz: e90a64e56fcb4e3f9d7727b36fbd71c327693bb8b4a4c7f1ff21332e01317215
+  data.tar.gz: 4b0abbf0dd1e86a939014a598d844ba56ee85c67df12938fecb5a0273192e2b7
 SHA512:
-  metadata.gz: 47ef47beccb9ccb021686a900af3c0db455eeb4d3b770e09bbc49acf5c479b2c24ee8e69c549fce7793b566e2b6fcafb1321f109f6edabb050944a8828e26ced
-  data.tar.gz: 61b8867940d3783b660fafeb0a27ae18baf426586168a84e1d36a9680c7399e2e79c69d76517c660f400120e76b21fa511e46fcb0ec6b218cf3d77f0342376cc
+  metadata.gz: 752150cdcefbcf39a836d3551ece95f0abbcd11a078c61b1283710fa8a6c24c391cd02a5ffba7241eaf839ab1d068bb66e716123b4f1f923b434872aea42a824
+  data.tar.gz: e44b79f9bfb77daa2165de8d3a2d2757636af2f6607fd218b12138853cc4c63898105f6ae5d1e6ae7c382a0503058ddbf3eb883ea1a5ea4d4a1d6c6b5c6afd3d

data/README.md

@@ -35,8 +35,8 @@ See `spw help` for guidance on invoking the command-line interface, and [this tu
 * {ws, wsa, asm} to {ws, wsa, asm}
 * all supported formats to C++ and PNG
 - [x] Execute all supported formats by converting to Whitespace and passing the results to a user-specified interpreter
-- [ ] Thoroughly document the standard library and make it searchable (eventually `spw docs`)
-- - [ ] using a doctest-like approach for free specs
+- [x] Thoroughly document the standard library and make it searchable (via `spw docs`)
+- - [x] using a doctest-like approach for free specs
 - [ ] Write a proper Spitewaste parser for better error reporting (and performance?)
 - [ ] Support user-specified aliases of the builtin mnemonics in case you wanna say `discard` instead of `pop`, etc.
 - [ ] Resolve missing identifiers by auto-importing the necessary standard library?

data/Rakefile

@@ -14,7 +14,8 @@ task :docs do |t|
   docs = {}
 
   Dir.chdir('lib/spitewaste/libspw') do |d|
-    %w[rational.spw array.spw stack.spw util.spw string.spw math.spw].each do |path|
+    Dir['*.spw'].each do |path|
+      next if path['random']
       lib = File.basename path, '.spw'
       docs[lib] = extract_docs path
     end

data/lib/spitewaste.rb

@@ -1,3 +1,5 @@
+Warning[:experimental] = false
+
 module Spitewaste
   OPERATORS_M2T = { # mnemonic to tokens
     push:  "  ",       copy: " \t ",   slide: " \t\n",   label: "\n  ",

data/lib/spitewaste/assembler.rb

@@ -1,6 +1,6 @@
 module Spitewaste
   class Assembler
-    attr_reader :src, :parser, :instructions
+    attr_reader :parser
 
     def initialize program, **options
       format = options[:format]
@@ -9,7 +9,7 @@ module Spitewaste
         raise ArgumentError, "unknown format for parse: #{format}"
       end
 
-      @parser =
+      parser =
         case format
         when :whitespace
           WhitespaceParser
@@ -19,9 +19,9 @@ module Spitewaste
           SpitewasteParser
         end
 
-      parser = @parser.new(program, **options).tap &:parse
-      @instructions = parser.instructions
-      @src = parser.src if format == :spitewaste
+      @parser = parser.new(program, **options).tap &:parse
+      @src = @parser.src if format == :spitewaste
+      @instructions = @parser.instructions
     end
 
     def assemble! format:, io: STDOUT, **options
@@ -42,7 +42,52 @@ module Spitewaste
         else
           AssemblyEmitter
         end
-      emitter.new(format == :wsassembly ? @src : @instructions, **options).emit io: io
+
+      # Worthwhile optimizations can only be done if we have a symbol table.
+      optimize! if parser.respond_to? :symbol_table
+
+      src = format == :wsassembly ? @src : @instructions
+      emitter.new(src, **options).emit io: io
+    end
+
+    def optimize_constant_pow
+      pow = parser.symbol_table['pow']
+
+      case @instructions[@ip - 2, 3]
+      in [[:push, base], [:push, exp], [:call, ^pow]]
+        @instructions[@ip - 2, 3] = [[:push, base ** exp]]
+
+      in [[:push, base], [:dup, _], [:call, ^pow]]
+        @instructions[@ip - 2, 3] = [[:push, base ** base]]
+
+      else nil
+      end
+    end
+
+    def optimize_constant_strpack
+      strpack = parser.symbol_table['strpack']
+      return if @instructions[@ip] != [:call, strpack]
+
+      # grab all the instructions between `push 0` and this `call strpack`
+      start = @instructions[0, @ip].rindex [:push, 0]
+      between = @instructions[start + 1...@ip]
+
+      bytes = []
+      # optimization only applies if all of the intervening ops are pushes
+      return unless between.all? { |op, arg| op == :push && bytes << arg }
+
+      packed = bytes.reverse.zip(0..).sum { |b, e| b * 128 ** e }
+      @instructions[start..@ip] = [[:push, packed]]
+      @ip = start + 1
+    end
+
+    def optimize!
+      @ip = 0
+      while @instructions[@ip]
+        next @ip -= 1 if optimize_constant_pow
+        next if optimize_constant_strpack
+        @ip += 1
+      end
     end
 
     def try_elide_main

data/lib/spitewaste/cli/docs.rb

@@ -29,7 +29,7 @@ class SpitewasteCLI
 
     docs.each do |lib, fns|
       fns.each do |fn, data|
-        full = data['full']
+        full = "#{lib}/#{bold under fn} #{data['full']}"
         ms = terms.count { |t| full[/#{t}/i] }
         found << [lib, fn, full, ms] if ms >= min
       end
@@ -41,9 +41,9 @@ class SpitewasteCLI
 
     IO.popen('less -R', 'w') do |io|
       found.each do |lib, fn, full|
-        full.gsub! /#{terms * ?|}/, &method(:hi)
+        full.gsub! /#{terms * ?|}/i, &method(:hi)
         desc, specs = full.split "\n\n"
-        io.puts "#{?- * 10}\n#{lib}/#{bold under fn} #{desc}\n\n"
+        io.puts "#{?- * 10}\n#{desc}\n\n"
         io.puts specs if options[:show_specs]
       end
     end

data/lib/spitewaste/libspw/array.spw

@@ -1,21 +1,57 @@
+;;; Pseudo-arrays
+
+; An "array" is really just a sequence of elements on the stack followed by
+; the number of elements, so care must be taken to ensure one knows what kind
+; of data is currently being operated on.
+
 import math  ; divmod, max, min, pos?
 import stack ; bury, dig, ncopy, nslide, roll
 import util  ; dec, die!, eq
 
 $amax = 1000
 
+; returns the sum of the array A
+; [A] => [sum]
+;
+; [3 1] => [3]
+; [4 3 2 1 4] => [10]
+; [-10 -5 7 5 10 5] => [7]
 arysum: reduce (add) ret
 
+; duplicates the array at the top of the stack
+; [A] => [A A]
+;
+; [1 2 3 3] => [1 2 3 3 1 2 3 3]
+; [7 50 10 2] => [7 50 10 2 50 10 2]
 arydup:
   dup $++ push -2 copy 1 store
   times (push -2 load $-- :ncopy) ret
 
+; removes the element at the end of the array A
+; [A] => [A']
+;
+; [10 1] => [0]
+; [1 2 3 4 4] => [1 2 3 3]
+; [7 10 20 30 3] => [7 10 20 2]
 arypop: slide 1 $-- ret
 
+; removes the element at the beginning of the array A
+; [A] => [A']
+;
+; [10 1] => [0]
+; [1 2 3 4 4] => [2 3 4 3]
+; [7 10 20 30 3] => [7 20 30 2]
 aryshift: dup :dig $-- ret
 
+; returns the concatenation of arrays A and B
+; [A B] => [A+B]
+;
+; [1 2 3 3 4 5 6 3] => [1 2 3 4 5 6 6]
+; [7 10 2 5 4 3 3] => [7 10 5 4 3 5]
 arycat: dup $++ :roll add ret
 
+;;;
+
 arypack:
   :arydup reduce (:max) $++ push -1 swap store
   $-- times (push -1 load mul add)
@@ -30,36 +66,43 @@ aryunpack:
 
 arylen: push $amax mod ret
 
-;;;
-
+; returns the index I of element E in array A (or -1 if not found)
+; [A E] => [I]
+;
+; [1 2 3 4 4 2] => [1]
+; [1 2 3 4 4 4] => [3]
+; [1 2 3 4 4 5] => [-1]
 aryindex: copy 1 ; two copies of length, one gets decremented, index is diff
-_aryindex_loop: ; [h n l]
-  dup jn _aryindex_notfound
+_aryindex_loop: dup jn _aryindex_notfound
   dup push 2 add :roll copy 2 :eq jz _aryindex_no
   copy 2 copy 1 sub swap $++ :nslide ret
-
 _aryindex_no: $-- jump _aryindex_loop
-
 _aryindex_notfound: slide 1 ret
 
-;;;
-
-; element at index i
-aryat: ; [a i]
+; returns the element E at index I in array A (or dies on out of bounds)
+; [A I] => [E]
+;
+; [1 2 3 4 4 0]  => [1]
+; [1 2 3 4 4 2]  => [3]
+; [1 2 3 4 4 -1] => [4]  negative index counts from the end
+aryat:
   dup jn _aryat_neg
   copy 1 swap sub dup :pos? jz _aryat_oob
   :roll swap $-- :nslide ret
-
 _aryat_neg: copy 1 add dup jn _aryat_oob jump aryat
-
 _aryat_oob: push "(aryat) index out of bounds!" :die!
 
+; returns the minimum and maximum elements of array A
+; [A] => [min max]
+;
+; [4 3 2 1 4] => [1 4]
+; [6 8 -3 4 0 5] => [-3 8]
+; [7 1] => [7 7]
 minmax:
-  :arydup reduce (:max)
-  push -1 swap store
+  :arydup reduce (:max) push -1 swap store
   reduce (:min) push -1 load ret
 
-;;;
+;;; TODO: make sort not atrociously inefficient
 
 sort: push -3 copy 1 store ; preserve length
 _sort_loop:
@@ -70,17 +113,25 @@ _sort_loop:
   push 0 copy 1 sub jn _sort_loop
   push 3 sub load 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
 
-;;;
-
+; returns the array A replicated N times
+; ! N must be greater than 1
+; [A N] => [A']
+;
+; [3 2 1 3 4] => [3 2 1 3 2 1 3 2 1 3 2 1 12]
 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

data/lib/spitewaste/libspw/bits.spw

@@ -1,74 +1,74 @@
-import math   ; ilog, pow
-import string ; strcat, strlen, strrev
-import util   ; bin, digits, itos
-
-; TODO: don't use strings for bitwise operations!
-
-; bitwise bitwise_and
-; ! clobbers heap address -1
-bitwise_and: ; [a b] => [a & b]
-  push -1 push 0 store ; empty string tally
-
-_bitwise_and_loop:
-  copy 1 copy 1 add jz _bitwise_done
-  copy 1 push 2 mod
-  copy 1 push 2 mod
-  add push 2 sub jz _bitwise_and_yes
-  push '0' jump _bitwise_and_update
-
-_bitwise_and_yes: push '1'
-_bitwise_and_update: :_bitwise_update jump _bitwise_and_loop
-
-_bitwise_update:
-  push -1 load swap :strcat
-  push -1 swap store
-  push 2 div swap push 2 div ret
-
-_bitwise_done: push -1 load :strrev :bin slide 2 ret
-
-; bitwise bitwise_or
-; ! clobbers heap address -1
-bitwise_or: ; [a b] => [a | b]
-  push -1 push 0 store ; empty string tally
-
-_bitwise_or_loop:
-  copy 1 copy 1 add jz _bitwise_done
-  copy 1 push 2 mod
-  copy 1 push 2 mod
-  add jz _bitwise_or_no
-  push '1' jump _bitwise_or_update
-
-_bitwise_or_no: push '0'
-_bitwise_or_update: :_bitwise_update jump _bitwise_or_loop
-
-; bitwise bitwise_xor
-; ! clobbers heap address -1
-bitwise_xor: ; [a b] => [a ^ b]
-  push -1 push 0 store ; empty string tally
-
-_bitwise_xor_loop:
-  copy 1 copy 1 add jz _bitwise_done
-  copy 1 push 2 mod
-  copy 1 push 2 mod
-  add push 1 sub jz _bitwise_xor_yes
-  push '0' jump _bitwise_xor_update
-
-_bitwise_xor_yes: push '1'
-_bitwise_xor_update: :_bitwise_update jump _bitwise_xor_loop
-
-; flip all bits in n ; [n]
-bitwise_not:
+import math ; ilog, pow
+import util ; digits
+
+; The bitwise operators all work very similarly, differing only in how they
+; map pairs of bits to 0 or 1. For AND, we simply multiply them. For OR, we
+; sum them, add 1, then divide by 2. For XOR, we only want 1 if they're neq.
+; We repeatedly halve the inputs while consuming bits and stop when at least
+; one of them becomes zero. For AND, the answer is in the accumulator and we
+; are done. For OR and XOR, it's likely the nonzero input still has bits to
+; contribute, so we also accumulate its product with the current power of 2.
+$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
+  push 2 div swap push 2 div
+  dup copy 2 mul jz _`op`_done swap jump _`op`_loop
+_`op`_done: `done` ret
+}
+
+; returns the bitwise AND of A and B
+; [A B] => [A & B]
+;
+; [65 47] => [1]    [83 25] => [17]
+; [40 64] => [0]    [74 59] => [10]
+; [31 18] => [18]   [86 32] => [0]
+; [93 79] => [77]   [11 79] => [11]
+band: $bitfun(band, mul, mul $-- load)
+
+; returns the bitwise OR of A and B
+; [A B] => [A | B]
+;
+; [66 51] => [115]   [64 4]  => [68]
+; [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)
+
+; returns the bitwise XOR of A and B
+; [A B] => [A ^ B]
+;
+; [4 14]  => [10]    [0 80]  => [80]
+; [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)
+
+; returns the infinite-precision bitwise NOT of N by inverting all of its bits
+; [N] => [~N]
+;
+; [58] => [5]    [46] => [17]
+; [48] => [15]   [87] => [40]
+; [98] => [29]   [51] => [12]
+; [3]  => [0]    [42] => [21]
+bnot:
   dup push 0 swap push 1 add sub
   swap push 2 :ilog push 2 swap :pow mod ret
 
-;;;
-
-; number of set bits in n ; [n]
+; returns the number of bits in the binary representation of N
+; [N] => [# of bits]
+;
+; [0] => [0]   [1] => [1]
+; [7] => [3]   [8] => [4]
+; [255] => [8]
+blength: dup jz _blength_zero push 2 :ilog $++ ret
+_blength_zero: ret
+
+; returns the number of set bits in N
+; [N] => [popcount]
+;
+; [0] => [0]   [1] => [1]
+; [7] => [3]   [8] => [1]
 popcount: push 2 :digits reduce (add) ret
-
-;;;
-
-; most significant set bit in n, as a power of 2 ; [n]
-msb: dup jz _msb_zero
-  push 2 :itos :strlen $-- push 2 swap :pow ret
-_msb_zero: ret

data/lib/spitewaste/libspw/case.spw

@@ -1,34 +1,40 @@
-import bits   ; bitwise_and, bitwise_or, bitwise_xor
-import string ; isalpha, strcat, strunpack
-
 ;;; Case conversion
 
-upcase: :strunpack push 0 ; tally
-_upcase_loop:
-  swap dup jz _upcase_done
-  dup :isalpha jz _upcase_cat
-  push 95 :bitwise_and
-_upcase_cat:
-  :strcat jump _upcase_loop
-
-_upcase_done: pop ret
+import bits   ; band, bor, bxor
+import string ; isalpha, strcat, strunpack
 
-downcase: :strunpack push 0 ; tally
-_downcase_loop:
-  swap dup jz _downcase_done
-  dup :isalpha jz _downcase_cat
-  push 32 :bitwise_or
-_downcase_cat:
-  :strcat jump _downcase_loop
+; The case conversion functions all behave very similarly, differing only in
+; how they modify the ordinal value V of a character to be kept.
+; upcase is V & 95, downcase is V | 32, and swapcase is V ^ 32.
+$casefun(case, op) {
+:strunpack push 0 ; get characters on stack and initialize accumulator
+_`case`_loop: swap dup jz _`case`_done dup :isalpha jz _`case`_cat `op`
+_`case`_cat: :strcat jump _`case`_loop
+_`case`_done: pop ret
+}
 
-_downcase_done: pop ret
+; returns string S with all alphabetical characters capitalized
+; [S] => [S']
+;
+; [""] => [""]
+; ["abc"] => ["ABC"]
+; ["123"] => ["123"]
+; ["Abc123Def"] => ["ABC123DEF"]
+upcase: $casefun(upcase, push 0x5F :band)
 
-swapcase: :strunpack push 0 ; tally
-_swapcase_loop:
-  swap dup jz _swapcase_done
-  dup :isalpha jz _swapcase_cat
-  push 32 :bitwise_xor
-_swapcase_cat:
-  :strcat jump _swapcase_loop
+; returns string S with all alphabetical characters lower-cased
+; [S] => [S']
+;
+; [""] => [""]
+; ["ABC"] => ["abc"]
+; ["123"] => ["123"]
+; ["aBC123dEF"] => ["abc123def"]
+downcase: $casefun(downcase, push 0x20 :bor)
 
-_swapcase_done: pop ret
+; returns string S with the case of all alphabetical characters swapped
+; [S] => [S']
+;
+; [""] => [""]
+; ["FooBar"] => ["fOObAR"]
+; ["Abc123deF"] => ["aBC123DEf"]
+swapcase: $casefun(swapcase, push 0x20 :bxor)