rsec 0.3.2

data/lib/rsec/parser.rb

@@ -0,0 +1,64 @@
+# coding: utf-8
+
+module Rsec #:nodoc:
+  # parser base
+  module Parser
+    # parses string<br/>
+    # returns nil if unparsed
+    def parse str, source_name='source'
+      ctx = ParseContext.new str, source_name
+      _parse ctx
+    end
+
+    # almost the same as parse<br/>
+    # but raises SyntaxError
+    def parse! str, source_name='source'
+      ctx = ParseContext.new str, source_name
+      ret = _parse ctx
+      if INVALID[ret]
+        raise ctx.generate_error source_name
+      end
+      ret
+    end
+
+    attr_accessor :name
+    def inspect
+      # TODO move
+      @name ||= self.class.to_s[/\w+$/]
+      case self
+      when Lazy
+        "<#{name}>"
+      when Binary
+        "<#{name} #{left.inspect} #{right.inspect}>"
+      when Seq, Seq_, Branch
+        # don't use redefined map!
+        res = []
+        each{|e| res << e.inspect}
+        "<#{name} #{res.join ' '}>"
+      when Unary
+        "<#{name} #{some.inspect}>"
+      else
+        "<#{name}>"
+      end
+    end
+  end
+
+  # parsers with 2 params base
+  Binary = Struct.new :left, :right
+  class Binary 
+    include Parser
+  end
+
+  # parsers with 1 param base
+  Unary = Struct.new :some
+  class Unary
+    include Parser
+  end
+end
+
+require "rsec/parsers/misc"
+require "rsec/parsers/seq"
+require "rsec/parsers/prim"
+require "rsec/parsers/join"
+require "rsec/parsers/repeat"
+

data/lib/rsec/parsers/join.rb

@@ -0,0 +1,86 @@
+module Rsec
+  
+  # Join base
+  class Join < Binary
+    def _parse ctx
+      e = left._parse ctx
+      return INVALID if INVALID[e]
+      ret = [e]
+      loop do
+        save_point = ctx.pos
+        i = right._parse ctx
+        if INVALID[i]
+          ctx.pos = save_point
+          break
+        end
+
+        t = left._parse ctx
+        if INVALID[t]
+          ctx.pos = save_point
+          break
+        end
+
+        break if save_point == ctx.pos # stop if no advance, prevent infinite loop
+        ret << i
+        ret << t
+      end # loop
+      ret
+    end
+  end
+
+  # keep only tokens
+  class JoinEven < Binary
+    def _parse ctx
+      e = left._parse ctx
+      return INVALID if INVALID[e]
+      ret = [e]
+      loop do
+        save_point = ctx.pos
+        i = right._parse ctx
+        if INVALID[i]
+          ctx.pos = save_point
+          break
+        end
+
+        t = left._parse ctx
+        if INVALID[t]
+          ctx.pos = save_point
+          break
+        end
+
+        break if save_point == ctx.pos # stop if no advance, prevent infinite loop
+        ret << t
+      end # loop
+      ret
+    end
+  end
+
+  # keep only inters
+  # NOTE if only 1 token matches, return empty array
+  class JoinOdd < Binary
+    def _parse ctx
+      e = left._parse ctx
+      return INVALID if INVALID[e]
+      ret = []
+      loop do
+        save_point = ctx.pos
+        i = right._parse ctx
+        if INVALID[i]
+          ctx.pos = save_point
+          break
+        end
+
+        t = left._parse ctx
+        if INVALID[t]
+          ctx.pos = save_point
+          break
+        end
+
+        break if save_point == ctx.pos # stop if no advance, prevent infinite loop
+        ret << i
+      end # loop
+      ret
+    end
+  end
+
+end

data/lib/rsec/parsers/misc.rb

@@ -0,0 +1,201 @@
+module Rsec #:nodoc
+
+  # transform parse result
+  class Map < Binary
+    def _parse ctx
+      res = left()._parse ctx
+      return INVALID if INVALID[res]
+      right()[res]
+    end
+  end
+
+  # set expect tokens for parsing error in ctx<br/>
+  # if left failed, the error would be registered
+  class Fail < Binary
+    def Fail.[] left, tokens
+      # TODO mutex
+      @mask_bit ||= 0
+      @token_table ||= []
+      if @mask_bit > 1000
+        raise "You've created too many fail parsers, If it is your intention, call Rsec::Fail.reset when previous expect settings can be thrown away."
+      end
+      parser = super(left, (1<<@mask_bit))
+      @token_table[@mask_bit] = tokens
+      @mask_bit += 1
+      parser
+    end
+
+    def Fail.reset
+      @mask_bit = 0
+      @token_table = []
+    end
+
+    def Fail.get_tokens mask
+      res = []
+      @token_table.each_with_index do |tokens, idx|
+        next unless tokens
+        if (mask & (1<<idx)) > 0
+          res += tokens
+        end
+      end
+      res.uniq!
+      res
+    end
+
+    def _parse ctx
+      res = left()._parse ctx
+      ctx.on_fail right if INVALID[res]
+      res
+    end
+  end
+
+  # look ahead
+  class LookAhead < Binary
+    def _parse ctx
+      res = left()._parse ctx
+      pos = ctx.pos
+      return INVALID if INVALID[right()._parse ctx]
+      ctx.pos = pos
+      res
+    end
+  end
+
+  # negative look ahead
+  class NegativeLookAhead < Binary
+    def _parse ctx
+      res = left()._parse ctx
+      pos = ctx.pos
+      if INVALID[right()._parse ctx]
+        ctx.pos = pos
+        res
+      end
+    end
+  end
+
+  # branch combinator<br/>
+  # result in one of the members, or INVALID
+  class Branch < Unary
+    def _parse ctx
+      save_point = ctx.pos
+      some.each do |e|
+        res = e._parse ctx
+        return res unless INVALID[res]
+        ctx.pos = save_point
+      end
+      INVALID
+    end
+  end
+
+  # matches a pattern
+  class Pattern < Unary
+    def _parse ctx
+      ctx.scan some() or INVALID
+    end
+  end
+
+  # scan until the pattern<br/>
+  # for optimizing
+  class UntilPattern < Unary
+    def _parse ctx
+      ctx.scan_until some() or INVALID
+    end
+  end
+
+  # for optimization, not disposed to users
+  class SkipPattern < Unary
+    def _parse ctx
+      ctx.skip some() or INVALID
+    end
+  end
+
+  # for optimization, not disposed to users
+  class SkipUntilPattern < Unary
+    def _parse ctx
+      ctx.skip_until some() or INVALID
+    end
+  end
+
+  # should be end-of-file after parsing
+  class Eof < Unary
+    def _parse ctx
+      ret = some()._parse ctx
+      ctx.eos? ? ret : INVALID
+    end
+  end
+
+  # one of char in string
+  class OneOf < Unary
+    def _parse ctx
+      return INVALID if ctx.eos?
+      chr = ctx.getch
+      if some().index(chr)
+        chr
+      else
+        ctx.pos = ctx.pos - 1
+        INVALID
+      end
+    end
+  end
+
+  # one of char in string
+  class OneOf_ < Unary
+    def _parse ctx
+      ctx.skip /\s*/
+      return INVALID if ctx.eos?
+      chr = ctx.getch
+      unless some().index(chr)
+        return INVALID
+      end
+      ctx.skip /\s*/
+      chr
+    end
+  end
+
+  # sometimes a variable is not defined yet<br/>
+  # lazy is used to capture it later
+  # NOTE the value is captured the first time it is called
+  class Lazy < Unary
+    def _parse ctx
+      @some ||= \
+        begin
+          some()[]
+        rescue NameError => ex
+          some().binding.eval ex.name.to_s
+        end
+      @some._parse ctx
+    end
+  end
+  
+  # parse result is cached in ctx.
+  # may improve performance
+  class Cached
+    include Parser
+    
+    def self.[] parser
+      self.new parser
+    end
+    
+    def initialize parser
+      @parser = parser
+      @salt = object_id() << 32
+    end
+    
+    def _parse ctx
+      key = ctx.pos | @salt
+      cache = ctx.cache
+      # result maybe nil, so don't use ||=
+      if cache.has_key? key
+        ret, pos = cache[key]
+        ctx.pos = pos
+        ret
+      else
+        ret = @parser._parse ctx
+        pos = ctx.pos
+        cache[key] = [ret, pos]
+        ret
+      end
+    end
+  end
+
+end
+

data/lib/rsec/parsers/prim.rb

@@ -0,0 +1,102 @@
+module Rsec
+
+  # primitive base
+  module Prim
+    def sign_strategy_to_pattern sign_strategy
+      case sign_strategy
+      when 3; '[\+\-]?'
+      when 2; '\+?'
+      when 1; '\-?'
+      when 0; ''
+      end
+    end
+  end
+
+  # double precision float parser
+  class PDouble < Binary
+    include Prim
+
+    def float_pattern sign_strategy, is_hex
+      sign = sign_strategy_to_pattern sign_strategy
+      if is_hex
+        /#{sign}0x[\da-f]+(\.[\da-f]+)?/i
+      else
+        /#{sign}\d+(\.\d+)?(e[\+\-]?\d+)?/i
+      end
+    end
+
+    def initialize sign_strategy, is_hex
+      self.left = float_pattern sign_strategy, is_hex
+    end
+
+    def _parse ctx
+      if (d = ctx.scan left)
+        d = Float(d)
+        return d if d.finite?
+      end
+      INVALID
+    end
+  end
+
+  # primitive int parser commons
+  class PInt < Binary
+    include Prim
+
+    def int_pattern sign_strategy, base
+      sign = sign_strategy_to_pattern sign_strategy
+      if base > 10
+        d_hi = 9
+        char_range = "a-#{('a'.ord + base - 11).chr}"
+      else
+        d_hi = base - 1
+        char_range = ''
+      end
+      /#{sign}[0-#{d_hi}#{char_range}]+/i
+    end
+
+    def _parse ctx
+      if (d = ctx.scan left)
+        d = d.to_i @base
+        return d if right.include?(d)
+      end
+      INVALID
+    end
+  end
+
+  # 32-bit int parser
+  class PInt32 < PInt
+    def initialize sign_strategy, base
+      @base = base
+      self.left = int_pattern sign_strategy, base
+      self.right = (-(1<<31))..((1<<31)-1)
+    end
+  end
+
+  # unsigned 32 bit int parser
+  class PUnsignedInt32 < PInt
+    def initialize sign_strategy, base
+      @base = base
+      self.left = int_pattern sign_strategy, base
+      self.right = 0...(1<<32)
+    end
+  end
+
+  # 64-bit int parser
+  class PInt64 < PInt
+    def initialize sign_strategy, base
+      @base = base
+      self.left = int_pattern sign_strategy, base
+      self.right = (-(1<<63))..((1<<63)-1)
+    end
+  end
+
+  # unsigned 64-bit int parser
+  class PUnsignedInt64 < PInt
+    def initialize sign_strategy, base
+      @base = base
+      self.left = int_pattern sign_strategy, base
+      self.right = 0...(1<<64)
+    end
+  end
+
+end