binary_parser 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 329750cafce1313147ce33ce73a6ead4622c7463
-  data.tar.gz: 810050523f1e4f013877ce96cca963424501b048
+  metadata.gz: f00ee4cb710d229fe1bd23f7d2dd5b9d2e63fe17
+  data.tar.gz: 50a4f28986bdc26f158531dcbda7040cdd16cd9a
 SHA512:
-  metadata.gz: a1dd40df83f438b9ca90c6bc15ad056868d1f62d5523e0209a3b71d4122a9b661748bdba897f24a75c72edaf8b94e6894b983b56ff7117c213bfa928e8d9b55b
-  data.tar.gz: 4f20fb77279fc8caac2d3512647dfefd17f597cc8a7e7b03886a982476fe24c6d4c23b85b0ca78a589f47a89161d1c6a5190d30c6c8c36876ad425f77f435a57
+  metadata.gz: f24c616c42e6a4b2866c18d28764f2885758a566d1df136118a0c9fcfb91dece7ec573e5a560a3f6655551e29641dd2bee5e8bc8a6da527660db30521a83e100
+  data.tar.gz: 666608cd8a53767641515c5164a9916cb537db71244e148da052831ed265920be5925d343c924ddb5703d297dd88601ac4453d0ac72e26446fa320d30f23c34a

data/.gitignore

@@ -1,3 +1,4 @@
+*.*~
 *.gem
 *.rbc
 .bundle

data/lib/binary_parser/version.rb

@@ -1,3 +1,3 @@
 module BinaryParser
-  VERSION = "1.1.0"
+  VERSION = "1.1.1"
 end

data/lib/binary_parser.rb

@@ -7,10 +7,12 @@ module BinaryParser
   # load general class file
   GENERAL_CLASS_DIR = '/lib/general_class/'
   GENERAL_CLASS_FILES =
-    ['abstract_binary',
+    ['binary_manipulate_function.rb',
+     'abstract_binary',
      'expression.rb',
      'bit_position.rb',
-     'condition.rb'
+     'condition.rb',
+     'buffered_stream.rb'
     ]
 
   GENERAL_CLASS_FILES.each do |path|
@@ -40,7 +42,7 @@ module BinaryParser
      'structure_definition.rb',
      'template_base.rb',
      'stream_template_base.rb',
-     'nameless_template.rb',
+     'nameless_template_maker.rb',
      'error.rb'
     ]
 

data/lib/general_class/abstract_binary.rb

@@ -4,65 +4,129 @@ module BinaryParser
     attr_reader :bit_length
 
     def initialize(binary_string, bit_index=nil, bit_length=nil)
-      unless binary_string.encoding == Encoding::BINARY
-        raise BadBinaryManipulationError, "binary_string's encoding should be" +
-          "ASCII_8BIT(BINARY). This is #{binary_string.encoding}."
-      end
       @bin_str = binary_string
       @bit_index = bit_index || 0
-      @bit_length = bit_length || binary_string.length * 8
+      @bit_length = bit_length || binary_string.length * 8 - @bit_index
     end
 
     def sub(spec)
-      additional_bit_index = spec[:bit_index].to_i + spec[:byte_index].to_i * 8
-      if additional_bit_index >= @bit_index + @bit_length
-        raise BadBinaryManipulationError, "Impossible index specification of sub binary " +
-          "(bit_index: #{additional_bit_index} on [#{@bit_index}, #{@bit_length}))"
+      new_bit_index, new_bit_length = decode_spec(spec)
+      check_invalid_sub_position(new_bit_index, new_bit_length)
+      return self.class.new(@bin_str, new_bit_index, new_bit_length)
+    end
+
+    def to_i
+      if @bit_length == 0
+        raise BadBinaryManipulationError, "Cannot convert empty binary into integer."
       end
+      str, ml, mr = BinaryManipulateFunction.needed_sub_string(@bin_str, 
+                                                               @bit_index,
+                                                               @bit_index + @bit_length - 1)
+      return BinaryManipulateFunction.to_unsigned_int(str, ml, mr)
+    end
+    
+    def to_chars
+      check_non_byte_position(@bit_index, @bit_length)
+      return @bin_str[@bit_index / 8, @bit_length / 8].unpack("C*")
+    end
 
-      if spec[:bit_length] || spec[:byte_length]
-        new_bit_length = spec[:bit_length].to_i + spec[:byte_length].to_i * 8
+    def to_s
+      check_non_byte_position(@bit_index, @bit_length)
+      return @bin_str[@bit_index / 8, @bit_length / 8]
+    end
+
+    def byte_position?
+      @bit_index % 8 == 0 && @bit_length % 8 == 0
+    end
+
+
+    # Methods for generating modified binary.
+    def alt(binary_or_uint)
+      case binary_or_uint
+      when Integer
+        alt_uint(binary_or_uint)
+      when String
+        alt_binary(binary_or_uint)
       else
-        new_bit_length = @bit_length - additional_bit_index
+        raise BadManipulationError, "Argument shouled be Integer or binary-encoded String."
       end
-      if additional_bit_index + new_bit_length > @bit_length
-        raise BadBinaryManipulationError, "Impossible length specification of" +
-          "sub binary (bit_index: #{additional_bit_index}, " +
-          "bit_length: #{new_bit_length} on [#{@bit_index}, #{@bit_length}])"
+    end
+    
+    def alt_uint(uint)
+      unless uint.is_a?(Integer) && uint >= 0
+        raise BadManipulationError, "Specified arg #{uint} is not number of unsigned int."
       end
+      unless uint < 2 ** @bit_length
+        raise BadBinaryManipulationError, "Specified arg #{uint} is too big to " +
+          "express by #{@bit_length} bit."
+      end
+      alt_binary = BinaryManipulateFunction.convert_uint_into_binary(uint, @bit_length)
+      alt_shift = 7 - ((@bit_length - 1) % 8)
+      return self.class.new(alt_binary, alt_shift)
+    end
 
-      return self.class.new(@bin_str, @bit_index + additional_bit_index, new_bit_length)
+    def alt_binary(binary)
+      unless binary.length * 8 == @bit_length
+        raise BadBinaryManipulationError, "Given binary'length doesn't match self."
+      end
+      return self.class.new(binary)
     end
 
-    def to_i
-      if @bit_length == 0
-        raise BadBinaryManipulationError, "Cannot convert empty binary into integer."
+    def naive_concat(other)
+      left_shift = 7 - ((self.bit_length - 1) % 8)
+      left_binary  = BinaryManipulateFunction.convert_uint_into_binary(self.to_i, self.bit_length)
+      
+      right_shift = 7 - ((other.bit_length - 1) % 8)
+      right_binary = BinaryManipulateFunction.convert_uint_into_binary(other.to_i << right_shift,
+                                                                       other.bit_length)
+
+      return self.class.new(left_binary + right_binary,
+                            left_shift,
+                            self.bit_length + other.bit_length)
+    end
+
+    def binary_concat(other)
+      self.class.new(self.to_s + other.to_s)
+    end
+
+    def +(other)
+      if self.byte_position? && other.byte_position?
+        binary_concat(other) 
+      else
+        naive_concat(other)
       end
-      res, rest_bit, char_pos = 0, @bit_length - 1, @bit_index % 8
-      @bin_str[@bit_index / 8, (@bit_length + @bit_index % 8) / 8 + 1].unpack("C*").each do |char|
-        (char_pos..7).each do |i|
-          res += char[7 - i] * (1 << rest_bit)
-          return res if (rest_bit -= 1) < 0
-        end
-        char_pos = 0
+    end
+
+
+    # Sub methods (helpers)
+
+    def decode_spec(spec)
+      new_bit_index  = @bit_index + spec[:bit_index].to_i + spec[:byte_index].to_i * 8
+      
+      if !spec[:bit_length] && !spec[:byte_length]
+        new_bit_length = @bit_length - (new_bit_index - @bit_index)
+      else
+        new_bit_length = spec[:bit_length].to_i + spec[:byte_length].to_i * 8
       end
-      raise ProgramAssertionError, "Failed to convert integer value."
+      
+      return new_bit_index, new_bit_length
     end
-    
-    def to_chars
-      unless @bit_index % 8 == 0 && @bit_length % 8 == 0
-        raise BadBinaryManipulationError, "Invalid position(from #{@bit_index} bit)" +
-          "and length(#{@bit_length} bit)."
+      
+    def check_invalid_sub_position(new_bit_index, new_bit_length)
+      if new_bit_length < 0
+        raise BadBinaryManipulationError, "Specified new bit length is negative (#{new_bit_length})."
+      end
+      unless @bit_index <= new_bit_index && new_bit_index + new_bit_length <= @bit_index + @bit_length
+        raise BadBinaryManipulationError, "Specified new bit index #{new_bit_index} is " +
+          "out of current binary bit_index=#{@bit_index}, bit_length=#{@bit_length}."
       end
-      return @bin_str[@bit_index / 8, @bit_length / 8].unpack("C*")
     end
 
-    def to_s
-      unless @bit_index % 8 == 0 && @bit_length % 8 == 0
-        raise BadBinaryManipulationError, "Invalid position(from #{@bit_index} bit) " +
-          "and length(#{@bit_length} bit)."
+    def check_non_byte_position(bit_index, bit_length)
+      unless bit_index % 8 == 0 && bit_length % 8 == 0
+        raise BadBinaryManipulationError, "Position {bit_index=#{bit_index}, " +
+          "bit_length=#{bit_length}} is not byte-position."
       end
-      return @bin_str[@bit_index / 8, @bit_length / 8]
     end
   end
 end

data/lib/general_class/binary_manipulate_function.rb

@@ -0,0 +1,54 @@
+module BinaryParser
+  module BinaryManipulateFunction
+    extend self
+
+    MASK = [0b11111111,
+            0b01111111,
+            0b00111111,
+            0b00011111,
+            0b00001111,
+            0b00000111,
+            0b00000011,
+            0b00000001]
+
+    def needed_sub_string(str, bit_first_pos, bit_last_pos)
+      return str[(bit_first_pos / 8)..(bit_last_pos / 8)], bit_first_pos % 8, 7 - (bit_last_pos % 8)
+    end
+
+    def needed_sub_string_in_domain_of_definition?(str, bfp, blp)
+      bfp < blp && blp / 8 < str.length
+    end
+
+    def to_unsigned_int(binary_string, margin_left=0, margin_right=0)
+      chars = binary_string.unpack("C*")
+      converted = chars.shift & MASK[margin_left]
+      chars.each do |char|
+        converted = (converted << 8) + char
+      end
+      return converted >> margin_right
+    end
+
+    def to_unsigned_int_in_domain_of_definition?(str, ml, mr)
+      [ str.length >= 1,
+        0 <= ml && ml <= 7,
+        0 <= mr && mr <= 7,
+        str.length != 1 || ml + mr <= 7 ].all?
+    end
+
+    def convert_uint_into_binary(uint, bit_length)
+      if uint == 0
+        if bit_length > 0
+          convert_uint_into_binary(0, bit_length - 8) + [0].pack("C1")
+        else
+          [].pack("C0")
+        end
+      else
+        convert_uint_into_binary(uint / 256, bit_length - 8) + [uint % 256].pack("C1")
+      end
+    end
+
+    def convert_uint_into_binary_in_domain_of_definition?(uint, bit_length)
+      bit_length >= 0 && 0 <= uint && uint < 2 ** bit_length
+    end
+  end
+end

data/lib/general_class/buffered_stream.rb

@@ -0,0 +1,21 @@
+module BinaryParser
+  class BufferedStream
+    require 'stringio'
+
+    def initialize(stream, buffer_size)
+      @stream, @buffer_size = stream, buffer_size
+    end
+
+    def read(length)
+      if !@buffer || @buffer.eof?
+        return nil unless next_buffer = @stream.read(@buffer_size)
+        @buffer = StringIO.new(next_buffer)
+      end
+      return @buffer.read(length)
+    end
+
+    def close
+      @stream.close
+    end
+  end
+end

data/lib/loop_list.rb

@@ -5,12 +5,12 @@ module BinaryParser
     def initialize(definition, abstract_binary, parent_scope)
       list, rest_binary = [], abstract_binary
       while rest_binary.bit_length > 0
-        scope = Scope.new(definition.structure, rest_binary, parent_scope)
-        if scope.eval_entire_bit_length == 0
+        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
-        rest_binary = rest_binary.sub(:bit_index => scope.eval_entire_bit_length)
-        list << NamelessTemplate.new(scope)
+        rest_binary = rest_binary.sub(:bit_index => template.structure_bit_length)
+        list << template
       end
       @list = list
     end
@@ -41,7 +41,6 @@ module BinaryParser
     #   recursively => Whether print recursively or not. Default is false.
     #   out         => Print target. Default is STDOUT.
     def show(recursively=false, out=STDOUT, depth=0)
-      #out.puts " " * (depth * 2) + "*** LIST with #{size} elements ***"
       @list.each_with_index do |element, i|
         out.puts sprintf(" " * (depth * 2) + "%-5s", "[#{i}]")
         element.show(true, out, depth + 1) if recursively

data/lib/nameless_template_maker.rb

@@ -0,0 +1,9 @@
+module BinaryParser
+  module NamelessTemplateMaker
+    def self.new(parent_structure=nil, structure_definition_proc)
+      Class.new(TemplateBase) do
+        Def(parent_structure, &structure_definition_proc)
+      end
+    end
+  end
+end

data/lib/scope.rb

@@ -10,11 +10,6 @@ module BinaryParser
       @data, @ebs, @ebl = {}, {}, {}
     end
 
-    def method_missing(name, *args)
-      return load_var(name) if @definition[name]
-      super
-    end
-
     def names
       @definition.names.dup
     end

data/lib/stream_template_base.rb

@@ -2,21 +2,38 @@ module BinaryParser
   class StreamTemplateBase
     include BuiltInTemplate
 
-    def self.def_stream(byte_length, &definition_proc)
+    def self.def_stream(byte_length, buffer_num=10000, &definition_proc)
       @byte_length = byte_length
-      used_method_names = NamelessTemplate.instance_methods + Scope.instance_methods
-      @structure = StructureDefinition.new(used_method_names, &definition_proc)
+      @buffer_size = buffer_num * byte_length
+      @template = NamelessTemplateMaker.new(definition_proc)
     end
 
-    def self.Def(byte_length, &definition_proc) def_stream(byte_length, &definition_proc) end
+    def self.Def(byte_length, buffer_num=10000, &definition_proc)
+      def_stream(byte_length, buffer_num, &definition_proc)
+    end
+
+    def self.get_template
+      raise BadManipulationError, "Structure is undefined." unless @template
+      return @template
+    end
+
+    def self.get_byte_length
+      raise BadManipulationError, "Byte-length is undefined." unless @byte_length
+      return @byte_length
+    end
 
-    def self.get_stream_definition
-      raise BadManipulationError, "Stream is undefined." unless @byte_length && @structure 
-      return @byte_length, @structure
+    def self.get_buffer_size
+      raise BadManipulationError, "Buffer-size is undefined." unless @buffer_size
+      return @buffer_size
     end
 
     def initialize(binary_stream, filters=[])
-      @binary_stream = binary_stream
+      case binary_stream
+      when BufferedStream
+        @buffered_binary_stream = binary_stream
+      else
+        @buffered_binary_stream = BufferedStream.new(binary_stream, self.class.get_buffer_size)
+      end
       @filters = filters
     end
 
@@ -24,7 +41,7 @@ module BinaryParser
     # return: new instance which has filter
     def filter(&filter_proc)
       raise BadManipulationError, "Filter Proc isn't given." unless filter_proc
-      return self.class.new(@binary_stream, @filters + [filter_proc])
+      return self.class.new(@buffered_binary_stream, @filters + [filter_proc])
     end
 
     # Get next element from binary-stream.
@@ -33,24 +50,40 @@ module BinaryParser
     # Special cases:
     #   (1) If rest of binary-stream's length is 0, this method returns nil.
     #   (2) If rest of binary-stream's length is shorter than required,
-    #       this method throws BadBinaryManipulationError.
+    #       this method throws ParsingError.
     def get_next
+      return take_lookahead || filtered_simply_get_next(@filters)
+    end
+
+    def non_proceed_get_next
+      @lookahead ||= get_next
+    end
+
+    def take_lookahead
+      res, @lookahead = @lookahead, nil
+      return res
+    end
+
+    def filtered_simply_get_next(filters)
       begin
-        if @lookahead
-          scope, @lookahead = @lookahead, nil
-        else
-          byte_length, structure = self.class.get_stream_definition
-          binary = @binary_stream.read(byte_length)
-          return nil unless binary
-          if binary.length < byte_length
-            raise ParsingError, "Stream's rest binary length" + 
-              "(#{binary.length} byte) is shorter than required length (#{byte_length} byte)."
-          end
-          abstract_binary = AbstractBinary.new(binary)
-          scope = Scope.new(structure, abstract_binary)
-        end
-      end until @filters.all?{|filter| filter.call(scope)}
-      return NamelessTemplate.new(scope)
+        structure = simply_get_next
+        return nil unless structure
+      end until filters.all?{|filter| filter.call(structure)}
+      return structure
+    end
+
+    def simply_get_next
+      return nil unless binary = next_binary
+      self.class.get_template.new(binary)
+    end
+
+    def next_binary
+      binary = @buffered_binary_stream.read(self.class.get_byte_length)
+      if binary && binary.length < self.class.get_byte_length
+        raise ParsingError, "Stream's rest binary length" + 
+          "(#{binary.length} byte) is shorter than required length (#{self.class.get_byte_length} byte)."
+      end
+      return binary
     end
 
     # Remove elements until finding element which fullfils proc-condition or reaching end of stream.
@@ -65,13 +98,8 @@ module BinaryParser
     def seek_top(&cond_proc)
       raise BadManipulationError, "Condition Proc isn't given." unless cond_proc
       abandoned = []
-      until @lookahead && cond_proc.call(@lookahead)
-        if @lookahead
-          abandoned << @lookahead
-          @lookahead = nil
-        end
-        return abandoned unless rest?
-        @lookahead = get_next
+      until !rest? || cond_proc.call(non_proceed_get_next)
+        abandoned << take_lookahead
       end
       return abandoned
     end
@@ -118,12 +146,12 @@ module BinaryParser
 
     # Check whether binary-stream remains or not.
     def rest?
-      return @lookahead || !@binary_stream.eof?
+      non_proceed_get_next
     end
-
+      
     # Simply close binary-stream.
     def close
-      @binary_stream.close
+      @buffered_binary_stream.close
     end
   end
 end

data/lib/structure_definition.rb

@@ -2,7 +2,7 @@ module BinaryParser
   class StructureDefinition
     
     DataDefinition  = Struct.new(:bit_position, :bit_length, :conditions, :klass)
-    LoopDefinition  = Struct.new(:bit_position, :bit_length, :conditions, :structure)
+    LoopDefinition  = Struct.new(:bit_position, :bit_length, :conditions, :klass)
 
     attr_reader :parent_structure, :bit_at, :names
 
@@ -28,18 +28,18 @@ module BinaryParser
     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)
+      klass = NamelessTemplateMaker.new(self, block)
+      @data_def[name] = LoopDefinition.new(bit_at, bit_length, @conditions.dup, klass)
       @names << name
     end
 
     def TIMES(times, name, &block)
       check_new_def_name(name)
-      structure = StructureDefinition.new(Scope.instance_methods, self, &block)
+      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, structure)
+        @data_def[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|
@@ -54,7 +54,7 @@ module BinaryParser
           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)
+        @data_def[name] = LoopDefinition.new(bit_at, bit_length, @conditions.dup, klass)
       end
       @names << name
     end
@@ -85,24 +85,39 @@ module BinaryParser
     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."
+      var_names.each do |var_name|
+        unless name_solvable?(var_name)
+          raise DefinitionError, "As condition variable, unsolvable variable #{var_name} is used."
+        end
       end
       return Condition.new(*var_names, &condition_proc)
     end
 
-    def var(name)
-      unless name_solvable?(name)
-        raise DefinitionError, "Unsolvable variable #{name} is used."
+    def match(var_name, value)
+      case value
+      when Integer
+        return cond(var_name){|v| v.to_i == value}
+      when String
+        return cond(var_name){|v| v.to_s == value}
+      when Symbol
+        return cond(var_name, value){|v1, v2| v1.to_i == v2.to_i}
+      else
+        raise DefinitionError, "Unknown type of matching value(#{value}) '#{value.class}'."
+      end
+    end
+
+    def var(var_name)
+      unless name_solvable?(var_name)
+        raise DefinitionError, "Unsolvable variable #{var_name} is used."
       end
-      return Expression.new([name])
+      return Expression.new([var_name])
     end
 
-    def len(name)
-      unless name_solvable?(name)
-        raise DefinitionError, "Unsolvable variable #{name} is used."
+    def len(var_name)
+      unless name_solvable?(var_name)
+        raise DefinitionError, "Unsolvable variable #{var_name} is used."
       end
-      symbol = ("__LEN__" + name.to_s).to_sym
+      symbol = ("__LEN__" + var_name.to_s).to_sym
       return Expression.new([symbol])
     end
 
@@ -114,8 +129,8 @@ module BinaryParser
       return Expression.new([:__rest])
     end
 
-    def [](name)
-      return @data_def[name]
+    def [](var_name)
+      return @data_def[var_name]
     end
 
     private

data/lib/template_base.rb

@@ -2,19 +2,38 @@ 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)
+    def self.def_structure(parent_structure=nil, &definition_proc)
+      @structure_def = StructureDefinition.new(instance_methods, parent_structure, &definition_proc)
+      @structure_def.names.each do |name|
+        def_var_method(name)
+      end
+    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
+      }
     end
 
-    def self.Def(&definition_proc) def_structure(&definition_proc) end
+    def self.Def(parent_structure=nil, &definition_proc)
+      def_structure(parent_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))
+    def initialize(binary, parent_scope=nil)
+      @scope = Scope.new(self.class.structure, convert_into_abstract_binary(binary), parent_scope)
     end
 
     def convert_into_abstract_binary(object)
@@ -25,16 +44,12 @@ module BinaryParser
       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)
+      @scope.load_var(name)
     end
 
     def names
-      return @scope.names
+      @scope.names
     end
 
     # Convert held binary into unsigned integer.

data/unit_test/general_class/test_abstract_binary.rb

@@ -6,7 +6,7 @@ module BinaryParser
     require 'test/unit'
 
     # load testing target
-    require $LIBRARY_ROOT_PATH + '/lib/general_class/abstract_binary.rb'
+    require $LIBRARY_ROOT_PATH + '/lib/binary_parser.rb'
 
     class AbstractBinaryTest < Test::Unit::TestCase
       
@@ -44,15 +44,60 @@ module BinaryParser
       def test_sub_error
         abin = AbstractBinary.new(gen_bin(0b11110000, 0b11111111))
         assert_raise(BadBinaryManipulationError) do
-          abin.sub(:bit_index => 16)
+          abin.sub(:bit_index => 17)
         end
         assert_raise(BadBinaryManipulationError) do
           abin.sub(:bit_length => 17)
         end
       end
 
+      def test_alt_binary
+        abin = AbstractBinary.new(gen_bin(0b00000000), 0, 8)
+        assert_equal(0,   abin.to_i)
+        assert_equal(255, abin.alt([0b11111111].pack("C*")).to_i)
+      end
+
+      def test_alt_uint
+        abin = AbstractBinary.new(gen_bin(0b00000000), 1, 3)
+        assert_equal(0, abin.to_i)
+        assert_equal(2, abin.alt(2).to_i)
+      end
+      
+      def test_naive_concat_CASE1
+        abin1 = AbstractBinary.new(gen_bin(0b11110000, 0b11110000), 3, 7)
+        assert_equal(0b1000011, abin1.to_i)
+
+        abin2 = AbstractBinary.new(gen_bin(0b11110000, 0b11110000), 7, 3)
+        assert_equal(0b011, abin2.to_i)
+
+        con_abin = abin1.naive_concat(abin2)
+        assert_equal(0b1000011011, con_abin.to_i)
+        assert_equal(10, con_abin.bit_length)
+      end
+        
+      def test_naive_concat_CASE2
+        abin1 = AbstractBinary.new(gen_bin(0b00000000, 0b00001111), 2, 14)
+        assert_equal(0b00000000001111, abin1.to_i)
+
+        abin2 = AbstractBinary.new(gen_bin(0b11110000), 0, 1)
+        assert_equal(0b1, abin2.to_i)
+
+        con_abin = abin1.naive_concat(abin2)
+        assert_equal(0b000000000011111, con_abin.to_i)
+        assert_equal(15, con_abin.bit_length)
+      end
+
+      def test_binary_concat_CASE1
+        abin1 = AbstractBinary.new(gen_bin(0b10000000), 0, 8)
+        abin2 = AbstractBinary.new(gen_bin(0b00000000), 0, 8)
+
+        con_abin = abin1.binary_concat(abin2)
+        assert_equal(0b1000000000000000, con_abin.to_i)
+        assert_equal(16, con_abin.bit_length)
+      end
+
       # helper for generating binary
-      def gen_bin(*chars)
+        def gen_bin(*chars)
         return chars.pack("C*")
       end
     end

data/unit_test/general_class/test_binary_manipulate_function.rb

@@ -0,0 +1,64 @@
+$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 BinaryManipulateFunctionTest < Test::Unit::TestCase
+      
+      def test_needed_sub_string
+        str = gen_bin(0, 0, 0)
+
+        assert_equal([str[0],    0,  0], nss(str,  0, 7))
+        assert_equal([str[0],    1,  2], nss(str,  1, 5))
+        assert_equal([str[0..1], 1,  7], nss(str,  1, 8))
+        assert_equal([str[0..2], 1,  3], nss(str,  1, 20))
+        assert_equal([str[1..2], 2,  3], nss(str, 10, 20))
+        assert_equal([str[1],    0,  0], nss(str,  8, 15))
+      end
+
+      def test_to_unsigned_int
+        str = gen_bin(0b11110000, 0b11110000)
+
+        assert_equal(0b01,               tui(str, 7, 7))
+        assert_equal(0b00001111,         tui(str, 4, 4))
+        assert_equal(0b1111000011110000, tui(str, 0, 0))
+      end
+
+      def test_convert_uint_into_binary
+        assert_equal([0x00],             cuib(0, 8).unpack("C*"))
+        assert_equal([0x00, 0x00],       cuib(0, 9).unpack("C*"))
+        assert_equal([0x00, 0x00, 0x00], cuib(0, 17).unpack("C*"))
+
+        assert_equal([0x01],       cuib(1, 8).unpack("C*"))
+        assert_equal([0x00, 0x01], cuib(1, 9).unpack("C*"))
+
+        assert_equal([0xff],       cuib(255, 8).unpack("C*"))
+        assert_equal([0x01, 0x00], cuib(256, 9).unpack("C*"))
+
+        assert_equal([0xff, 0xff],       cuib(0xffff, 16).unpack("C*"))
+        assert_equal([0x00, 0xff, 0xff], cuib(0xffff, 17).unpack("C*"))
+      end
+
+      # helper for generating binary
+      def gen_bin(*chars)
+        return chars.pack("C*")
+      end
+
+      def nss(*args)
+        BinaryManipulateFunction.needed_sub_string(*args)
+      end
+
+      def tui(*args)
+        BinaryManipulateFunction.to_unsigned_int(*args)
+      end
+
+      def cuib(*args)
+        BinaryManipulateFunction.convert_uint_into_binary(*args)
+      end
+    end
+  end
+end

data/unit_test/general_class/test_bit_position.rb

@@ -6,7 +6,7 @@ module BinaryParser
     require 'test/unit'
 
     # load testing target
-    require $LIBRARY_ROOT_PATH + '/lib/general_class/bit_position.rb'
+    require $LIBRARY_ROOT_PATH + '/lib/binary_parser.rb'
 
     class BitPositionTest < Test::Unit::TestCase
 

data/unit_test/general_class/test_condition.rb

@@ -6,7 +6,7 @@ module BinaryParser
     require 'test/unit'
 
     # load testing target
-    require $LIBRARY_ROOT_PATH + '/lib/general_class/condition.rb'
+    require $LIBRARY_ROOT_PATH + '/lib/binary_parser.rb'
 
     class ConditionTest < Test::Unit::TestCase
 

data/unit_test/general_class/test_expression.rb

@@ -6,7 +6,7 @@ module BinaryParser
     require 'test/unit'
 
     # load testing target
-    require $LIBRARY_ROOT_PATH + '/lib/general_class/expression.rb'
+    require $LIBRARY_ROOT_PATH + '/lib/binary_parser.rb'
 
     class ExpressionTest < Test::Unit::TestCase
       VAL = {:hoge => 10, :fuga => 1000}

data/unit_test/test_structure_definition.rb

@@ -46,8 +46,8 @@ module BinaryParser
           data :dat3, C3, 8
         end
         
-        assert_equal(8,  st[:lp].structure[:dat1].bit_length.eval{})
-        assert_equal(16, st[:lp].structure[:dat2].bit_length.eval{})
+        assert_equal(8,  st[:lp].klass.structure[:dat1].bit_length.eval{})
+        assert_equal(16, st[:lp].klass.structure[:dat2].bit_length.eval{})
         assert_equal(48, st[:dat3].bit_position.eval{})
       end
 
@@ -83,6 +83,30 @@ module BinaryParser
         assert_equal(0, st[:dat4].conditions.size)
       end
 
+      def test_match
+        st = StructureDefinition.new do
+          data :hoge, C1, 1
+          data :fuga, C1, 1
+        end
+
+        eval_proc = Proc.new do |var_name|
+          {:hoge => 1, :fuga => 1}[var_name]
+        end
+
+        cond1 = st.match(:hoge, 1)
+        assert_equal(true, cond1.eval(&eval_proc))
+
+        cond2 = st.match(:hoge, "ABC")
+        assert_equal(false, cond2.eval(&eval_proc))
+
+        cond3 = st.match(:hoge, :fuga)
+        assert_equal(true, cond3.eval(&eval_proc))
+
+        assert_raise(DefinitionError) do
+          st.match(:hoge, Object.new)
+        end
+      end
+
       def test_VARIABLE_REFERENCE_ERROR
         assert_raise(DefinitionError) do
           st = StructureDefinition.new do

data/unit_test/test_template_base.rb

@@ -53,6 +53,16 @@ module BinaryParser
         assert_equal(40, t.structure_bit_length)
       end
 
+      def test_data_method_block_call
+        t = gen(0b10000001, 0, 0, 0, 0)
+
+        assert_equal(0b1000000, t.number.to_i)
+        assert_equal(0b1000000, t.number{ to_i })
+        t.number do |n|
+          assert_equal(0b1000000, n.to_i)
+        end
+      end
+
       # helper for generating binary
       def gen(*chars)
         return TestingTemplate.new(chars.pack("C*"))

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: binary_parser
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - rokugats(u)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-10 00:00:00.000000000 Z
+date: 2014-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -64,16 +64,19 @@ files:
 - lib/built_in_template/uint.rb
 - lib/error.rb
 - lib/general_class/abstract_binary.rb
+- lib/general_class/binary_manipulate_function.rb
 - lib/general_class/bit_position.rb
+- lib/general_class/buffered_stream.rb
 - lib/general_class/condition.rb
 - lib/general_class/expression.rb
 - lib/loop_list.rb
-- lib/nameless_template.rb
+- lib/nameless_template_maker.rb
 - lib/scope.rb
 - lib/stream_template_base.rb
 - lib/structure_definition.rb
 - lib/template_base.rb
 - unit_test/general_class/test_abstract_binary.rb
+- unit_test/general_class/test_binary_manipulate_function.rb
 - unit_test/general_class/test_bit_position.rb
 - unit_test/general_class/test_condition.rb
 - unit_test/general_class/test_expression.rb

data/lib/nameless_template.rb

@@ -1,7 +0,0 @@
-module BinaryParser
-  class NamelessTemplate < TemplateBase
-    def initialize(scope)
-      @scope = scope
-    end
-  end
-end