lex_input_stream.h

/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 *
 *  Copyright (C) 2008 Sun Microsystems, Inc.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; version 2 of the License.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#pragma once

namespace drizzled {

class Lex_input_stream
{
public:
  Lex_input_stream(Session *session, const char* buff, unsigned int length);

  void set_echo(bool echo)
  {
    m_echo= echo;
  }

  void skip_binary(int n)
  {
    if (m_echo)
    {
      memcpy(m_cpp_ptr, m_ptr, n);
      m_cpp_ptr += n;
    }
    m_ptr += n;
  }

  char yyGet()
  {
    char c= *m_ptr++;
    if (m_echo)
      *m_cpp_ptr++ = c;
    return c;
  }

  char yyGetLast() const
  {
    return m_ptr[-1];
  }

  char yyPeek() const
  {
    return m_ptr[0];
  }

  char yyPeekn(int n) const
  {
    return m_ptr[n];
  }

  void yyUnget()
  {
    m_ptr--;
    if (m_echo)
      m_cpp_ptr--;
  }

  void yySkip()
  {
    if (m_echo)
      *m_cpp_ptr++ = *m_ptr++;
    else
      m_ptr++;
  }

  void yySkipn(int n)
  {
    if (m_echo)
    {
      memcpy(m_cpp_ptr, m_ptr, n);
      m_cpp_ptr += n;
    }
    m_ptr += n;
  }

  bool eof() const
  {
    return m_ptr >= m_end_of_query;
  }

  bool eof(int n) const
  {
    return m_ptr + n >= m_end_of_query;
  }

  const char *get_buf() const
  {
    return m_buf;
  }

  const char *get_cpp_buf() const
  {
    return m_cpp_buf;
  }

  const char *get_end_of_query() const
  {
    return m_end_of_query;
  }

  void start_token()
  {
    m_tok_start_prev= m_tok_start;
    m_tok_start= m_ptr;
    m_tok_end= m_ptr;

    m_cpp_tok_start_prev= m_cpp_tok_start;
    m_cpp_tok_start= m_cpp_ptr;
    m_cpp_tok_end= m_cpp_ptr;
  }

  void restart_token()
  {
    m_tok_start= m_ptr;
    m_cpp_tok_start= m_cpp_ptr;
  }

  const char *get_tok_start() const
  {
    return m_tok_start;
  }

  const char *get_cpp_tok_start() const
  {
    return m_cpp_tok_start;
  }

  const char *get_tok_end() const
  {
    return m_tok_end;
  }

  const char *get_cpp_tok_end() const
  {
    return m_cpp_tok_end;
  }

  const char *get_tok_start_prev() const
  {
    return m_tok_start_prev;
  }

  const char *get_ptr() const
  {
    return m_ptr;
  }

  const char *get_cpp_ptr() const
  {
    return m_cpp_ptr;
  }

  uint32_t yyLength() const
  {
    /*
      The assumption is that the lexical analyser is always 1 character ahead,
      which the -1 account for.
    */
    assert(m_ptr > m_tok_start);
    return (uint32_t) ((m_ptr - m_tok_start) - 1);
  }

  const char *get_body_utf8_str() const
  {
    return m_body_utf8;
  }

  uint32_t get_body_utf8_length() const
  {
    return m_body_utf8_ptr - m_body_utf8;
  }

  void body_utf8_append(const char *ptr);
  void body_utf8_append(const char *ptr, const char *end_ptr);
  void body_utf8_append_literal(str_ref, const char *end_ptr);

  Session *m_session;

  uint32_t yylineno;

  uint32_t yytoklen;

  LEX_YYSTYPE yylval;

  int lookahead_token;

  LEX_YYSTYPE lookahead_yylval;

private:
  const char *m_ptr;

  const char *m_tok_start;

  const char *m_tok_end;

  const char *m_end_of_query;

  const char *m_tok_start_prev;

  const char *m_buf;

  uint32_t m_buf_length;

  bool m_echo;

  char *m_cpp_buf;

  char *m_cpp_ptr;

  const char *m_cpp_tok_start;

  const char *m_cpp_tok_start_prev;

  const char *m_cpp_tok_end;

  char *m_body_utf8;

  char *m_body_utf8_ptr;

  const char *m_cpp_utf8_processed_ptr;

public:

  enum my_lex_states next_state;

  unsigned char tok_bitmap;

  bool ignore_space;

  enum_comment_state in_comment;

  const char *m_cpp_text_start;

  const char *m_cpp_text_end;

};

} /* namespace drizzled */