haxor 0.3.0 → 0.4.0

data/bin/{hcc → hc}

@@ -4,7 +4,7 @@ require_relative '../lib/haxor'
 require 'optparse'
 
 parser = OptionParser.new do |opts|
-  opts.banner = 'Usage: hcc [options] [file.hax]'
+  opts.banner = 'Usage: hc [options] [file.hax]'
 
   opts.on_tail('-h', '--help', 'Show this message') do
     puts opts
@@ -28,12 +28,4 @@ end
 source = File.absolute_path ARGV[0]
 
 compiler = Haxor::Compiler::Core.new
-compiler.register_unit Haxor::Compiler::Component::Arithmetic.new
-compiler.register_unit Haxor::Compiler::Component::Data.new
-compiler.register_unit Haxor::Compiler::Component::Jumps.new
-compiler.register_unit Haxor::Compiler::Component::Logical.new
-compiler.register_unit Haxor::Compiler::Component::Other.new
-compiler.register_unit Haxor::Compiler::Component::Transfer.new
-compiler.register_unit Haxor::Compiler::Component::Various.new
-
 compiler.compile source

data/bin/hvm

@@ -26,11 +26,16 @@ if ARGV[0].nil?
   exit
 end
 
-vm = Haxor::Vm::Core.new
-
-filename = ARGV[0]
-# make life easier ;)
-filename += '.e' if filename.end_with? '.hax'
-
-vm.load_program filename
-vm.execute
+begin
+  vm = Haxor::Vm::Core.new
+
+  filename = ARGV[0]
+  # make life easier ;)
+  filename += '.e' if filename.end_with? '.hax'
+
+  vm.load_program filename
+  vm.execute
+rescue => e
+  puts "An error occurred: #{e}."
+  exit 1
+end

data/examples/build.sh

@@ -5,6 +5,6 @@ set -e
 
 for program in *.hax ; do
     echo "Compiling example $program ..."
-    ../bin/hcc $program
+    ../bin/hc $program
     ../bin/hld -o $program.e $program.u
 done

data/examples/guess-the-number.hax

@@ -11,90 +11,79 @@ dw min,          1
 dw max,          1000
 
 section .bss
-dw number,       0
-dw answer,       0
-dw tries,        0
+dw number
+dw answer
+dw tries
 
 section .text
-label bigger
-mov sc, 02h
-lea r01, bigger_msg
-push r01
-push 1
-syscall
-jmp question
 
-label smaller
-mov sc, 02h
-lea r01, smaller_msg
-push r01
-push 1
-syscall
-jmp question
+bigger:
+  addi $sc, $0, 01h
+  pushi bigger_msg
+  pushi 1
+  syscall
+  j question
 
-label win
-mov sc, 02h
-push tries
-lea r01, win_msg
-push r01
-push 1
-syscall
-jmp exit
+smaller:
+  addi $sc, $0, 01h
+  pushi smaller_msg
+  pushi 1
+  syscall
+  j question
 
-label invalid_number
-mov sc, 02h
-lea r01, invalid_msg
-push r01
-push 1
-syscall
-jmp question
+win:
+  addi $sc, $0, 01h
+  pushm tries
+  pushi win_msg
+  push 1
+  syscall
+  exiti 0
 
-label main
+invalid_number:
+  addi $sc, $0, 01h
+  pushi invalid_msg
+  push 1
+  syscall
+  j question
 
-label welcome
-mov sc, 02h
-lea r01, welcome_msg
-push r01
-push 1
-syscall
+main:
+  addi $sc, $0, 01h
+  pushi welcome_msg
+  push 1
+  syscall
 
-label generate
-mov sc, 02h
-push max
-push min
-lea r01, generate_msg
-push r01
-push 1
-syscall
-mov sc, 04h
-push max
-push min
-syscall
-pop number
+generate:
+  addi $sc, $0, 01h
+  pushm max
+  pushm min
+  pushi generate_msg
+  pushi 1
+  syscall
+  addi $sc, $0, 03h
+  pushm max
+  pushm min
+  syscall
+  popm number
 
-label question
-mov sc, 02h
-lea r01, question_msg
-push r01
-push 1
-syscall
-mov sc, 03h
-lea r01, answer
-push r01
-lea r01, answer_fmt
-push r01
-push 0
-syscall
-cmp sc, -1
-je invalid_number
-inc tries
+question:
+  addi $sc, $0, 01h
+  pushi question_msg
+  pushi 1
+  syscall
+  addi $sc, $0, 02h
+  pushi answer
+  pushi answer_fmt
+  pushi 0
+  syscall
 
-cmp number, answer
-je win
-jg bigger
-jl smaller
+  addi $5, $0, -1
+  beq $sc, $5, invalid_number
+  lw $6, $0, tries
+  addi $6, $6, 1
+  sw $0, tries, $6
 
-label exit
-mov sc, 01h
-push 0
-syscall
+  lw $7, $0, number
+  lw $8, $0, answer
+  beq $7, $8, win
+  bgt $7, $8, bigger
+  blt $7, $8, smaller

data/lib/haxor.rb

@@ -3,9 +3,11 @@ require 'json'
 require 'io/console'
 require 'scanf'
 require 'digest'
+require 'ostruct'
 
 require_relative 'haxor/consts'
 require_relative 'haxor/header'
+require_relative 'haxor/utils'
 
 # vm
 require_relative 'haxor/vm/core'
@@ -15,24 +17,10 @@ require_relative 'haxor/vm/stack'
 require_relative 'haxor/vm/os'
 require_relative 'haxor/vm/registers'
 require_relative 'haxor/vm/cpu/core'
-require_relative 'haxor/vm/cpu/unit/base'
-require_relative 'haxor/vm/cpu/unit/logical'
-require_relative 'haxor/vm/cpu/unit/arithmetic'
-require_relative 'haxor/vm/cpu/unit/jumps'
-require_relative 'haxor/vm/cpu/unit/various'
-require_relative 'haxor/vm/cpu/unit/transfer'
 
 # compiler
 require_relative 'haxor/compiler/unit'
 require_relative 'haxor/compiler/core'
-require_relative 'haxor/compiler/component/base'
-require_relative 'haxor/compiler/component/logical'
-require_relative 'haxor/compiler/component/arithmetic'
-require_relative 'haxor/compiler/component/jumps'
-require_relative 'haxor/compiler/component/various'
-require_relative 'haxor/compiler/component/transfer'
-require_relative 'haxor/compiler/component/data'
-require_relative 'haxor/compiler/component/other'
 
 # linker
 require_relative 'haxor/linker'

data/lib/haxor/compiler/core.rb

@@ -1,25 +1,85 @@
 module Haxor
   module Compiler
     class Core
+      REG_ALIASES = {
+        '$sp'  => Vm::Cpu::Core::REG_STACK,
+        '$ret' => Vm::Cpu::Core::REG_RETURN,
+        '$sc'  => Vm::Cpu::Core::REG_SYSCALL
+      }
+
       def initialize
         @units = []
-        @cmds = {}
+        @cmds = []
         @autolabel = 0
         @prev_sections = []
 
-        bind_cmd 'section', self, :cmd_section
+        init_cmds
       end
 
-      def register_unit(unit)
-        @units << unit
-        unit.compiler = self
-        unit.register
+      def init_cmds
+        bind_cmd 'section', [:any],       :cmd_section
+        bind_cmd 'dw',      [:wildcard],  :cmd_dw
+        bind_cmd 'resw',    [:any],       :cmd_resw
+        bind_cmd '#',       [:wildcard],  :cmd_rem
+        bind_cmd 'push',    [:reg],       :cmd_push
+        bind_cmd 'pushi',   [:imm],       :cmd_pushi
+        bind_cmd 'pushm',   [:imm],       :cmd_pushm
+        bind_cmd 'pop',     [:reg],       :cmd_pop
+        bind_cmd 'popm',    [:imm],       :cmd_popm
+        bind_cmd 'move',    [:reg, :reg], :cmd_move
+        bind_cmd 'clear',   [:reg],       :cmd_clear
+        bind_cmd 'not',     [:reg, :reg], :cmd_not
+        bind_cmd 'ret',     [],           :cmd_ret
+
+        bind_cmd 'b',       [:imm],             :cmd_b
+        bind_cmd 'bal',     [:imm],             :cmd_bal
+        bind_cmd 'bgt',     [:reg, :reg, :imm], :cmd_bgt
+        bind_cmd 'blt',     [:reg, :reg, :imm], :cmd_blt
+        bind_cmd 'bge',     [:reg, :reg, :imm], :cmd_bge
+        bind_cmd 'ble',     [:reg, :reg, :imm], :cmd_ble
+        bind_cmd 'blez',    [:reg, :imm],       :cmd_blez
+        bind_cmd 'bgtz',    [:reg, :imm],       :cmd_bgtz
+        bind_cmd 'beqz',    [:reg, :imm],       :cmd_beqz
+
+        bind_cmd 'nop',     [],                 Vm::Cpu::Core::OP_NOP
+        bind_cmd 'add',     [:reg, :reg, :reg], Vm::Cpu::Core::OP_ADD
+        bind_cmd 'addi',    [:reg, :reg, :imm], Vm::Cpu::Core::OP_ADDI
+        bind_cmd 'sub',     [:reg, :reg, :reg], Vm::Cpu::Core::OP_SUB
+        bind_cmd 'mult',    [:reg, :reg, :reg], Vm::Cpu::Core::OP_MULT
+        bind_cmd 'div',     [:reg, :reg, :reg], Vm::Cpu::Core::OP_DIV
+        bind_cmd 'mod',     [:reg, :reg, :reg], Vm::Cpu::Core::OP_MOD
+        bind_cmd 'lw',      [:reg, :reg, :imm], Vm::Cpu::Core::OP_LW
+        bind_cmd 'sw',      [:reg, :imm, :reg], Vm::Cpu::Core::OP_SW
+        bind_cmd 'lui',     [:reg, :imm],       Vm::Cpu::Core::OP_LUI
+        bind_cmd 'and',     [:reg, :reg, :reg], Vm::Cpu::Core::OP_AND
+        bind_cmd 'andi',    [:reg, :reg, :imm], Vm::Cpu::Core::OP_ANDI
+        bind_cmd 'or',      [:reg, :reg, :reg], Vm::Cpu::Core::OP_OR
+        bind_cmd 'ori',     [:reg, :reg, :imm], Vm::Cpu::Core::OP_ORI
+        bind_cmd 'xor',     [:reg, :reg, :reg], Vm::Cpu::Core::OP_XOR
+        bind_cmd 'nor',     [:reg, :reg, :reg], Vm::Cpu::Core::OP_NOR
+        bind_cmd 'slt',     [:reg, :reg, :reg], Vm::Cpu::Core::OP_SLT
+        bind_cmd 'slti',    [:reg, :reg, :imm], Vm::Cpu::Core::OP_SLTI
+        bind_cmd 'slli',    [:reg, :reg, :imm], Vm::Cpu::Core::OP_SLLI
+        bind_cmd 'srli',    [:reg, :reg, :imm], Vm::Cpu::Core::OP_SRLI
+        bind_cmd 'sll',     [:reg, :reg, :reg], Vm::Cpu::Core::OP_SLL
+        bind_cmd 'srl',     [:reg, :reg, :reg], Vm::Cpu::Core::OP_SRL
+        bind_cmd 'beq',     [:reg, :reg, :imm], Vm::Cpu::Core::OP_BEQ,  [:rel_imm, :x8]
+        bind_cmd 'beql',    [:reg, :reg, :imm], Vm::Cpu::Core::OP_BEQL, [:rel_imm, :x8]
+        bind_cmd 'bne',     [:reg, :reg, :imm], Vm::Cpu::Core::OP_BNE,  [:rel_imm, :x8]
+        bind_cmd 'bnel',    [:reg, :reg, :imm], Vm::Cpu::Core::OP_BNEL, [:rel_imm, :x8]
+        bind_cmd 'j',       [:imm],             Vm::Cpu::Core::OP_J,    [:x8]
+        bind_cmd 'jr',      [:reg],             Vm::Cpu::Core::OP_JR
+        bind_cmd 'jal',     [:imm],             Vm::Cpu::Core::OP_JAL,  [:x8]
+        bind_cmd 'exiti',   [:imm],             Vm::Cpu::Core::OP_EXITI
+        bind_cmd 'syscall', [],                 Vm::Cpu::Core::OP_SYSCALL
       end
 
-      def bind_cmd(cmd, object, method)
-        @cmds[cmd] = {
-          object: object,
-          method: method
+      def bind_cmd(cmd, args, opcode, opts = [])
+        @cmds << {
+          cmd: cmd,
+          args: args,
+          opcode: opcode,
+          opts: opts
         }
       end
 
@@ -27,6 +87,122 @@ module Haxor
         @unit.section = name[1..-1].to_sym
       end
 
+      def cmd_dw(*args)
+        add Token::Label.new(args[0])
+
+        if args.size == 1
+          add Token::Int64.new(0)
+        else
+          (1...args.size).each do |i|
+            begin
+              add Token::Int64.new(Integer(args[i]))
+            rescue
+              args[i][1...-1].each_char do |c|
+                add Token::Int64.new(c.ord)
+              end
+            end
+          end
+        end
+      end
+
+      def cmd_resw(*args)
+        (1..args[0].to_i).each do
+          add Token::Int64.new(0)
+        end
+      end
+
+      def cmd_rem(*)
+      end
+
+      def cmd_push(*args)
+        process_cmd 'addi', ['$sp', '$sp', '-' + Consts::WORD_SIZE.to_s]
+        process_cmd 'sw',   ['$sp', '0', args[0]]
+      end
+
+      def cmd_pushi(*args)
+        process_cmd 'addi', ['$1', '$0', args[0]]
+        process_cmd 'addi', ['$sp', '$sp', '-' + Consts::WORD_SIZE.to_s]
+        process_cmd 'sw',   ['$sp', '0', '$1']
+      end
+
+      def cmd_pushm(*args)
+        process_cmd 'lw', ['$1', '$0', args[0]]
+        process_cmd 'addi', ['$sp', '$sp', '-' + Consts::WORD_SIZE.to_s]
+        process_cmd 'sw',   ['$sp', '0', '$1']
+      end
+
+      def cmd_pop(*args)
+        process_cmd 'lw', [args[0], '$sp', '0']
+        process_cmd 'addi', ['$sp', '$sp', Consts::WORD_SIZE.to_s]
+      end
+
+      def cmd_popm(*args)
+        process_cmd 'lw', ['$1', '$sp', '0']
+        process_cmd 'sw', ['$0', args[0], '$1']
+        process_cmd 'addi', ['$sp', '$sp', Consts::WORD_SIZE.to_s]
+      end
+
+      def cmd_move(*args)
+        process_cmd 'add', [args[0], args[1], '$0']
+      end
+
+      def cmd_clear(*args)
+        process_cmd 'add', [args[0], '$0', '$0']
+      end
+
+      def cmd_not(*args)
+        process_cmd 'nor', [args[0], args[1], '$0']
+      end
+
+      def cmd_ret(*_args)
+        process_cmd 'jr', ['$' + Vm::Cpu::Core::REG_RETURN.to_s]
+      end
+
+      def cmd_b(*args)
+        process_cmd 'beq', ['$0', '$0', args[0]]
+      end
+
+      def cmd_bal(*args)
+        process_cmd 'beql', ['$0', '$0', args[0]]
+      end
+
+      # branch is greater than
+      def cmd_bgt(*args)
+        process_cmd 'slt', ['$1', args[1], args[0]]
+        process_cmd 'bne', ['$1', '$0', args[2]]
+      end
+
+      # branch if less than
+      def cmd_blt(*args)
+        process_cmd 'slt', ['$1', args[0], args[1]]
+        process_cmd 'bne', ['$1', '$0', args[2]]
+      end
+
+      # branch is greater or equal
+      def cmd_bge(*args)
+        process_cmd 'slt', ['$1', args[0], args[1]]
+        process_cmd 'beq', ['$1', '$0', args[2]]
+      end
+
+      def cmd_ble(*args)
+        process_cmd 'slt', ['$1', args[1], args[0]]
+        process_cmd 'beq', ['$1', '$0', args[2]]
+      end
+
+      def cmd_blez(*args)
+        process_cmd 'slt', ['$1', '$0', args[0]]
+        process_cmd 'beq', ['$1', '$0', args[1]]
+      end
+
+      def cmd_bgtz(*args)
+        process_cmd 'slt', ['$1', '$0', args[0]]
+        process_cmd 'bne', ['$1', '$0', args[1]]
+      end
+
+      def cmd_beqz(*args)
+        process_cmd 'beq', [args[0], '$0', args[1]]
+      end
+
       # this is ugly and must be reworked
       def split_arguments(string)
         inside_quotes = false
@@ -52,6 +228,23 @@ module Haxor
         args.map!(&:strip).delete_if { |x| x.length == 0 }
       end
 
+      def process_cmd(cmd, args)
+        @cmds.each do |item|
+          next if item[:cmd] != cmd
+
+          if item[:opcode].is_a? Symbol
+            send(item[:opcode], *args)
+            return
+          end
+
+          add_cmd item, args
+          return
+        end
+
+        puts cmd
+        fail
+      end
+
       def compile(filename)
         input = File.read(filename, encoding: 'ASCII-8BIT')
 
@@ -64,9 +257,11 @@ module Haxor
           cmd = tmp[0]
           args = split_arguments(tmp[1] || '')
 
-          fail "Unknown command #{cmd} in line #{index}." unless @cmds.key? cmd
-
-          @cmds[cmd][:object].send(@cmds[cmd][:method], *args)
+          if cmd[-1] == ':'
+            add Token::Label.new(cmd[0...-1])
+          else
+            process_cmd(cmd, args)
+          end
         end
 
         @unit.save(filename + '.u')
@@ -76,11 +271,47 @@ module Haxor
         @unit.add token
       end
 
-      def add_cmd(opcode, a = nil, b = nil)
-        opcode |= offset_flags(a, b)
-        add Token::Cmd.new(opcode)
-        parse_value a unless a.nil?
-        parse_value b unless b.nil?
+#      def resolve_arg(a, type)
+#        case type
+#        when :reg
+#          return a[1..-1].to_i
+#        when :imm
+#          return a.to_i
+#        else
+#          fail
+#        end
+#      end
+
+      def add_cmd(info, args = [])
+        registers = []
+        immediate = 0
+        info[:args].each_with_index do |type, index|
+          if type == :reg
+            if REG_ALIASES.key? args[index]
+              registers << REG_ALIASES[args[index]]
+            else
+              registers << args[index][1..-1].to_i
+            end
+          elsif type == :imm
+            begin
+              immediate = parse_number args[index]
+            rescue
+              immediate = args[index]
+            end
+          end
+        end
+
+        registers.fill 0, registers.size...3
+
+        token      = Token::Cmd.new
+        token.cmd  = info[:opcode]
+        token.reg1 = registers[0]
+        token.reg2 = registers[1]
+        token.reg3 = registers[2]
+        token.imm  = immediate
+        token.opts = info[:opts]
+
+        add token
       end
 
       def parse_number(value)