haxor 0.2.0 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: 293f0584494d168aa8bfe9d97871fc62fd11936b
4
- data.tar.gz: 2a06187130337634f8a271d8d9a869928792919a
3
+ metadata.gz: aaec13d5834cb5769a776fb6c5acd91880848a5a
4
+ data.tar.gz: 0b48149b0b1688d740930bd5ecd2b6ec42345dbf
5
5
  SHA512:
6
- metadata.gz: ef117dfbef1487268cf206d24dfd89aefcc909f9c8702c6e1502edbb9b2c498b023bb57fd89d73508278238a0c52a509f79d6dc240ea67143a2035bf31d6eccd
7
- data.tar.gz: c853651c044c0d7c53a1b465b9116a0d33b919f14ccbb55f38e5eff02b9975c02db0f344f0b6c97fa98ec16925750547b2645f86939801cfc80010562c802db4
6
+ metadata.gz: 7d1b084b85d5fce1afdfe30dc5c520aabd3f02b1c3a1ab7fea33a6b62b71d9e3eb69885492f21454643764742102902557dbbfb1495c021de689472b2012520a
7
+ data.tar.gz: de72d7b52c53f58a6788631a0b060d58833f20e000b968ee9782b52690567eb789a202be23fa9fd636303555b93d60a73825a74b915cd57cc4ed2a6d468b712f
@@ -2,6 +2,7 @@
2
2
  require 'json'
3
3
  require 'io/console'
4
4
  require 'scanf'
5
+ require 'digest'
5
6
 
6
7
  require_relative 'haxor/consts'
7
8
  require_relative 'haxor/header'
@@ -13,41 +13,31 @@ module Haxor
13
13
  end
14
14
 
15
15
  def cmd_add(a, b)
16
- add Token::Cmd.new(Vm::Cpu::Unit::Arithmetic::OP_ADD | offset_flags(a, b))
17
- parse_value a
18
- parse_value b
16
+ add_cmd Vm::Cpu::Unit::Arithmetic::OP_ADD, a, b
19
17
  end
20
18
 
21
19
  def cmd_sub(a, b)
22
- add Token::Cmd.new(Vm::Cpu::Unit::Arithmetic::OP_SUB | offset_flags(a, b))
23
- parse_value a
24
- parse_value b
20
+ add_cmd Vm::Cpu::Unit::Arithmetic::OP_SUB, a, b
25
21
  end
26
22
 
27
23
  def cmd_div(a)
28
- add Token::Cmd.new(Vm::Cpu::Unit::Arithmetic::OP_DIV | offset_flags(a))
29
- parse_value a
24
+ add_cmd Vm::Cpu::Unit::Arithmetic::OP_DIV, a
30
25
  end
31
26
 
32
27
  def cmd_mul(a)
33
- add Token::Cmd.new(Vm::Cpu::Unit::Arithmetic::OP_MUL | offset_flags(a))
34
- parse_value a
28
+ add_cmd Vm::Cpu::Unit::Arithmetic::OP_MUL, a
35
29
  end
36
30
 
37
31
  def cmd_cmp(a, b)
38
- add Token::Cmd.new(Vm::Cpu::Unit::Arithmetic::OP_CMP | offset_flags(a, b))
39
- parse_value a
40
- parse_value b
32
+ add_cmd Vm::Cpu::Unit::Arithmetic::OP_CMP, a, b
41
33
  end
42
34
 
43
35
  def cmd_inc(a)
44
- add Token::Cmd.new(Vm::Cpu::Unit::Arithmetic::OP_INC | offset_flags(a))
45
- parse_value a
36
+ add_cmd Vm::Cpu::Unit::Arithmetic::OP_INC, a
46
37
  end
47
38
 
48
39
  def cmd_dec(a)
49
- add Token::Cmd.new(Vm::Cpu::Unit::Arithmetic::OP_DEC | offset_flags(a))
50
- parse_value a
40
+ add_cmd Vm::Cpu::Unit::Arithmetic::OP_DEC, a
51
41
  end
52
42
  end
53
43
  end
@@ -16,6 +16,10 @@ module Haxor
16
16
  compiler.add token
17
17
  end
18
18
 
19
+ def add_cmd(opcode, a = nil, b = nil)
20
+ compiler.add_cmd opcode, a, b
21
+ end
22
+
19
23
  def parse_value(value)
20
24
  compiler.parse_value value
21
25
  end
@@ -23,71 +23,59 @@ module Haxor
23
23
  end
24
24
 
25
25
  def cmd_call(a)
26
- add Token::Cmd.new(Vm::Cpu::Unit::Jumps::OP_CALL | offset_flags(a))
27
- parse_value a
26
+ add_cmd Vm::Cpu::Unit::Jumps::OP_CALL, a
28
27
  end
29
28
 
30
29
  def cmd_ret(*_args)
31
- add Token::Cmd.new(Vm::Cpu::Unit::Jumps::OP_RET)
30
+ add_cmd Vm::Cpu::Unit::Jumps::OP_RET
32
31
  end
33
32
 
34
33
  def cmd_iret(*_args)
35
- add Token::Cmd.new(Vm::Cpu::Unit::Jumps::OP_IRET)
34
+ add_cmd Vm::Cpu::Unit::Jumps::OP_IRET
36
35
  end
37
36
 
38
37
  def cmd_jmp(a)
39
- add Token::Cmd.new(Vm::Cpu::Unit::Jumps::OP_JMP | offset_flags(a))
40
- parse_value a
38
+ add_cmd Vm::Cpu::Unit::Jumps::OP_JMP, a
41
39
  end
42
40
 
43
41
  def cmd_je(a)
44
- add Token::Cmd.new(Vm::Cpu::Unit::Jumps::OP_JE)
45
- parse_value a
42
+ add_cmd Vm::Cpu::Unit::Jumps::OP_JE, a
46
43
  end
47
44
 
48
45
  def cmd_jg(a)
49
- add Token::Cmd.new(Vm::Cpu::Unit::Jumps::OP_JG)
50
- parse_value a
46
+ add_cmd Vm::Cpu::Unit::Jumps::OP_JG, a
51
47
  end
52
48
 
53
49
  def cmd_jge(a)
54
- add Token::Cmd.new(Vm::Cpu::Unit::Jumps::OP_JGE)
55
- parse_value a
50
+ add_cmd Vm::Cpu::Unit::Jumps::OP_JGE, a
56
51
  end
57
52
 
58
53
  def cmd_jl(a)
59
- add Token::Cmd.new(Vm::Cpu::Unit::Jumps::OP_JL)
60
- parse_value a
54
+ add_cmd Vm::Cpu::Unit::Jumps::OP_JL, a
61
55
  end
62
56
 
63
57
  def cmd_jle(a)
64
- add Token::Cmd.new(Vm::Cpu::Unit::Jumps::OP_JLE)
65
- parse_value a
58
+ add_cmd Vm::Cpu::Unit::Jumps::OP_JLE, a
66
59
  end
67
60
 
68
61
  def cmd_jne(a)
69
- add Token::Cmd.new(Vm::Cpu::Unit::Jumps::OP_JNE)
70
- parse_value a
62
+ add_cmd Vm::Cpu::Unit::Jumps::OP_JNE, a
71
63
  end
72
64
 
73
65
  def cmd_jng(a)
74
- add Token::Cmd.new(Vm::Cpu::Unit::Jumps::OP_JNG)
75
- parse_value a
66
+ add_cmd Vm::Cpu::Unit::Jumps::OP_JNG, a
76
67
  end
77
68
 
78
69
  def cmd_jnge(a)
79
- add Token::Cmd.new(Vm::Cpu::Unit::Jumps::OP_JNGE)
80
- parse_value a
70
+ add_cmd Vm::Cpu::Unit::Jumps::OP_JNGE, a
81
71
  end
82
72
 
83
73
  def cmd_jnl(a)
84
- add Token::Cmd.new(Vm::Cpu::Unit::Jumps::OP_JNL)
85
- parse_value a
74
+ add_cmd Vm::Cpu::Unit::Jumps::OP_JNL, a
86
75
  end
87
76
 
88
77
  def cmd_jnle(a)
89
- add Token::Cmd.new(Vm::Cpu::Unit::Jumps::OP_JNLE)
90
- parse_value a
78
+ add_cmd Vm::Cpu::Unit::Jumps::OP_JNLE, a
91
79
  end
92
80
  end
93
81
  end
@@ -11,31 +11,23 @@ module Haxor
11
11
  end
12
12
 
13
13
  def cmd_and(a, b)
14
- add Token::Cmd.new(Vm::Cpu::Unit::Logical::OP_AND | offset_flags(a, b))
15
- parse_value a
16
- parse_value b
14
+ add_cmd Vm::Cpu::Unit::Logical::OP_AND, a, b
17
15
  end
18
16
 
19
17
  def cmd_neg(a)
20
- add Token::Cmd.new(Vm::Cpu::Unit::Logical::OP_NEG | offset_flags(a))
21
- parse_value a
18
+ add_cmd Vm::Cpu::Unit::Logical::OP_NEG, a
22
19
  end
23
20
 
24
21
  def cmd_not(a)
25
- add Token::Cmd.new(Vm::Cpu::Unit::Logical::OP_NOT | offset_flags(a))
26
- parse_value a
22
+ add_cmd Vm::Cpu::Unit::Logical::OP_NOT, a
27
23
  end
28
24
 
29
25
  def cmd_or(a, b)
30
- add Token::Cmd.new(Vm::Cpu::Unit::Logical::OP_OR | offset_flags(a, b))
31
- parse_value a
32
- parse_value b
26
+ add_cmd Vm::Cpu::Unit::Logical::OP_OR, a, b
33
27
  end
34
28
 
35
29
  def cmd_xor(a, b)
36
- add Token::Cmd.new(Vm::Cpu::Unit::Logical::OP_XOR | offset_flags(a, b))
37
- parse_value a
38
- parse_value b
30
+ add_cmd Vm::Cpu::Unit::Logical::OP_XOR, a, b
39
31
  end
40
32
  end
41
33
  end
@@ -9,19 +9,15 @@ module Haxor
9
9
  end
10
10
 
11
11
  def cmd_push(a)
12
- add Token::Cmd.new(Vm::Cpu::Unit::Transfer::OP_PUSH | offset_flags(a))
13
- parse_value a
12
+ add_cmd Vm::Cpu::Unit::Transfer::OP_PUSH, a
14
13
  end
15
14
 
16
15
  def cmd_pop(a)
17
- add Token::Cmd.new(Vm::Cpu::Unit::Transfer::OP_POP | offset_flags(a))
18
- parse_value a
16
+ add_cmd Vm::Cpu::Unit::Transfer::OP_POP, a
19
17
  end
20
18
 
21
19
  def cmd_mov(a, b)
22
- add Token::Cmd.new(Vm::Cpu::Unit::Transfer::OP_MOV | offset_flags(a, b))
23
- parse_value a
24
- parse_value b
20
+ add_cmd Vm::Cpu::Unit::Transfer::OP_MOV, a, b
25
21
  end
26
22
  end
27
23
  end
@@ -10,22 +10,19 @@ module Haxor
10
10
  end
11
11
 
12
12
  def cmd_nop(*_args)
13
- add Token::Cmd.new(Vm::Cpu::Unit::Various::OP_NOP)
13
+ add_cmd Vm::Cpu::Unit::Various::OP_NOP
14
14
  end
15
15
 
16
16
  def cmd_lea(a, b)
17
- add Token::Cmd.new(Vm::Cpu::Unit::Various::OP_LEA | offset_flags(a, b))
18
- parse_value a
19
- parse_value b
17
+ add_cmd Vm::Cpu::Unit::Various::OP_LEA, a, b
20
18
  end
21
19
 
22
20
  def cmd_int(a)
23
- add Token::Cmd.new(Vm::Cpu::Unit::Various::OP_INT)
24
- parse_value a
21
+ add_cmd Vm::Cpu::Unit::Various::OP_INT, a
25
22
  end
26
23
 
27
24
  def cmd_syscall
28
- add Token::Cmd.new(Vm::Cpu::Unit::Various::OP_SYSCALL)
25
+ add_cmd Vm::Cpu::Unit::Various::OP_SYSCALL
29
26
  end
30
27
  end
31
28
  end
@@ -55,7 +55,7 @@ module Haxor
55
55
  def compile(filename)
56
56
  input = File.read(filename, encoding: 'ASCII-8BIT')
57
57
 
58
- @unit = Unit.new
58
+ @unit = Unit.new filename
59
59
 
60
60
  input.lines.map(&:chomp).each_with_index do |line, index|
61
61
  next if line.empty?
@@ -76,6 +76,13 @@ module Haxor
76
76
  @unit.add token
77
77
  end
78
78
 
79
+ def add_cmd(opcode, a = nil, b = nil)
80
+ opcode |= offset_flags(a, b)
81
+ add Token::Cmd.new(opcode)
82
+ parse_value a unless a.nil?
83
+ parse_value b unless b.nil?
84
+ end
85
+
79
86
  def parse_number(value)
80
87
  md = value.match(/\A([-+]?[0-9]+[0-9A-F]*)([bhd]?)\z/)
81
88
  fail if md.nil?
@@ -99,7 +106,7 @@ module Haxor
99
106
  begin
100
107
  number = parse_number(value)
101
108
  @autolabel += 1
102
- label = "__autolabel_#{@autolabel}"
109
+ label = "__autolabel_#{@unit.hash}_#{@autolabel}"
103
110
 
104
111
  old_section = @unit.section
105
112
  @unit.section = :data
@@ -113,10 +120,15 @@ module Haxor
113
120
  end
114
121
  end
115
122
 
116
- def offset_flags(a, b = nil)
123
+ def offset_flags(*operands)
117
124
  result = 0
118
- result |= Consts::OPCODE_FLG_DA if offset?(a)
119
- result |= Consts::OPCODE_FLG_DB if offset?(b)
125
+ flag = Consts::OPERAND_DEREFERENCE << Consts::OPCODE_FLG_OFFSET
126
+
127
+ operands.each do |operand|
128
+ result |= flag if offset?(operand)
129
+ flag << Consts::OPERAND_FLAGS
130
+ end
131
+
120
132
  result
121
133
  end
122
134
 
@@ -2,14 +2,17 @@ module Haxor
2
2
  module Compiler
3
3
  class Unit
4
4
  attr_reader :section
5
+ attr_reader :hash
5
6
 
6
- def initialize
7
+ def initialize(filename)
7
8
  @section = :text
8
9
  @sections = {
9
10
  text: [],
10
11
  data: [],
11
12
  bss: []
12
13
  }
14
+ @filename = filename
15
+ @hash = Digest::SHA1.hexdigest filename
13
16
  end
14
17
 
15
18
  def add(item)
@@ -1,7 +1,7 @@
1
1
  module Haxor
2
2
  class Consts
3
3
  MAJOR = 0
4
- MINOR = 2
4
+ MINOR = 3
5
5
  PATCH = 0
6
6
  GEM_VERSION = "#{MAJOR}.#{MINOR}.#{PATCH}"
7
7
  VERSION = (MAJOR << 16) | (MINOR << 8) | PATCH
@@ -16,10 +16,13 @@ module Haxor
16
16
 
17
17
  # OpCode
18
18
  OPCODE_CMD_MASK = 0x0000_0000_0000_00ff
19
- OPCODE_FLG_MASK = 0xffff_ffff_ffff_ff00
19
+ OPCODE_FLG_MASK = 0xffff_ffff_ffff_ff00 # << 8
20
20
  OPCODE_FLG_OFFSET = 8
21
- OPCODE_FLG_DA = 1 << OPCODE_FLG_OFFSET # dereference A operand
22
- OPCODE_FLG_DB = 2 << OPCODE_FLG_OFFSET # dereference B operand
21
+ # 8 bits of flag - 1st operand
22
+ # 8 bits of flag - 2nd operand
23
+
24
+ OPERAND_FLAGS = 8 # how many bits per operand
25
+ OPERAND_DEREFERENCE = (1 << 0) # Dereference operand (aka *operand)
23
26
 
24
27
  # Flags Registry Flags
25
28
  FR_ZERO = 1 << 0 # a-b == 0
@@ -48,22 +48,22 @@ module Haxor
48
48
  end
49
49
 
50
50
  def operand
51
- flg = (subsystem(:mem).read 'op') & Consts::OPCODE_FLG_MASK
52
- a = subsystem(:mem).next_cell
53
- a = subsystem(:mem).read a if (flg & Consts::OPCODE_FLG_DA != 0)
54
- a
51
+ operands(1)[0]
55
52
  end
56
53
 
57
- def operands
58
- flg = (subsystem(:mem).read 'op') & Consts::OPCODE_FLG_MASK
54
+ def operands(n = 2)
55
+ flg = subsystem(:mem).read('op') & Consts::OPCODE_FLG_MASK
56
+ flg >> Consts::OPCODE_FLG_OFFSET
59
57
 
60
- a = subsystem(:mem).next_cell
61
- a = subsystem(:mem).read a if (flg & Consts::OPCODE_FLG_DA != 0)
62
-
63
- b = subsystem(:mem).next_cell
64
- b = subsystem(:mem).read b if (flg & Consts::OPCODE_FLG_DB != 0)
58
+ result = []
59
+ n.times do
60
+ v = subsystem(:mem).next_cell
61
+ v = subsystem(:mem).read a if (flg & Consts::OPERAND_DEREFERENCE != 0)
62
+ result << v
63
+ flg << Consts::OPERAND_FLAGS
64
+ end
65
65
 
66
- [a, b]
66
+ result
67
67
  end
68
68
 
69
69
  private
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: haxor
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.2.0
4
+ version: 0.3.0
5
5
  platform: ruby
6
6
  authors:
7
7
  - Krzysztof Magosa
8
8
  autorequire:
9
9
  bindir: bin
10
10
  cert_chain: []
11
- date: 2015-12-30 00:00:00.000000000 Z
11
+ date: 2016-01-02 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
14
  name: bundler