hackasm 0.1.0

data/lib/hackasm/assembler/instructions/address_instruction.rb

@@ -0,0 +1,18 @@
+module Assembler
+  module Instructions
+    class AddressInstruction
+      def initialize(instruction, symbol_table)
+        @instruction = instruction.compact.map { |key, value| [key, value.to_s] }.to_h
+        @symbol_table = symbol_table
+      end
+
+      def to_b
+        if memory_address = @instruction[:memory_address]
+          memory_address.to_i
+        elsif identifier = @instruction[:identifier]
+          @symbol_table[identifier]
+        end.to_s(2).rjust(16, '0')
+      end
+    end
+  end
+end

data/lib/hackasm/assembler/instructions/command_instruction.rb

@@ -0,0 +1,76 @@
+require_relative "../constants/jumps"
+require_relative "../constants/dests"
+
+module Assembler
+  module Instructions
+    class CommandInstruction
+      JUMPS_TABLE = [nil, *JUMPS].zip(
+        (0..8).map { |i| i.to_s(2).rjust(3, "0") }
+      ).to_h.freeze
+      DESTS_TABLE = [nil, *DESTS].zip(
+        (0..8).map { |i| i.to_s(2).rjust(3, "0") }
+      ).to_h.freeze
+      COMPS_TABLE = {
+        "0"   => "0101010",
+        "1"   => "0111111",
+        "-1"  => "0111010",
+        "D"   => "0001100",
+        "A"   => "0110000",
+        "!D"  => "0001101",
+        "!A"  => "0110001",
+        "-D"  => "0001111",
+        "-A"  => "0110011",
+        "D+1" => "0011111",
+        "A+1" => "0110111",
+        "D-1" => "0001110",
+        "A-1" => "0110010",
+        "D+A" => "0000010",
+        "D-A" => "0010011",
+        "A-D" => "0000111",
+        "D&A" => "0000000",
+        "D|A" => "0010101",
+        "M"   => "1110000",
+        "!M"  => "1110001",
+        "-M"  => "1110011",
+        "M+1" => "1110111",
+        "M-1" => "1110010",
+        "D+M" => "1000010",
+        "D-M" => "1010011",
+        "M-D" => "1000111",
+        "D&M" => "1000000",
+        "D|M" => "1010101",
+      }
+
+      def initialize(instruction)
+        @instruction = instruction
+      end
+
+      def to_b
+        comp_bits = COMPS_TABLE[comp]
+
+        binary_instruction = "111"
+        binary_instruction << COMPS_TABLE[comp]
+        binary_instruction << DESTS_TABLE[dest]
+        binary_instruction << JUMPS_TABLE[jump]
+
+        binary_instruction
+      rescue
+        binding.pry
+      end
+
+      private
+
+      def dest
+        @instruction[:dest] && @instruction[:dest].to_s
+      end
+
+      def jump
+        @instruction[:jump] && @instruction[:jump].to_s
+      end
+
+      def comp
+        @instruction[:comp] && @instruction[:comp].to_s.tr(" ", "")
+      end
+    end
+  end
+end

data/lib/hackasm/assembler/symbol_table.rb

@@ -0,0 +1,53 @@
+module Assembler
+  class SymbolTable
+    DEFAULT_SYMBOL_TABLE = {
+      "SP" => 0,
+      "LCL" => 1,
+      "ARG" => 2,
+      "THIS" => 3,
+      "THAT" => 4,
+      "SCREEN" => 16384,
+      "KBD" => 24576,
+    }.merge(("0".."15").map { |i| ["R" + i, i.to_i] }.to_h).freeze
+
+    def initialize(expressions)
+      @expressions = expressions
+    end
+
+    def to_h
+      DEFAULT_SYMBOL_TABLE.merge(
+        label_symbols
+      ).merge(
+        variable_symbols
+      )
+    end
+
+    private
+
+    def label_symbols
+      @label_symbols ||= begin
+                         label_count = 0
+                         @expressions.each.with_index.with_object({}) do |(expression, index), symbol_table|
+                           symbol = expression.dig(:jump_label, :identifier)
+                           symbol = symbol && symbol.to_s
+                           if symbol
+                             symbol_table[symbol] = index - label_count
+                             label_count += 1
+                           end
+                         end
+                       end
+    end
+
+    def variable_symbols
+      memory_location = 16
+      @expressions.each.with_index.with_object({}) do |(expression, index), symbol_table|
+        symbol = expression.dig(:address_instruction, :identifier)
+        symbol = symbol && symbol.to_s
+        if symbol && symbol_table[symbol].nil? && DEFAULT_SYMBOL_TABLE[symbol].nil? && label_symbols[symbol].nil?
+          symbol_table[symbol] = memory_location
+          memory_location += 1
+        end
+      end
+    end
+  end
+end

data/lib/hackasm/assembler/translator.rb

@@ -0,0 +1,51 @@
+require "pry"
+require_relative "./hack_parser"
+require_relative "./symbol_table"
+require_relative "./instructions/address_instruction"
+require_relative "./instructions/command_instruction"
+
+module Assembler
+  class Translator
+    def initialize(text)
+      @text = text
+    end
+
+    def translate
+      expressions = parser.parse(@text)
+      expressions.map do |expression|
+        process_instruction(expression)
+      end.compact.join("\n") << "\n"
+    rescue Parslet::ParseFailed => failure
+      failure.parse_failure_cause.ascii_tree
+    end
+
+    private
+
+    def process_instruction(instruction)
+      instruction_name = instruction.keys.first
+      instruction_body = instruction.values.first
+
+      case instruction_name
+      when :address_instruction
+        Instructions::AddressInstruction.new(instruction_body, symbol_table).to_b
+      when :command_instruction
+        Instructions::CommandInstruction.new(instruction_body).to_b
+      when :jump_label
+        nil
+      else raise "Unknown instruction!"
+      end
+    end
+
+    def parser
+      @parser ||= HackParser.new
+    end
+
+    def expressions
+      @expressions ||= parser.parse(@text)
+    end
+
+    def symbol_table
+      @symbol_table ||= SymbolTable.new(expressions).to_h
+    end
+  end
+end

data/lib/hackasm/cli.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'thor'
+
+module Hackasm
+  # Handle the application command line parsing
+  # and the dispatch to various command objects
+  #
+  # @api public
+  class CLI < Thor
+    # Error raised by this runner
+    Error = Class.new(StandardError)
+
+    desc 'version', 'hackasm version'
+    def version
+      require_relative 'version'
+      puts "v#{Hackasm::VERSION}"
+    end
+    map %w(--version -v) => :version
+
+    desc 'vm2asm FILE', 'Translate *.vm file with virtual machine code or a folder of *.vm files to the single *.asm file of assembler commands'
+    method_option :help, aliases: '-h', type: :boolean,
+                         desc: 'Display usage information'
+    def vm2asm(base_path)
+      if options[:help]
+        invoke :help, ['vm2asm']
+      else
+        require_relative 'commands/vm2asm'
+        Hackasm::Commands::Vm2Asm.new(base_path, options).execute
+      end
+    end
+
+    desc 'asm2binary FILE', 'Translate *.asm file of assembler commands to *.hack file of binary commands'
+    method_option :help, aliases: '-h', type: :boolean,
+                         desc: 'Display usage information'
+    def asm2binary(file)
+      if options[:help]
+        invoke :help, ['asm2binary']
+      else
+        require_relative 'commands/asm2binary'
+        Hackasm::Commands::Asm2Binary.new(file, options).execute
+      end
+    end
+  end
+end

data/lib/hackasm/command.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Hackasm
+  class Command
+    extend Forwardable
+
+    def_delegators :command, :run
+
+    # Execute this command
+    #
+    # @api public
+    def execute(*)
+      raise(
+        NotImplementedError,
+        "#{self.class}##{__method__} must be implemented"
+      )
+    end
+
+    # The external commands runner
+    #
+    # @see http://www.rubydoc.info/gems/tty-command
+    #
+    # @api public
+    def command(**options)
+      require 'tty-command'
+      TTY::Command.new(options)
+    end
+
+    # The cursor movement
+    #
+    # @see http://www.rubydoc.info/gems/tty-cursor
+    #
+    # @api public
+    def cursor
+      require 'tty-cursor'
+      TTY::Cursor
+    end
+
+    # Open a file or text in the user's preferred editor
+    #
+    # @see http://www.rubydoc.info/gems/tty-editor
+    #
+    # @api public
+    def editor
+      require 'tty-editor'
+      TTY::Editor
+    end
+
+    # File manipulation utility methods
+    #
+    # @see http://www.rubydoc.info/gems/tty-file
+    #
+    # @api public
+    def generator
+      require 'tty-file'
+      TTY::File
+    end
+
+    # Terminal output paging
+    #
+    # @see http://www.rubydoc.info/gems/tty-pager
+    #
+    # @api public
+    def pager(**options)
+      require 'tty-pager'
+      TTY::Pager.new(options)
+    end
+
+    # Terminal platform and OS properties
+    #
+    # @see http://www.rubydoc.info/gems/tty-pager
+    #
+    # @api public
+    def platform
+      require 'tty-platform'
+      TTY::Platform.new
+    end
+
+    # The interactive prompt
+    #
+    # @see http://www.rubydoc.info/gems/tty-prompt
+    #
+    # @api public
+    def prompt(**options)
+      require 'tty-prompt'
+      TTY::Prompt.new(options)
+    end
+
+    # Get terminal screen properties
+    #
+    # @see http://www.rubydoc.info/gems/tty-screen
+    #
+    # @api public
+    def screen
+      require 'tty-screen'
+      TTY::Screen
+    end
+
+    # The unix which utility
+    #
+    # @see http://www.rubydoc.info/gems/tty-which
+    #
+    # @api public
+    def which(*args)
+      require 'tty-which'
+      TTY::Which.which(*args)
+    end
+
+    # Check if executable exists
+    #
+    # @see http://www.rubydoc.info/gems/tty-which
+    #
+    # @api public
+    def exec_exist?(*args)
+      require 'tty-which'
+      TTY::Which.exist?(*args)
+    end
+  end
+end

data/lib/hackasm/commands/.gitkeep

@@ -0,0 +1 @@
+#

data/lib/hackasm/commands/asm2binary.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative '../command'
+require_relative '../assembler/translator'
+
+module Hackasm
+  module Commands
+    class Asm2Binary < Hackasm::Command
+      FILE_NAME = "a.hack".freeze
+
+      def initialize(file, options)
+        @file = file
+        @options = options
+      end
+
+      def execute(input: $stdin, output: $stdout)
+        assembler_code = File.read(@file)
+
+        binary = Assembler::Translator.new(assembler_code).translate
+
+        output.puts binary
+        File.write(FILE_NAME, binary)
+      end
+    end
+  end
+end

data/lib/hackasm/commands/vm2asm.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative '../command'
+require_relative '../vm/translator'
+
+module Hackasm
+  module Commands
+    class Vm2Asm < Hackasm::Command
+      attr_reader :base_path
+
+      def initialize(base_path, options)
+        @base_path = base_path
+        @options = options
+      end
+
+      def execute(input: $stdin, output: $stdout)
+        if File.directory?(base_path)
+          assembler_code = Dir[File.join(base_path, "*")].inject do |code_buffer, path|
+            object_name = File.basename(path, ".vm")
+            vm_code = File.read(path)
+            code_buffer + Vm::Translator.new(vm_code, object_name).translate
+          end
+          file_name = "#{base_path}.asm"
+        else
+          object_name = File.basename(base_path, ".vm")
+          vm_code = File.read(base_path)
+          assembler_code = Vm::Translator.new(vm_code, object_name).translate
+          file_name = File.join(File.dirname(base_path), "#{object_name}.asm")
+        end
+
+        output.puts assembler_code
+        File.write(file_name, assembler_code)
+      end
+    end
+  end
+end

data/lib/hackasm/templates/.gitkeep

@@ -0,0 +1 @@
+#

data/lib/hackasm/templates/assemble/.gitkeep

@@ -0,0 +1 @@
+#