spitewaste 0.1.001

data/lib/spitewaste/parsers/fucktional.rb

@@ -0,0 +1,72 @@
+module Spitewaste
+  # select() and reject() do almost the exact same thing, differing only in
+  # whether they drop or keep the match, so this is a bit of deduplication.
+  def self.generate_filter_spw fn, a, b
+    ops = ['push -10 dup call dec load swap store', 'pop']
+    yes, no = ops[a], ops[b]
+    <<SPW
+push -10 dup store
+#{fn}_loop_%1$s:
+  push 1 sub dup jn #{fn}_restore_%1$s
+  swap dup %2$s jz #{fn}_no_%1$s #{yes}
+  jump #{fn}_loop_%1$s
+#{fn}_no_%1$s: #{no} jump #{fn}_loop_%1$s
+#{fn}_restore_%1$s: push 9 sub load
+#{fn}_restore_loop_%1$s:
+  dup push 10 add jz #{fn}_done_%1$s
+  dup load swap push 1 add
+  jump #{fn}_restore_loop_%1$s
+#{fn}_done_%1$s: dup load sub
+SPW
+  end
+
+  FUCKTIONAL = {
+    'map' => <<SPW,
+push -9 push -1 store swap
+map_loop_%1$s:
+  push -9 call inc swap dup dup
+  push -9 load sub jz map_done_%1$s
+  call roll %2$s jump map_loop_%1$s
+map_done_%1$s: pop
+SPW
+
+    'reduce' => <<SPW,
+dup dup push 2 sub jn reduce_done_%1$s pop
+push -9 swap push 1 sub store
+reduce_loop_%1$s: %2$s
+  push -9 dup load push 1 sub dup jz reduce_done_%1$s
+  store jump reduce_loop_%1$s
+reduce_done_%1$s: pop pop
+SPW
+
+    'times' => <<SPW,
+push -5 swap push -1 mul store
+times_loop_%1$s: %2$s push -5 dup call inc load jn times_loop_%1$s
+SPW
+
+    'find' => <<SPW,
+find_loop_%1$s:
+  dup jz find_done_%1$s dup call roll
+  dup %2$s jz find_no_%1$s
+  swap push 1 sub call nslide push 1 add jump find_done_%1$s
+find_no_%1$s: pop push 1 sub jump find_loop_%1$s
+find_done_%1$s: push 1 sub
+SPW
+
+    'maxby' => <<SPW,
+push -3 swap store
+maxby_loop_%1$s:
+  copy 1 %2$s copy 1 %2$s sub jn maxby_lesser_%1$s
+maxby_resume_%1$s: pop push -3 dup call dec load push 1 call eq
+  jz maxby_loop_%1$s
+  jump maxby_done_%1$s
+maxby_lesser_%1$s: swap jump maxby_resume_%1$s
+maxby_done_%1$s:
+SPW
+
+    'minby' => 'maxby (%2$s push -1 mul)',
+    'each' => 'dup times (dup call roll %2$s push 1 sub) pop',
+    'select' => generate_filter_spw('select', 0, 1),
+    'reject' => generate_filter_spw('reject', 1, 0),
+  }
+end

data/lib/spitewaste/parsers/spitewaste.rb

@@ -0,0 +1,192 @@
+require 'json'
+require 'set'
+require_relative 'fucktional'
+
+module Spitewaste
+  LIBSPW = File.expand_path '../libspw', __dir__
+
+  class SpitewasteParser
+    NameError = Class.new Exception
+
+    INSTRUCTIONS = /(\S+):|(\b(#{OPERATORS_M2T.keys * ?|})\s+(-?\d\S*)?)/
+    SPECIAL_INSN = /(call|jump|jz|jn)\s+(\S+)/
+
+    attr_reader :src, :instructions, :error
+
+    def initialize program, **options
+      @src = program.dup
+      @macros = {}
+      @symbol_file = options['symbol_file']
+
+      preprocess!
+      eliminate_dead_code!
+    end
+
+    def parse
+      @instructions = []
+
+      # first-come, first-served mapping from label names to auto-incrementing
+      # indices starting from 0; it would be nice if names could round-trip,
+      # but even encoding short ones would result in unpleasantly wide code.
+      @symbol_table = Hash.new { |h, k| h[k] = h.size }
+      @src.scan(/(\S+):/) { @symbol_table[$1] } # populate label indices
+      File.write @symbol_file, @symbol_table.to_json if @symbol_file
+
+      special = @src.scan SPECIAL_INSN
+      @src.scan INSTRUCTIONS do |label, _, operator, arg|
+        next @instructions << [:label, @symbol_table[label]] if label
+
+        if %i[call jump jz jn].include? operator = operator.to_sym
+          arg = @symbol_table[special.shift[1]]
+        else
+          if OPERATORS_M2T.keys.index(operator) < 8 && !arg
+            raise "missing arg for #{operator}"
+          elsif arg
+            begin
+              arg = Integer arg
+            rescue ArgumentError
+              raise "invalid argument '#{arg}' for #{operator}"
+            end
+          end
+        end
+
+        @instructions << [operator, arg]
+      end
+    end
+
+    private
+
+    def preprocess!
+      resolve_imports
+      seed_prng if @seen.include? 'random'
+      resolve_strings
+      remove_comments
+      add_sugar
+      fucktionalize
+      propagate_macros
+    end
+
+    def resolve_imports
+      @seen = Set.new
+
+      # "Recursively" resolve `import L (...)` statements with implicit include
+      # guarding. Each chunk of imports is appended to the end of the current
+      # source all at once to prevent having to explicitly jump to the actual
+      # start of the program. Some care must be taken to ensure that the final
+      # routine of one library won't inadvertently "flow" into the next.
+      while @src['import']
+        imports = []
+        @src.gsub!(/import\s+(\S+).*/) {
+          imports << resolve($1) if @seen.add? $1
+          '' # remove import statement
+        }
+        @src << imports.join(?\n)
+      end
+    end
+
+    def resolve path
+      library = path[?/] ? path : File.join(LIBSPW, path)
+      File.read "#{library}.spw"
+    end
+
+    def seed_prng
+      @src.prepend "push $seed,#{rand 2**31} store $seed = -9001"
+    end
+
+    def resolve_strings
+      @src.gsub!(/"([^"]+)"/m) {
+        [0, *$1.reverse.bytes] * ' push ' + ' :strpack'
+      }
+    end
+
+    def remove_comments
+      @src.gsub!(/;.+/, '')
+    end
+
+    def add_sugar
+      # `:foo` = `call foo`
+      @src.gsub!(/:(\S+)/, 'call \1')
+      # character literals
+      @src.gsub!(/'(.)'/) { $1.ord }
+      # quick push (`push 1,2,3` desugars to individual pushes)
+      @src.gsub!(/push \S+/) { _1.split(?,) * ' push ' }
+    end
+
+    def gensym
+      (@sym ||= ?`).succ!
+    end
+
+    def fucktionalize
+      # Iteratively remove pseudo-fp calls until we can't to allow nesting.
+      1 while @src.gsub!(/(#{FUCKTIONAL.keys * ?|})\s*\((.+)\)/) do
+        FUCKTIONAL[$1] % [gensym, $2]
+      end
+    end
+
+    def propagate_macros
+      @src.gsub!(/(\$\S+)\s*=\s*(.+)/) { @macros[$1] = $2; '' }
+      @src.gsub!(/(\$\S+)/) { @macros[$1] || raise("no macro '#{$1}'") }
+
+      # @src.gsub!(/(\$[^(]+)\s*\((.+)\)\s*{(.+)}/m) { @macros[$1] = $2, $3; '' }
+      # @src.gsub!(/(\$[^(]+)\((.+?)\)/m) {
+      #   unless (params, body = @macros[$1])
+      #     raise "no macro function '#{$1}'"
+      #   end
+
+      #   params = params.split(?,).map &:strip
+      #   args = $2.split ?,
+      #   body.gsub /\b(#{params * ?|})\b/, params.zip(args).to_h
+      # }
+    end
+
+    def eliminate_dead_code!
+      tokens = @src.split
+
+      # We need an entry point from which to begin determining which routines
+      # are never invoked, but Whitespace programs aren't required to start
+      # with a label. Here, we add an implcit "main" to the beginning of the
+      # source unless it already contains an explicit entry point. TODO: better?
+      start = tokens[0][/(\S+):/, 1] || 'main'
+      tokens.prepend "#{start}:" unless $1
+
+      # Group the whole program into subroutines to facilitate the discovery
+      # of code which can be safely removed without affecting its behavior.
+      subroutines = {}
+      while label = tokens.shift
+        sublen = tokens.index { |t| t[/:$/] } || tokens.size
+        subroutines[label.chop] = tokens.shift sublen
+      end
+
+      # A subroutine may indirectly depend on the one immediately after by
+      # "flowing" into it; we assume this is the case if the subroutine's final
+      # instruction isn't one of {jump, jz, jn, exit, ret}.
+      flow = subroutines.each_cons(2).reject { |(_, tokens), _|
+        tokens.last(2).any? { |t| %w[jump jz jn exit ret].include? t }
+      }.map{ |pair| pair.map &:first }.to_h
+
+      alive = Set.new
+      queue = [start]
+      until queue.empty?
+        # Bail early if the queue is empty or we've already handled this label.
+        next unless label = queue.shift and alive.add? label
+
+        unless subroutines[label]
+          raise NameError, "can't branch to '#{label}', no such label"
+        end
+
+        # Naively(?) assume that subroutines hit all of their branch targets.
+        branches = subroutines[label].each_cons(2).select { |insn, _|
+          %w[jump jz jn call].include? insn
+        }.map &:last
+
+        # Check dependencies for further dependencies.
+        queue.concat branches, [flow[label]]
+      end
+
+      # warn alive.grep_v(/^_/).sort_by(&:upcase).inspect
+      @src = subroutines.filter_map { |label, instructions|
+        "#{label}: #{instructions * ' '}" if alive.include? label
+      } * ?\n + ' ' # trailing space required for regex reasons!
+    end
+  end
+end

data/lib/spitewaste/parsers/whitespace.rb

@@ -0,0 +1,60 @@
+module Spitewaste
+  class WhitespaceParser
+    SyntaxError = Class.new Exception
+
+    attr_reader :instructions, :error
+
+    def initialize program, **options
+      @tokens = program.delete "^\s\t\n" # Remove comments.
+    end
+
+    def parse
+      @instructions = []
+      @line = @column = 1
+      operator_buffer = ''
+      mnemonics = OPERATORS_M2T.keys
+
+      while token = @tokens.slice!(0)
+        operator_buffer << token
+        if @operator = OPERATORS_T2M[operator_buffer]
+          argument = parse_number if mnemonics.index(@operator) < 8
+          @instructions << [@operator, argument]
+          operator_buffer.clear
+          argument = nil
+        end
+
+        if OPERATORS_T2M.none? { |tokens,| tokens.start_with? operator_buffer }
+          @error = [:illegal, operator_buffer, [@line, @column]]
+          raise SyntaxError,
+            "illegal token sequence: #{operator_buffer.inspect} " +
+            "(line #@line, column #@column)"
+        end
+
+        if token == ?\n
+          @line, @column = @line + 1, 1
+        else
+          @column += 1
+        end
+      end
+    end
+
+    def parse_number
+      unless end_of_number = @tokens.index(?\n)
+        @column += @tokens.size
+        @error = [:number, @operator, [@line, @column]]
+        raise SyntaxError,
+          "found EOF before end of number for #@operator operator " +
+          "(line #@line, column #@column)"
+      end
+
+      digits = @tokens.slice! 0, end_of_number + 1
+
+      raise SyntaxError,
+        "too few digits in number for #@operator operator " +
+        "(line #@line, column #@column)" if digits.size <3
+
+      digits[0] = ?- if digits[0] == ?\t
+      digits.tr("\s\t", '01').to_i 2
+    end
+  end
+end

data/lib/spitewaste/version.rb

@@ -0,0 +1,3 @@
+module Spitewaste
+  VERSION = '0.1.001'
+end

data/spitewaste.gemspec

@@ -0,0 +1,17 @@
+require_relative 'lib/spitewaste/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'spitewaste'
+  spec.version       = Spitewaste::VERSION
+  spec.author        = 'Collided Scope (collidedscope)'
+
+  spec.summary       = 'Make programming in Whitespace even better.'
+  spec.description   = 'Spitewaste is a collection of tools that makes it almost too easy to write Whitespace.'
+  spec.homepage      = 'https://github.com/collidedscope/spitewaste'
+  spec.license       = 'WTFPL'
+
+  spec.files         = `git ls-files`.split.reject { |f| f[/^test/] }
+  spec.bindir        = 'bin'
+  spec.executables   = ['spw']
+  spec.require_paths = ['lib']
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: spitewaste
+version: !ruby/object:Gem::Version
+  version: 0.1.001
+platform: ruby
+authors:
+- Collided Scope (collidedscope)
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-12-12 00:00:00.000000000 Z
+dependencies: []
+description: Spitewaste is a collection of tools that makes it almost too easy to
+  write Whitespace.
+email:
+executables:
+- spw
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- Rakefile
+- TUTORIAL.md
+- bin/spw
+- demo/factorial-nicespace.png
+- demo/factorial.asm
+- demo/factorial.png
+- demo/factorial.wsa
+- lib/spitewaste.rb
+- lib/spitewaste/assembler.rb
+- lib/spitewaste/cli.rb
+- lib/spitewaste/cli/asm.rb
+- lib/spitewaste/cli/compile.rb
+- lib/spitewaste/cli/convert.rb
+- lib/spitewaste/cli/exec.rb
+- lib/spitewaste/cli/image.rb
+- lib/spitewaste/emitter.rb
+- lib/spitewaste/emitters/assembly.rb
+- lib/spitewaste/emitters/codegen.rb
+- lib/spitewaste/emitters/image.rb
+- lib/spitewaste/emitters/linefeed.png
+- lib/spitewaste/emitters/schemes.yaml
+- lib/spitewaste/emitters/whitespace.rb
+- lib/spitewaste/emitters/wsassembly.rb
+- lib/spitewaste/libspw/array.spw
+- lib/spitewaste/libspw/bits.spw
+- lib/spitewaste/libspw/case.spw
+- lib/spitewaste/libspw/fun.spw
+- lib/spitewaste/libspw/io.spw
+- lib/spitewaste/libspw/math.spw
+- lib/spitewaste/libspw/prime.spw
+- lib/spitewaste/libspw/random.spw
+- lib/spitewaste/libspw/stack.spw
+- lib/spitewaste/libspw/string.spw
+- lib/spitewaste/libspw/syntax.spw
+- lib/spitewaste/libspw/test.spw
+- lib/spitewaste/libspw/util.spw
+- lib/spitewaste/parsers/assembly.rb
+- lib/spitewaste/parsers/fucktional.rb
+- lib/spitewaste/parsers/spitewaste.rb
+- lib/spitewaste/parsers/whitespace.rb
+- lib/spitewaste/version.rb
+- spitewaste.gemspec
+homepage: https://github.com/collidedscope/spitewaste
+licenses:
+- WTFPL
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key:
+specification_version: 4
+summary: Make programming in Whitespace even better.
+test_files: []