haxor 0.1.0

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/hcc

@@ -0,0 +1,21 @@
+#! /usr/bin/env ruby
+
+require_relative '../lib/haxor'
+
+if ARGV[0].nil?
+  puts "You must specify .hax file to be compiled."
+  exit 1
+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/hld

@@ -0,0 +1,38 @@
+#! /usr/bin/env ruby
+
+require_relative '../lib/haxor'
+require 'optparse'
+
+options = {}
+parser = OptionParser.new do |opts|
+  opts.banner = 'Usage: hld [options] [file.hax.u] [...]'
+
+  opts.on('-o', '--output FILENAME', 'Write output to FILENAME') do |v|
+    options[:output] = v
+  end
+
+  opts.on('-s', '--stack SIZE', OptionParser::DecimalInteger, 'Stack size in bytes') do |v|
+    options[:stack] = v
+  end
+
+  opts.on_tail('-h', '--help', 'Show this message') do
+    puts opts
+    exit
+  end
+end
+
+parser.parse!
+
+unless options.key?(:output) && !ARGV.empty?
+  puts 'You must specify output filename and at least one .hax.u file to be linked.'
+  puts parser
+  exit
+end
+
+linker = Haxor::Linker.new
+ARGV.map do |x|
+  linker.load_unit File.absolute_path(x)
+end
+
+linker.stack = options[:stack] if options.key? :stack
+linker.link options[:output]

data/bin/hvm

@@ -0,0 +1,17 @@
+#! /usr/bin/env ruby
+
+require_relative '../lib/haxor'
+
+if ARGV[0].nil?
+  puts "You must specify .hax.e file to be run."
+  exit 1
+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

data/examples/build.sh

@@ -0,0 +1,10 @@
+#! /bin/sh
+
+# Fail on first error
+set -e
+
+for program in *.hax ; do
+    echo "Compiling example $program ..."
+    ../bin/hcc $program
+    ../bin/hld -o $program.e $program.u
+done

data/examples/guess-the-number.hax

@@ -0,0 +1,100 @@
+section .data
+dw welcome_msg,  "Simple 'Guess the number' game. Powered by Haxor VM.", 10, 0
+dw generate_msg, "I will pick a number between %d and %d, your job is to guess it in smallest number of tries.", 10, 0
+dw question_msg, 10, "What is the number? ", 0
+dw bigger_msg,   "Sorry, but my number is bigger.", 10, 0
+dw smaller_msg,  "Sorry, but my number is smaller.", 10, 0
+dw win_msg,      "Yeah! You guessed my number after %d tries!", 10, 0
+dw invalid_msg,  "Man, do you need definition of a number?! Try wikipedia then ;)", 10, 0
+dw answer_fmt,   "%d", 0
+dw min,          1
+dw max,          1000
+
+section .bss
+dw number,       0
+dw answer,       0
+dw tries,        0
+
+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
+
+label win
+mov sc, 02h
+push tries
+lea r01, win_msg
+push r01
+push 1
+syscall
+jmp exit
+
+label invalid_number
+mov sc, 02h
+lea r01, invalid_msg
+push r01
+push 1
+syscall
+jmp question
+
+label main
+
+label welcome
+mov sc, 02h
+lea r01, welcome_msg
+push r01
+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
+
+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
+
+cmp number, answer
+je win
+jg bigger
+jl smaller
+
+label exit
+mov sc, 01h
+push 0
+syscall

data/haxor.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'haxor/consts'
+
+Gem::Specification.new do |spec|
+  spec.name          = "haxor"
+  spec.version       = Haxor::Consts::GEM_VERSION
+  spec.authors       = ["Krzysztof Magosa"]
+  spec.email         = ["krzysztof@magosa.pl"]
+
+  spec.summary       = "Educational Assembly Language running on custom VM"
+  spec.description   = "Please follow to GitHub repository for more information."
+  spec.homepage      = "https://github.com/krzysztof-magosa/haxor"
+  spec.license       = "BSD-3"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/lib/haxor.rb

@@ -0,0 +1,44 @@
+# 3rd party
+require 'json'
+require 'io/console'
+require 'scanf'
+
+require_relative 'haxor/consts'
+require_relative 'haxor/header'
+
+# vm
+require_relative 'haxor/vm/core'
+require_relative 'haxor/vm/subsystem'
+require_relative 'haxor/vm/mem'
+require_relative 'haxor/vm/stack'
+require_relative 'haxor/vm/os'
+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'
+
+# tokens
+require_relative 'haxor/token/base'
+require_relative 'haxor/token/data'
+require_relative 'haxor/token/int64'
+require_relative 'haxor/token/label'
+require_relative 'haxor/token/pointer'
+require_relative 'haxor/token/cmd'

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

@@ -0,0 +1,55 @@
+module Haxor
+  module Compiler
+    module Component
+      class Arithmetic < Base
+        def register
+          bind_cmd 'inc', :cmd_inc
+          bind_cmd 'dec', :cmd_dec
+          bind_cmd 'add', :cmd_add
+          bind_cmd 'sub', :cmd_sub
+          bind_cmd 'div', :cmd_div
+          bind_cmd 'mul', :cmd_mul
+          bind_cmd 'cmp', :cmd_cmp
+        end
+
+        def cmd_add(a, b)
+          add Token::Cmd.new(Vm::Cpu::Unit::Arithmetic::OP_ADD | offset_flags(a, b))
+          parse_value a
+          parse_value b
+        end
+
+        def cmd_sub(a, b)
+          add Token::Cmd.new(Vm::Cpu::Unit::Arithmetic::OP_SUB | offset_flags(a, b))
+          parse_value a
+          parse_value b
+        end
+
+        def cmd_div(a)
+          add Token::Cmd.new(Vm::Cpu::Unit::Arithmetic::OP_DIV | offset_flags(a))
+          parse_value a
+        end
+
+        def cmd_mul(a)
+          add Token::Cmd.new(Vm::Cpu::Unit::Arithmetic::OP_MUL | offset_flags(a))
+          parse_value a
+        end
+
+        def cmd_cmp(a, b)
+          add Token::Cmd.new(Vm::Cpu::Unit::Arithmetic::OP_CMP | offset_flags(a, b))
+          parse_value a
+          parse_value b
+        end
+
+        def cmd_inc(a)
+          add Token::Cmd.new(Vm::Cpu::Unit::Arithmetic::OP_INC | offset_flags(a))
+          parse_value a
+        end
+
+        def cmd_dec(a)
+          add Token::Cmd.new(Vm::Cpu::Unit::Arithmetic::OP_DEC | offset_flags(a))
+          parse_value a
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Haxor
+  module Compiler
+    module Component
+      class Base
+        attr_accessor :compiler
+
+        def register
+          fail 'this method must be implemented.'
+        end
+
+        def bind_cmd(cmd, method)
+          compiler.bind_cmd cmd, self, method
+        end
+
+        def add(token)
+          compiler.add token
+        end
+
+        def parse_value(value)
+          compiler.parse_value value
+        end
+
+        def offset_flags(a, b = nil)
+          compiler.offset_flags(a, b)
+        end
+
+        def offset?(value)
+          compiler.offset? value
+        end
+
+        def strip_offset(value)
+          compiler.strip_offset value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Haxor
+  module Compiler
+    module Component
+      class Data < Base
+        def register
+          bind_cmd 'dw', :cmd_dw
+          bind_cmd 'resw', :cmd_resw
+        end
+
+        def cmd_dw(*args)
+          add Token::Label.new(args[0])
+
+          (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
+
+        def cmd_resw(*args)
+          (1..args[0].to_i).each do
+            add Token::Int64.new(0)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+module Haxor
+  module Compiler
+    module Component
+      class Jumps < Base
+        def register
+          bind_cmd 'call', :cmd_call
+          bind_cmd 'ret', :cmd_ret
+          bind_cmd 'iret', :cmd_iret
+
+          bind_cmd 'jmp', :cmd_jmp
+
+          bind_cmd 'je',  :cmd_je
+          bind_cmd 'jg',  :cmd_jg
+          bind_cmd 'jge', :cmd_jge
+          bind_cmd 'jl',  :cmd_jl
+          bind_cmd 'jle', :cmd_jle
+
+          bind_cmd 'jne',  :cmd_jne
+          bind_cmd 'jng',  :cmd_jng
+          bind_cmd 'jnge', :cmd_jnge
+          bind_cmd 'jnl',  :cmd_jnl
+          bind_cmd 'jnle', :cmd_jnle
+        end
+
+        def cmd_call(a)
+          add Token::Cmd.new(Vm::Cpu::Unit::Jumps::OP_CALL | offset_flags(a))
+          parse_value a
+        end
+
+        def cmd_ret(*_args)
+          add Token::Cmd.new(Vm::Cpu::Unit::Jumps::OP_RET)
+        end
+
+        def cmd_iret(*_args)
+          add Token::Cmd.new(Vm::Cpu::Unit::Jumps::OP_IRET)
+        end
+
+        def cmd_jmp(a)
+          add Token::Cmd.new(Vm::Cpu::Unit::Jumps::OP_JMP | offset_flags(a))
+          parse_value a
+        end
+
+        def cmd_je(a)
+          add Token::Cmd.new(Vm::Cpu::Unit::Jumps::OP_JE)
+          parse_value a
+        end
+
+        def cmd_jg(a)
+          add Token::Cmd.new(Vm::Cpu::Unit::Jumps::OP_JG)
+          parse_value a
+        end
+
+        def cmd_jge(a)
+          add Token::Cmd.new(Vm::Cpu::Unit::Jumps::OP_JGE)
+          parse_value a
+        end
+
+        def cmd_jl(a)
+          add Token::Cmd.new(Vm::Cpu::Unit::Jumps::OP_JL)
+          parse_value a
+        end
+
+        def cmd_jle(a)
+          add Token::Cmd.new(Vm::Cpu::Unit::Jumps::OP_JLE)
+          parse_value a
+        end
+
+        def cmd_jne(a)
+          add Token::Cmd.new(Vm::Cpu::Unit::Jumps::OP_JNE)
+          parse_value a
+        end
+
+        def cmd_jng(a)
+          add Token::Cmd.new(Vm::Cpu::Unit::Jumps::OP_JNG)
+          parse_value a
+        end
+
+        def cmd_jnge(a)
+          add Token::Cmd.new(Vm::Cpu::Unit::Jumps::OP_JNGE)
+          parse_value a
+        end
+
+        def cmd_jnl(a)
+          add Token::Cmd.new(Vm::Cpu::Unit::Jumps::OP_JNL)
+          parse_value a
+        end
+
+        def cmd_jnle(a)
+          add Token::Cmd.new(Vm::Cpu::Unit::Jumps::OP_JNLE)
+          parse_value a
+        end
+      end
+    end
+  end
+end