Skip navigation links

 Systems for MySQL

The world's most popular open source database

Contact a MySQL Representative

Login | Register

• MySQL.com
• Developer Zone
• Partners & Solutions
• Customer Login

• DevZone
• Downloads
• Documentation
• Articles
• Forums
• Bugs
• Forge
• Blogs

 

---

Learn about new MySQL releases, technical articles, events and more.

Subscribe Now »

mysql/src/5.1-dbg/sql/gen_lex_hash.cc File Reference

#include "my_global.h"
#include "my_sys.h"
#include "m_string.h"
#include <my_getopt.h>
#include "mysql_version.h"
#include "lex.h"

Include dependency graph for gen_lex_hash.cc:

Go to the source code of this file.

Classes
struct	hash_lex_struct
Defines
#define	NO_YACC_SYMBOLS
#define	__GNU_LIBRARY__
Functions
hash_lex_struct *	get_hash_struct_by_len (hash_lex_struct **root_by_len, int len, int *max_len)
void	insert_into_hash (hash_lex_struct *root, const char *name, int len_from_begin, int index, int function)
void	insert_symbols ()
void	insert_sql_functions ()
void	calc_length ()
void	generate_find_structs ()
void	add_struct_to_map (hash_lex_struct *st)
void	add_structs_to_map (hash_lex_struct *st, int len)
void	set_links (hash_lex_struct *st, int len)
void	print_hash_map (const char *name)
void	print_find_structs ()
static void	usage (int version)
my_bool	get_one_option (int optid, const struct my_option *opt __attribute__((unused)), char *argument __attribute__((unused)))
static int	get_options (int argc, char **argv)
int	check_dup_symbols (SYMBOL *s1, SYMBOL *s2)
int	check_duplicates ()
int	main (int argc, char **argv)
Variables
const char *	default_dbug_option = "d:t:o,/tmp/gen_lex_hash.trace"
my_option	my_long_options []
hash_lex_struct *	root_by_len = 0
int	max_len = 0
hash_lex_struct *	root_by_len2 = 0
int	max_len2 = 0
char *	hash_map = 0
int	size_hash_map = 0

---

Define Documentation

#define __GNU_LIBRARY__

Definition at line 80 of file gen_lex_hash.cc.

#define NO_YACC_SYMBOLS

Definition at line 75 of file gen_lex_hash.cc.

---

Function Documentation

void add_struct_to_map

(

hash_lex_struct *

st

)

Definition at line 248 of file gen_lex_hash.cc.

References array_elements, hash_lex_struct::first_char, hash_map, int(), hash_lex_struct::iresult, hash_lex_struct::ithis, hash_lex_struct::last_char, realloc, size_hash_map, and symbols.

Referenced by add_structs_to_map().

{
  st->ithis= size_hash_map/4;
  size_hash_map+= 4;
  hash_map= (char*)realloc((char*)hash_map,size_hash_map);
  hash_map[size_hash_map-4]= (char) (st->first_char == -1 ? 0 :
                                     st->first_char);
  hash_map[size_hash_map-3]= (char) (st->first_char == -1 ||
                                     st->first_char == 0 ? 0 : st->last_char);
  if (st->first_char == -1)
  {
    hash_map[size_hash_map-2]= ((unsigned int)(int16)st->iresult)&255;
    hash_map[size_hash_map-1]= ((unsigned int)(int16)st->iresult)>>8;
  }
  else if (st->first_char == 0)
  {
    hash_map[size_hash_map-2]= ((unsigned int)(int16)array_elements(symbols))&255;
    hash_map[size_hash_map-1]= ((unsigned int)(int16)array_elements(symbols))>>8;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void add_structs_to_map	(	hash_lex_struct *	st,
		int	len
	)

Definition at line 270 of file gen_lex_hash.cc.

References add_struct_to_map(), hash_lex_struct::char_tails, hash_lex_struct::first_char, and hash_lex_struct::last_char.

Referenced by print_find_structs().

{
  hash_lex_struct *cur, *end= st+len;
  for (cur= st; cur<end; cur++)
    add_struct_to_map(cur);
  for (cur= st; cur<end; cur++)
  {
    if (cur->first_char && cur->first_char != -1)
      add_structs_to_map(cur->char_tails,cur->last_char-cur->first_char+1);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void calc_length

(

)

Definition at line 218 of file gen_lex_hash.cc.

References array_elements, st_symbol::length, st_symbol::name, sql_functions, strlen(), and symbols.

Referenced by main().

{
  SYMBOL *cur, *end= symbols + array_elements(symbols);
  for (cur= symbols; cur < end; cur++)
    cur->length=(uchar) strlen(cur->name);
  end= sql_functions + array_elements(sql_functions);
  for (cur= sql_functions; cur<end; cur++)
    cur->length=(uchar) strlen(cur->name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int check_dup_symbols	(	SYMBOL *	s1,
		SYMBOL *	s2
	)

Definition at line 389 of file gen_lex_hash.cc.

References st_symbol::length, and st_symbol::name.

Referenced by check_duplicates().

{
  if (s1->length!=s2->length || strncmp(s1->name,s2->name,s1->length))
    return 0;

  const char *err_tmpl= "\ngen_lex_hash fatal error : \
Unfortunately gen_lex_hash can not generate a hash,\n since \
your lex.h has duplicate definition for a symbol \"%s\"\n\n";
  printf (err_tmpl,s1->name);
  fprintf (stderr,err_tmpl,s1->name);

  return 1;
}

Here is the caller graph for this function:

int check_duplicates

(

)

Definition at line 404 of file gen_lex_hash.cc.

References array_elements, check_dup_symbols(), sql_functions, and symbols.

Referenced by main().

{
  SYMBOL *cur1, *cur2, *s_end, *f_end;

  s_end= symbols + array_elements(symbols);
  f_end= sql_functions + array_elements(sql_functions);

  for (cur1= symbols; cur1<s_end; cur1++)
  {
    for (cur2= cur1+1; cur2<s_end; cur2++)
    {
      if (check_dup_symbols(cur1,cur2))
        return 1;
    }
    for (cur2= sql_functions; cur2<f_end; cur2++)
    {
      if (check_dup_symbols(cur1,cur2))
        return 1;
    }
  }

  for (cur1= sql_functions; cur1<f_end; cur1++)
  {
    for (cur2= cur1+1; cur2< f_end; cur2++)
    {
      if (check_dup_symbols(cur1,cur2))
        return 1;
    }
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void generate_find_structs

(

)

Definition at line 228 of file gen_lex_hash.cc.

References insert_sql_functions(), insert_symbols(), max_len, max_len2, root_by_len, and root_by_len2.

Referenced by main().

{
  root_by_len= 0;
  max_len=0;

  insert_symbols();

  root_by_len2= root_by_len;
  max_len2= max_len;

  root_by_len= 0;
  max_len= 0;

  insert_symbols();
  insert_sql_functions();
}

Here is the call graph for this function:

Here is the caller graph for this function:

hash_lex_struct* get_hash_struct_by_len	(	hash_lex_struct **	root_by_len,
		int	len,
		int *	max_len
	)

Definition at line 115 of file gen_lex_hash.cc.

References hash_lex_struct::first_char, realloc, and root_by_len.

Referenced by insert_sql_functions(), and insert_symbols().

{
  if (*max_len<len){
    *root_by_len= (hash_lex_struct *)realloc((char*)*root_by_len,
                                             sizeof(hash_lex_struct)*len);
    hash_lex_struct *cur, *end= *root_by_len + len;
    for (cur= *root_by_len + *max_len; cur<end; cur++)
      cur->first_char= 0;
    *max_len= len;
  }
  return (*root_by_len)+(len-1);
}

Here is the caller graph for this function:

my_bool get_one_option	(	int	optid,
		const struct my_option *opt	__attribute__((unused)),
		char *argument	__attribute__((unused))
	)

Definition at line 354 of file gen_lex_hash.cc.

References DBUG_PUSH, default_dbug_option, exit, and usage().

{
  switch(optid) {
  case 'V':
    usage(1);
    exit(0);
  case 'I':
  case '?':
    usage(0);
    exit(0);
  case '#':
    DBUG_PUSH(argument ? argument : default_dbug_option);
    break;
  }
  return 0;
}

Here is the call graph for this function:

static int get_options	(	int	argc,
		char **	argv
	)			[static]

Definition at line 373 of file gen_lex_hash.cc.

References exit, get_one_option(), handle_options(), my_long_options, and usage().

{
  int ho_error;

  if ((ho_error= handle_options(&argc, &argv, my_long_options, get_one_option)))
    exit(ho_error);

  if (argc >= 1)
  {
    usage(0);
     exit(1);
  }
  return(0);
}

Here is the call graph for this function:

void insert_into_hash	(	hash_lex_struct *	root,
		const char *	name,
		int	len_from_begin,
		int	index,
		int	function
	)

Definition at line 129 of file gen_lex_hash.cc.

References hash_lex_struct::char_tails, hash_lex_struct::first_char, int(), hash_lex_struct::iresult, hash_lex_struct::last_char, malloc, memmove, realloc, sql_functions, and symbols.

Referenced by insert_sql_functions(), and insert_symbols().

{
  hash_lex_struct *end, *cur, *tails;

  if (!root->first_char)
  {
    root->first_char= -1;
    root->iresult= index;
    return;
  }

  if (root->first_char == -1)
  {
    int index2= root->iresult;
    const char *name2= (index2 < 0 ? sql_functions[-index2-1] :
                        symbols[index2]).name + len_from_begin;
    root->first_char= (int) (uchar) name2[0];
    root->last_char= (char) root->first_char;
    tails= (hash_lex_struct*)malloc(sizeof(hash_lex_struct));
    root->char_tails= tails;
    tails->first_char= -1;
    tails->iresult= index2;
  }

  size_t real_size= (root->last_char-root->first_char+1);

  if (root->first_char>(*name))
  {
    size_t new_size= root->last_char-(*name)+1;
    if (new_size<real_size) printf("error!!!!\n");
    tails= root->char_tails;
    tails= (hash_lex_struct*)realloc((char*)tails,
                                       sizeof(hash_lex_struct)*new_size);
    root->char_tails= tails;
    memmove(tails+(new_size-real_size),tails,real_size*sizeof(hash_lex_struct));
    end= tails + new_size - real_size;
    for (cur= tails; cur<end; cur++)
      cur->first_char= 0;
    root->first_char= (int) (uchar) *name;
  }

  if (root->last_char<(*name))
  {
    size_t new_size= (*name)-root->first_char+1;
    if (new_size<real_size) printf("error!!!!\n");
    tails= root->char_tails;
    tails= (hash_lex_struct*)realloc((char*)tails,
                                    sizeof(hash_lex_struct)*new_size);
    root->char_tails= tails;
    end= tails + new_size;
    for (cur= tails+real_size; cur<end; cur++)
      cur->first_char= 0;
    root->last_char= (*name);
  }

  insert_into_hash(root->char_tails+(*name)-root->first_char,
                   name+1,len_from_begin+1,index,function);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void insert_sql_functions

(

)

Definition at line 207 of file gen_lex_hash.cc.

References array_elements, get_hash_struct_by_len(), insert_into_hash(), st_symbol::length, max_len, st_symbol::name, root_by_len, and sql_functions.

Referenced by generate_find_structs().

{
  size_t i= 0;
  SYMBOL *cur;
  for (cur= sql_functions; i<array_elements(sql_functions); cur++, i++){
    hash_lex_struct *root= 
      get_hash_struct_by_len(&root_by_len,cur->length,&max_len);
    insert_into_hash(root,cur->name,0,-i-1,1);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void insert_symbols

(

)

Definition at line 196 of file gen_lex_hash.cc.

References array_elements, get_hash_struct_by_len(), insert_into_hash(), st_symbol::length, max_len, st_symbol::name, root_by_len, and symbols.

Referenced by generate_find_structs().

{
  size_t i= 0;
  SYMBOL *cur;
  for (cur= symbols; i<array_elements(symbols); cur++, i++){
    hash_lex_struct *root= 
      get_hash_struct_by_len(&root_by_len,cur->length,&max_len);
    insert_into_hash(root,cur->name,0,i,0);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int main	(	int	argc,
		char **	argv
	)

Definition at line 437 of file gen_lex_hash.cc.

References calc_length(), check_duplicates(), DBUG_PROCESS, exit, generate_find_structs(), get_options(), max_len, max_len2, my_end(), MY_INIT, and print_find_structs().

{
  MY_INIT(argv[0]);
  DBUG_PROCESS(argv[0]);

  if (get_options(argc,(char **) argv))
    exit(1);

  printf("/* Copyright (C) 2001-2004 MySQL AB\n\
   This software comes with ABSOLUTELY NO WARRANTY. This is free software,\n\
   and you are welcome to modify and redistribute it under the GPL license\n\
   \n*/\n\n");

  printf("/* This code is generated by gen_lex_hash.cc that seeks for\
 a perfect\nhash function */\n\n");
  printf("#include \"lex.h\"\n\n");

  calc_length();

  if (check_duplicates())
    exit(1);

  generate_find_structs();
  print_find_structs();

  printf("\nstatic unsigned int sql_functions_max_len=%d;\n", max_len);
  printf("\nstatic unsigned int symbols_max_len=%d;\n\n", max_len2);

  printf("\
static inline SYMBOL *get_hash_symbol(const char *s,\n\
                                    unsigned int len,bool function)\n\
{\n\
  register uchar *hash_map;\n\
  register const char *cur_str= s;\n\
  if (function){\n\
    if (len>sql_functions_max_len) return 0;\n\
    hash_map= sql_functions_map;\n\
    register uint32 cur_struct= uint4korr(hash_map+((len-1)*4));\n\
\n\
    for (;;){\n\
      register uchar first_char= (uchar)cur_struct;\n\
\n\
      if (first_char == 0)\n\
      {\n\
        register int16 ires= (int16)(cur_struct>>16);\n\
        if (ires==array_elements(symbols)) return 0;\n\
        register SYMBOL *res;\n\
        if (ires>=0) \n\
          res= symbols+ires;\n\
        else\n\
          res= sql_functions-ires-1;\n\
        register uint count= cur_str-s;\n\
        return lex_casecmp(cur_str,res->name+count,len-count) ? 0 : res;\n\
      }\n\
\n\
      register uchar cur_char= (uchar)to_upper_lex[(uchar)*cur_str];\n\
      if (cur_char<first_char) return 0;\n\
      cur_struct>>=8;\n\
      if (cur_char>(uchar)cur_struct) return 0;\n\
\n\
      cur_struct>>=8;\n\
      cur_struct= uint4korr(hash_map+\n\
                        (((uint16)cur_struct + cur_char - first_char)*4));\n\
      cur_str++;\n\
    }\n\
  }else{\n\
    if (len>symbols_max_len) return 0;\n\
    hash_map= symbols_map;\n\
    register uint32 cur_struct= uint4korr(hash_map+((len-1)*4));\n\
\n\
    for (;;){\n\
      register uchar first_char= (uchar)cur_struct;\n\
\n\
      if (first_char==0){\n\
        register int16 ires= (int16)(cur_struct>>16);\n\
        if (ires==array_elements(symbols)) return 0;\n\
        register SYMBOL *res= symbols+ires;\n\
        register uint count= cur_str-s;\n\
        return lex_casecmp(cur_str,res->name+count,len-count)!=0 ? 0 : res;\n\
      }\n\
\n\
      register uchar cur_char= (uchar)to_upper_lex[(uchar)*cur_str];\n\
      if (cur_char<first_char) return 0;\n\
      cur_struct>>=8;\n\
      if (cur_char>(uchar)cur_struct) return 0;\n\
\n\
      cur_struct>>=8;\n\
      cur_struct= uint4korr(hash_map+\n\
                        (((uint16)cur_struct + cur_char - first_char)*4));\n\
      cur_str++;\n\
    }\n\
  }\n\
}\n"
);
  my_end(0);
  exit(0);
}

Here is the call graph for this function:

void print_find_structs

(

)

Definition at line 321 of file gen_lex_hash.cc.

References add_structs_to_map(), hash_map, max_len, max_len2, print_hash_map(), root_by_len, root_by_len2, set_links(), and size_hash_map.

Referenced by main().

{
  add_structs_to_map(root_by_len,max_len);
  set_links(root_by_len,max_len);
  print_hash_map("sql_functions_map");

  hash_map= 0;
  size_hash_map= 0;

  printf("\n");

  add_structs_to_map(root_by_len2,max_len2);
  set_links(root_by_len2,max_len2);
  print_hash_map("symbols_map");
}

Here is the call graph for this function:

Here is the caller graph for this function:

void print_hash_map

(

const char *

name

)

Definition at line 298 of file gen_lex_hash.cc.

References hash_map, and size_hash_map.

Referenced by print_find_structs().

{
  char *cur;
  int i;

  printf("static uchar %s[%d]= {\n",name,size_hash_map);
  for (i=0, cur= hash_map; i<size_hash_map; i++, cur++)
  {
    switch(i%4){
    case 0: case 1:
      if (!*cur)
        printf("0,   ");
      else
        printf("\'%c\', ",*cur);
      break;
    case 2: printf("%u, ",(uint)(uchar)*cur); break;
    case 3: printf("%u,\n",(uint)(uchar)*cur); break;
    }
  }
  printf("};\n");
}

Here is the caller graph for this function:

void set_links	(	hash_lex_struct *	st,
		int	len
	)

Definition at line 282 of file gen_lex_hash.cc.

References hash_lex_struct::char_tails, hash_lex_struct::first_char, hash_map, hash_lex_struct::ithis, and hash_lex_struct::last_char.

Referenced by print_find_structs().

{
  hash_lex_struct *cur, *end= st+len;
  for (cur= st; cur<end; cur++)
  {
    if (cur->first_char != 0 && cur->first_char != -1)
    {
      int ilink= cur->char_tails->ithis;
      hash_map[cur->ithis*4+2]= ilink%256;
      hash_map[cur->ithis*4+3]= ilink/256;
      set_links(cur->char_tails,cur->last_char-cur->first_char+1);
    }
  }
}

Here is the caller graph for this function:

static void usage

(

int

version

)

[static]

Definition at line 338 of file gen_lex_hash.cc.

References MACHINE_TYPE, my_long_options, my_print_help(), my_progname, MYSQL_SERVER_VERSION, and SYSTEM_TYPE.

{
  printf("%s  Ver 3.6 Distrib %s, for %s (%s)\n",
         my_progname, MYSQL_SERVER_VERSION, SYSTEM_TYPE, MACHINE_TYPE);
  if (version)
    return;
  puts("Copyright (C) 2001 MySQL AB, by VVA and Monty");
  puts("This software comes with ABSOLUTELY NO WARRANTY. This is free software,\n\
and you are welcome to modify and redistribute it under the GPL license\n");
  puts("This program generates a perfect hashing function for the sql_lex.cc");
  printf("Usage: %s [OPTIONS]\n\n", my_progname);
  my_print_help(my_long_options);
}

Here is the call graph for this function:

---

Variable Documentation

const char* default_dbug_option = "d:t:o,/tmp/gen_lex_hash.trace"

Definition at line 86 of file gen_lex_hash.cc.

char* hash_map = 0

Definition at line 245 of file gen_lex_hash.cc.

Referenced by add_struct_to_map(), get_hash_symbol(), print_find_structs(), print_hash_map(), and set_links().

int max_len = 0

Definition at line 191 of file gen_lex_hash.cc.

Referenced by expand_var_part(), generate_find_structs(), NdbColumnImpl::get_var_length(), insert_sql_functions(), insert_symbols(), main(), and print_find_structs().

int max_len2 = 0

Definition at line 194 of file gen_lex_hash.cc.

Referenced by generate_find_structs(), main(), and print_find_structs().

struct my_option my_long_options[]

Initial value:

{




  {"debug", '#', "Output debug log", (gptr*) &default_dbug_option,
   (gptr*) &default_dbug_option, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},

  {"help", '?', "Display help and exit",
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"version", 'V', "Output version information and exit",
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  {0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
}

Definition at line 88 of file gen_lex_hash.cc.

hash_lex_struct* root_by_len = 0

Definition at line 190 of file gen_lex_hash.cc.

Referenced by generate_find_structs(), get_hash_struct_by_len(), insert_sql_functions(), insert_symbols(), and print_find_structs().

hash_lex_struct* root_by_len2 = 0

Definition at line 193 of file gen_lex_hash.cc.

Referenced by generate_find_structs(), and print_find_structs().

int size_hash_map = 0

Definition at line 246 of file gen_lex_hash.cc.

Referenced by add_struct_to_map(), print_find_structs(), and print_hash_map().

---

© 1995-2008 MySQL AB, 2008 Sun Microsystems, Inc.

• Online Shop
• Site Map
• About MySQL
• Legal
• Privacy Policy
• Contact Us
• Job Opportunities