binary_parser 1.1.1 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f00ee4cb710d229fe1bd23f7d2dd5b9d2e63fe17
-  data.tar.gz: 50a4f28986bdc26f158531dcbda7040cdd16cd9a
+  metadata.gz: fc0580a7a3667f74608fc328897ce3ee3772b94a
+  data.tar.gz: d9c1e1b204e9813ff8239cd2d36f45a509430c54
 SHA512:
-  metadata.gz: f24c616c42e6a4b2866c18d28764f2885758a566d1df136118a0c9fcfb91dece7ec573e5a560a3f6655551e29641dd2bee5e8bc8a6da527660db30521a83e100
-  data.tar.gz: 666608cd8a53767641515c5164a9916cb537db71244e148da052831ed265920be5925d343c924ddb5703d297dd88601ac4453d0ac72e26446fa320d30f23c34a
+  metadata.gz: 658d10fb088312e15f51965c4a8a9f366b60a58e3be00a61d0dc70fc243f0f124e8adac9b5ef5f113eb2e43ca7b0fa7f83b0998684a7001492819cec4f94547e
+  data.tar.gz: c8347f938c25674e959014f1bcc1f4097a6d8efdde741f819a5c72f490297d372415c70c68121eea7a14cb6cfffab3a24f46ba394a64163472548ec6a8dc850e

data/.gitignore

@@ -11,6 +11,7 @@ coverage
 doc/
 lib/bundler/man
 pkg
+test
 rdoc
 spec/reports
 test/tmp

data/binary_parser.gemspec

@@ -7,10 +7,10 @@ require 'binary_parser/version'
 Gem::Specification.new do |spec|
   spec.name          = "binary_parser"
   spec.version       = BinaryParser::VERSION
-  spec.authors       = ["rokugats(u)"]
+  spec.authors       = ["sawaken"]
   spec.email         = ["sasasawada@gmail.com"]
   spec.summary       = "An elegant DSL library for parsing binary-data."
-  spec.homepage      = "https://github.com/rokugats/ruby-binary-parser"
+  spec.homepage      = "https://github.com/sawaken/ruby-binary-parser"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)

data/lib/binary_parser/version.rb

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

data/lib/binary_parser.rb

@@ -12,7 +12,10 @@ module BinaryParser
      'expression.rb',
      'bit_position.rb',
      'condition.rb',
-     'buffered_stream.rb'
+     'free_condition.rb',
+     'buffered_stream.rb',
+     'proxy.rb',
+     'memorize.rb'
     ]
 
   GENERAL_CLASS_FILES.each do |path|
@@ -38,6 +41,7 @@ module BinaryParser
   LIB_DIR = '/lib/'
   LIB_FILES =
     ['loop_list.rb',
+     'while_list.rb',
      'scope.rb',
      'structure_definition.rb',
      'template_base.rb',

data/lib/built_in_template/binary.rb

@@ -6,6 +6,20 @@ module BinaryParser
         bytes = chars[0, 5].map{|i| sprintf("0x%02x", i)}.join(", ")
         return "[" + bytes + (chars.length > 5 ? ", ..." : "") + "]"
       end
+
+      def to_str
+        self.to_s
+      end
+
+      def ==(other)
+        if other.is_a?(Binary)
+          self.to_s == other.to_s
+        elsif other.is_a?(String)
+          self.to_s == other
+        else
+          super
+        end
+      end
     end
   end
 end

data/lib/built_in_template/uint.rb

@@ -1,8 +1,81 @@
 module BinaryParser
   module BuiltInTemplate
     class UInt < TemplateBase
+
+      include Comparable
+
       def content_description
-        to_i.to_s
+        self.to_i.to_s
+      end
+
+      def to_s(base=10)
+        self.to_i.to_s(base)
+      end
+
+      def [](bit_index)
+        self.to_i[bit_index]
+      end
+
+      def coerce(other)
+        if other.is_a?(Integer)
+          return other, self.to_i
+        else
+          super
+        end
+      end
+
+      def +(other)
+        if other.is_a?(UInt)
+          self.to_i + other.to_i
+        elsif other.is_a?(Integer)
+          self.to_i + other
+        else
+          x, y = other.coerce(self)
+          x + y
+        end
+      end
+
+      def *(other)
+        if other.is_a?(UInt)
+          self.to_i * other.to_i
+        elsif other.is_a?(Integer)
+          self.to_i * other
+        else
+          x, y = other.coerce(self)
+          x * y
+        end
+      end
+
+      def -(other)
+        if other.is_a?(UInt)
+          self.to_i - other.to_i
+        elsif other.is_a?(Integer)
+          self.to_i - other
+        else
+          x, y = other.coerce(self)
+          x - y
+        end
+      end
+
+      def /(other)
+        if other.is_a?(UInt)
+          self.to_i / other.to_i
+        elsif other.is_a?(Integer)
+          self.to_i / other
+        else
+          x, y = other.coerce(self)
+          x / y
+        end
+      end
+
+      def <=>(other)
+        if other.is_a?(UInt)
+          self.to_i <=> other.to_i
+        elsif other.is_a?(Integer)
+          self.to_i <=> other
+        else
+          nil
+        end
       end
     end
   end

data/lib/general_class/bit_position.rb

@@ -12,7 +12,7 @@ module BinaryParser
     end
 
     def add_name(name)
-      return BitPosition.new(@imm, @names + [name])
+      return BitPosition.new(@imm, @names + [Expression.length_var(name)])
     end
 
     def eval(&name_eval_block)

data/lib/general_class/condition.rb

@@ -1,11 +1,12 @@
 module BinaryParser
   class Condition
     def initialize(*var_names, &condition_proc)
-      @var_names, @condition_proc = var_names, condition_proc
+      @tokens = var_names.map{|symbol| Expression.value_var(symbol)}
+      @condition_proc = condition_proc
     end
 
-    def eval(&name_eval_proc)
-      return @condition_proc.call(*@var_names.map{|name| name_eval_proc.call(name)})
+    def eval(&token_eval_proc)
+      return @condition_proc.call(*@tokens.map{|token| token_eval_proc.call(token)})
     end
   end
 end

data/lib/general_class/expression.rb

@@ -1,66 +1,242 @@
 module BinaryParser
   class Expression
-    attr_reader :rpn
 
-    def initialize(rpn)
-      @rpn = rpn
+    def self.value_var(symbol)
+      Token::Variable::Value.new(symbol)
+    end
+
+    def self.length_var(symbol)
+      Token::Variable::Length.new(symbol)
+    end
+
+    def self.control_var(symbol)
+      Token::Variable::Control.new(symbol)
+    end
+
+    def self.nextbits_var(length)
+      Token::Variable::Nextbits.new(length)
+    end
+
+    def self.immediate(value)
+      Token::Immediate.new(value)
+    end
+
+    def value_var?
+      self.is_a?(Token::Variable::Value)
+    end
+
+    def length_var?
+      self.is_a?(Token::Variable::Length)
+    end
+
+    def control_var?
+      self.is_a?(Token::Variable::Control)
+    end
+
+    def nextbits_var?
+      self.is_a?(Token::Variable::Nextbits)
+    end
+
+    def immediate?
+      self.is_a?(Token::Immediate)
+    end
+
+    def coerce(other)
+      if other.is_a?(Integer)
+        return Token::Immediate.new(other), self
+      else
+        super
+      end
     end
 
     def +(other)
-      return Expression.new(@rpn + to_rpn(other) + [:__add])
+      binary_op(other, Token::Operator::Add.instance)
     end
 
     def -(other)
-      return Expression.new(@rpn + to_rpn(other) + [:__sub])
+      binary_op(other, Token::Operator::Sub.instance)
     end
 
     def *(other)
-      return Expression.new(@rpn + to_rpn(other) + [:__mul])
+      binary_op(other, Token::Operator::Mul.instance)
     end
 
     def /(other)
-      return Expression.new(@rpn + to_rpn(other) + [:__div])
+      binary_op(other, Token::Operator::Div.instance)
     end
 
-    def to_rpn(other)
-      case other
-      when Integer
-        return [other]
-      when Expression
-        return other.rpn
+    def %(other)
+      binary_op(other, Token::Operator::Mod.instance)
+    end
+
+    def binary_op(other, op)
+      BinaryOperator.new(self, other, op)
+    end
+
+    def to_exp(exp)
+      if exp.is_a?(Expression)
+        exp
+      elsif exp.is_a?(Integer)
+        Token::Immediate.new(exp)
       else
-        raise BadManipulationError, "Unknown type of other (#{other.class})."
+        raise BadManipulationError, "Can't convert #{exp} into Expression."
+      end
+    end
+
+    def eval(&token_eval_proc)
+      to_rpn.eval(&token_eval_proc)
+    end
+
+    def variable_tokens
+      to_rpn.tokens.select{|token| token.is_a?(Token::Variable)}
+    end
+
+    def initialize(*args)
+      raise BadManipulationError, "Expression is abstract class."
+    end
+
+    class BinaryOperator < self
+      def initialize(chl, chr, op)
+        check_op(op)
+        @chl, @chr, @op = to_exp(chl), to_exp(chr), op
+      end
+
+      def check_op(op)
+        unless op.is_a?(Token::Operator)
+          raise BadManipulationError, "Argument should be Token::Operator."
+        end
+      end
+
+      def to_rpn
+        @rpn ||= @chl.to_rpn + @chr.to_rpn + @op.to_rpn
       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)
+    class Token < self
+
+      def initialize
+        #override but do nothing
+      end
+
+      def to_rpn
+        @rpn ||= RPN.new(self)
+      end
+
+      class Variable < self
+
+        attr_reader :symbol
+
+        def initialize(symbol)
+          raise BadManipulationError, "Argument should be Symbol." unless symbol.is_a?(Symbol)
+          @symbol = symbol
+        end
+
+        class Length < self
+
+        end
+
+        class Value < self
+
+        end
+
+        class Control < self
+
+        end
+
+        class Nextbits < self
+
+          attr_reader :length
+
+          def initialize(length)
+            unless length.is_a?(Integer) && length > 0
+              raise BadManipulationError, "Argument should be positive Integer."
+            end
+            @length = length
+          end
+        end
+      end
+
+      class Immediate < self
+
+        attr_reader :value
+
+        def initialize(value)
+          raise BadManipulationError, "Argument should be Integer." unless value.is_a?(Integer)
+          @value = value
+        end
+      end
+
+      class Operator < self
+
+        require 'singleton'
+        include Singleton
+
+        class Add < self
+          def operate(op1, op2)
+            op1 + op2
+          end
+        end
+
+        class Sub < self
+          def operate(op1, op2)
+            op1 - op2
+          end
+        end
+
+        class Mul < self
+          def operate(op1, op2)
+            op1 * op2
+          end
+        end
+
+        class Div < self
+          def operate(op1, op2)
+            op1 / op2
+          end
+        end
+
+        class Mod < self
+          def operate(op1, op2)
+            op1 % op2
+          end
+        end
+      end
+    end
+
+    class RPN
+      attr_reader :tokens
+
+      def initialize(*tokens)
+        check_tokens(tokens)
+        @tokens = tokens
+      end
+
+      def check_tokens(tokens)
+        tokens.all?{|token| token.is_a?(Expression::Token)}
+      end
+
+      def +(other)
+        RPN.new(*(self.tokens + other.tokens))
+      end
+
+      def eval(&token_eval_proc)
+        stack = @tokens.inject([]) do |stack, token|
+          if token.is_a?(Expression::Token::Operator)
+            raise BadManipulationError, "Cannot calculate this RPN." if stack.length < 2
+            stack + [token.operate(*[stack.pop, stack.pop].reverse)]
+          elsif token.is_a?(Expression::Token::Immediate)
+            stack + [token.value]
+          elsif token.is_a?(Expression::Token::Variable)
+            eval_value = token_eval_proc.call(token)
+            unless eval_value.is_a?(Integer)
+              raise BadManipulationError, "Evaluation is faild. #{eval_value} is not Integer."
+            end
+            stack + [eval_value]
+          end
         end
+        raise BadManipulationError, "Cannot calculate this RPN." if stack.length != 1
+        return stack.last
       end
-      raise ProgramAssertionError, "Cannot calc RPN." unless stack.length == 1
-      return stack.last
     end
   end
 end

data/lib/general_class/free_condition.rb

@@ -0,0 +1,20 @@
+module BinaryParser
+  class FreeCondition
+    def initialize(&condition_proc)
+      @condition_proc = condition_proc
+    end
+
+    def eval(&name_eval_proc)
+      @name_eval_proc = name_eval_proc
+      return Proxy.new(self, []).instance_eval(&@condition_proc)
+    end
+
+    def symbol_call(symbol, *args, &block)
+      if symbol == :nextbits && args.length == 1
+        @name_eval_proc.call(Expression.nextbits_var(args[0]))
+      else
+        @name_eval_proc.call(Expression.value_var(symbol))
+      end
+    end
+  end
+end

data/lib/general_class/memorize.rb

@@ -0,0 +1,36 @@
+module BinaryParser
+  module Memorize
+    module Extension
+
+      attr_accessor :memorize_methods
+      
+      def method_added(method_name)
+        @memorized ||= Hash.new
+        if @memorize_methods.include?(method_name) && !@memorized[method_name]
+          @memorized[method_name] = true
+          memorize(method_name) 
+        end
+      end
+
+      def memorize(method_name)
+        pure_method_name = "pure_#{method_name}".to_sym
+        alias_method pure_method_name, method_name
+        define_method(method_name) do |arg|
+          @memo ||= Hash.new
+          @memo[method_name] ||= Hash.new
+          @memo[method_name][arg] ||= send(pure_method_name, arg)
+        end
+      end
+    end
+
+    def self.one_arg_method(*method_names)
+      @method_names = method_names
+      return self
+    end
+
+    def self.included(klass)
+      klass.extend Extension
+      klass.memorize_methods = @method_names
+    end
+  end
+end

data/lib/general_class/proxy.rb

@@ -0,0 +1,14 @@
+class Proxy < BasicObject
+  def initialize(target, proxy_methods)
+    @target = target
+    @proxy_methods = proxy_methods
+  end
+
+  def method_missing(message, *args, &block)
+    if @proxy_methods.include?(message)
+      @target.__send__(message, *args, &block)
+    else
+      @target.symbol_call(message, *args, &block)
+    end
+  end
+end

data/lib/loop_list.rb

@@ -31,6 +31,8 @@ module BinaryParser
       return @list.size
     end
 
+    alias_method :length, :size
+
     # String that describes this object.
     def content_description
       "list with #{size} elements"

data/lib/scope.rb

@@ -1,5 +1,6 @@
 module BinaryParser
   class Scope
+    include Memorize.one_arg_method(:load_var, :eval_bit_position, :eval_bit_length)
 
     attr_reader :abstract_binary
 
@@ -7,7 +8,6 @@ module BinaryParser
       @definition = structure_definition
       @abstract_binary = abstract_binary
       @parent_scope = parent_scope
-      @data, @ebs, @ebl = {}, {}, {}
     end
 
     def names
@@ -18,16 +18,17 @@ module BinaryParser
       raise UndefinedError, "Undefined data-name '#{name}'." unless @definition[name]
     end
 
-    # * Unsatisfactory memorized method (little obfuscated? : need refactoring?)
     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))
+        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)
+        LoopList.new(@definition[name], load_binary(name), self)
+      when StructureDefinition::WhileDefinition
+        sub_binary = @abstract_binary.sub(:bit_index => eval_bit_position(name))
+        WhileList.new(@definition[name], sub_binary, self, name)
       else
         raise ProgramAssertionError, "Unknown definition-class '#{@definition[name].class}'."
       end
@@ -45,52 +46,61 @@ module BinaryParser
       end
     end
 
-    # * memorized method (little obfuscated? : need refactoring?)
+    def preview_as_integer(start_pos, length)
+      sub_binary = @abstract_binary.sub(:bit_index => start_pos, :bit_length => length)
+      TemplateBase.new(sub_binary).to_i
+    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
+      return eval(@definition[name].bit_position, nil)
     end
 
-    # * memorized method (little obfuscated? : need refactoring?)
     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)}
+      unless @definition[name].conditions.all?{|cond| eval(cond, name)}
+        return 0
       end
-      return @ebl[name] ||= @definition[name].bit_length.eval do |var_name|
-        if var_name[0..1] == "__"
-          bit_length_control_variable_resolution(name, var_name)
-        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
+      return eval(@definition[name].bit_length, name)
+    end
+  
+    def eval_entire_bit_length
+      eval(@definition.bit_at, nil)
+    end
+
+    def eval(target, name)
+      target.eval do |token|
+        token_eval(token, name)
       end
     end
 
-    def bit_length_control_variable_resolution(name, var_name)
-      if var_name == :__rest
+    def token_eval(token, name)
+      if token.control_var?
+        bit_length_control_variable_resolution(name, token.symbol)
+      elsif token.nextbits_var?
+        preview_as_integer(eval_bit_position(name), token.length)
+      elsif token.length_var?
+        eval_bit_length(token.symbol)
+      elsif token.value_var?
+        unless val = load_var(token.symbol)
+          raise ParsingError, "Variable '#{token.symbol}' assigned  to Nil is referenced" +
+            "at the time of resolving '#{name}'."
+        end
+        val.to_i
+      end
+    end
+    
+    def bit_length_control_variable_resolution(name, symbol)
+      if symbol == :rest
         length = @abstract_binary.bit_length - eval_bit_position(name)
         raise ParsingError, "Binary is too short. (So, 'rest' is failed.)" if length < 0
         return length
-      elsif var_name == :__position
+      elsif symbol == :position
         return eval_bit_position(name)
-      elsif var_name[0..6] == "__LEN__"
-        return eval_bit_length(var_name[7..(var_name.length - 1)].to_sym)
+      elsif symbol == :non_fixed
+        return load_var(name).bit_length
       else
-        raise ProgramAssertionError, "Unknown Control-Variable '#{var_name}'."
-      end
-    end
-    
-    def eval_entire_bit_length
-      return @definition.bit_at.eval do |name|
-        eval_bit_length(name)
+        raise ProgramAssertionError, "Unknown Control-Variable '#{symbol}'."
       end
     end
   end