~drizzle-trunk/drizzle/development

#define DRIZZLE_LEX 1

#include <drizzled/server_includes.h>

static unsigned char to_upper_lex[]=

inline int lex_casecmp(const char *s, const char *t, uint32_t len)

         to_upper_lex[(unsigned char) *s++] == to_upper_lex[(unsigned char) *t++]) ;

  uint32_t i;

    symbols[i].length=(unsigned char) strlen(symbols[i].name);

    sql_functions[i].length=(unsigned char) strlen(sql_functions[i].name);

  return;

  return;

  allows_variable= true;

  allows_select_into= true;

  allows_select_procedure= true;

  allows_derived= true;

  m_echo(true),

  assert(begin_ptr);

  assert(m_cpp_buf <= begin_ptr && begin_ptr <= m_cpp_buf + m_buf_length);

  uint32_t body_utf8_length=

  assert(m_cpp_buf <= ptr && ptr <= m_cpp_buf + m_buf_length);

  assert(m_cpp_buf <= end_ptr && end_ptr <= m_cpp_buf + m_buf_length);

                                                const CHARSET_INFO * const txt_cs,

  lex->subqueries= false;

  lex->escape_used= false;

  lex->reset_query_tables_list(false);

  lex->expr_allows_subselect= true;

  lex->use_only_table_context= false;

    I tried "memset" in the sql_yacc.yy code, but that for

  lex->is_lex_started= true;

  return;

    free(lex->yacc_yyss);

    free(lex->yacc_yyvs);

  delete lex->result;

  lex->result= 0;

 

  return;

static int find_keyword(Lex_input_stream *lip, uint32_t len, bool function)

bool is_keyword(const char *name, uint32_t len)

  assert(len != 0);

  assert(name != NULL);

static LEX_STRING get_token(Lex_input_stream *lip, uint32_t skip, uint32_t length)

                                   uint32_t skip,

                                   uint32_t length, char quote)

  register unsigned char c,sep;

  uint32_t found_escape=0;

  const CHARSET_INFO * const cs= lip->m_thd->charset();

      assert(end >= str);

          if (*str == '\\' && str+1 != end)

** Calc type of integer; long integer, int64_t integer or real.

** is done with int64_t or double.

static const uint32_t long_len=10;

static const char *int64_t_str="9223372036854775807";

static const uint32_t int64_t_len=19;

static const char *signed_int64_t_str="-9223372036854775808";

static const uint32_t signed_int64_t_len=19;

static const char *unsigned_int64_t_str="18446744073709551615";

static const uint32_t unsigned_int64_t_len=20;

static inline uint32_t int_token(const char *str,uint32_t length)

  uint32_t smaller,bigger;

    else if (length < signed_int64_t_len)

    else if (length > signed_int64_t_len)

      cmp=signed_int64_t_str+1;

      smaller=LONG_NUM;                         // If <= signed_int64_t_str

    else if (length < int64_t_len)

    else if (length > int64_t_len)

      if (length > unsigned_int64_t_len)

      cmp=unsigned_int64_t_str;

      cmp=int64_t_str;

  return ((unsigned char) str[-1] <= (unsigned char) cmp[-1]) ? smaller : bigger;

      Parsing 'WITH' 'ROLLUP' requires 2 look ups,

    if (token == ROLLUP_SYM)

    {

    }

    else

    {

  const CHARSET_INFO * const cs= thd->charset();

  unsigned char *state_map= cs->state_map;

  unsigned char *ident_map= cs->ident_map;

        const CHARSET_INFO * const cs= get_charset_by_csname(yylval->lex_str.str + 1,

                                                             MY_CS_PRIMARY, MYF(0));

      uint32_t double_quotes= 0;

        lip->set_echo(false);

          if (version <= DRIZZLE_VERSION_ID)

            lip->set_echo(true);

          lip->set_echo(true);

      comment_closed= false;

            comment_closed= true;

      lip->set_echo(true);

        lip->set_echo(true);

        if ((thd->client_capabilities & CLIENT_MULTI_STATEMENTS))

          lip->set_echo(true);

        lip->set_echo(false);

        lip->set_echo(true);

void trim_whitespace(const CHARSET_INFO * const cs, LEX_STRING *str)

  having= where= 0;

  exclude_from_table_unique_test= false;

  order_list.next= (unsigned char**) &order_list.first;

    s->is_correlated= true;

      subquery_predicate->is_correlated= true;

bool st_select_lex_node::set_braces(bool value __attribute__((unused)))

{ return 1; }

uint32_t st_select_lex_node::get_in_sum_expr()           { return 0; }

TableList* st_select_lex_node::get_table_list()     { return 0; }

TableList *st_select_lex_node::add_table_to_list (THD *thd __attribute__((unused)),

                                                   Table_ident *table __attribute__((unused)),

                                                  LEX_STRING *alias __attribute__((unused)),

                                                  uint32_t table_join_options __attribute__((unused)),

                                                  thr_lock_type flags __attribute__((unused)),

                                                  List<Index_hint> *hints __attribute__((unused)),

                                                  LEX_STRING *option __attribute__((unused)))