class Regexp::Expression::Base

def ascii_classes?
  (@options and @options[:a]) ? true : false
end

def case_insensitive?
  (@options and @options[:i]) ? true : false
end

def clone
  copy = self.dup
  copy.text       = (self.text        ? self.text.dup         : nil)
  copy.options    = (self.options     ? self.options.dup      : nil)
  copy.quantifier = (self.quantifier  ? self.quantifier.clone : nil)
  copy
end

def coded_offset
  '@%d+%d' % offset
end

def default_classes?
  (@options and @options[:d]) ? true : false
end

def free_spacing?
  (@options and @options[:x]) ? true : false
end

def full_length
  to_s.length
end

def greedy?
  quantified? and @quantifier.mode == :greedy
end

def initialize(token)
  @type               = token.type
  @token              = token.token
  @text               = token.text
  @ts                 = token.ts
  @level              = token.level
  @set_level          = token.set_level
  @conditional_level  = token.conditional_level
  @quantifier         = nil
  @options            = nil
end

def is?(test_token, test_type = nil)
  return true if test_token === :*
  token == test_token and (test_type ? type?(test_type) : true)
end

def match(string, offset)
  Regexp.new(to_s).match(string, offset)
end

def matches?(string)
  Regexp.new(to_s) =~ string ? true : false
end

def multiline?
  (@options and @options[:m]) ? true : false
end

def offset
  [starts_at, full_length]
end

def one_of?(scope, top = true)
  case scope
  when Array
    if scope.include?(:*)
      return (scope.include?(token) or scope.include?(:*))
    else
      return scope.include?(token)
    end
  when Hash
    if scope.has_key?(:*)
      test_type = scope.has_key?(type) ? type : :*
      return one_of?(scope[test_type], false)
    else
      return (scope.has_key?(type) and one_of?(scope[type], false))
    end
  when Symbol
    return true if scope == :*
    return is?(scope) unless top
    return type?(scope) if top
  else
    raise "Array, Hash, or Symbol expected, #{scope.class.name} given"
  end
  false
end

def possessive?
  quantified? and @quantifier.mode == :possessive
end

def quantified?
  not @quantifier.nil?
end

def quantify(token, text, min = nil, max = nil, mode = :greedy)
  @quantifier = Quantifier.new(token, text, min, max, mode)
end

def quantity
  return [nil,nil] unless quantified?
  [@quantifier.min, @quantifier.max]
end

def reluctant?
  quantified? and @quantifier.mode == :reluctant
end

def starts_at
  @ts
end

def strfregexp(format = '%a', indent_offset = 0, index = nil)
  have_index    = index ? true : false
  part = {}
  # Order is important! Fields that use other fields in their
  # definition must appear before the fields they use.
  part_keys = %w{a m b o i l x s e S y k c q Q z Z t ~t T >}
  part.keys.each {|k| part[k] = "<?#{k}?>"}
  part['>'] = level ? ('  ' * (level + indent_offset)) : ''
  part['l'] = level ? "#{'%d' % level}" : 'root'
  part['x'] = "#{'%d' % index}" if have_index
  part['s'] = starts_at
  part['S'] = full_length
  part['e'] = starts_at + full_length
  part['o'] = coded_offset
  part['k'] = token
  part['y'] = type
  part['i'] = '%y:%k'
  part['c'] = self.class.name
  if quantified?
    if quantifier.max == -1
      part['q'] = "{#{quantifier.min}, or-more}"
    else
      part['q'] = "{#{quantifier.min}, #{quantifier.max}}"
    end
    part['Q'] = quantifier.text
    part['z'] = quantifier.min
    part['Z'] = quantifier.max
  else
    part['q'] = '{1}'
    part['Q'] = ''
    part['z'] = '1'
    part['Z'] = '1'
  end
  part['t'] = to_s(:base)
  part['~t'] = terminal? ? to_s : "#{type}:#{token}"
  part['T'] = to_s(:full)
  part['b'] = '%o %i'
  part['m'] = '%b %q'
  part['a'] = '%m %t'
  out = format.dup
  part_keys.each do |k|
    out.gsub!(/%#{k}/, part[k].to_s)
  end
  out
end

def terminal?
  !respond_to?(:expressions)
end

def to_h
  {
    :type               => @type,
    :token              => @token,
    :text               => to_s(:base),
    :starts_at          => @ts,
    :length             => full_length,
    :level              => @level,
    :set_level          => @set_level,
    :conditional_level  => @conditional_level,
    :options            => @options,
    :quantifier         => quantified? ? @quantifier.to_h : nil
  }
end

def to_re(format = :full)
  ::Regexp.new(to_s(format))
end

def to_s(format = :full)
  s = ''
  case format
  when :base
    s << @text.dup
  else
    s << @text.dup
    s << @quantifier if quantified?
  end
  s
end

def type?(test_type)
  case test_type
  when Array
    if test_type.include?(:*)
      return (test_type.include?(type) or test_type.include?(:*))
    else
      return test_type.include?(type)
    end
  when Symbol
    return (type == test_type or test_type == :*)
  else
    raise "Array or Symbol expected, #{test_type.class.name} given"
  end
end

def unicode_classes?
  (@options and @options[:u]) ? true : false
end