class Parser::Base

def self.default_parser
  parser = new
  parser.diagnostics.all_errors_are_fatal = true
  parser.diagnostics.ignore_warnings      = true
  parser.diagnostics.consumer = lambda do |diagnostic|
    $stderr.puts(diagnostic.render)
  end
  parser
end

def self.parse(string, file='(string)', line=1)
  parser = default_parser
  source_buffer = setup_source_buffer(file, line, string, parser.default_encoding)
  parser.parse(source_buffer)
end

def self.parse_file(filename)
  parse(File.read(filename), filename)
end

def self.parse_file_with_comments(filename)
  parse_with_comments(File.read(filename), filename)
end

def self.parse_with_comments(string, file='(string)', line=1)
  parser = default_parser
  source_buffer = setup_source_buffer(file, line, string, parser.default_encoding)
  parser.parse_with_comments(source_buffer)
end

def self.setup_source_buffer(file, line, string, encoding)
  string = string.dup.force_encoding(encoding)
  source_buffer = Source::Buffer.new(file, line)
  if name == 'Parser::Ruby18'
    source_buffer.raw_source = string
  else
    source_buffer.source     = string
  end
  source_buffer
end

def check_kwarg_name(name_t)
  case name_t[0]
  when /^[a-z_]/
    # OK
  when /^[A-Z]/
    diagnostic :error, :argument_const, nil, name_t
  end
end

def diagnostic(level, reason, arguments, location_t, highlights_ts=[])
  _, location = location_t
  highlights = highlights_ts.map do |token|
    _, range = token
    range
  end
  @diagnostics.process(
      Diagnostic.new(level, reason, arguments, location, highlights))
  if level == :error
    yyerror
  end
end

def initialize(builder=Parser::Builders::Default.new)
  @diagnostics = Diagnostic::Engine.new
  @static_env  = StaticEnvironment.new
  # Stack that holds current parsing context
  @context = Context.new
  # Maximum numbered parameters stack
  @max_numparam_stack = MaxNumparamStack.new
  # Current argument names stack
  @current_arg_stack = CurrentArgStack.new
  # Stack of set of variables used in the current pattern
  @pattern_variables = VariablesStack.new
  # Stack of set of keys used in the current hash in pattern matchinig
  @pattern_hash_keys = VariablesStack.new
  @lexer = Lexer.new(version)
  @lexer.diagnostics = @diagnostics
  @lexer.static_env  = @static_env
  @lexer.context     = @context
  @builder = builder
  @builder.parser = self
  # Last emitted token
  @last_token = nil
  if self.class::Racc_debug_parser && ENV['RACC_DEBUG']
    @yydebug = true
  end
  reset
end

def next_token
  token = @lexer.advance
  @last_token = token
  token
end

def on_error(error_token_id, error_value, value_stack)
  token_name = token_to_str(error_token_id)
  _, location = error_value
  @diagnostics.process(Diagnostic.new(
      :error, :unexpected_token, { :token => token_name }, location))
end

def parse(source_buffer)
  @lexer.source_buffer = source_buffer
  @source_buffer       = source_buffer
  do_parse || nil # Force `false` to `nil`, see https://github.com/ruby/racc/pull/136
ensure
  # Don't keep references to the source file.
  @source_buffer       = nil
  @lexer.source_buffer = nil
end

def parse_with_comments(source_buffer)
  @lexer.comments = []
  [ parse(source_buffer), @lexer.comments ]
ensure
  @lexer.comments = nil
end

def reset
  @source_buffer = nil
  @lexer.reset
  @static_env.reset
  @context.reset
  @current_arg_stack.reset
  @pattern_variables.reset
  @pattern_hash_keys.reset
  self
end

def tokenize(source_buffer, recover=false)
  @lexer.tokens = []
  @lexer.comments = []
  begin
    ast = parse(source_buffer)
  rescue Parser::SyntaxError
    raise if !recover
  end
  [ ast, @lexer.comments, @lexer.tokens ]
ensure
  @lexer.tokens = nil
  @lexer.comments = nil
end