hackasm 0.1.0

data/lib/hackasm/templates/vm2asm/.gitkeep

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

data/lib/hackasm/version.rb

@@ -0,0 +1,3 @@
+module Hackasm
+  VERSION = "0.1.0"
+end

data/lib/hackasm/vm/instructions/arithmetic_instruction.rb

@@ -0,0 +1,30 @@
+require_relative './arithmetic_operations/comparison'
+require_relative './arithmetic_operations/binary_operation'
+require_relative './arithmetic_operations/unary_operation'
+
+module Vm
+  module Instructions
+    class ArithmeticInstruction
+      attr_reader :operation
+
+      def initialize(instruction)
+        @operation = instruction[:operation].to_s
+      end
+
+      def to_asm
+        comment + case operation
+        when *ArithmeticOperations::Comparison.operations
+          ArithmeticOperations::Comparison.new(operation).to_asm
+        when *ArithmeticOperations::UnaryOperation.operations
+          ArithmeticOperations::UnaryOperation.new(operation).to_asm
+        when *ArithmeticOperations::BinaryOperation.operations
+          ArithmeticOperations::BinaryOperation.new(operation).to_asm
+        end.split("\n").map(&:strip).join("\n")
+      end
+
+      def comment
+        "// #{operation}\n"
+      end
+    end
+  end
+end

data/lib/hackasm/vm/instructions/arithmetic_operations/binary_operation.rb

@@ -0,0 +1,47 @@
+module Vm
+  module Instructions
+    module ArithmeticOperations
+      class BinaryOperation
+        OPERATION_TO_INSTRUCTION = {
+          "add" => "M=M+D",
+          "sub" => "M=M-D",
+          "and" => "M=M&D",
+          "or" => "M=M|D",
+        }.freeze
+
+        attr_reader :operation
+
+        def initialize(operation)
+          @operation = operation
+        end
+
+        def to_asm
+          %Q{
+            @SP
+            M=M-1
+            @SP
+            A=M
+            D=M
+            @SP
+            M=M-1
+            @SP
+            A=M
+            #{instruction}
+            @SP
+            M=M+1
+          }.strip
+        end
+
+        def self.operations
+          OPERATION_TO_INSTRUCTION.keys
+        end
+
+        private
+
+        def instruction
+          OPERATION_TO_INSTRUCTION[operation]
+        end
+      end
+    end
+  end
+end

data/lib/hackasm/vm/instructions/arithmetic_operations/comparison.rb

@@ -0,0 +1,50 @@
+require 'securerandom'
+
+module Vm
+  module Instructions
+    module ArithmeticOperations
+      class Comparison
+        attr_reader :operation
+
+        def initialize(operation)
+          @operation = operation
+        end
+
+        def to_asm
+          if_label = 'c_if_' + SecureRandom.hex(10)
+          else_label = 'c_else_' + SecureRandom.hex(10)
+          %Q{
+            @SP
+            M=M-1
+            @SP
+            A=M
+            D=M
+            @SP
+            M=M-1
+            @SP
+            A=M
+            D=M-D
+            @#{if_label}
+            D;J#{operation.upcase}
+            D=0
+            @#{else_label}
+            0;JEQ
+            (#{if_label})
+            D=-1
+            (#{else_label})
+            @SP
+            A=M
+            M=D
+            @SP
+            M=M+1
+          }.strip
+        end
+
+        def self.operations
+          %w[gt lt eq]
+        end
+      end
+    end
+  end
+end
+

data/lib/hackasm/vm/instructions/arithmetic_operations/unary_operation.rb

@@ -0,0 +1,34 @@
+module Vm
+  module Instructions
+    module ArithmeticOperations
+      class UnaryOperation
+        OPERATION_TO_INSTRUCTION = {
+          "neg" => "M=-M",
+          "not" => "M=!M"
+        }.freeze
+
+        attr_reader :operation
+
+        def initialize(operation)
+          @operation = operation
+        end
+
+        def to_asm
+          %Q{
+          @SP
+          M=M-1
+          @SP
+          A=M
+          #{OPERATION_TO_INSTRUCTION[operation]}
+          @SP
+          M=M+1
+          }.strip
+        end
+
+        def self.operations
+          OPERATION_TO_INSTRUCTION.keys
+        end
+      end
+    end
+  end
+end

data/lib/hackasm/vm/instructions/memory_access_instruction.rb

@@ -0,0 +1,36 @@
+require_relative './memory_access_operations/static_operation'
+require_relative './memory_access_operations/constant_operation'
+require_relative './memory_access_operations/fixed_segment_operation'
+require_relative './memory_access_operations/virtual_segment_operation.rb'
+
+module Vm
+  module Instructions
+    class MemoryAccessInstruction
+      attr_reader :segment, :operation, :index, :object_name
+
+      def initialize(instruction, object_name)
+        @segment = instruction[:segment].to_s
+        @operation = instruction[:operation].to_s
+        @index = instruction[:index].to_s
+        @object_name = object_name
+      end
+
+      def to_asm
+        comment + case segment
+        when *MemoryAccessOperations::ConstantOperation.segments
+          MemoryAccessOperations::ConstantOperation.new(index).to_asm
+        when *MemoryAccessOperations::StaticOperation.segments
+          MemoryAccessOperations::StaticOperation.new(index, object_name).to_asm
+        when *MemoryAccessOperations::VirtualSegmentOperation.segments
+          MemoryAccessOperations::VirtualSegmentOperation.new(operation, segment, index).to_asm
+        when *MemoryAccessOperations::FixedSegmentOperation.segments
+          MemoryAccessOperations::FixedSegmentOperation.new(operation, segment, index).to_asm
+        end.split("\n").map(&:strip).join("\n")
+      end
+
+      def comment
+        "// #{operation} #{segment} #{index}\n"
+      end
+    end
+  end
+end

data/lib/hackasm/vm/instructions/memory_access_operations/constant_operation.rb

@@ -0,0 +1,30 @@
+module Vm
+  module Instructions
+    module MemoryAccessOperations
+      class ConstantOperation
+
+        attr_reader :index
+
+        def initialize(index)
+          @index = index
+        end
+
+        def to_asm
+          %Q{
+            @#{index}
+            D=A
+            @SP
+            A=M
+            M=D
+            @SP
+            M=M+1
+          }.strip
+        end
+
+        def self.segments
+          %w[constant]
+        end
+      end
+    end
+  end
+end

data/lib/hackasm/vm/instructions/memory_access_operations/fixed_segment_operation.rb

@@ -0,0 +1,62 @@
+module Vm
+  module Instructions
+    module MemoryAccessOperations
+      class FixedSegmentOperation
+        FIXED_SEGMENT_TO_START_INDEX = {
+          'temp' => '5',
+          'pointer' => '3',
+        }.freeze
+
+        attr_reader :operation, :segment, :index
+
+        def initialize(operation, segment, index)
+          @operation = operation
+          @segment = segment
+          @index = index
+        end
+
+        def to_asm
+          if operation == "push"
+            %Q{
+              @#{index}
+              D=A
+              @#{FIXED_SEGMENT_TO_START_INDEX[segment]}
+              A=A+D
+              D=M
+              @SP
+              A=M
+              M=D
+              @SP
+              M=M+1
+            }.strip
+          else
+            %Q{
+              @SP
+              M=M-1
+              @SP
+              A=M
+              D=M
+              @R14
+              M=D
+              @#{index}
+              D=A
+              @#{FIXED_SEGMENT_TO_START_INDEX[segment]}
+              D=A+D
+              @R15
+              M=D
+              @R14
+              D=M
+              @R15
+              A=M
+              M=D
+            }.strip
+          end
+        end
+
+        def self.segments
+          FIXED_SEGMENT_TO_START_INDEX.keys
+        end
+      end
+    end
+  end
+end

data/lib/hackasm/vm/instructions/memory_access_operations/static_operation.rb

@@ -0,0 +1,43 @@
+module Vm
+  module Instructions
+    module MemoryAccessOperations
+      class StaticOperation
+
+        attr_reader :object_name, :index
+
+        def initialize(object_name, index)
+          @index = index
+          @object_name = object_name
+        end
+
+        def to_asm
+          if operation == "push"
+            %Q{
+              @#{object_name}.#{index}
+              D=M
+              @SP
+              A=M
+              M=D
+              @SP
+              M=M+1
+            }.strip
+          else
+            %Q{
+              @SP
+              M=M-1
+              @SP
+              A=M
+              D=M
+              @#{object_name}.#{index}
+              M=D
+            }.strip
+          end
+        end
+
+        def self.segments
+          %w[static]
+        end
+      end
+    end
+  end
+end

data/lib/hackasm/vm/instructions/memory_access_operations/virtual_segment_operation.rb

@@ -0,0 +1,65 @@
+module Vm
+  module Instructions
+    module MemoryAccessOperations
+      class VirtualSegmentOperation
+        VIRTUAL_SEGMENT_TO_POINTER_NAME = {
+          'argument' => 'ARG',
+          'local' => 'LCL',
+          'this' => 'THIS',
+          'that' => 'THAT',
+        }.freeze
+
+
+        attr_reader :operation, :segment, :index
+
+        def initialize(operation, segment, index)
+          @operation = operation
+          @segment = segment
+          @index = index
+        end
+
+        def to_asm
+          if operation == "push"
+            %Q{
+              @#{index}
+              D=A
+              @#{VIRTUAL_SEGMENT_TO_POINTER_NAME[segment]}
+              A=M+D
+              D=M
+              @SP
+              A=M
+              M=D
+              @SP
+              M=M+1
+            }.strip
+          else
+            %Q{
+              @SP
+              M=M-1
+              @SP
+              A=M
+              D=M
+              @R14
+              M=D
+              @#{index}
+              D=A
+              @#{VIRTUAL_SEGMENT_TO_POINTER_NAME[segment]}
+              D=M+D
+              @R15
+              M=D
+              @R14
+              D=M
+              @R15
+              A=M
+              M=D
+            }.strip
+          end
+        end
+
+        def self.segments
+          VIRTUAL_SEGMENT_TO_POINTER_NAME.keys
+        end
+      end
+    end
+  end
+end

data/lib/hackasm/vm/translator.rb

@@ -0,0 +1,46 @@
+require_relative "./vm_code_parser"
+require_relative "./instructions/arithmetic_instruction"
+require_relative "./instructions/memory_access_instruction"
+
+module Vm
+  class Translator
+    def initialize(text, object_name)
+      @text = text
+      @object_name = object_name
+    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 :arithmetic_instruction
+        Instructions::ArithmeticInstruction.new(instruction_body).to_asm
+      when :memory_access_instruction
+        Instructions::MemoryAccessInstruction.new(instruction_body, @object_name).to_asm
+      when :jump_label
+        nil
+      else raise "Unknown instruction!"
+      end
+    end
+
+    def parser
+      @parser ||= VmCodeParser.new
+    end
+
+    def expressions
+      @expressions ||= parser.parse(@text)
+    end
+  end
+end