Ticket #749: reproductible_regexp_crash.rb

str = <<EOT
class PrintProxy
  # instance_methods.each {
  #   |m| undef_method m unless m =~ /(^__|^send$|^object_id$)/
  # }
  
  def initialize(obj, &block)
    @obj = obj
  end

  protected

  def method_missing(symbol, *args, &block)
    print "foo"
    if @block then print "foo\n" else print "\n" end
    
    @obj.send(symbol, *args, &block)
  end
end
EOT

class StringScanner
  attr_reader :string, :pos

  def initialize(string, dup = false)
    @string = string
    @pos = 0
  end

  def eos?
    self.pos >= self.string.size
  end

  def rest
    string[pos..-1]
  end

  def skip_until(pattern)
    _scan(pattern, true, false, false)
  end

  def pos=(n)
    n = (n + string.size) if (n < 0)
    raise RangeError, "index out of range" if (n < 0 || (string && n > string.size))
    @pos = n
  end

  def matched?
    !@match.nil?
  end 

  def matched
    @match.to_s if matched?
  end

  def matched_size
    @match.to_s.size if matched?
  end

  def _scan(pattern, succptr, getstr, headonly)
    raise TypeError, "bad pattern argument: #{pattern.inspect}" unless
      String === pattern or Regexp === pattern or pattern.respond_to? :to_str
 
    @match = nil
    rest = self.rest
    
    return nil if rest.size < 0
  
    if headonly
      headonly_pattern = Regexp.new('^' + pattern.source, pattern.options)
      @match = headonly_pattern.match rest
    else
      @match = pattern.match rest
    end
 
    return nil unless @match
 
    m = rest[0, @match.end(0)]
 
    if succptr
      @prev_pos = pos
      self.pos += m.size
    end
    
    getstr ? m : m.size
  end
end

match = []
ss = StringScanner.new(str)

while ss.skip_until(/(class(?![^ \n])|def(?![^ \n]))/)
  a = ss.pos - ss.matched_size
  b = ss.matched_size

  warn "[#{a}, #{b}] = \"#{ss.matched}\""
  x = [a, b, ss.matched]
  match << x
end