haxor 0.3.0 → 0.4.0

data/lib/haxor/compiler/component/transfer.rb

@@ -1,25 +0,0 @@
-module Haxor
-  module Compiler
-    module Component
-      class Transfer < Base
-        def register
-          bind_cmd 'mov', :cmd_mov
-          bind_cmd 'push', :cmd_push
-          bind_cmd 'pop', :cmd_pop
-        end
-
-        def cmd_push(a)
-          add_cmd Vm::Cpu::Unit::Transfer::OP_PUSH, a
-        end
-
-        def cmd_pop(a)
-          add_cmd Vm::Cpu::Unit::Transfer::OP_POP, a
-        end
-
-        def cmd_mov(a, b)
-          add_cmd Vm::Cpu::Unit::Transfer::OP_MOV, a, b
-        end
-      end
-    end
-  end
-end

data/lib/haxor/compiler/component/various.rb

@@ -1,30 +0,0 @@
-module Haxor
-  module Compiler
-    module Component
-      class Various < Base
-        def register
-          bind_cmd 'nop', :cmd_nop
-          bind_cmd 'lea', :cmd_lea
-          bind_cmd 'int', :cmd_int
-          bind_cmd 'syscall', :cmd_syscall
-        end
-
-        def cmd_nop(*_args)
-          add_cmd Vm::Cpu::Unit::Various::OP_NOP
-        end
-
-        def cmd_lea(a, b)
-          add_cmd Vm::Cpu::Unit::Various::OP_LEA, a, b
-        end
-
-        def cmd_int(a)
-          add_cmd Vm::Cpu::Unit::Various::OP_INT, a
-        end
-
-        def cmd_syscall
-          add_cmd Vm::Cpu::Unit::Various::OP_SYSCALL
-        end
-      end
-    end
-  end
-end

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

@@ -1,78 +0,0 @@
-module Haxor
-  module Vm
-    module Cpu
-    module Unit
-      class Arithmetic < Base
-        #            0x00 (not used)
-        OP_ADD     = 0x01 # add a, b
-        OP_SUB     = 0x02 # sub a, b
-        OP_DIV     = 0x03 # div a
-        OP_MUL     = 0x04 # mul a
-        OP_INC     = 0x05 # inc a
-        OP_DEC     = 0x06 # dec a
-        OP_CMP     = 0x07 # cmp a, b
-        #            0x1f
-
-        def register
-          bind_opcode OP_ADD, :op_add
-          bind_opcode OP_SUB, :op_sub
-          bind_opcode OP_DIV, :op_div
-          bind_opcode OP_MUL, :op_mul
-          bind_opcode OP_INC, :op_inc
-          bind_opcode OP_DEC, :op_dec
-          bind_opcode OP_CMP, :op_cmp
-        end
-
-        def op_add
-          a, b = operands
-          c = @vm.subsystem(:mem).read(a) + @vm.subsystem(:mem).read(b)
-          @vm.subsystem(:mem).write a, c
-        end
-
-        def op_sub
-          a, b = operands
-          c = @vm.subsystem(:mem).read(a) - @vm.subsystem(:mem).read(b)
-          @vm.subsystem(:mem).write a, c
-        end
-
-        def op_div
-          a = operand
-          av = @vm.subsystem(:mem).read a
-          arv = @vm.subsystem(:registers).read 'ar'
-          @vm.subsystem(:registers).write 'ar', (arv / av)
-          @vm.subsystem(:registers).write 'dr', (arv % av)
-        end
-
-        def op_mul
-          a = operand
-          av = @vm.subsystem(:mem).read a
-          arv = @vm.subsystem(:registers).read 'ar'
-          @vm.subsystem(:registers).write 'ar', (arv * av)
-        end
-
-        def op_inc
-          a = operand
-          av = @vm.subsystem(:mem).read a
-          @vm.subsystem(:mem).write a, (av + 1)
-        end
-
-        def op_dec
-          a = operand
-          av = @vm.subsystem(:mem).read a
-          @vm.subsystem(:mem).write a, (av - 1)
-        end
-
-        def op_cmp
-          a, b = operands
-          av = @vm.subsystem(:mem).read a
-          bv = @vm.subsystem(:mem).read b
-          v = av - bv
-
-          @vm.subsystem(:registers).flag Consts::FR_ZERO, v == 0
-          @vm.subsystem(:registers).flag Consts::FR_SIGN, v < 0
-        end
-      end
-    end
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-module Haxor
-  module Vm
-    module Cpu
-    module Unit
-      class Base
-        attr_accessor :vm
-
-        def register
-          fail 'this method must be implemented.'
-        end
-
-        def bind_opcode(opcode, method)
-          @vm.bind_opcode opcode, self, method
-        end
-
-        # TODO: BC
-        def next_cell
-          @vm.subsystem(:mem).next_word
-        end
-
-        # TODO: BC
-        def fetch_cell(addr)
-          @vm.subsystem(:mem).read addr
-        end
-
-        def dereference(addr)
-          @vm.subsystem(:mem).read addr
-        end
-
-        # TODO: BC
-        def replace_cell(addr, value)
-          @vm.subsystem(:mem).write addr, value
-        end
-
-        def operand
-          @vm.operand
-        end
-
-        def operands
-          @vm.operands
-        end
-      end
-    end
-    end
-  end
-end

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

@@ -1,118 +0,0 @@
-module Haxor
-  module Vm
-    module Cpu
-    module Unit
-      class Jumps < Base
-        #         0x20
-        OP_CALL = 0x20 # call a
-        OP_JMP  = 0x21 # jmp a
-        OP_JE   = 0x22 # je a
-        OP_JG   = 0x23 # jg a
-        OP_JGE  = 0x24 # jge a
-        OP_JL   = 0x25 # jl a
-        OP_JLE  = 0x26 # jle a
-        OP_JNE  = 0x27 # jne a
-        OP_JNG  = 0x28 # jng a
-        OP_JNGE = 0x29 # jnge a
-        OP_JNL  = 0x2a # jnl a
-        OP_JNLE = 0x2b # jnle a
-        OP_RET  = 0x2c # ret
-        OP_IRET = 0x2d # iret
-        #         0x3f
-
-        def register
-          bind_opcode OP_CALL,   :op_call
-          bind_opcode OP_JMP,    :op_jmp
-          bind_opcode OP_JE,     :op_je
-          bind_opcode OP_JG,     :op_jg
-          bind_opcode OP_JGE,    :op_jge
-          bind_opcode OP_JL,     :op_jl
-          bind_opcode OP_JLE,    :op_jle
-          bind_opcode OP_JNE,    :op_jne
-          bind_opcode OP_JNG,    :op_jng
-          bind_opcode OP_JNGE,   :op_jnge
-          bind_opcode OP_JNL,    :op_jnl
-          bind_opcode OP_JNLE,   :op_jnle
-          bind_opcode OP_RET,    :op_ret
-          bind_opcode OP_IRET,   :op_iret
-        end
-
-        def op_call
-          a = operand
-          @vm.subsystem(:stack).push 'ip'
-          jmp a
-        end
-
-        def op_jmp
-          a = operand
-          jmp a
-        end
-
-        def op_je
-          a = operand
-          jmp a if @vm.subsystem(:registers).check_flag Consts::FR_ZERO
-        end
-
-        def op_jg
-          a = operand
-          jmp a if !@vm.subsystem(:registers).check_flag(Consts::FR_ZERO) && !@vm.subsystem(:registers).check_flag(Consts::FR_SIGN)
-        end
-
-        def op_jge
-          a = operand
-          jmp a if !@vm.subsystem(:registers).check_flag(Consts::FR_SIGN) || @vm.subsystem(:registers).check_flag(Consts::FR_ZERO)
-        end
-
-        def op_jl
-          a = operand
-          jmp a if !@vm.subsystem(:registers).check_flag(Consts::FR_ZERO) && @vm.subsystem(:registers).check_flag(Consts::FR_SIGN)
-        end
-
-        def op_jle
-          a = operand
-          jmp a if @vm.subsystem(:registers).check_flag(Consts::FR_SIGN) || @vm.subsystem(:registers).check_flag(Consts::FR_ZERO)
-        end
-
-        def op_jne
-          a = operand
-          jmp a unless @vm.subsystem(:registers).check_flag Consts::FR_ZERO
-        end
-
-        def op_jng
-          a = operand
-          jmp a unless !@vm.subsystem(:registers).check_flag(Consts::FR_ZERO) && !@vm.subsystem(:registers).check_flag(Consts::FR_SIGN)
-        end
-
-        def op_jnge
-          a = operand
-          jmp a unless !@vm.subsystem(:registers).check_flag(Consts::FR_SIGN) || @vm.subsystem(:registers).check_flag(Consts::FR_ZERO)
-        end
-
-        def op_jnl
-          a = operand
-          jmp a unless !@vm.subsystem(:registers).check_flag(Consts::FR_ZERO) && @vm.subsystem(:registers).check_flag(Consts::FR_SIGN)
-        end
-
-        def op_jnle
-          a = operand
-          jmp a unless @vm.subsystem(:registers).check_flag(Consts::FR_SIGN) || @vm.subsystem(:registers).check_flag(Consts::FR_ZERO)
-        end
-
-        def op_ret
-          @vm.subsystem(:stack).pop 'ip'
-        end
-
-        def op_iret
-          @vm.subsystem(:stack).pop 'ip'
-        end
-
-        private
-
-        def jmp(addr)
-          @vm.subsystem(:registers).write 'ip', addr
-        end
-      end
-    end
-  end
-end
-end

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

@@ -1,59 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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