spitewaste 0.1.001

data/lib/spitewaste/emitters/whitespace.rb

@@ -0,0 +1,14 @@
+module Spitewaste
+  class WhitespaceEmitter < Emitter
+    def emit io:
+      instructions.each do |op, arg|
+        io.write OPERATORS_M2T[op]
+        io.write self.class.encode(arg) if arg
+      end
+    end
+
+    def self.encode n
+      (n < 0 ? ?\t : ' ') + n.abs.to_s(2).tr('01', " \t") + ?\n
+    end
+  end
+end

data/lib/spitewaste/emitters/wsassembly.rb

@@ -0,0 +1,7 @@
+module Spitewaste
+  class WSAssemblyEmitter < Emitter
+    def emit io:
+      io.puts @instructions # actually just preprocessed Spitewaste
+    end
+  end
+end

data/lib/spitewaste/libspw/array.spw

@@ -0,0 +1,82 @@
+$amax = 1000
+
+arysum: reduce (add) ret
+
+arydup:
+  dup $++ push -2 copy 1 store
+  times (push -2 load $-- :ncopy) ret
+
+arypop: slide 1 $-- ret
+
+aryshift: dup :dig $-- ret
+
+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
+
+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 2 sub load ret
+
+arylen: push $amax mod ret
+
+;;;
+
+aryindex: copy 1 ; two copies of length, one gets decremented, index is diff
+_aryindex_loop: ; [h n l]
+  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]
+  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
+
+minmax:
+  :arydup reduce (:max)
+  push -1 swap store
+  reduce (:min) push -1 load ret
+
+;;;
+
+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
+  copy 1 swap sub :dig $-- ; remove minimum element from array
+  push 0 copy 1 sub jn _sort_loop
+  push 3 sub load ret
+
+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
+
+;;;
+
+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

@@ -0,0 +1,72 @@
+import math
+
+; 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:
+  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]
+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

@@ -0,0 +1,32 @@
+import bits
+;;; 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
+
+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
+
+_downcase_done: pop ret
+
+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
+
+_swapcase_done: pop ret

data/lib/spitewaste/libspw/fun.spw

@@ -0,0 +1,42 @@
+import string
+
+palindrome?: dup :strrev :eq ret
+
+;;;
+
+anagrams?:
+  :strunpack push 0 :to_a :sort :strjoin swap
+  :strunpack push 0 :to_a :sort :strjoin :eq ret
+
+;;;
+
+isop: :upcase push 0 swap ; tally
+_isop_loop: ; [t s]
+  dup jz _isop_done
+  swap copy 1 push 128 mod
+  dup :isalpha jz _isop_no ; ignore non-alphabetical
+  push 64
+_isop_resume:
+  sub add
+  swap push 128 div jump _isop_loop
+
+_isop_no: dup jump _isop_resume
+
+_isop_done: pop ret
+
+;;;
+
+collatz: push 1 ; sequence length
+_collatz_loop:
+  copy 1 dup push 1 sub jz _collatz_done
+  dup push 2 mod ; m2 n m2
+  swap copy 1 push 2 mul $++ mul
+  push 2 copy 2 sub div add
+  swap $++ jump _collatz_loop
+
+_collatz_done: pop ret
+
+;;;
+
+ruby:
+  push "'" :strcat push "ruby -e 'p " swap :strcat shell ret

data/lib/spitewaste/libspw/io.spw

@@ -0,0 +1,39 @@
+; prints the character at the top of the stack until terminating zero
+print: :strunpack
+_print_loop:
+  dup jz _print_done
+  ochr jump _print_loop
+_print_done: pop ret
+
+; print with newline
+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
+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
+
+;;;
+
+prompt: :print :getline ret
+
+;;;
+
+; consume stdin until EOF
+readall: push 0 ; accumulated string
+_readall_loop:
+  :getline dup jz _readall_done
+  :strcat jump _readall_loop
+
+_readall_done: pop ret

data/lib/spitewaste/libspw/math.spw

@@ -0,0 +1,117 @@
+import util (range) ; for factorial
+
+; [b e] => [b^e]
+pow:
+  push 1 swap
+
+_pow_loop: ; [b n e]
+  dup jz _pow_done
+  swap copy 2 mul ; [b e n*b]
+  swap push 1 sub jump _pow_loop
+
+_pow_done: ; b n e
+  pop slide 1 ret
+
+;;;
+
+; [n] => [n!]
+factorial: push 0 swap :range
+_fac_loop: swap dup jz _fac_done mul jump _fac_loop
+_fac_done: pop ret
+
+;;;
+
+isqrt: ; [n] -> [isqrt(n)]
+  dup push 2 sub jn _isqrt_done
+  dup push 4 div :isqrt push 2 mul
+  dup push 1 add
+  copy 2 copy 1 dup mul sub jn _isqrt_cleanup
+  swap
+_isqrt_cleanup: swap slide 2
+_isqrt_done: ret
+
+;;;
+
+; intger logarithm ; [a b] => [log(a, b)]
+; ! clobbers heap address -1 TODO: maybe not necessary?
+ilog:
+  push -1 push 0 store ; tally
+
+_ilog_loop: ; a b
+  swap dup jz _ilog_done
+  push -1 :inc
+  copy 1 div swap
+  jump _ilog_loop
+
+_ilog_done: ; a b t
+  push -1 load slide 2 ret
+
+;;;
+
+; greatest common divisor
+gcd: ; [a  b]
+  dup jz _gcd_done
+  swap copy 1 mod
+  jump gcd
+
+_gcd_done: pop ret
+
+; least common multiple
+lcm: ; [a b]
+  copy 1 mul
+  swap dup copy 2 swap div
+  :gcd div ret
+
+;;;
+
+min: ; [a b]
+  copy 1 copy 1 sub jn _min_done swap
+_min_done: pop ret
+
+max: ; [a b]
+  copy 1 copy 1 sub jn _max_done swap
+_max_done: slide 1 ret
+
+;;;
+
+; -1, 0, or 1 to indicate the sign of the argument
+sign: ; [n]
+  dup jz _sign_zero
+  jn _sign_neg
+  push 1 ret
+_sign_zero: ret
+_sign_neg: push -1 ret
+
+; absolute value ; [n] => [abs(n)]
+abs: dup :sign mul ret
+
+;;;
+
+divmod:
+  push -1 swap store
+  dup push -1 load div
+  swap push -1 load mod ret
+
+;;;
+
+pos?: :sign push  1 :eq ret
+neg?: :sign push -1 :eq ret
+
+;;;
+
+divisors: ; [n]
+  dup push -1 swap store ; preserve n because array operations
+  :isqrt push 1 swap :range dup ; 1..n**0.5
+  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
+
+_divisors_square: slide 1 $-- ret ; de-duplicate when N is a perfect square
+
+;;;
+
+nCk:
+  copy 1 copy 1 sub :factorial
+  swap :factorial mul
+  swap :factorial swap div ret

data/lib/spitewaste/libspw/prime.spw

@@ -0,0 +1,46 @@
+; [n] => [0|1]
+prime?: ; [n]
+  dup push 3 sub jn _prime_special ; special-case < 3
+  dup push 2 mod jz _prime_even ; otherwise, even -> false
+  push 3
+
+_prime_loop: ; [n d]
+  copy 1 copy 1 dup mul sub jn _prime_yes ; divisor > isqrt(n), n is prime
+  copy 1 copy 1 mod jz _prime_no
+  push 2 add jump _prime_loop
+
+_prime_yes:
+  pop dup div ret ; return 1
+
+_prime_even:
+  push 1
+_prime_no:
+  pop dup sub ret ; return 0
+
+_prime_special: ; [n]
+  push 2 sub jz _prime_two
+  push 0 ret ; false for n < 2
+
+_prime_two:
+  push 1 ret
+
+;;;
+
+next_prime: push 1 add dup :prime? jz next_prime ret
+
+;;;
+
+; prime factorization
+factor: ; [n]
+  push 2 swap ; initial divisor
+  push -2,0 store ; number of prime factors
+_factor_loop: ; [d n]
+  dup push 2 sub jn _factor_done
+  jump _divisor_loop ; prevent dead code elimination :(
+_divisor_loop:
+  dup copy 2 :divmod jz _divisor_keep
+  pop swap :next_prime swap jump _factor_loop
+
+_divisor_keep: push -2 :inc slide 1 copy 1 swap jump _factor_loop
+
+_factor_done: slide 1 push 3 sub load ret