# frozen_string_literal: true
# encoding: UTF-8
#--
# This file is automatically generated. Do not modify it.
# Generated by: oedipus_lex version 2.6.0.
# Source: lib/synvert/core/node_query/lexer.rex
#++


##
# The generated lexer Synvert::Core::NodeQuery::Lexer

class Synvert::Core::NodeQuery::Lexer
  require 'strscan'

  # :stopdoc:
  OPEN_ATTRIBUTE          = /\[/
  CLOSE_ATTRIBUTE         = /\]/
  OPEN_ARRAY              = /\(/
  CLOSE_ARRAY             = /\)/
  OPEN_SELECTOR           = /\(/
  CLOSE_SELECTOR          = /\)/
  OPEN_DYNAMIC_ATTRIBUTE  = /{{/
  CLOSE_DYNAMIC_ATTRIBUTE = /}}/
  NODE_TYPE               = /\.[a-z]+/
  IDENTIFIER              = /[\.\w]+/
  IDENTIFIER_VALUE        = /[\.\w!&:\?<>=]+/
  FALSE                   = /false/
  FLOAT                   = /\d+\.\d+/
  INTEGER                 = /\d+/
  NIL                     = /nil/
  REGEXP_BODY             = /(?:[^\/]|\\\/)*/
  REGEXP                  = /\/(#{REGEXP_BODY})(?<!\\)\/([imxo]*)/
  SYMBOL                  = /:[\w!\?<>=]+/
  TRUE                    = /true/
  SINGLE_QUOTE_STRING     = /'.*?'/
  DOUBLE_QUOTE_STRING     = /".*?"/
  # :startdoc:
  # :stopdoc:
  class LexerError < StandardError ; end
  class ScanError < LexerError ; end
  # :startdoc:

  ##
  # The file name / path

  attr_accessor :filename

  ##
  # The StringScanner for this lexer.

  attr_accessor :ss

  ##
  # The current lexical state.

  attr_accessor :state

  alias :match :ss

  ##
  # The match groups for the current scan.

  def matches
    m = (1..9).map { |i| ss[i] }
    m.pop until m[-1] or m.empty?
    m
  end

  ##
  # Yields on the current action.

  def action
    yield
  end


  ##
  # The current scanner class. Must be overridden in subclasses.

  def scanner_class
    StringScanner
  end unless instance_methods(false).map(&:to_s).include?("scanner_class")

  ##
  # Parse the given string.

  def parse str
    self.ss     = scanner_class.new str
    self.state  ||= nil

    do_parse
  end

  ##
  # Read in and parse the file at +path+.

  def parse_file path
    self.filename = path
    open path do |f|
      parse f.read
    end
  end

  ##
  # The current location in the parse.

  def location
    [
      (filename || "<input>"),
    ].compact.join(":")
  end

  ##
  # Lex the next token.

  def next_token

    token = nil

    until ss.eos? or token do
      token =
        case state
        when nil then
          case
          when ss.skip(/\s+/) then
            # do nothing
          when text = ss.scan(/:has/) then
            action { [:tPSEUDO_CLASS, text[1..-1]] }
          when text = ss.scan(/:not_has/) then
            action { [:tPSEUDO_CLASS, text[1..-1]] }
          when text = ss.scan(/#{NODE_TYPE}/) then
            action { [:tNODE_TYPE, text[1..]] }
          when text = ss.scan(/#{IDENTIFIER}/) then
            action { [:tGOTO_SCOPE, text] }
          when text = ss.scan(/>/) then
            action { [:tRELATIONSHIP, text] }
          when text = ss.scan(/~/) then
            action { [:tRELATIONSHIP, text] }
          when text = ss.scan(/\+/) then
            action { [:tRELATIONSHIP, text] }
          when text = ss.scan(/#{OPEN_SELECTOR}/) then
            action { [:tOPEN_SELECTOR, text] }
          when text = ss.scan(/#{CLOSE_SELECTOR}/) then
            action { [:tCLOSE_SELECTOR, text] }
          when text = ss.scan(/#{OPEN_ATTRIBUTE}/) then
            action { @nested_count += 1; @state = :KEY; [:tOPEN_ATTRIBUTE, text] }
          else
            text = ss.string[ss.pos .. -1]
            raise ScanError, "can not match (#{state.inspect}) at #{location}: '#{text}'"
          end
        when :KEY then
          case
          when ss.skip(/\s+/) then
            # do nothing
          when ss.skip(/\^=/) then
            action { @state = :VALUE; [:tOPERATOR, '^='] }
          when ss.skip(/\$=/) then
            action { @state = :VALUE; [:tOPERATOR, '$='] }
          when ss.skip(/\*=/) then
            action { @state = :VALUE; [:tOPERATOR, '*='] }
          when ss.skip(/!=/) then
            action { @state = :VALUE; [:tOPERATOR, '!='] }
          when ss.skip(/=~/) then
            action { @state = :VALUE; [:tOPERATOR, '=~'] }
          when ss.skip(/!~/) then
            action { @state = :VALUE; [:tOPERATOR, '!~'] }
          when ss.skip(/>=/) then
            action { @state = :VALUE; [:tOPERATOR, '>='] }
          when ss.skip(/<=/) then
            action { @state = :VALUE; [:tOPERATOR, '<='] }
          when ss.skip(/>/) then
            action { @state = :VALUE; [:tOPERATOR, '>'] }
          when ss.skip(/</) then
            action { @state = :VALUE; [:tOPERATOR, '<'] }
          when ss.skip(/=/) then
            action { @state = :VALUE; [:tOPERATOR, '=='] }
          when ss.skip(/includes/i) then
            action { @state = :VALUE; [:tOPERATOR, 'includes'] }
          when ss.skip(/not in/i) then
            action { @state = :VALUE; [:tOPERATOR, 'not_in'] }
          when ss.skip(/in/i) then
            action { @state = :VALUE; [:tOPERATOR, 'in'] }
          when text = ss.scan(/#{IDENTIFIER}/) then
            action { [:tKEY, text] }
          else
            text = ss.string[ss.pos .. -1]
            raise ScanError, "can not match (#{state.inspect}) at #{location}: '#{text}'"
          end
        when :VALUE then
          case
          when ss.skip(/\s+/) then
            # do nothing
          when text = ss.scan(/\[\]=/) then
            action { [:tIDENTIFIER_VALUE, text] }
          when text = ss.scan(/\[\]/) then
            action { [:tIDENTIFIER_VALUE, text] }
          when text = ss.scan(/:\[\]=/) then
            action { [:tSYMBOL, text[1..-1].to_sym] }
          when text = ss.scan(/:\[\]/) then
            action { [:tSYMBOL, text[1..-1].to_sym] }
          when text = ss.scan(/#{OPEN_DYNAMIC_ATTRIBUTE}/) then
            action { @state = :DYNAMIC_ATTRIBUTE; [:tOPEN_DYNAMIC_ATTRIBUTE, text] }
          when text = ss.scan(/#{OPEN_ARRAY}/) then
            action { @state = :ARRAY_VALUE; [:tOPEN_ARRAY, text] }
          when text = ss.scan(/#{CLOSE_ATTRIBUTE}/) then
            action { @nested_count -= 1; @state = @nested_count == 0 ? nil : :VALUE; [:tCLOSE_ATTRIBUTE, text] }
          when text = ss.scan(/#{NIL}\?/) then
            action { [:tIDENTIFIER_VALUE, text] }
          when ss.skip(/#{NIL}/) then
            action { [:tNIL, nil] }
          when ss.skip(/#{TRUE}/) then
            action { [:tBOOLEAN, true] }
          when ss.skip(/#{FALSE}/) then
            action { [:tBOOLEAN, false] }
          when text = ss.scan(/#{SYMBOL}/) then
            action { [:tSYMBOL, text[1..-1].to_sym] }
          when text = ss.scan(/#{FLOAT}/) then
            action { [:tFLOAT, text.to_f] }
          when text = ss.scan(/#{INTEGER}/) then
            action { [:tINTEGER, text.to_i] }
          when text = ss.scan(/#{REGEXP}/) then
            action { [:tREGEXP, eval(text)] }
          when text = ss.scan(/#{DOUBLE_QUOTE_STRING}/) then
            action { [:tSTRING, text[1...-1]] }
          when text = ss.scan(/#{SINGLE_QUOTE_STRING}/) then
            action { [:tSTRING, text[1...-1]] }
          when text = ss.scan(/#{NODE_TYPE}/) then
            action { [:tNODE_TYPE, text[1..]] }
          when text = ss.scan(/#{OPEN_ATTRIBUTE}/) then
            action { @nested_count += 1; @state = :KEY; [:tOPEN_ATTRIBUTE, text] }
          when text = ss.scan(/#{IDENTIFIER_VALUE}/) then
            action { [:tIDENTIFIER_VALUE, text] }
          else
            text = ss.string[ss.pos .. -1]
            raise ScanError, "can not match (#{state.inspect}) at #{location}: '#{text}'"
          end
        when :DYNAMIC_ATTRIBUTE then
          case
          when text = ss.scan(/#{CLOSE_DYNAMIC_ATTRIBUTE}/) then
            action { @state = :VALUE; [:tCLOSE_DYNAMIC_ATTRIBUTE, text] }
          when text = ss.scan(/#{IDENTIFIER}/) then
            action { [:tDYNAMIC_ATTRIBUTE, text] }
          else
            text = ss.string[ss.pos .. -1]
            raise ScanError, "can not match (#{state.inspect}) at #{location}: '#{text}'"
          end
        when :ARRAY_VALUE then
          case
          when ss.skip(/\s+/) then
            # do nothing
          when text = ss.scan(/#{CLOSE_ARRAY}/) then
            action { @state = :VALUE; [:tCLOSE_ARRAY, text] }
          when text = ss.scan(/#{NIL}\?/) then
            action { [:tIDENTIFIER_VALUE, text] }
          when ss.skip(/#{NIL}/) then
            action { [:tNIL, nil] }
          when ss.skip(/#{TRUE}/) then
            action { [:tBOOLEAN, true] }
          when ss.skip(/#{FALSE}/) then
            action { [:tBOOLEAN, false] }
          when text = ss.scan(/#{SYMBOL}/) then
            action { [:tSYMBOL, text[1..-1].to_sym] }
          when text = ss.scan(/#{FLOAT}/) then
            action { [:tFLOAT, text.to_f] }
          when text = ss.scan(/#{INTEGER}/) then
            action { [:tINTEGER, text.to_i] }
          when text = ss.scan(/#{REGEXP}/) then
            action { [:tREGEXP, eval(text)] }
          when text = ss.scan(/#{DOUBLE_QUOTE_STRING}/) then
            action { [:tSTRING, text[1...-1]] }
          when text = ss.scan(/#{SINGLE_QUOTE_STRING}/) then
            action { [:tSTRING, text[1...-1]] }
          when text = ss.scan(/#{IDENTIFIER_VALUE}/) then
            action { [:tIDENTIFIER_VALUE, text] }
          else
            text = ss.string[ss.pos .. -1]
            raise ScanError, "can not match (#{state.inspect}) at #{location}: '#{text}'"
          end
        else
          raise ScanError, "undefined state at #{location}: '#{state}'"
        end # token = case state

      next unless token # allow functions to trigger redo w/ nil
    end # while

    raise LexerError, "bad lexical result at #{location}: #{token.inspect}" unless
      token.nil? || (Array === token && token.size >= 2)

    # auto-switch state
    self.state = token.last if token && token.first == :state

    token
  end # def next_token
    def initialize
      @nested_count = 0
    end
    def do_parse; end
end # class