haxor 0.1.0

data/lib/haxor/vm/cpu/unit/logical.rb

@@ -0,0 +1,59 @@
+module Haxor
+  module Vm
+    module Cpu
+    module Unit
+      class Logical < Base
+        #            0x40
+        OP_AND     = 0x40 # and a, b
+        OP_NEG     = 0x41 # neg a
+        OP_NOT     = 0x42 # not a
+        OP_OR      = 0x43 # or a, b
+        OP_XOR     = 0x44 # xor a, b
+        #            0x5f
+
+        def register
+          bind_opcode OP_AND,     :op_and
+          bind_opcode OP_NEG,     :op_neg
+          bind_opcode OP_NOT,     :op_not
+          bind_opcode OP_OR,      :op_or
+          bind_opcode OP_XOR,     :op_xor
+        end
+
+        def op_and
+          a, b = operands
+          av = @vm.subsystem(:mem).read a
+          bv = @vm.subsystem(:mem).read b
+          v = av & bv
+          @vm.subsystem(:mem).write a, v
+        end
+
+        def op_neg
+          a = operand
+          av = @vm.subsystem(:mem).read a
+          @vm.subsystem(:mem).write a, -av
+        end
+
+        def op_not
+          a = operand
+          av = @vm.subsystem(:mem).read a
+          @vm.subsystem(:mem).write a, ~av
+        end
+
+        def op_or
+          a, b = operands
+          av = @vm.subsystem(:mem).read a
+          bv = @vm.subsystem(:mem).read b
+          @vm.subsystem(:mem).write a, (av | bv)
+        end
+
+        def op_xor
+          a, b = operands
+          av = @vm.subsystem(:mem).read a
+          bv = @vm.subsystem(:mem).read b
+          @vm.subsystem(:mem).write a, (av ^ bv)
+        end
+      end
+    end
+  end
+end
+end

data/lib/haxor/vm/cpu/unit/transfer.rb

@@ -0,0 +1,37 @@
+module Haxor
+  module Vm
+    module Cpu
+    module Unit
+      class Transfer < Base
+        #            0x60
+        OP_MOV     = 0x60 # mov a, b
+        OP_PUSH    = 0x61 # push a
+        OP_POP     = 0x62 # pop a
+        #            0x7f
+
+        def register
+          bind_opcode OP_MOV,     :op_mov
+          bind_opcode OP_PUSH,    :op_push
+          bind_opcode OP_POP,     :op_pop
+        end
+
+        def op_mov
+          a, b = operands
+          v = @vm.subsystem(:mem).read b
+          @vm.subsystem(:mem).write a, v
+        end
+
+        def op_push
+          a = operand
+          @vm.subsystem(:stack).push a
+        end
+
+        def op_pop
+          a = operand
+          @vm.subsystem(:stack).pop a
+        end
+      end
+    end
+  end
+end
+end

data/lib/haxor/vm/cpu/unit/various.rb

@@ -0,0 +1,47 @@
+module Haxor
+  module Vm
+    module Cpu
+      module Unit
+        class Various < Base
+          #            = 0x80
+          OP_LEA       = 0x80 # lea a
+          OP_NOP       = 0x81 # nop
+          OP_INT       = 0x85 # int a
+          OP_SYSCALL   = 0x86 # syscall
+          #              0x9f
+
+          def register
+            bind_opcode OP_LEA,      :op_lea
+            bind_opcode OP_NOP,      :op_nop
+            bind_opcode OP_INT,      :op_int
+            bind_opcode OP_SYSCALL,  :op_syscall
+          end
+
+          def op_lea
+            a, b = operands
+            @vm.subsystem(:mem).write a, b
+          end
+
+          def op_nop
+            # intentionally nothing here
+          end
+
+          def op_int
+            a = operand
+
+            @vm.subsystem(:stack).push 'ip'
+
+            av = @vm.subsystem(:mem).read a
+            ivt = Consts::IVT_ADDR + (av * 8)
+            handler = @vm.subsystem(:mem).read ivt
+            @vm.subsystem(:mem).write 'ip', handler
+          end
+
+          def op_syscall
+            @vm.subsystem(:os).syscall
+          end
+        end
+      end
+    end
+  end
+end

data/lib/haxor/vm/mem.rb

@@ -0,0 +1,101 @@
+module Haxor
+  module Vm
+    class Mem < Subsystem
+      attr_accessor :memory
+
+      def initialize(bytes)
+        @memory = Array.new(bytes, 0).pack('C*')
+        @labels = {}
+      end
+
+      def size
+        @memory.size
+      end
+
+      def enlarge(bytes)
+        replace_region size, Array.new(bytes, 0).pack('C*')
+      end
+
+      # Adds label
+      #
+      # @param name [String] Name of label
+      # @param addr [Integer] Address in memory to point to
+      def add_label(name, addr)
+        fail if @labels.key? name
+        @labels[name] = addr
+      end
+
+      # Reads word from memory
+      #
+      # @param addr [String|Integer] Label or address in memory
+      # @return [Integer] Data stored under specified address
+      def read(addr)
+        @memory[resolve addr].unpack(Consts::WORD_UNPACK)[0]
+      end
+
+      # Writes word to memory
+      #
+      # @param addr [String|Integer] Label or address in memory
+      # @param value [Integer] Data to store under specified address
+      def write(addr, value)
+        @memory[resolve addr] = [value].pack(Consts::WORD_UNPACK)
+      end
+
+      def write_string(addr, value)
+        i = 0
+        value.each_char do |x|
+          write addr + i, x.ord
+          i += Consts::WORD_SIZE
+        end
+
+        write addr + i, 0
+      end
+
+      def replace_region(addr, data)
+        x = addr + data.size
+        @memory[addr...x] = data
+      end
+
+      # (see #read)
+      def dereference(addr)
+        read addr
+      end
+
+      # Reads data pointed by IP register and moves IP forward
+      #
+      # @return [Integer] Data stored under address pointed by IP
+      def next_word
+        data = read ip
+        move_ip Consts::WORD_SIZE
+        data
+      end
+
+      # TODO: BC
+      def next_cell
+        next_word
+      end
+
+      def ip
+        read 'ip'
+      end
+
+      def move_ip(step)
+        write 'ip', ip + step
+      end
+
+      def label(name)
+        @labels[addr]
+      end
+
+      private
+
+      def resolve(addr)
+        if addr.is_a? String
+          fail "Unknown label #{addr}." unless @labels.key? addr
+          addr = @labels[addr]
+        end
+        Range.new(addr, addr + Consts::WORD_SIZE, true)
+      end
+    end
+  end
+end

data/lib/haxor/vm/os.rb

@@ -0,0 +1,115 @@
+module Haxor
+  module Vm
+    class Os < Subsystem
+      TABLE = {
+        0x01 => :sys_exit,
+        0x02 => :sys_printf,
+        0x03 => :sys_scanf,
+        0x04 => :sys_rand
+      }
+
+      def syscall
+        func = subsystem(:mem).read 'sc'
+        send(TABLE[func])
+      end
+
+      def collect_string(addr)
+        i = 0
+        string = ''
+        loop do
+          char = @vm.subsystem(:mem).read(addr + i)
+          break if char == 0
+          string << char.ord
+
+          i += Consts::WORD_SIZE
+        end
+
+        string
+      end
+
+      def parse_format(fmt)
+        fmt = fmt.tr '^A-Za-z%', ''
+        fmt = fmt.gsub '%%', ''
+
+        types = []
+        last_char = nil
+        fmt.each_char do |char|
+          if last_char == '%'
+            if %w(b B d i o u x X).include? char
+              types << :integer
+            elsif %w(c s).include? char
+              types << :string
+            else
+              fail
+            end
+          end
+
+          last_char = char
+        end
+
+        types
+      end
+
+      def sys_exit
+        code = subsystem(:stack).pop_value
+        exit code
+      end
+
+      def sys_printf
+        fd = subsystem(:stack).pop_value
+
+        x = subsystem(:stack).pop_value
+        fmt = collect_string x
+        args = []
+        parse_format(fmt).each do |type|
+          case type
+          when :string
+            args << collect_string(subsystem(:stack).pop_value)
+          when :integer
+            args << subsystem(:stack).pop_value
+          else
+            fail
+          end
+        end
+
+        file = IO.new(fd, 'a')
+        file.write sprintf(fmt, *args)
+      end
+
+      def sys_scanf
+        fd = subsystem(:stack).pop_value
+        fmt = collect_string subsystem(:stack).pop_value
+        types = parse_format fmt
+
+        file = IO.new(fd, 'r')
+        result = file.scanf fmt
+
+        if result.size != types.size
+          subsystem(:mem).write 'sc', -1
+          return
+        end
+
+        types.each do |type|
+          value = result.shift
+
+          case type
+          when :string
+            subsystem(:mem).write_string subsystem(:stack).pop_value, value
+          when :integer
+            subsystem(:mem).write subsystem(:stack).pop_value, value
+          else
+            fail
+          end
+        end
+      end
+
+      def sys_rand
+        min = subsystem(:stack).pop_value
+        max = subsystem(:stack).pop_value
+
+        prng = Random.new
+        subsystem(:stack).push_value prng.rand(min..max)
+      end
+    end
+  end
+end

data/lib/haxor/vm/stack.rb

@@ -0,0 +1,31 @@
+module Haxor
+  module Vm
+    class Stack < Subsystem
+      def push(addr)
+        value = @vm.subsystem(:mem).read addr
+        push_value value
+      end
+
+      def push_value(value)
+        sp = @vm.subsystem(:mem).read 'sp'
+        sp -= Consts::WORD_SIZE
+        @vm.subsystem(:mem).write 'sp', sp
+        @vm.subsystem(:mem).write sp, value
+      end
+
+      def pop(addr)
+        value = pop_value
+        @vm.subsystem(:mem).write addr, value
+      end
+
+      def pop_value
+        sp = @vm.subsystem(:mem).read 'sp'
+        value = @vm.subsystem(:mem).read sp
+        sp += Consts::WORD_SIZE
+        @vm.subsystem(:mem).write 'sp', sp
+
+        value
+      end
+    end
+  end
+end

data/lib/haxor/vm/subsystem.rb

@@ -0,0 +1,16 @@
+module Haxor
+  module Vm
+    class Subsystem
+      attr_accessor :vm
+
+      def register
+        # method called after registering to VM
+      end
+
+      # shortcut
+      def subsystem(id)
+        @vm.subsystem(id)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: haxor
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Krzysztof Magosa
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Please follow to GitHub repository for more information.
+email:
+- krzysztof@magosa.pl
+executables:
+- hcc
+- hld
+- hvm
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/hcc
+- bin/hld
+- bin/hvm
+- examples/build.sh
+- examples/guess-the-number.hax
+- haxor.gemspec
+- lib/haxor.rb
+- lib/haxor/compiler/component/arithmetic.rb
+- lib/haxor/compiler/component/base.rb
+- lib/haxor/compiler/component/data.rb
+- lib/haxor/compiler/component/jumps.rb
+- lib/haxor/compiler/component/logical.rb
+- lib/haxor/compiler/component/other.rb
+- lib/haxor/compiler/component/transfer.rb
+- lib/haxor/compiler/component/various.rb
+- lib/haxor/compiler/core.rb
+- lib/haxor/compiler/section.rb
+- lib/haxor/compiler/unit.rb
+- lib/haxor/consts.rb
+- lib/haxor/header.rb
+- lib/haxor/linker.rb
+- lib/haxor/token/base.rb
+- lib/haxor/token/cmd.rb
+- lib/haxor/token/data.rb
+- lib/haxor/token/int64.rb
+- lib/haxor/token/label.rb
+- lib/haxor/token/pointer.rb
+- lib/haxor/vm/core.rb
+- lib/haxor/vm/cpu/core.rb
+- lib/haxor/vm/cpu/unit/arithmetic.rb
+- lib/haxor/vm/cpu/unit/base.rb
+- lib/haxor/vm/cpu/unit/jumps.rb
+- lib/haxor/vm/cpu/unit/logical.rb
+- lib/haxor/vm/cpu/unit/transfer.rb
+- lib/haxor/vm/cpu/unit/various.rb
+- lib/haxor/vm/mem.rb
+- lib/haxor/vm/os.rb
+- lib/haxor/vm/stack.rb
+- lib/haxor/vm/subsystem.rb
+- media/memory.png
+- media/vm.png
+homepage: https://github.com/krzysztof-magosa/haxor
+licenses:
+- BSD-3
+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: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Educational Assembly Language running on custom VM
+test_files: []