spitewaste 0.1.001

data/lib/spitewaste/libspw/random.spw

@@ -0,0 +1,10 @@
+srand: push $seed swap store ret
+
+rand:
+  push $seed dup dup load
+  push 3,13,10244807 mul mul mul
+  push 2,32 :pow mod
+  store load ret
+
+rand_range: ; [a b]
+  copy 1 sub :rand swap mod add ret

data/lib/spitewaste/libspw/stack.spw

@@ -0,0 +1,84 @@
+roll:
+  push -10 dup store ; current heap index kept at -10
+
+_roll_keep: ; [n]
+  dup jz _roll_remove
+  push -10 :dec
+  swap push -10 load swap store
+  push 1 sub jump _roll_keep
+
+_roll_remove:
+  push 10 sub load
+  swap push -10 swap store
+
+_roll_restore: ; i
+  dup load swap push 1 add
+  dup push 10 add jz _roll_done
+  jump _roll_restore
+
+_roll_done: load ret
+
+;;;
+
+bury:
+  push -10 dup store ; current heap index kept at -10
+  swap push -9 swap store ; preserve element to bury
+
+_bury_keep: ; [n]
+  dup jz _bury_restore
+  push -10 :dec
+  swap push -10 load swap store
+  push 1 sub jump _bury_keep
+
+_bury_restore:
+  push 9 sub load
+  push -10 load :_roll_restore pop ret
+
+;;;
+
+dig: :roll pop ret
+
+;;;
+
+to_a:
+  push -1 swap store
+  push -10 dup store
+
+_to_a_loop:
+  dup push -1 load 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
+  push 1 sub dup load swap
+  jump _to_a_restore
+
+_to_a_done: push -10 swap sub ret
+
+;;;
+
+; dynamic pop ; [n]
+npop:
+  dup jz _npop_done
+  swap pop push 1 sub jump npop
+
+_npop_done: pop ret
+
+; dynamic slide ; [n]
+nslide:
+  swap push -1 swap store
+  :npop push -1 load ret
+
+ncopy: push -10 dup store
+_ncopy_loop:
+  dup jz _ncopy_save swap
+  push -10 dup :dec load swap store
+  push 1 sub jump _ncopy_loop
+_ncopy_save: push 10 sub dup load swap copy 2 store
+_ncopy_restore:
+  dup push 9 add jz _ncopy_done
+  dup load swap push 1 add jump _ncopy_restore
+_ncopy_done: pop ret

data/lib/spitewaste/libspw/string.spw

@@ -0,0 +1,233 @@
+import math
+import case
+
+;;; String packing and unpacking
+
+; convert a 0-terminated string on the stack to a single base-128 integer
+strpack: push 0 ; tally
+_strpack_loop:
+  swap dup jz _strpack_done
+  copy 1 push 128 mul add
+  slide 1
+  jump _strpack_loop
+
+_strpack_done: pop :strrev ret
+
+; convert a single base-128 integer to a 0-terminated string on the stack
+strunpack:
+  :strrev push 0 swap ; terminator
+
+_strunpack_loop:
+  dup jz _strunpack_done
+  dup push 128 mod swap push 128 div
+  jump _strunpack_loop
+
+_strunpack_done: pop ret
+
+;;;
+
+; takes a packed string and just returns it log128 to give the length
+strlen: push 128 :ilog ret
+
+;;;
+
+; takes two packed strings and returns their concatenation (as a packed string)
+strcat:
+  push 128 copy 2 :strlen :pow
+  mul add ret
+
+;;;
+
+; reverses a packed string in-place (heapless) [s] => [s.reverse]
+strrev: push 0 swap ; [tally string]
+
+_strrev_loop: ; [t s]
+  dup jz _strrev_done
+  swap push 128 mul ; [s t]
+  copy 1 push 128 mod add
+  swap push 128 div
+  jump _strrev_loop
+
+_strrev_done: pop ret
+
+;;;
+
+; takes a packed string, a start index, and a length and returns the
+; corresponding substring (simply by doing division with powers of 128; neat)
+strslice:
+  swap push 128 swap :pow
+  copy 2 swap div
+  swap push 128 swap :pow
+  mod slide 1 ret
+
+;;;
+
+; index of substring t in string s ; [s t]
+strindex: swap push 0
+
+_strindex_loop: ; [t s i]
+  copy 1 copy 3 :strlen push 0 swap :strslice
+  copy 3 sub jz _strindex_found
+  push 1 add ; increment index
+  swap push 128 div dup jz _strindex_no
+  swap jump _strindex_loop
+
+_strindex_no: push -1 slide 3 ret
+
+_strindex_found: slide 2 ret
+
+;;;
+
+charat: push 1 :strslice ret
+
+;;;
+
+; 1 if the character at the top of the stack is alphabetical, 0 otherwise
+isalpha:
+  dup push 123 :lt jz _isalpha_no
+  dup push 64 :gt jz _isalpha_no
+  push 32 mod $-- push 32 mod push 26 :lt ret
+_isalpha_no: dup sub ret
+
+;;;
+
+; repeat a string s n times [s n]
+strrep: push 0 swap
+_strrep_loop: ; [s t n]
+  dup jz _strrep_done
+  swap copy 2 :strcat
+  swap push 1 sub
+  jump _strrep_loop
+
+_strrep_done: swap slide 2 ret
+
+;;; String alignment
+
+; helper function for ljustc and rjustc, since the only difference is whether
+; we swap before calling strcat.
+_justc: swap copy 2 :strlen sub push 0 :max :strrep ret
+
+; Left-justify string s to width w with character c. [s w c]
+ljustc: :_justc :strcat ret
+
+; Left-justify string s to width w with spaces. [s w]
+ljust: push ' ' :ljustc ret
+
+; Right-justify string s to width w with character c. [s w c]
+rjustc: :_justc swap :strcat ret
+
+; Right-justify string s to width w with spaces. [s w]
+rjust: push ' ' :rjustc ret
+
+; Center string s to width w with character c. [s w c]
+centerc:
+  swap dup copy 3 :strlen sub
+  push 0 :max push 2 div
+  copy 2 swap :strrep
+  copy 3 :strcat
+  swap copy 1 :strlen sub
+  push 0 :max
+  copy 2 swap :strrep :strcat
+  slide 2 ret
+
+; Center string s to width w with spaces. [s w]
+center: push ' ' :centerc ret
+
+;;;
+
+; remove the last character of a string
+strchop:
+  dup :strlen push 1 sub
+  push 0 swap :strslice ret
+
+; Split string s on delimiting character d.
+; ! clobbers heap addresses -1 and -2
+strsplit: ; [s d]
+  push -3 push 1 store ; number of found substrings
+  push -2 swap store ; stash delimiter to allow some stack juggling
+_strsplit_loop: ; [s]
+  dup dup push -2 load
+  :strindex dup jn _strsplit_done ; done when index of delimiter is -1
+  push 0 swap :strslice
+  swap copy 1 push -3 load
+  swap :strlen
+  swap push -3 swap push 1 add store ; update number of found
+  push 1 add push 128 swap :pow div ; shrink haystack
+  jump _strsplit_loop
+
+_strsplit_done: push 2 sub slide 1 load ret
+
+;;;
+
+; [...strs n delim]
+; ! clobbers heap address -2 (strlen uses -1)
+strjoinc:
+  dup :strlen pop ; get delimiter length into -1
+  push -2 swap store
+  map (push -2 load :strcat) ; add delimiter to all elements
+  swap push 128 copy 1 :strlen
+  push -2 load :strlen
+  sub :pow mod swap ; remove delimiter from last and flow
+strjoin: reduce (:strcat) ret
+
+;;;
+
+; return the number of ocurrences of character c in string s [s c]
+strcountc: swap push 0 swap
+
+_strcountc_loop: ; c t s
+  dup jz _strcountc_done
+  dup push 128 mod copy 3 sub jz _strcountc_yes
+  push 128 div jump _strcountc_loop
+
+_strcountc_yes:
+  swap push 1 add swap push 128 div
+  jump _strcountc_loop
+
+_strcountc_done: swap slide 2 ret
+
+; number of ocurrences of all characters in string c [s c]
+; ! clobbers heap address -2
+strcount:
+  swap push -2 swap store
+  :strunpack push 0 :to_a
+  map (push -2 load swap :strcountc)
+  reduce (add) ret
+
+;;;
+
+; Convert all characters in src to the corresponding characters in dest.
+; ! clobbers heap addresses -1, -2, and -3
+strtrans: ; [string src dest]
+  push -3 swap store
+  push -2 swap store
+  dup :strlen push -1 swap store
+  :strunpack push -1 load
+  map (:_strtrans) pop
+  :strpack ret
+
+_strtrans:
+  dup push -2 load swap :strindex
+  dup jn _strtrans_no
+  push -3 load swap :charat
+  slide 1 ret
+
+_strtrans_no: pop ret
+
+strexpand:
+  push 0 swap push 128 :divmod
+  swap :range :strpack :strrev ret
+
+strsqueeze: push 0 swap ; [sentinel s]
+_strsqueeze_loop: ; [s]
+  dup jz _strsqueeze_done
+  push 128 :divmod dup copy 3 sub jz _strsqueeze_skip
+  swap jump _strsqueeze_loop
+
+_strsqueeze_skip: pop jump _strsqueeze_loop
+
+_strsqueeze_done: pop :strpack :strrev ret
+
+strsum: :strunpack push 0 :to_a :arysum ret
+
+lines: push 10 :strsplit ret

data/lib/spitewaste/libspw/syntax.spw

@@ -0,0 +1,2 @@
+$++ = push 1 add
+$-- = push 1 sub

data/lib/spitewaste/libspw/test.spw

@@ -0,0 +1,8 @@
+assert_eq:
+  dup copy 2 sub jz _assert_eq_yes
+  push "expected " :print onum
+  push ", got " :print onum
+  push " for test " :strcat :print :println
+  exit
+
+_assert_eq_yes: pop pop pop ret

data/lib/spitewaste/libspw/util.spw

@@ -0,0 +1,98 @@
+import syntax
+
+; Calling range() will insert between the top two stack values all of the
+; intervening consecutive elements: [9 10 3 7] -> [9 10 3 4 5 6 7]
+range:
+  copy 1 push 1 add swap
+  copy 1 copy 1 sub jn range
+  pop ret
+
+;;;
+
+die: :println exit
+;;;
+
+alpha: push "0123456789abcdefghijklmnopqrstuvwxyz" ret
+
+; string to integer in base b
+stoi: ; [s b]
+  swap push 0 ; tally
+
+_stoi_loop: ; [b s t]
+  swap dup jz _stoi_done
+  swap copy 2 copy 2
+  :strlen push 1 sub :pow
+  copy 2 push 128 mod
+  :alpha swap :strindex
+  dup jn _stoi_invalid ; found something non-alphanumeric
+  mul add swap push 128 div swap
+  jump _stoi_loop
+
+_stoi_invalid: pop pop slide 1 swap div ret
+
+_stoi_done: swap slide 2 ret
+
+;;;
+
+bin:  push  2 :stoi ret
+oct:  push  8 :stoi ret
+to_i: push 10 :stoi ret
+hex:  push 16 :stoi ret
+
+;;;
+
+; integer to string in base b
+itos: ; [i b]
+  swap push 0 ; empty string
+
+_itos_loop:
+  swap dup jz _itos_done
+  swap copy 1 copy 3 mod
+  :alpha swap :charat
+  swap :strcat
+  swap copy 2 div
+  swap jump _itos_loop
+
+_itos_done: swap slide 2 ret
+
+to_s: push 10 :itos ret
+
+;;;
+
+digits: ; [ n d ]
+  copy 1 jz _digits_zero ; special case
+  push -1 swap store
+  push -1 swap ; sentinel value
+
+_digits_loop:
+  dup jz _digits_done
+  push -1 load :divmod
+  swap jump _digits_loop
+
+_digits_zero: dup div ret
+
+_digits_done: push 1 sub :to_a ret
+
+; increment value at heap address n
+inc: dup load $++ store ret
+
+; decrement value at heap address n
+dec: dup load $-- store ret
+
+;;;
+
+eq: sub jz _eq_yes push 0 ret
+_eq_yes: push 1 ret
+
+neq: sub jz _neq_no push 1 ret
+_neq_no: push 0 ret
+
+gt: swap
+lt: sub jn _lt_yes push 0 ret
+_lt_yes: push 1 ret
+
+;;;
+
+heap_search:
+  $++ dup load copy 2 :eq jz heap_search
+  slide 1 ret

data/lib/spitewaste/parsers/assembly.rb

@@ -0,0 +1,35 @@
+module Spitewaste
+  class AssemblyParser
+    OperatorError = Class.new Exception
+    SyntaxError = Class.new Exception
+
+    attr_reader :instructions, :error
+
+    def initialize program, **options
+      @program = program
+    end
+
+    def parse
+      mnemonics = OPERATORS_M2T.keys
+      @instructions = @program.lines.map.with_index(1) { |insn, no|
+        op, arg = insn.split
+
+        unless i = mnemonics.index(op = op.to_sym)
+          @error = [:unknown, op, [i, 1]]
+          raise OperatorError, "unknown operator '#{op}' (line #{no})", []
+        end
+
+        bad_arg = -> kind {
+          @error = [kind, op, [i, 1]]
+          raise SyntaxError, "#{kind} argument for #{op} operator (line #{no})", []
+        }
+
+        bad_arg[:missing] if i < 8 && !arg
+        bad_arg[:invalid] if i < 8 && !arg[/^-?\d+$/]
+        bad_arg[:useless] if i > 7 && arg
+
+        [op, arg && arg.to_i]
+      }
+    end
+  end
+end