开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
sql_lex.cc
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：22k
源码类别：

MySQL数据库

开发平台：

Visual C++

sql_lex.cc：源码内容
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  7.    
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  12.    
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  18. /* A lexical scanner on a temporary buffer with a yacc interface */
  20. #include "mysql_priv.h"
  21. #include "item_create.h"
  22. #include <m_ctype.h>
  23. #include <hash.h>
  25. LEX_STRING tmp_table_alias= {(char*) "tmp-table",8};
  27. /* Macros to look like lex */
  29. #define yyGet() *(lex->ptr++)
  30. #define yyGetLast() lex->ptr[-1]
  31. #define yyPeek() lex->ptr[0]
  32. #define yyPeek2() lex->ptr[1]
  33. #define yyUnget() lex->ptr--
  34. #define yySkip() lex->ptr++
  35. #define yyLength() ((uint) (lex->ptr - lex->tok_start)-1)
  37. #if MYSQL_VERSION_ID < 32300
  38. #define FLOAT_NUM REAL_NUM
  39. #endif
  41. pthread_key(LEX*,THR_LEX);
  43. #define TOCK_NAME_LENGTH 24
  45. /*
  46.   The following is based on the latin1 character set, and is only
  47.   used when comparing keywords
  48. */
  50. uchar to_upper_lex[] = {
  51.     0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
  52.    16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
  53.    32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
  54.    48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
  55.    64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
  56.    80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
  57.    96, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
  58.    80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,123,124,125,126,127,
  59.   128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
  60.   144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,
  61.   160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,
  62.   176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,
  63.   192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,
  64.   208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,
  65.   192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,
  66.   208,209,210,211,212,213,214,247,216,217,218,219,220,221,222,255
  67. };
  69. inline int lex_casecmp(const char *s, const char *t, uint len)
  70. {
  71.   while (len-- != 0 &&
  72.  to_upper_lex[(uchar) *s++] == to_upper_lex[(uchar) *t++]) ;
  73.   return (int) len+1;
  74. }
  76. #include "lex_hash.h"
  78. static uchar state_map[256];
  81. void lex_init(void)
  82. {
  83.   uint i;
  84.   DBUG_ENTER("lex_init");
  85.   for (i=0 ; i < array_elements(symbols) ; i++)
  86.     symbols[i].length=(uchar) strlen(symbols[i].name);
  87.   for (i=0 ; i < array_elements(sql_functions) ; i++)
  88.     sql_functions[i].length=(uchar) strlen(sql_functions[i].name);
  90.   VOID(pthread_key_create(&THR_LEX,NULL));
  92.   /* Fill state_map with states to get a faster parser */
  93.   for (i=0; i < 256 ; i++)
  94.   {
  95.     if (isalpha(i))
  96.       state_map[i]=(uchar) STATE_IDENT;
  97.     else if (isdigit(i))
  98.       state_map[i]=(uchar) STATE_NUMBER_IDENT;
  99. #if defined(USE_MB) && defined(USE_MB_IDENT)
  100.     else if (use_mb(default_charset_info) && my_ismbhead(default_charset_info, i))
  101.       state_map[i]=(uchar) STATE_IDENT;
  102. #endif
  103.     else if (!isgraph(i))
  104.       state_map[i]=(uchar) STATE_SKIP;      
  105.     else
  106.       state_map[i]=(uchar) STATE_CHAR;
  107.   }
  108.   state_map[(uchar)'_']=state_map[(uchar)'$']=(uchar) STATE_IDENT;
  109.   state_map[(uchar)''']=state_map[(uchar)'"']=(uchar) STATE_STRING;
  110.   state_map[(uchar)'-']=state_map[(uchar)'+']=(uchar) STATE_SIGNED_NUMBER;
  111.   state_map[(uchar)'.']=(uchar) STATE_REAL_OR_POINT;
  112.   state_map[(uchar)'>']=state_map[(uchar)'=']=state_map[(uchar)'!']= (uchar) STATE_CMP_OP;
  113.   state_map[(uchar)'<']= (uchar) STATE_LONG_CMP_OP;
  114.   state_map[(uchar)'&']=state_map[(uchar)'|']=(uchar) STATE_BOOL;
  115.   state_map[(uchar)'#']=(uchar) STATE_COMMENT;
  116.   state_map[(uchar)';']=(uchar) STATE_COLON;
  117.   state_map[(uchar)':']=(uchar) STATE_SET_VAR;
  118.   state_map[0]=(uchar) STATE_EOL;
  119.   state_map[(uchar)'\']= (uchar) STATE_ESCAPE;
  120.   state_map[(uchar)'/']= (uchar) STATE_LONG_COMMENT;
  121.   state_map[(uchar)'*']= (uchar) STATE_END_LONG_COMMENT;
  122.   state_map[(uchar)'@']= (uchar) STATE_USER_END;
  123.   state_map[(uchar) '`']= (uchar) STATE_USER_VARIABLE_DELIMITER;
  124.   if (thd_startup_options & OPTION_ANSI_MODE)
  125.   {
  126.     state_map[(uchar) '"'] = STATE_USER_VARIABLE_DELIMITER;
  127.   }
  128.   DBUG_VOID_RETURN;
  129. }
  132. void lex_free(void)
  133. { // Call this when daemon ends
  134.   DBUG_ENTER("lex_free");
  135.   DBUG_VOID_RETURN;
  136. }
  139. LEX *lex_start(THD *thd, uchar *buf,uint length)
  140. {
  141.   LEX *lex= &thd->lex;
  142.   lex->next_state=STATE_START;
  143.   lex->end_of_query=(lex->ptr=buf)+length;
  144.   lex->yylineno = 1;
  145.   lex->create_refs=lex->in_comment=0;
  146.   lex->length=0;
  147.   lex->in_sum_expr=0;
  148.   lex->expr_list.empty();
  149.   lex->ftfunc_list.empty();
  150.   lex->convert_set=(lex->thd=thd)->convert_set;
  151.   lex->yacc_yyss=lex->yacc_yyvs=0;
  152.   lex->ignore_space=test(thd->client_capabilities & CLIENT_IGNORE_SPACE);
  153.   return lex;
  154. }
  156. void lex_end(LEX *lex)
  157. {
  158.   lex->expr_list.delete_elements(); // If error when parsing sql-varargs
  159.   x_free(lex->yacc_yyss);
  160.   x_free(lex->yacc_yyvs);
  161. }
  164. static int find_keyword(LEX *lex, uint len, bool function)
  165. {
  166.   uchar *tok=lex->tok_start;
  168.   SYMBOL *symbol = get_hash_symbol((const char *)tok,len,function);
  169.   if (symbol)
  170.   {
  171.     lex->yylval->symbol.symbol=symbol;
  172.     lex->yylval->symbol.str= (char*) tok;
  173.     lex->yylval->symbol.length=len;
  174.     return symbol->tok;
  175.   }
  176. #ifdef HAVE_DLOPEN
  177.   udf_func *udf;
  178.   if (function && using_udf_functions && (udf=find_udf((char*) tok, len)))
  179.   {
  180.     switch (udf->returns) {
  181.     case STRING_RESULT:
  182.       lex->yylval->udf=udf;
  183.       return (udf->type == UDFTYPE_FUNCTION) ? UDF_CHAR_FUNC : UDA_CHAR_SUM;
  184.     case REAL_RESULT:
  185.       lex->yylval->udf=udf;
  186.       return (udf->type == UDFTYPE_FUNCTION) ? UDF_FLOAT_FUNC : UDA_FLOAT_SUM;
  187.     case INT_RESULT:
  188.       lex->yylval->udf=udf;
  189.       return (udf->type == UDFTYPE_FUNCTION) ? UDF_INT_FUNC : UDA_INT_SUM;
  190.     }
  191.   }
  192. #endif
  193.   return 0;
  194. }
  197. /* make a copy of token before ptr and set yytoklen */
  199. static inline LEX_STRING get_token(LEX *lex,uint length)
  200. {
  201.   LEX_STRING tmp;
  202.   yyUnget(); // ptr points now after last token char
  203.   tmp.length=lex->yytoklen=length;
  204.   tmp.str=(char*) sql_strmake((char*) lex->tok_start,tmp.length);
  205.   return tmp;
  206. }
  208. /* Return an unescaped text literal without quotes */
  209. /* Fix sometimes to do only one scan of the string */
  211. static char *get_text(LEX *lex)
  212. {
  213.   reg1 uchar c,sep;
  214.   uint found_escape=0;
  216.   sep= yyGetLast(); // String should end with this
  217.   //lex->tok_start=lex->ptr-1; // Remember '
  218.   while (lex->ptr != lex->end_of_query)
  219.   {
  220.     c = yyGet();
  221. #ifdef USE_MB
  222.     int l;
  223.     if (use_mb(default_charset_info) &&
  224.         (l = my_ismbchar(default_charset_info,
  225.                          (const char *)lex->ptr-1,
  226.                          (const char *)lex->end_of_query))) {
  227. lex->ptr += l-1;
  228. continue;
  229.     }
  230. #endif
  231.     if (c == '\')
  232.     { // Escaped character
  233.       found_escape=1;
  234.       if (lex->ptr == lex->end_of_query)
  235. return 0;
  236.       yySkip();
  237.     }
  238.     else if (c == sep)
  239.     {
  240.       if (c == yyGet()) // Check if two separators in a row
  241.       {
  242. found_escape=1; // dupplicate. Remember for delete
  243. continue;
  244.       }
  245.       else
  246. yyUnget();
  248.       /* Found end. Unescape and return string */
  249.       uchar *str,*end,*start;
  251.       str=lex->tok_start+1;
  252.       end=lex->ptr-1;
  253.       if (!(start=(uchar*) sql_alloc((uint) (end-str)+1)))
  254. return (char*) ""; // Sql_alloc has set error flag
  255.       if (!found_escape)
  256.       {
  257. lex->yytoklen=(uint) (end-str);
  258. memcpy(start,str,lex->yytoklen);
  259. start[lex->yytoklen]=0;
  260.       }
  261.       else
  262.       {
  263. uchar *to;
  264. for (to=start ; str != end ; str++)
  265. {
  266. #ifdef USE_MB
  267.   int l;
  268.   if (use_mb(default_charset_info) &&
  269.               (l = my_ismbchar(default_charset_info,
  270.                                (const char *)str, (const char *)end))) {
  271.       while (l--)
  272.   *to++ = *str++;
  273.       str--;
  274.       continue;
  275.   }
  276. #endif
  277.   if (*str == '\' && str+1 != end)
  278.   {
  279.     switch(*++str) {
  280.     case 'n':
  281.       *to++='n';
  282.       break;
  283.     case 't':
  284.       *to++= 't';
  285.       break;
  286.     case 'r':
  287.       *to++ = 'r';
  288.       break;
  289.     case 'b':
  290.       *to++ = 'b';
  291.       break;
  292.     case '0':
  293.       *to++= 0; // Ascii null
  294.       break;
  295.     case 'Z': // ^Z must be escaped on Win32
  296.       *to++='32';
  297.       break;
  298.     case '_':
  299.     case '%':
  300.       *to++= '\'; // remember prefix for wildcard
  301.       /* Fall through */
  302.     default:
  303.       *to++ = *str;
  304.       break;
  305.     }
  306.   }
  307.   else if (*str == sep)
  308.     *to++= *str++; // Two ' or "
  309.   else
  310.     *to++ = *str;
  312. }
  313. *to=0;
  314. lex->yytoklen=(uint) (to-start);
  315.       }
  316.       if (lex->convert_set)
  317. lex->convert_set->convert((char*) start,lex->yytoklen);
  318.       return (char*) start;
  319.     }
  320.   }
  321.   return 0; // unexpected end of query
  322. }
  325. /*
  326. ** Calc type of integer; long integer, longlong integer or real.
  327. ** Returns smallest type that match the string.
  328. ** When using unsigned long long values the result is converted to a real
  329. ** because else they will be unexpected sign changes because all calculation
  330. ** is done with longlong or double.
  331. */
  333. static const char *long_str="2147483647";
  334. static const uint long_len=10;
  335. static const char *signed_long_str="-2147483648";
  336. static const char *longlong_str="9223372036854775807";
  337. static const uint longlong_len=19;
  338. static const char *signed_longlong_str="-9223372036854775808";
  339. static const uint signed_longlong_len=19;
  342. inline static uint int_token(const char *str,uint length)
  343. {
  344.   if (length < long_len) // quick normal case
  345.     return NUM;
  346.   bool neg=0;
  348.   if (*str == '+') // Remove sign and pre-zeros
  349.   {
  350.     str++; length--;
  351.   }
  352.   else if (*str == '-')
  353.   {
  354.     str++; length--;
  355.     neg=1;
  356.   }
  357.   while (*str == '0' && length)
  358.   {
  359.     str++; length --;
  360.   }
  361.   if (length < long_len)
  362.     return NUM;
  364.   uint smaller,bigger;
  365.   const char *cmp;
  366.   if (neg)
  367.   {
  368.     if (length == long_len)
  369.     {
  370.       cmp= signed_long_str+1;
  371.       smaller=NUM; // If <= signed_long_str
  372.       bigger=LONG_NUM; // If >= signed_long_str
  373.     }
  374.     else if (length < signed_longlong_len)
  375.       return LONG_NUM;
  376.     else if (length > signed_longlong_len)
  377.       return REAL_NUM;
  378.     else
  379.     {
  380.       cmp=signed_longlong_str+1;
  381.       smaller=LONG_NUM; // If <= signed_longlong_str
  382.       bigger=REAL_NUM;
  383.     }
  384.   }
  385.   else
  386.   {
  387.     if (length == long_len)
  388.     {
  389.       cmp= long_str;
  390.       smaller=NUM;
  391.       bigger=LONG_NUM;
  392.     }
  393.     else if (length < longlong_len)
  394.       return LONG_NUM;
  395.     else if (length > longlong_len)
  396.       return REAL_NUM;
  397.     else
  398.     {
  399.       cmp=longlong_str;
  400.       smaller=LONG_NUM;
  401.       bigger=REAL_NUM;
  402.     }
  403.   }
  404.   while (*cmp && *cmp++ == *str++) ;
  405.   return ((uchar) str[-1] <= (uchar) cmp[-1]) ? smaller : bigger;
  406. }
  409. // yylex remember the following states from the following yylex()
  410. // STATE_EOQ ; found end of query
  411. // STATE_OPERATOR_OR_IDENT ; last state was an ident, text or number
  412. //       (which can't be followed by a signed number)
  414. int yylex(void *arg)
  415. {
  416.   reg1 uchar c;
  417.   int tokval;
  418.   uint length;
  419.   enum lex_states state,prev_state;
  420.   LEX *lex=current_lex;
  421.   YYSTYPE *yylval=(YYSTYPE*) arg;
  423.   lex->yylval=yylval; // The global state
  424.   lex->tok_start=lex->tok_end=lex->ptr;
  425.   prev_state=state=lex->next_state;
  426.   lex->next_state=STATE_OPERATOR_OR_IDENT;
  427.   LINT_INIT(c);
  428.   for (;;)
  429.   {
  430.     switch(state) {
  431.     case STATE_OPERATOR_OR_IDENT: // Next is operator or keyword
  432.     case STATE_START: // Start of token
  433.       // Skipp startspace
  434.       for (c=yyGet() ; (state_map[c] == STATE_SKIP) ; c= yyGet())
  435.       {
  436. if (c == 'n')
  437.   lex->yylineno++;
  438.       }
  439.       lex->tok_start=lex->ptr-1; // Start of real token
  440.       state= (enum lex_states) state_map[c];
  441.       break;
  442.     case STATE_ESCAPE:
  443.       if (yyGet() == 'N')
  444.       { // Allow N as shortcut for NULL
  445. yylval->lex_str.str=(char*) "\N";
  446. yylval->lex_str.length=2;
  447. return NULL_SYM;
  448.       }
  449.     case STATE_CHAR: // Unknown or single char token
  450.     case STATE_SKIP: // This should not happen
  451.       yylval->lex_str.str=(char*) (lex->ptr=lex->tok_start);// Set to first char
  452.       yylval->lex_str.length=1;
  453.       c=yyGet();
  454.       if (c != ')')
  455. lex->next_state= STATE_START; // Allow signed numbers
  456.       if (c == ',')
  457. lex->tok_start=lex->ptr; // Let tok_start point at next item
  458.       return((int) c);
  460.     case STATE_IDENT: // Incomplete keyword or ident
  461. #if defined(USE_MB) && defined(USE_MB_IDENT)
  462.       if (use_mb(default_charset_info))
  463.       {
  464.         if (my_ismbhead(default_charset_info, yyGetLast()))
  465.         {
  466.           int l = my_ismbchar(default_charset_info,
  467.                               (const char *)lex->ptr-1,
  468.                               (const char *)lex->end_of_query);
  469.           if (l == 0) {
  470.             state = STATE_CHAR;
  471.             continue;
  472.           }
  473.           lex->ptr += l - 1;
  474.         }
  475.         while (state_map[c=yyGet()] == STATE_IDENT ||
  476.                state_map[c] == STATE_NUMBER_IDENT)
  477.         {
  478.           if (my_ismbhead(default_charset_info, c))
  479.           {
  480.             int l;
  481.             if ((l = my_ismbchar(default_charset_info,
  482.                               (const char *)lex->ptr-1,
  483.                               (const char *)lex->end_of_query)) == 0)
  484.               break;
  485.             lex->ptr += l-1;
  486.           }
  487.         }
  488.       }
  489.       else
  490. #endif
  491.         while (state_map[c=yyGet()] == STATE_IDENT ||
  492.                state_map[c] == STATE_NUMBER_IDENT) ;
  493.       length= (uint) (lex->ptr - lex->tok_start)-1;
  494.       if (lex->ignore_space)
  495.       {
  496. for ( ; state_map[c] == STATE_SKIP ; c= yyGet());
  497.       }
  498.       if (c == '.' && (state_map[yyPeek()] == STATE_IDENT ||
  499.        state_map[yyPeek()] == STATE_NUMBER_IDENT))
  500. lex->next_state=STATE_IDENT_SEP;
  501.       else
  502.       { // '(' must follow directly if function
  503. yyUnget();
  504. if ((tokval = find_keyword(lex,length,c == '(')))
  505. {
  506.   lex->next_state= STATE_START; // Allow signed numbers
  507.   return(tokval); // Was keyword
  508. }
  509. yySkip(); // next state does a unget
  510.       }
  511.       yylval->lex_str=get_token(lex,length);
  512.       return(IDENT);
  514.     case STATE_IDENT_SEP: // Found ident and now '.'
  515.       lex->next_state=STATE_IDENT_START;// Next is an ident (not a keyword)
  516.       yylval->lex_str.str=(char*) lex->ptr;
  517.       yylval->lex_str.length=1;
  518.       c=yyGet(); // should be '.'
  519.       return((int) c);
  521.     case STATE_NUMBER_IDENT: // number or ident which starts with num
  522.       while (isdigit((c = yyGet()))) ;
  523.       if (state_map[c] != STATE_IDENT)
  524.       { // Can't be identifier
  525. state=STATE_INT_OR_REAL;
  526. break;
  527.       }
  528.       if (c == 'e' || c == 'E')
  529.       {
  530. // The following test is written this way to allow numbers of type 1e1
  531. if (isdigit(yyPeek()) || (c=(yyGet())) == '+' || c == '-')
  532. { // Allow 1E+10
  533.   if (isdigit(yyPeek())) // Number must have digit after sign
  534.   {
  535.     yySkip();
  536.     while (isdigit(yyGet())) ;
  537.     yylval->lex_str=get_token(lex,yyLength());
  538.     return(FLOAT_NUM);
  539.   }
  540. }
  541. yyUnget(); /* purecov: inspected */
  542.       }
  543.       else if (c == 'x' && (lex->ptr - lex->tok_start) == 2 &&
  544.   lex->tok_start[0] == '0' )
  545.       { // Varbinary
  546. while (isxdigit((c = yyGet()))) ;
  547. if ((lex->ptr - lex->tok_start) >= 4)
  548. {
  549.   yylval->lex_str=get_token(lex,yyLength());
  550.   yylval->lex_str.str+=2; // Skipp 0x
  551.   yylval->lex_str.length-=2;
  552.   lex->yytoklen-=2;
  553.   return (HEX_NUM);
  554. }
  555. yyUnget();
  556.       }
  557.       // fall through
  558.     case STATE_IDENT_START: // Incomplete ident
  559. #if defined(USE_MB) && defined(USE_MB_IDENT)
  560.       if (use_mb(default_charset_info))
  561.       {
  562.         if (my_ismbhead(default_charset_info, yyGetLast()))
  563.         {
  564.           int l = my_ismbchar(default_charset_info,
  565.                               (const char *)lex->ptr-1,
  566.                               (const char *)lex->end_of_query);
  567.           if (l == 0)
  568.           {
  569.             state = STATE_CHAR;
  570.             continue;
  571.           }
  572.           lex->ptr += l - 1;
  573.         }
  574.         while (state_map[c=yyGet()] == STATE_IDENT ||
  575.                state_map[c] == STATE_NUMBER_IDENT)
  576.         {
  577.           if (my_ismbhead(default_charset_info, c))
  578.           {
  579.             int l;
  580.             if ((l = my_ismbchar(default_charset_info,
  581.                                  (const char *)lex->ptr-1,
  582.                                  (const char *)lex->end_of_query)) == 0)
  583.               break;
  584.             lex->ptr += l-1;
  585.           }
  586.         }
  587.       }
  588.       else
  589. #endif
  590.         while (state_map[c = yyGet()] == STATE_IDENT ||
  591.                state_map[c] == STATE_NUMBER_IDENT) ;
  593.       if (c == '.' && (state_map[yyPeek()] == STATE_IDENT ||
  594.        state_map[yyPeek()] == STATE_NUMBER_IDENT))
  595. lex->next_state=STATE_IDENT_SEP;// Next is '.'
  596.       // fall through
  598.     case STATE_FOUND_IDENT: // Complete ident
  599.       yylval->lex_str=get_token(lex,yyLength());
  600.       return(IDENT);
  602.     case STATE_USER_VARIABLE_DELIMITER:
  603.       lex->tok_start=lex->ptr; // Skipp first `
  604.       while ((c=yyGet()) && state_map[c] != STATE_USER_VARIABLE_DELIMITER &&
  605.      c != (uchar) NAMES_SEP_CHAR) ;
  606.       yylval->lex_str=get_token(lex,yyLength());
  607.       if (state_map[c] == STATE_USER_VARIABLE_DELIMITER)
  608. yySkip(); // Skipp end `
  609.       return(IDENT);
  611.     case STATE_SIGNED_NUMBER: // Incomplete signed number
  612.       if (prev_state == STATE_OPERATOR_OR_IDENT)
  613.       {
  614. if (c == '-' && yyPeek() == '-' && isspace(yyPeek2()))
  615.   state=STATE_COMMENT;
  616. else
  617.   state= STATE_CHAR; // Must be operator
  618. break;
  619.       }
  620.       if (!isdigit(c=yyGet()) || yyPeek() == 'x')
  621.       {
  622. if (c != '.')
  623. {
  624.   if (c == '-' && isspace(yyPeek()))
  625.     state=STATE_COMMENT;
  626.   else
  627.     state = STATE_CHAR; // Return sign as single char
  628.   break;
  629. }
  630. yyUnget(); // Fix for next loop
  631.       }
  632.       while (isdigit(c=yyGet())) ; // Incomplete real or int number
  633.       if ((c == 'e' || c == 'E') &&
  634.   (yyPeek() == '+' || yyPeek() == '-' || isdigit(yyPeek())))
  635.       { // Real number
  636. yyUnget();
  637. c= '.'; // Fool next test
  638.       }
  639.       // fall through
  640.     case STATE_INT_OR_REAL: // Compleat int or incompleat real
  641.       if (c != '.')
  642.       { // Found complete integer number.
  643. yylval->lex_str=get_token(lex,yyLength());
  644. return int_token(yylval->lex_str.str,yylval->lex_str.length);
  645.       }
  646.       // fall through
  647.     case STATE_REAL: // Incomplete real number
  648.       while (isdigit(c = yyGet())) ;
  650.       if (c == 'e' || c == 'E')
  651.       {
  652. c = yyGet();
  653. if (c != '-' && c != '+' && !isdigit(c))
  654. { // No exp sig found
  655.   state= STATE_CHAR;
  656.   break;
  657. }
  658. if (!isdigit(yyGet()))
  659. { // No digit after sign
  660.   state= STATE_CHAR;
  661.   break;
  662. }
  663. while (isdigit(yyGet())) ;
  664. yylval->lex_str=get_token(lex,yyLength());
  665. return(FLOAT_NUM);
  666.       }
  667.       yylval->lex_str=get_token(lex,yyLength());
  668.       return(REAL_NUM);
  670.     case STATE_CMP_OP: // Incomplete comparison operator
  671.       if (state_map[yyPeek()] == STATE_CMP_OP ||
  672.   state_map[yyPeek()] == STATE_LONG_CMP_OP)
  673. yySkip();
  674.       if ((tokval = find_keyword(lex,(uint) (lex->ptr - lex->tok_start),0)))
  675.       {
  676. lex->next_state= STATE_START; // Allow signed numbers
  677. return(tokval);
  678.       }
  679.       state = STATE_CHAR; // Something fishy found
  680.       break;
  682.     case STATE_LONG_CMP_OP: // Incomplete comparison operator
  683.       if (state_map[yyPeek()] == STATE_CMP_OP ||
  684.   state_map[yyPeek()] == STATE_LONG_CMP_OP)
  685.       {
  686. yySkip();
  687. if (state_map[yyPeek()] == STATE_CMP_OP)
  688.   yySkip();
  689.       }
  690.       if ((tokval = find_keyword(lex,(uint) (lex->ptr - lex->tok_start),0)))
  691.       {
  692. lex->next_state= STATE_START; // Found long op
  693. return(tokval);
  694.       }
  695.       state = STATE_CHAR; // Something fishy found
  696.       break;
  698.     case STATE_BOOL:
  699.       if (c != yyPeek())
  700.       {
  701. state=STATE_CHAR;
  702. break;
  703.       }
  704.       yySkip();
  705.       tokval = find_keyword(lex,2,0); // Is a bool operator
  706.       lex->next_state= STATE_START; // Allow signed numbers
  707.       return(tokval);
  709.     case STATE_STRING: // Incomplete text string
  710.       if (!(yylval->lex_str.str = get_text(lex)))
  711.       {
  712. state= STATE_CHAR; // Read char by char
  713. break;
  714.       }
  715.       yylval->lex_str.length=lex->yytoklen;
  716.       return(TEXT_STRING);
  718.     case STATE_COMMENT: //  Comment
  719.       while ((c = yyGet()) != 'n' && c) ;
  720.       yyUnget(); // Safety against eof
  721.       state = STATE_START; // Try again
  722.       break;
  723.     case STATE_LONG_COMMENT: /* Long C comment? */
  724.       if (yyPeek() != '*')
  725.       {
  726. state=STATE_CHAR; // Probable division
  727. break;
  728.       }
  729.       yySkip(); // Skip '*'
  730.       if (yyPeek() == '!') // MySQL command in comment
  731.       {
  732. ulong version=MYSQL_VERSION_ID;
  733. yySkip();
  734. state=STATE_START;
  735. if (isdigit(yyPeek()))
  736. { // Version number
  737.   version=strtol((char*) lex->ptr,(char**) &lex->ptr,10);
  738. }
  739. if (version <= MYSQL_VERSION_ID)
  740. {
  741.   lex->in_comment=1;
  742.   break;
  743. }
  744.       }
  745.       while (lex->ptr != lex->end_of_query &&
  746.      ((c=yyGet()) != '*' || yyPeek() != '/'))
  747.       {
  748. if (c == 'n')
  749.   lex->yylineno++;
  750.       }
  751.       if (lex->ptr != lex->end_of_query)
  752. yySkip(); // remove last '/'
  753.       state = STATE_START; // Try again
  754.       break;
  755.     case STATE_END_LONG_COMMENT:
  756.       if (lex->in_comment && yyPeek() == '/')
  757.       {
  758. yySkip();
  759. lex->in_comment=0;
  760. state=STATE_START;
  761.       }
  762.       else
  763. state=STATE_CHAR; // Return '*'
  764.       break;
  765.     case STATE_SET_VAR: // Check if ':='
  766.       if (yyPeek() != '=')
  767.       {
  768. state=STATE_CHAR; // Return ':'
  769. break;
  770.       }
  771.       yySkip();
  772.       return (SET_VAR);
  773.     case STATE_COLON: // optional line terminator
  774.       if (yyPeek())
  775.       {
  776. state=STATE_CHAR; // Return ';'
  777. break;
  778.       }
  779.       /* fall true */
  780.     case STATE_EOL:
  781.       lex->next_state=STATE_END; // Mark for next loop
  782.       return(END_OF_INPUT);
  783.     case STATE_END:
  784.       lex->next_state=STATE_END;
  785.       return(0); // We found end of input last time
  787.       // Actually real shouldn't start
  788.       // with . but allow them anyhow
  789.     case STATE_REAL_OR_POINT:
  790.       if (isdigit(yyPeek()))
  791. state = STATE_REAL; // Real
  792.       else
  793.       {
  794. state = STATE_CHAR; // return '.'
  795. lex->next_state=STATE_IDENT_START;// Next is an ident (not a keyword)
  796.       }
  797.       break;
  798.     case STATE_USER_END: // end '@' of user@hostname
  799.       if (state_map[yyPeek()] != STATE_STRING &&
  800.   state_map[yyPeek()] != STATE_USER_VARIABLE_DELIMITER)
  801. lex->next_state=STATE_HOSTNAME; // Mark for next loop     
  802.       yylval->lex_str.str=(char*) lex->ptr;
  803.       yylval->lex_str.length=1;
  804.       return((int) '@');
  805.     case STATE_HOSTNAME: // end '@' of user@hostname
  806.       for (c=yyGet() ;
  807.    isalnum(c) || c == '.' || c == '_' || c == '$';
  808.    c= yyGet()) ;
  809.       yylval->lex_str=get_token(lex,yyLength());
  810.       return(LEX_HOSTNAME);
  811.     }
  812.   }
  813. }