binary_parser 1.0.0

data/lib/general_class/abstract_binary.rb

@@ -0,0 +1,68 @@
+module BinaryParser
+  class AbstractBinary
+
+    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
+    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}))"
+      end
+
+      if spec[:bit_length] || spec[:byte_length]
+        new_bit_length = spec[:bit_length].to_i + spec[:byte_length].to_i * 8
+      else
+        new_bit_length = @bit_length - additional_bit_index
+      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
+
+      return self.class.new(@bin_str, @bit_index + additional_bit_index, new_bit_length)
+    end
+
+    def to_i
+      if @bit_length == 0
+        raise BadBinaryManipulationError, "Cannot convert empty binary into integer."
+      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
+      raise ProgramAssertionError, "Failed to convert integer value."
+    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)."
+      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)."
+      end
+      return @bin_str[@bit_index / 8, @bit_length / 8]
+    end
+  end
+end

data/lib/general_class/bit_position.rb

@@ -0,0 +1,22 @@
+module BinaryParser
+  class BitPosition
+    
+    attr_reader :imm, :names
+
+    def initialize(imm=0, names=[])
+      @imm, @names = imm, names
+    end
+
+    def add_imm(length)
+      return BitPosition.new(@imm + length, @names)
+    end
+
+    def add_name(name)
+      return BitPosition.new(@imm, @names + [name])
+    end
+
+    def eval(&name_eval_block)
+      return @imm + @names.inject(0){|sum, name| sum + name_eval_block.call(name)}
+    end
+  end
+end

data/lib/general_class/condition.rb

@@ -0,0 +1,11 @@
+module BinaryParser
+  class Condition
+    def initialize(*var_names, &condition_proc)
+      @var_names, @condition_proc = var_names, condition_proc
+    end
+
+    def eval(&name_eval_proc)
+      return @condition_proc.call(*@var_names.map{|name| name_eval_proc.call(name)})
+    end
+  end
+end

data/lib/general_class/expression.rb

@@ -0,0 +1,66 @@
+module BinaryParser
+  class Expression
+    attr_reader :rpn
+
+    def initialize(rpn)
+      @rpn = rpn
+    end
+
+    def +(other)
+      return Expression.new(@rpn + to_rpn(other) + [:__add])
+    end
+
+    def -(other)
+      return Expression.new(@rpn + to_rpn(other) + [:__sub])
+    end
+
+    def *(other)
+      return Expression.new(@rpn + to_rpn(other) + [:__mul])
+    end
+
+    def /(other)
+      return Expression.new(@rpn + to_rpn(other) + [:__div])
+    end
+
+    def to_rpn(other)
+      case other
+      when Integer
+        return [other]
+      when Expression
+        return other.rpn
+      else
+        raise BadManipulationError, "Unknown type of other (#{other.class})."
+      end
+    end
+
+    def variables
+      control_symbols = [:__add, :__sub, :__mul, :__div]
+      return @rpn.select{|token| token.is_a?(Symbol) && !control_symbols.include?(token)}
+    end
+
+    def eval(&name_eval_block)
+      stack, rpn = [], @rpn.dup
+      until rpn.empty?
+        stack << rpn.shift
+        case stack.last
+        when :__add
+          arg = [stack.pop, stack.pop, stack.pop]
+          stack << arg[2] + arg[1]
+        when :__sub
+          arg = [stack.pop, stack.pop, stack.pop]
+          stack << arg[2] - arg[1]
+        when :__mul
+          arg = [stack.pop, stack.pop, stack.pop]
+          stack << arg[2] * arg[1]
+        when :__div
+          arg = [stack.pop, stack.pop, stack.pop]
+          stack << arg[2] / arg[1]
+        when Symbol
+          stack << name_eval_block.call(stack.pop)
+        end
+      end
+      raise ProgramAssertionError, "Cannot calc RPN." unless stack.length == 1
+      return stack.last
+    end
+  end
+end

data/lib/loop_list.rb

@@ -0,0 +1,52 @@
+module BinaryParser
+  class LoopList
+    include Enumerable
+
+    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
+          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)
+      end
+      @list = list
+    end
+
+    def each(&block)
+      @list.each(&block)
+    end
+
+    def [](index)
+      unless @list[index]
+        raise BadManipulationError, "Index is out of bounds. List size is #{@list.size}." +
+          "You accessed list[#{index}]." 
+      end
+      return @list[index]
+    end
+
+    def size
+      return @list.size
+    end
+
+    # String that describes this object.
+    def content_description
+      "list with #{size} elements"
+    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)
+      #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
+      end
+    end
+  end
+end
+

data/lib/nameless_template.rb

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

data/lib/scope.rb

@@ -0,0 +1,87 @@
+module BinaryParser
+  class Scope
+
+    attr_reader :abstract_binary
+
+    def initialize(structure_definition, abstract_binary, parent_scope=nil)
+      @definition = structure_definition
+      @abstract_binary = abstract_binary
+      @parent_scope = parent_scope
+      @data, @ebs, @ebl = {}, {}, {}
+    end
+
+    def method_missing(name, *args)
+      return load_var(name) if @definition[name]
+      super
+    end
+
+    def names
+      @definition.names.dup
+    end
+
+    def check_name_defined(name)
+      raise UndefinedError, "Undefined data-name '#{name}'." unless @definition[name]
+    end
+
+    def load_var(name)
+      return @parent_scope.load_var(name) if !@definition[name] && @parent_scope
+      check_name_defined(name)
+      case @definition[name]
+      when StructureDefinition::DataDefinition
+        return @data[name] ||= eval_bit_length(name) == 0 ? nil :
+          @definition[name].klass.new(load_binary(name))
+      when StructureDefinition::LoopDefinition
+        return @data[name] ||= LoopList.new(@definition[name], load_binary(name), self)
+      else
+        raise ProgramAssertionError, "Unknown definition-class '#{@definition[name].class}'."
+      end
+    end
+
+    def load_binary(name)
+      check_name_defined(name)
+      start  = eval_bit_position(name)
+      length = eval_bit_length(name)
+      begin
+        return @abstract_binary.sub(:bit_index => start, :bit_length => length)
+      rescue BadBinaryManipulationError => error
+        raise ParsingError, "Cannot load binary of '#{name}'.\n" +
+          "*** #{error.backtrace.first} ***\n#{error.message}\n"
+      end
+    end
+
+    def eval_bit_position(name)
+      check_name_defined(name)
+      return @ebs[name] ||= @definition[name].bit_position.eval do |name|
+        eval_bit_length(name)
+      end
+    end
+
+    def eval_bit_length(name)
+      check_name_defined(name)
+      return @ebl[name] if @ebl[name]
+      return @ebl[name] = 0 unless @definition[name].conditions.all? do |cond|
+        cond.eval{|name| load_var(name)}
+      end
+      return @ebl[name] ||= @definition[name].bit_length.eval do |var_name|
+        if var_name == :__rest
+          length = @abstract_binary.bit_length - eval_bit_position(name)
+          raise ParsingError, "Binary is too short. (So, 'rest' is failed.)" if length < 0
+          length
+        else
+          val = load_var(var_name)
+          unless val
+            raise ParsingError, "Variable '#{var_name}' assigned  to Nil is referenced" +
+              "at the time of resolving bit_length of '#{var_name}'."
+          end
+          val.to_i
+        end
+      end
+    end
+    
+    def eval_entire_bit_length
+      return @definition.bit_at.eval do |name|
+        eval_bit_length(name)
+      end
+    end
+  end
+end

data/lib/stream_template_base.rb

@@ -0,0 +1,129 @@
+module BinaryParser
+  class StreamTemplateBase
+    include BuiltInTemplate
+
+    def self.def_stream(byte_length, &definition_proc)
+      @byte_length = byte_length
+      used_method_names = NamelessTemplate.instance_methods + Scope.instance_methods
+      @structure = StructureDefinition.new(used_method_names, &definition_proc)
+    end
+
+    def self.Def(byte_length, &definition_proc) def_stream(byte_length, &definition_proc) end
+
+    def self.get_stream_definition
+      raise BadManipulationError, "Stream is undefined." unless @byte_length && @structure 
+      return @byte_length, @structure
+    end
+
+    def initialize(binary_stream, filters=[])
+      @binary_stream = binary_stream
+      @filters = filters
+    end
+
+    # Add fileter to instance (not disruptive)
+    # 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])
+    end
+
+    # Get next element from binary-stream.
+    # If instance has filters, the unsatisfied element is to be abandoned
+    #  and recursively returns next element.
+    # 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.
+    def get_next
+      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)
+    end
+
+    # Remove elements until finding element which fullfils proc-condition or reaching end of stream.
+    # return: array of removed elements
+    #
+    # Concrete example:
+    #   If stream has [F1, F2, T3, F4, ...] and given cond_proc is Proc.new{|a| a == Tx},
+    #   seek_top(&cond_proc) returns array of [F1, F2] and then stream has [T3, F4, ...].
+    #   In the same way, (1) [T1, F2, ...] => return: [],       stream: [T1, F2, ...]
+    #                    (2) [F1, F2]      => return: [F1, F2], stream: [] (end)
+    #                    (3) [] (end)      => return: [],       stream: [] (end)
+    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
+      end
+      return abandoned
+    end
+
+    # Get sequence by specifing head-condition.
+    # Concrete example:
+    #   If stream has [F1, T2, F3, F4, T5, ...] and given cond_proc is Proc.new{|a| a == Tx},
+    #   get_sequence(&cond_proc) returns array of [T2, F3, F4] and then stream has [T5, ...].
+    #
+    #   In the same way, (1) [T1, F2, T3, ...] => return: [T1, F2], stream: [T3, ...]
+    #                    (2) [T1, T2, F3, ...] => return: [T1],     stream: [T2, F3, ...]
+    #                    (3) [T1, F2]          => return: [],       stream: [] (end)
+    #                    (4) [F1, F2]          => return: [],       stream: [] (end)
+    #                    (5) [] (end)          => return: [],       stream: [] (end)
+    #
+    #   * But if option-arg "allow_incomplete_sequence" is set as true, above example of (3) is
+    #                        [T1, F2, F3, F4]  => return: [T1, F2, F3, F4], stream: [] (end)
+    def get_sequence(allow_incomplete_sequence = false, &cond_proc)
+      raise BadManipulationError, "Condition Proc isn't given." unless cond_proc
+      seek_top(&cond_proc)
+      return [] unless rest?
+      res = [get_next] + seek_top(&cond_proc)
+      return [] unless rest? || allow_incomplete_sequence
+      return res
+    end
+
+    # Accumulate elements
+    # Concrete example:
+    #   If stream has [1, 2, 3, 4, 5, ...] and given reduce_proc is Proc.new{|acc, a| acc + a},
+    #   accumulate(0, 6, &reduce_proc) returns array of [1, 2, 3] and then stream has[4, 5, ...].
+    #
+    # Special case: If enough elements don't remain, this method returns nil.
+    #   Example: [1, 2, 3], accumulate(0, 7, &reduce_proc) => return: nil, stream: [] (end)
+    def accumulate(init_amount, dest_amount, &reduce_proc)
+      raise BadManipulationError, "Reduce Proc isn't given." unless reduce_proc
+      accumulation, amount = [], init_amount
+      while amount < dest_amount
+        return nil unless rest?
+        accumulation << get_next
+        amount = reduce_proc.call(amount, accumulation.last)
+      end
+      return accumulation
+    end
+
+    # Check whether binary-stream remains or not.
+    def rest?
+      return @lookahead || !@binary_stream.eof?
+    end
+
+    # Simply close binary-stream.
+    def close
+      @binary_stream.close
+    end
+  end
+end