binary_parser 1.1.1 → 1.1.2

data/lib/structure_definition.rb

@@ -3,96 +3,97 @@ module BinaryParser
     
     DataDefinition  = Struct.new(:bit_position, :bit_length, :conditions, :klass)
     LoopDefinition  = Struct.new(:bit_position, :bit_length, :conditions, :klass)
+    WhileDefinition = Struct.new(:bit_position, :bit_length, :conditions, :klass, :loop_condition)
 
-    attr_reader :parent_structure, :bit_at, :names
+    KEYWORDS = 
+      [
+       :data, :SPEND, :TIMES, :WHILE, :IF, :E, :cond, :match, :var, :len, :nextbits, :position,
+       :rest, :[]
+      ]
 
-    def initialize(method_names=[], parent_structure=nil, &init_proc)
-      @method_names = method_names
+    attr_reader :parent_structure, :bit_at, :names
+    
+    def initialize(forbidden_method_names=[], parent_structure=nil, &init_proc)
+      @forbidden_method_names = forbidden_method_names
       @parent_structure = parent_structure
       @bit_at = BitPosition.new     
-      @data_def, @var = {}, {}
+      @data_def = {}
       @conditions, @names = [], []
-      instance_eval(&init_proc) if init_proc
+      Proxy.new(self, KEYWORDS).instance_eval(&init_proc) if init_proc
     end
 
     def data(name, klass, bit_length)
-      check_new_def_name(name)
+      __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
+      bit_at, bit_length = __process_bit_length(bit_length, name)
+      define(name, DataDefinition.new(bit_at, bit_length, @conditions.dup, klass))
     end
 
     def SPEND(bit_length, name, &block)
-      check_new_def_name(name)
-      bit_at, bit_length = process_bit_length(bit_length, name)
+      __check_new_def_name(name)
+      bit_at, bit_length = __process_bit_length(bit_length, name)
       klass = NamelessTemplateMaker.new(self, block)
-      @data_def[name] = LoopDefinition.new(bit_at, bit_length, @conditions.dup, klass)
-      @names << name
+      define(name, LoopDefinition.new(bit_at, bit_length, @conditions.dup, klass))
     end
 
     def TIMES(times, name, &block)
-      check_new_def_name(name)
+      __check_new_def_name(name)
       klass = NamelessTemplateMaker.new(self, block)
       structure = klass.structure
       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, klass)
+        bit_at, bit_length = __process_bit_length(times * structure.bit_at.imm, name)
+        define(name, LoopDefinition.new(bit_at, bit_length, @conditions.dup, klass))
       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." + 
+        bit_length = Expression.immediate(0)
+        structure.bit_at.names.each do |depending_token|
+          depending_length_exp = structure[depending_token.symbol].bit_length
+          depending_length_exp.variable_tokens.each do |token|
+            if structure[token.symbol]
+              raise DefinitionError, "In '#{name}', same level variable #{token.symbol} 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, klass)
+        bit_at, bit_length = __process_bit_length(bit_length * times, name)
+        define(name, LoopDefinition.new(bit_at, bit_length, @conditions.dup, klass))
       end
+    end
+
+    def define(name, data)
+      @data_def[name] = data
       @names << name
     end
 
+    def WHILE(condition, name, &block)
+      __check_new_def_name(name)
+      klass = NamelessTemplateMaker.new(self, block)
+      bit_at, bit_length = __process_bit_length(Expression.control_var(:non_fixed), name)
+      define(name, WhileDefinition.new(bit_at, bit_length, @conditions.dup, klass, condition))
+    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)
       var_names.each do |var_name|
-        unless name_solvable?(var_name)
+        unless __name_resolvable?(var_name)
           raise DefinitionError, "As condition variable, unsolvable variable #{var_name} is used."
         end
       end
       return Condition.new(*var_names, &condition_proc)
     end
 
+    def E(&condition_proc)
+      return FreeCondition.new(&condition_proc)
+    end
+
     def match(var_name, value)
       case value
       when Integer
@@ -107,35 +108,48 @@ module BinaryParser
     end
 
     def var(var_name)
-      unless name_solvable?(var_name)
+      unless __name_resolvable?(var_name)
         raise DefinitionError, "Unsolvable variable #{var_name} is used."
       end
-      return Expression.new([var_name])
+      return Expression.value_var(var_name)
     end
 
     def len(var_name)
-      unless name_solvable?(var_name)
+      unless __name_resolvable?(var_name)
         raise DefinitionError, "Unsolvable variable #{var_name} is used."
       end
-      symbol = ("__LEN__" + var_name.to_s).to_sym
-      return Expression.new([symbol])
+      return Expression.length_var(var_name)
+    end
+
+    def nextbits(length)
+      return Expression.nextbits_var(length)
     end
 
     def position
-      return Expression.new([:__position])
+      Expression.control_var(:position)
     end
 
     def rest
-      return Expression.new([:__rest])
+      Expression.control_var(:rest)
     end
 
     def [](var_name)
       return @data_def[var_name]
     end
 
+    def symbol_call(symbol, *args, &block)
+      if args.length == 0
+        return var(symbol)
+      elsif args.length == 2
+        return data(symbol, *args)
+      else
+        raise DefinitionError, "Unknown use of keyword '#{var_name}' with args(#{args})."
+      end
+    end
+
     private
 
-    def process_bit_length(bit_length, name)
+    def __process_bit_length(bit_length, name)
       bit_at = @bit_at
       case bit_length
       when Integer
@@ -144,10 +158,10 @@ module BinaryParser
         else
           @bit_at = @bit_at.add_name(name)
         end
-        return bit_at, Expression.new([bit_length])
+        return bit_at, Expression.immediate(bit_length)
       when Expression
-        bit_length.variables.reject{|s| s[0..1] == "__"}.each do |symbol|
-          unless name_solvable?(symbol)
+        bit_length.variable_tokens.each do |token|
+          if (token.value_var? || token.length_var?) && !__name_resolvable?(token.symbol)
             raise DefinitionError, "In #{name}, unsolvable variable #{symbol} is used."
           end
         end
@@ -157,5 +171,24 @@ module BinaryParser
         raise DefinitionError, "Unknown type of bit_length (#{bit_length.class})."
       end
     end
+
+    def __check_new_def_name(name)
+      if name[0..1] == "__"
+        raise DefinitionError, "Name that starts with '__' is system-reserved."
+      end
+      if @forbidden_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_resolvable?(name, structure=self)
+      return structure[name] ||
+        (structure.parent_structure && __name_resolvable?(name, structure.parent_structure))
+    end
   end
 end

data/lib/template_base.rb

@@ -10,18 +10,7 @@ module BinaryParser
     end
 
     def self.def_var_method(name)
-      define_method(name){|&block|
-        if block
-          case block.arity
-          when 0
-            @scope.load_var(name).instance_eval(&block)
-          when 1
-            block.call(@scope.load_var(name))
-          end
-        else
-          @scope.load_var(name)
-        end
-      }
+      define_method(name){|&block| load(name, &block) }
     end
 
     def self.Def(parent_structure=nil, &definition_proc)
@@ -36,6 +25,19 @@ module BinaryParser
       @scope = Scope.new(self.class.structure, convert_into_abstract_binary(binary), parent_scope)
     end
 
+    def load(name, &block)
+      if block
+        case block.arity
+        when 0
+          @scope.load_var(name).instance_eval(&block)
+        when 1
+          block.call(@scope.load_var(name))
+        end
+      else
+        @scope.load_var(name)
+      end
+    end
+
     def convert_into_abstract_binary(object)
       return object if object.is_a?(AbstractBinary)
       if object.is_a?(String) && object.encoding == Encoding::BINARY

data/lib/while_list.rb

@@ -0,0 +1,31 @@
+module BinaryParser
+  class WhileList < LoopList
+    
+    attr_reader :bit_length
+    
+    def initialize(definition, abstract_binary, parent_scope, name)
+      parsed_length = 0
+      list, rest_binary = [], abstract_binary
+      while continue?(definition, rest_binary, parent_scope, name)
+        template = definition.klass.new(rest_binary, parent_scope)
+        if template.structure_bit_length == 0
+          raise ParsingError, "0 bit-length repetition happens. This means infinite loop."
+        end
+        parsed_length += template.structure_bit_length
+        rest_binary = rest_binary.sub(:bit_index => template.structure_bit_length)
+        list << template
+      end
+      @list, @bit_length = list, parsed_length
+    end
+
+    def continue?(definition, rest_binary, parent_scope, name)
+      definition.loop_condition.eval do |token|
+        if token.nextbits_var?
+          TemplateBase.new(rest_binary.sub(:bit_length => token.length)).to_i
+        else
+          parent_scope.token_eval(token, name)
+        end
+      end
+    end
+  end
+end

data/unit_test/built_in_template/test_binary.rb

@@ -0,0 +1,40 @@
+# -*- 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/binary_parser.rb'
+    
+    class BinaryTemplateTest < Test::Unit::TestCase
+      
+      class TestingTemplate < TemplateBase
+        def_structure do
+          data :b1, Binary, 16
+          data :b2, Binary, 16
+          data :b3, Binary, 16
+        end
+      end
+
+      def test_data_method_block_call
+        t = gen(0x41, 0x42, 0x41, 0x42, 0, 0)
+
+        assert_equal(true, t.b1 == "AB")
+        assert_equal(false, t.b1 == "BA")
+
+        assert_equal(true, "AB" == t.b1)
+        assert_equal(false,"BA" == t.b1)
+
+        assert_equal(true,  t.b1 == t.b2)
+        assert_equal(false, t.b1 == t.b3)
+      end
+
+      # helper for generating binary
+      def gen(*chars)
+        return TestingTemplate.new(chars.pack("C*"))
+      end
+    end
+  end
+end

data/unit_test/built_in_template/test_uint.rb

@@ -0,0 +1,87 @@
+# -*- 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/binary_parser.rb'
+    
+    class UIntTemplateTest < Test::Unit::TestCase
+      
+      class TestingTemplate < TemplateBase
+        def_structure do
+          data :n1, UInt, 8
+          data :n2, UInt, 8
+          data :n3, UInt, 8
+        end
+      end
+
+      def test_bit_access
+        t = gen(1, 2, 4)
+        
+        assert_equal(1, t.n1[0])
+        assert_equal(0, t.n1[1])
+        assert_equal(0, t.n1[2])
+
+        assert_equal(0, t.n2[0])
+        assert_equal(1, t.n2[1])
+        assert_equal(0, t.n2[2])
+
+        assert_equal(0, t.n3[0])
+        assert_equal(0, t.n3[1])
+        assert_equal(1, t.n3[2])
+      end
+
+      def test_to_s
+        t = gen(10, 16, 0)
+        
+        assert_equal("10", t.n1.to_s)
+        assert_equal("a",  t.n1.to_s(16))
+        assert_equal("10", t.n2.to_s(16))
+      end
+
+      def test_operation
+        t = gen(2, 3, 3)
+
+        assert_equal(BuiltInTemplate::UInt, t.n1.class)
+
+        assert_equal(3, t.n1 + 1)
+        assert_equal(4, t.n1 * 2)
+        assert_equal(1, t.n1 - 1)
+        assert_equal(1, t.n1 / 2)
+        assert_equal(false, t.n1 == 1)
+        assert_equal(true,  t.n1 == 2)
+        assert_equal(true,  t.n1 != 1)
+        assert_equal(false, t.n1 != 2)
+        assert_equal(false, t.n1 < 1)
+        assert_equal(true,  t.n1 > 1)
+
+        assert_equal(3, 1 + t.n1)
+        assert_equal(4, 2 * t.n1)
+        assert_equal(1, 3 - t.n1)
+        assert_equal(1, 2 / t.n1)
+        assert_equal(false, 1 == t.n1)
+        assert_equal(true,  2 == t.n1)
+        assert_equal(true,  1 != t.n1)
+        assert_equal(false, 2 != t.n1)
+        assert_equal(true, 1 < t.n1)
+        assert_equal(false,  1 > t.n1)
+
+        assert_equal(5,  t.n1 + t.n2)
+        assert_equal(6,  t.n1 * t.n2)
+        assert_equal(-1, t.n1 - t.n2)
+        assert_equal(0,  t.n1 / t.n2)
+        
+        assert_equal(false, t.n1 == t.n2)
+        assert_equal(true,  t.n2 == t.n3)
+      end
+
+      # helper for generating binary
+      def gen(*chars)
+        return TestingTemplate.new(chars.pack("C*"))
+      end
+    end
+  end
+end

data/unit_test/general_class/test_bit_position.rb

@@ -14,7 +14,7 @@ module BinaryParser
 
       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]}
+        pos = bp.add_imm(4).add_name(:hoge).add_imm(3).add_name(:fuga).eval{|token| VAL[token.symbol]}
         assert_equal(1017, pos)
       end
     end

data/unit_test/general_class/test_condition.rb

@@ -15,8 +15,8 @@ module BinaryParser
       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]})
+        assert_equal(true,  cond1.eval{|token| VAL[token.symbol]})
+        assert_equal(false, cond2.eval{|token| VAL[token.symbol]})
       end
     end
   end

data/unit_test/general_class/test_expression.rb

@@ -9,13 +9,37 @@ module BinaryParser
     require $LIBRARY_ROOT_PATH + '/lib/binary_parser.rb'
 
     class ExpressionTest < Test::Unit::TestCase
-      VAL = {:hoge => 10, :fuga => 1000}
+      VAL = {:a =>  1, :b =>  2, :c =>  3, :d =>  4}
+      LEN = {:a =>  5, :b =>  6, :c =>  7, :d =>  8}
+      CON = {:a => -1, :b => -2, :c => -3, :d => -4}
 
       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]})
+        exp = (1 + val(:a)) * len(:b) + 2 * con(:c) - (3 % val(:d))
+        res = exp.eval do |token|
+          if token.value_var?
+            VAL[token.symbol]
+          elsif token.length_var?
+            LEN[token.symbol]
+          elsif token.control_var?
+            CON[token.symbol]
+          end
+        end
+        
+        assert_equal((1 + 1) * 6 + 2 * -3 - (3 % 4), res)
+      end
+
+      # helpers
+      
+      def val(symbol)
+        Expression.value_var(symbol)
+      end
+
+      def len(symbol)
+        Expression.length_var(symbol)
+      end
+
+      def con(symbol)
+        Expression.control_var(symbol)
       end
     end
   end

data/unit_test/general_class/test_free_condition.rb

@@ -0,0 +1,20 @@
+# -*- 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/binary_parser.rb'
+
+    class FreeConditionTest < Test::Unit::TestCase
+
+      def test_free_condition
+        cond1 = FreeCondition.new{ v1 * 100 == v2 }
+        assert_equal(true,  cond1.eval{|token| {:v1 => 1, :v2 => 100}[token.symbol]})
+        assert_equal(false, cond1.eval{|token| {:v1 => 2, :v2 => 100}[token.symbol]})
+      end
+    end
+  end
+end

data/unit_test/test_scope.rb

@@ -213,6 +213,52 @@ module BinaryParser
         assert_equal("AB", i.rest_binary.to_s)
       end
 
+      # TEST CASE STRUCTURE 8
+      # * nextbits
+      class ST8 < TemplateBase
+        Def do
+          data :n1, UInt, nextbits(8) * 8
+          data :n2, UInt, 8
+        end
+      end
+
+      def test_ST8_CASE1
+        i = ST8.new(gen_bin(3, 0, 0, 1))
+        assert_equal(24, i.n1.binary_bit_length)
+        assert_equal(0x030000, i.n1)
+        assert_equal(1, i.n2)
+      end
+
+      # TEST CASE STRUCTURE 9
+      # * WHILE
+      class ST9 < TemplateBase
+        Def do
+          WHILE E{ nextbits(4) == 0xA }, :ls do
+            data :id, UInt, 8
+          end
+          data :suffix, UInt, 8
+        end
+      end
+
+      def test_ST9_CASE1
+        i = ST9.new(gen_bin(0xA1, 0xA2, 0xA3, 0xB4))
+
+        assert_equal(3, i.ls.length)
+        assert_equal(0xA1, i.ls[0].id)
+        assert_equal(0xA2, i.ls[1].id)
+        assert_equal(0xA3, i.ls[2].id)
+        assert_equal(0xB4, i.suffix)
+        assert_equal(4 * 8, i.structure_bit_length)
+      end
+
+      def test_ST9_CASE2
+        i = ST9.new(gen_bin(0xB0))
+
+        assert_equal(0, i.ls.length)
+        assert_equal(0xB0, i.suffix)
+        assert_equal(1 * 8, i.structure_bit_length)
+      end
+
       # helpers
       def gen_bin(*chars)
         return AbstractBinary.new(chars.pack("C*"))

data/unit_test/test_structure_definition.rb

@@ -28,11 +28,11 @@ module BinaryParser
 
         assert_equal(C2, st[:b].klass)
         assert_equal(3,  st[:b].bit_position.eval{})
-        assert_equal(24, st[:b].bit_length.eval{|name| {:a => 3}[name]})
+        assert_equal(24, st[:b].bit_length.eval{|token| {:a => 3}[token.symbol]})
         assert_equal([], st[:b].conditions)
 
         assert_equal(C3, st[:c].klass)
-        assert_equal(27, st[:c].bit_position.eval{|name| {:b => 24}[name]})
+        assert_equal(27, st[:c].bit_position.eval{|token| {:b => 24}[token.symbol]})
         assert_equal(4,  st[:c].bit_length.eval{})
         assert_equal([], st[:c].conditions)
       end
@@ -61,8 +61,8 @@ module BinaryParser
         end
         
         assert_equal(8,  st[:list].bit_position.eval{})
-        assert_equal(12, st[:list].bit_length.eval{|name| {:outer => 3}[name]})
-        assert_equal(20, st[:foot].bit_position.eval{|name| {:list => 12}[name]})
+        assert_equal(12, st[:list].bit_length.eval{|token| {:outer => 3}[token.symbol]})
+        assert_equal(20, st[:foot].bit_position.eval{|token| {:list => 12}[token.symbol]})
       end
 
       def test_IF
@@ -89,8 +89,8 @@ module BinaryParser
           data :fuga, C1, 1
         end
 
-        eval_proc = Proc.new do |var_name|
-          {:hoge => 1, :fuga => 1}[var_name]
+        eval_proc = Proc.new do |token|
+          {:hoge => 1, :fuga => 1}[token.symbol]
         end
 
         cond1 = st.match(:hoge, 1)
@@ -134,6 +134,47 @@ module BinaryParser
           end
         end
       end
+
+      def test_E
+        st = StructureDefinition.new do
+          IF E{ hoge == 1 } do
+            data :fuga, C1, 8
+          end
+        end
+        
+        assert_equal(true, st[:fuga].conditions[0].eval{|token| {:hoge => 1}[token.symbol]})
+      end
+
+      def test_ABBREVIATED_NOTATION
+        st = StructureDefinition.new do
+          d2 C2, 8
+        end
+
+        assert_equal(8, st[:d2].bit_length.eval{})
+      end
+
+      def test_VARIABLE_RESOLUTION
+        st = StructureDefinition.new do
+          data :a, C1, 3
+          data :b, C2, a * 8
+          data :c, C3, 4
+        end
+
+        assert_equal(C1, st[:a].klass)
+        assert_equal(0,  st[:a].bit_position.eval{})
+        assert_equal(3,  st[:a].bit_length.eval{})
+        assert_equal([], st[:a].conditions)
+
+        assert_equal(C2, st[:b].klass)
+        assert_equal(3,  st[:b].bit_position.eval{})
+        assert_equal(24, st[:b].bit_length.eval{|token| {:a => 3}[token.symbol]})
+        assert_equal([], st[:b].conditions)
+
+        assert_equal(C3, st[:c].klass)
+        assert_equal(27, st[:c].bit_position.eval{|token| {:b => 24}[token.symbol]})
+        assert_equal(4,  st[:c].bit_length.eval{})
+        assert_equal([], st[:c].conditions)
+      end
     end
   end
 end