Added Register#type, Immediate#type, Memory#type (closes #61).

Author: postmodern

lib/ronin/asm/immediate.rb

@@ -31,6 +31,11 @@ module ASM
     #
     class Immediate < Operand
 
+      # The assembly class type.
+      #
+      # @return [:imm8, :imm16, :imm32, :imm64]
+      attr_reader :type
+
       # The immediate operand's value.
       #
       # @return [Integer]
@@ -57,6 +62,7 @@ def initialize(value,width=nil)
                           else
                             (@value.bit_length / 8.0).ceil
                           end
+        @type  = :"imm#{@width * 8}"
       end
 
       #

lib/ronin/asm/memory.rb

@@ -32,6 +32,11 @@ module ASM
     #
     class Memory < Operand
 
+      # The assembly class type.
+      #
+      # @return [nil, :mem8, :mem16, :mem32, :mem64]
+      attr_reader :type
+
       # The base of the memory operand.
       #
       # @return [Register, nil]
@@ -102,6 +107,10 @@ def initialize(base=nil,displacement=0,index=nil,scale=1,width=nil)
         @width        = width || if base
                                    base.width
                                  end
+
+        if @width
+          @type = :"mem#{@width * 8}"
+        end
       end
 
       #

lib/ronin/asm/register.rb

@@ -28,6 +28,11 @@ module ASM
     #
     class Register < Operand
 
+      # The assembly class type.
+      #
+      # @return [:reg8, :reg16, :reg32, :reg64]
+      attr_reader :type
+
       # The register name.
       #
       # @return [Symbol]
@@ -55,6 +60,8 @@ def initialize(name, width: , general: false)
 
         @width   = width
         @general = general
+
+        @type = :"reg#{width * 8}"
       end
 
       #

spec/immediate_spec.rb

@@ -16,6 +16,48 @@
     end
   end
 
+  describe "#type" do
+    context "when #width is 1" do
+      let(:width) { 1 }
+
+      subject { described_class.new(value,width) }
+
+      it "must return :imm8" do
+        expect(subject.type).to eq(:imm8)
+      end
+    end
+
+    context "when #width is 2" do
+      let(:width) { 2 }
+
+      subject { described_class.new(value,width) }
+
+      it "must return :imm16" do
+        expect(subject.type).to eq(:imm16)
+      end
+    end
+
+    context "when #width is 4" do
+      let(:width) { 4 }
+
+      subject { described_class.new(value,width) }
+
+      it "must return :imm32" do
+        expect(subject.type).to eq(:imm32)
+      end
+    end
+
+    context "when #width is 8" do
+      let(:width) { 8 }
+
+      subject { described_class.new(value,width) }
+
+      it "must return :imm64" do
+        expect(subject.type).to eq(:imm64)
+      end
+    end
+  end
+
   describe "#width" do
     context "when #width is not explicitly set by #initialize" do
       context "and it is 0" do

spec/memory_spec.rb

@@ -67,6 +67,48 @@
     end
   end
 
+  describe "#type" do
+    context "when the #width is 1" do
+      let(:width) { 1 }
+
+      subject { described_class.new(register,0,nil,1,width) }
+
+      it "must return :mem8" do
+        expect(subject.type).to be(:mem8)
+      end
+    end
+
+    context "when the #width is 2" do
+      let(:width) { 2 }
+
+      subject { described_class.new(register,0,nil,1,width) }
+
+      it "must return :mem16" do
+        expect(subject.type).to be(:mem16)
+      end
+    end
+
+    context "when the #width is 4" do
+      let(:width) { 4 }
+
+      subject { described_class.new(register,0,nil,1,width) }
+
+      it "must return :mem32" do
+        expect(subject.type).to be(:mem32)
+      end
+    end
+
+    context "when the #width is 8" do
+      let(:width) { 8 }
+
+      subject { described_class.new(register,0,nil,1,width) }
+
+      it "must return :mem64" do
+        expect(subject.type).to be(:mem64)
+      end
+    end
+  end
+
   describe "#+" do
     let(:operand) { described_class.new(register,4,register,2) }
 

spec/register_spec.rb

@@ -6,6 +6,48 @@
 
   subject { register }
 
+  describe "#type" do
+    context "when #width is 1" do
+      let(:width) { 1 }
+
+      subject { described_class.new(:eax, width: width) }
+
+      it "must return :reg8" do
+        expect(subject.type).to eq(:reg8)
+      end
+    end
+
+    context "when #width is 2" do
+      let(:width) { 2 }
+
+      subject { described_class.new(:eax, width: width) }
+
+      it "must return :reg16" do
+        expect(subject.type).to eq(:reg16)
+      end
+    end
+
+    context "when #width is 4" do
+      let(:width) { 4 }
+
+      subject { described_class.new(:eax, width: width) }
+
+      it "must return :reg32" do
+        expect(subject.type).to eq(:reg32)
+      end
+    end
+
+    context "when #width is 8" do
+      let(:width) { 8 }
+
+      subject { described_class.new(:eax, width: width) }
+
+      it "must return :reg64" do
+        expect(subject.type).to eq(:reg64)
+      end
+    end
+  end
+
   describe "#+" do
     context "when given an Ronin::ASM::Memory" do
       let(:operand) do