binary_parser 1.0.0

data/lib/structure_definition.rb

@@ -0,0 +1,131 @@
+module BinaryParser
+  class StructureDefinition
+    
+    DataDefinition  = Struct.new(:bit_position, :bit_length, :conditions, :klass)
+    LoopDefinition  = Struct.new(:bit_position, :bit_length, :conditions, :structure)
+
+    attr_reader :parent_structure, :bit_at, :names
+
+    def initialize(method_names=[], parent_structure=nil, &init_proc)
+      @method_names = method_names
+      @parent_structure = parent_structure
+      @bit_at = BitPosition.new     
+      @data_def, @var = {}, {}
+      @conditions, @names = [], []
+      instance_eval(&init_proc) if init_proc
+    end
+
+    def data(name, klass, bit_length)
+      check_new_def_name(name)
+      unless klass.ancestors.include?(TemplateBase)
+        raise DefinitionError, "Class #{klass} should be TemplateBase."
+      end
+      bit_at, bit_length = process_bit_length(bit_length, name)
+      @data_def[name] = DataDefinition.new(bit_at, bit_length, @conditions.dup, klass)
+      @names << name
+    end
+
+    def SPEND(bit_length, name, &block)
+      check_new_def_name(name)
+      bit_at, bit_length = process_bit_length(bit_length, name)
+      used_method_names = NamelessTemplate.instance_methods + Scope.instance_methods
+      structure = StructureDefinition.new(used_method_names, self, &block)
+      @data_def[name] = LoopDefinition.new(bit_at, bit_length, @conditions.dup, structure)
+      @names << name
+    end
+
+    def TIMES(times, name, &block)
+      check_new_def_name(name)
+      structure = StructureDefinition.new(Scope.instance_methods, self, &block)
+      if structure.bit_at.names.empty?
+        bit_at, bit_length = process_bit_length(times * structure.bit_at.imm, name)
+        @data_def[name] = LoopDefinition.new(bit_at, bit_length, @conditions.dup, structure)
+      else
+        bit_length = Expression.new([0])
+        structure.bit_at.names.each do |bit_at_depending_name|
+          depending_length_exp = structure[bit_at_depending_name].bit_length
+          depending_length_exp.variables.each do |var_name|
+            if structure[var_name]
+              raise DefinitionError, "In '#{name}', same level variable #{var_name} is referenced." + 
+                "*** TIMES's inner structure's bit-length must be always same." +
+                "In other words, that bit-length must not rely on same level variables. ***"
+            end
+          end
+          bit_length += depending_length_exp
+        end
+        bit_at, bit_length = process_bit_length(bit_length * times, name)
+        @data_def[name] = LoopDefinition.new(bit_at, bit_length, @conditions.dup, structure)
+      end
+      @names << name
+    end
+
+    def IF(condition, &block)
+      @conditions.push(condition)
+      block.call
+      @conditions.pop
+    end
+
+    def check_new_def_name(name)
+      if name[0..1] == "__"
+        raise DefinitionError, "Name that starts with '__' is system-reserved."
+      end
+      if @method_names.include?(name)
+        raise DefinitionError, "Name '#{name}' is already used as method name." +
+          "You should chanege to other name."
+      end
+      if @data_def[name]
+        raise DefinitionError, "Name #{name} is already defined." +
+          "You should change to other name."
+      end
+    end
+
+    def name_solvable?(name, structure=self)
+      return structure[name] ||
+        (structure.parent_structure && name_solvable?(name, structure.parent_structure))
+    end
+
+    def cond(*var_names, &condition_proc)
+      unless var_names.all?{|name| name_solvable?(name)}
+        raise DefinitionError, "As condition variable, unsolvable variable #{symbol} is used."
+      end
+      return Condition.new(*var_names, &condition_proc)
+    end
+
+    def var(name)
+      return @var[name] ||= Expression.new([name])
+    end
+
+    def rest
+      return var(:__rest)
+    end
+
+    def [](name)
+      return @data_def[name]
+    end
+
+    private
+
+    def process_bit_length(bit_length, name)
+      bit_at = @bit_at
+      case bit_length
+      when Integer
+        if @conditions.empty?
+          @bit_at = @bit_at.add_imm(bit_length)
+        else
+          @bit_at = @bit_at.add_name(name)
+        end
+        return bit_at, Expression.new([bit_length])
+      when Expression
+        bit_length.variables.reject{|s| s[0..1] == "__"}.each do |symbol|
+          unless name_solvable?(symbol)
+            raise DefinitionError, "In #{name}, unsolvable variable #{symbol} is used."
+          end
+        end
+        @bit_at = @bit_at.add_name(name)
+        return bit_at, bit_length
+      else
+        raise DefinitionError, "Unknown type of bit_length (#{bit_length.class})."
+      end
+    end
+  end
+end

data/lib/template_base.rb

@@ -0,0 +1,120 @@
+module BinaryParser
+  class TemplateBase
+    include BuiltInTemplate
+
+    def self.def_structure(&definition_proc)
+      used_method_names = self.instance_methods + Scope.instance_methods
+      @structure_def = StructureDefinition.new(used_method_names, &definition_proc)
+    end
+
+    def self.Def(&definition_proc) def_structure(&definition_proc) end
+    
+    def self.structure
+      return @structure_def ||= StructureDefinition.new
+    end
+
+    def initialize(binary)
+      @scope = Scope.new(self.class.structure, convert_into_abstract_binary(binary))
+    end
+
+    def convert_into_abstract_binary(object)
+      return object if object.is_a?(AbstractBinary)
+      if object.is_a?(String) && object.encoding == Encoding::BINARY
+        return AbstractBinary.new(object)
+      end
+      raise BadManipulationError, "Argument should be AbstractBinary or BINAY String."
+    end
+
+    def method_missing(name, *args)
+      return @scope.method_missing(name, *args)
+    end
+
+    def [](name)
+      return @scope.method_missing(name)
+    end
+
+    def names
+      return @scope.names
+    end
+
+    # Convert held binary into unsigned integer.
+    # Special case:
+    #   If held binary's length is 0, this method throws BadBinaryManipulationError.
+    def to_i
+      @scope.abstract_binary.to_i
+    end
+
+    # Convert held binary into string encoded in Encoding::BINARY.
+    # Special case:
+    #   If held binary's length or start position isn't a multiple of 8,
+    #   this method throws BadBinaryManipulationError.
+    def to_s
+      @scope.abstract_binary.to_s
+    end
+
+    # Convert held binary into character-numbers.
+    # Example: If held binary is "ABC" in ascii, this returns [0x41, 0x42, 0x43].
+    # Special case:
+    #   If held binary's length or start position isn't a multiple of 8,
+    #   this method throws BadBinaryManipulationError.
+    def to_chars
+      @scope.abstract_binary.to_chars
+    end
+
+    # Real length(bit) of held binary
+    def binary_bit_length
+      @scope.abstract_binary.bit_length
+    end
+
+    # Structure-specified length(bit) of binary.
+    # Special case:
+    #   If held binary's length is too short to calculate structure-specified length,
+    #   this method throws ParsingError.
+    def structure_bit_length
+      @scope.eval_entire_bit_length
+    end
+
+    # Whether real length of held binary is NOT smaller than structure-specified length of binary.
+    # Special case:
+    #   If held binary's length is too short to calculate structure-specified length,
+    #   this method throws ParsingError.
+    def hold_enough_binary?
+      structure_bit_length <= binary_bit_length
+    end
+
+    # Whether real length of held binary is equal to structure-specified length of binary.
+    # Special case:
+    #   If held binary's length is too short to calculate structure-specified length,
+    #   this method throws ParsingError.
+    def hold_just_binary?
+      structure_bit_length == binary_bit_length
+    end
+
+    # String that describes this object.
+    #   * If you want to print some of this content-description in 'show' method,
+    #     override this method.
+    def content_description
+      ""
+    end
+
+    # Print all elements' information.
+    # Args:
+    #   recursively => Whether print recursively or not. Default is false.
+    #   out         => Print target. Default is STDOUT.
+    def show(recursively=false, out=STDOUT, depth=0)
+      max_name_length = names.inject(5){|max_len, name| [max_len, name.length].max}
+      if names.size > 0
+        out.puts "#{" " * (depth*2)}*#{"-" * 80}"
+      end
+      names.each do |name|
+        out.puts sprintf("#{" " * (depth*2)}%-#{max_name_length}s  Pos: %6s  Len: %6s  Type: %10s  Cont: %s",
+                         name.to_s,
+                         @scope.eval_bit_position(name),
+                         @scope.eval_bit_length(name),
+                         self[name].class.name.split("::").last,
+                         self[name] ? self[name].content_description : "Nil")
+        self[name].show(true, out, depth + 1) if recursively && self[name]
+      end
+    end
+  end
+end

data/unit_test/general_class/test_abstract_binary.rb

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+$LIBRARY_ROOT_PATH = File.dirname(File.dirname(File.expand_path(File.dirname(__FILE__))))
+
+module BinaryParser
+  module UnitTest
+    require 'test/unit'
+
+    # load testing target
+    require $LIBRARY_ROOT_PATH + '/lib/general_class/abstract_binary.rb'
+
+    class AbstractBinaryTest < Test::Unit::TestCase
+      
+      def test_to_i
+        abin = AbstractBinary.new(gen_bin(0b10101010, 0b01010101))
+        assert_equal(0b1010101001010101, abin.to_i)
+      end
+
+      def test_to_chars
+        abin = AbstractBinary.new(gen_bin(0b10101010, 0b01010101))
+        assert_equal(0b10101010, abin.to_chars[0])
+        assert_equal(0b01010101, abin.to_chars[1])
+      end
+
+      def test_to_s
+        abin = AbstractBinary.new(gen_bin(0x48, 0x4f, 0x47, 0x45))
+        assert_equal("HOGE", abin.to_s)
+      end
+
+        def test_sub
+        abin = AbstractBinary.new(gen_bin(0b11110000, 0b11110000, 0b11110001))
+        assert_equal(0b110, abin.sub(:bit_index => 2, :bit_length => 3).to_i)
+        assert_equal([0b11110000, 0b11110001], abin.sub(:bit_index => 6).sub(:bit_index => 2).to_chars)
+      end
+
+      def test_to_chars_error
+        abin = AbstractBinary.new(gen_bin(0b11110000, 0b11111111))
+        sub = abin.sub(:bit_index => 4, :bit_length => 8)
+        assert_equal(0b00001111, sub.to_i)
+        assert_raise(BadBinaryManipulationError) do
+          sub.to_chars
+        end
+      end
+
+      def test_sub_error
+        abin = AbstractBinary.new(gen_bin(0b11110000, 0b11111111))
+        assert_raise(BadBinaryManipulationError) do
+          abin.sub(:bit_index => 16)
+        end
+        assert_raise(BadBinaryManipulationError) do
+          abin.sub(:bit_length => 17)
+        end
+      end
+
+      # helper for generating binary
+      def gen_bin(*chars)
+        return chars.pack("C*")
+      end
+    end
+  end
+end

data/unit_test/general_class/test_bit_position.rb

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+$LIBRARY_ROOT_PATH = File.dirname(File.dirname(File.expand_path(File.dirname(__FILE__))))
+
+module BinaryParser
+  module UnitTest
+    require 'test/unit'
+
+    # load testing target
+    require $LIBRARY_ROOT_PATH + '/lib/general_class/bit_position.rb'
+
+    class BitPositionTest < Test::Unit::TestCase
+
+      VAL = {:hoge => 10, :fuga => 1000}
+
+      def test_bit_position
+        bp = BitPosition.new
+        pos = bp.add_imm(4).add_name(:hoge).add_imm(3).add_name(:fuga).eval{|name| VAL[name]}
+        assert_equal(1017, pos)
+      end
+    end
+  end
+end

data/unit_test/general_class/test_condition.rb

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+$LIBRARY_ROOT_PATH = File.dirname(File.dirname(File.expand_path(File.dirname(__FILE__))))
+
+module BinaryParser
+  module UnitTest
+    require 'test/unit'
+
+    # load testing target
+    require $LIBRARY_ROOT_PATH + '/lib/general_class/condition.rb'
+
+    class ConditionTest < Test::Unit::TestCase
+
+      VAL = {:hoge => 10, :fuga => 1000}  
+
+      def test_condition
+        cond1 = Condition.new(:hoge, :fuga){|v1, v2| v1 * 100 == v2}
+        cond2 = Condition.new(:hoge, :fuga){|v1, v2| v1 * 10  == v2}
+        assert_equal(true,  cond1.eval{|name| VAL[name]})
+        assert_equal(false, cond2.eval{|name| VAL[name]})
+      end
+    end
+  end
+end

data/unit_test/general_class/test_expression.rb

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+$LIBRARY_ROOT_PATH = File.dirname(File.dirname(File.expand_path(File.dirname(__FILE__))))
+
+module BinaryParser
+  module UnitTest
+    require 'test/unit'
+
+    # load testing target
+    require $LIBRARY_ROOT_PATH + '/lib/general_class/expression.rb'
+
+    class ExpressionTest < Test::Unit::TestCase
+      VAL = {:hoge => 10, :fuga => 1000}
+
+      def test_expression
+        var_exp1 = Expression.new([:hoge])
+        var_exp2 = Expression.new([:fuga])
+        exp = (var_exp1 + 3) * 12 + var_exp2 / 10 - 4
+        assert_equal((10 + 3) * 12 + 1000 / 10 - 4, exp.eval{|name| VAL[name]})
+      end
+    end
+  end
+end

data/unit_test/test_scope.rb

@@ -0,0 +1,191 @@
+# -*- coding: utf-8 -*-
+$LIBRARY_ROOT_PATH = File.dirname(File.expand_path(File.dirname(__FILE__)))
+
+module BinaryParser
+  module UnitTest
+    require 'test/unit'
+
+    # load testing target
+    require $LIBRARY_ROOT_PATH + '/lib/binary_parser.rb'
+
+    class ScopeTest < Test::Unit::TestCase
+      
+      # TEST CASE STRUCTURE 1
+      # * roughly test various
+      class ST1 < TemplateBase
+        Def do
+          data :cond_num, UInt, 8
+          IF cond(:cond_num){|v| v.to_i == 1} do
+            data :length, UInt, 8
+            data :data,   Binary, var(:length) * 8
+          end
+          
+          data :binary_len, UInt, 8
+          SPEND var(:binary_len) * 8, :list do
+            data :length, UInt, 8
+            data :data,   Binary, var(:length) * 8
+          end
+
+          data :foot, UInt, 32
+        end
+      end
+
+      def test_ST1_CASE1
+        bin = gen_bin(*[0x01, [0x04, [0x48, 0x4f, 0x47, 0x45]],
+                        0x06, [0x1, [0x70], 0x3, [0x69, 0x79, 0x6f]],
+                        0xff, 0xff, 0xff, 0xff].flatten)
+
+        sc = ST1.new(bin)
+
+        assert_equal(1,      sc.cond_num.to_i)
+        assert_equal(4,      sc.length.to_i)
+        assert_equal("HOGE", sc.data.to_s)
+
+        assert_equal(6,      sc.binary_len.to_i)
+        assert_equal(2,      sc.list.size)
+        assert_equal("p",    sc.list[0].data.to_s)
+        assert_equal("iyo",  sc.list[1].data.to_s)   
+        
+        assert_equal(0xffffffff, sc.foot.to_i)
+      end
+
+      # TEST CASE STRUCTURE 2
+      # * about IF
+      class ST2 < TemplateBase
+        Def do
+          data :number1, UInt, 8
+          IF cond(:number1){|v| v.to_i == 1} do
+            data :number2, UInt, 8
+            IF cond(:number2){|v| v.to_i == 2} do
+              data :number3, UInt, var(:number2) * 4
+            end
+          end
+          data :number4, UInt, 8
+        end
+      end
+
+      def test_ST2_CASE1
+        bin = gen_bin(1, 2, 3, 4)
+        i = ST2.new(bin)
+
+        assert_equal(1, i.number1.to_i)
+        assert_equal(2, i.number2.to_i)
+        assert_equal(3, i.number3.to_i)
+        assert_equal(4, i.number4.to_i)
+        assert(i.hold_just_binary?)
+      end
+
+      def test_ST2_CASE2
+        bin = gen_bin(1, 0, 4)
+        i = ST2.new(bin)
+
+        assert_equal(1,   i.number1.to_i)
+        assert_equal(0,   i.number2.to_i)
+        assert_equal(nil, i.number3)
+        assert_equal(4,   i.number4.to_i)
+        assert(i.hold_just_binary?)
+      end
+
+      def test_ST2_CASE3
+        bin = gen_bin(0, 4)
+        i = ST2.new(bin)
+        
+        assert_equal(0,   i.number1.to_i)
+        assert_equal(nil, i.number2)
+        assert_equal(nil, i.number3)
+        assert_equal(4,   i.number4.to_i)
+        assert(i.hold_just_binary?)
+      end
+
+      # TEST CASE STRUCTURE 3
+      # * SPEND and TIMES
+      class ST3 < TemplateBase
+        Def do
+          data :size, UInt, 8
+          SPEND var(:size), :l1 do
+            data :dat, UInt, 8
+          end
+          data :times, UInt, 8
+          TIMES var(:times), :l2 do
+            data :dat, UInt, 8
+          end
+          data :dat, UInt, 8
+        end
+      end
+
+      def test_ST3_CASE1
+        bin = gen_bin(0, 0, 0xff)
+        i = ST3.new(bin)
+
+        assert_equal(0,    i.size.to_i)
+        assert_equal(0,    i.l1.size)
+        assert_equal(0,    i.times.to_i)
+        assert_equal(0,    i.l2.size)
+        assert_equal(0xff, i.dat.to_i)
+        assert(i.hold_just_binary?)
+      end
+
+      # TEST CASE STRUCTURE 4
+      # * Dynamic length test
+      class ST4 < TemplateBase
+        Def do
+          data :v1, UInt, 8
+          data :v2, UInt, var(:v1)
+          data :v3, UInt, var(:v2)
+          data :v4, UInt, rest
+          data :v5, UInt, rest
+        end
+      end
+
+      def test_ST4_CASE1
+        bin = gen_bin(8, 0, 0xff, 0xff)
+        i = ST4.new(bin)
+
+        assert_equal(8,      i.v1.to_i)
+        assert_equal(0,      i.v2.to_i)
+        assert_equal(nil,    i.v3)
+        assert_equal(0xffff, i.v4.to_i)
+        assert_equal(nil,    i.v5)
+        assert(i.hold_just_binary?)
+      end
+
+      def test_ST4_CASE2
+        bin = gen_bin(8, 8, 0xff)
+        i = ST4.new(bin)
+
+        assert_equal(8,    i.v1.to_i)
+        assert_equal(8,    i.v2.to_i)
+        assert_equal(0xff, i.v3.to_i)
+        assert_equal(nil,  i.v4)
+        assert_equal(nil,  i.v5)
+        assert(i.hold_just_binary?)
+      end
+
+      # TEST CASE STRUCTURE 5
+      # * structure size test
+      class ST5 < TemplateBase
+        Def do
+          data :v1, UInt, 8
+          data :v2, UInt, var(:v1)
+          data :v3, UInt, var(:v2)
+        end
+      end
+
+      def test_ST5_CASE1
+        i1 = ST5.new(gen_bin(8, 8))
+        assert(!i1.hold_enough_binary?)
+          
+        i2 = ST5.new(gen_bin(8))
+        assert_raise(ParsingError) do
+          assert(!i2.hold_enough_binary?)
+        end
+      end
+
+      # helpers
+      def gen_bin(*chars)
+        return AbstractBinary.new(chars.pack("C*"))
+      end
+    end
+  end
+end
+