← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_lex.cc

  • Committer: Mark Atwood
  • Date: 2011-10-14 15:59:08 UTC
  • mfrom: (2430.1.12 refactor3a)
  • Revision ID: me@mark.atwood.name-20111014155908-whqmrmaf2grpsg5c
merge lp:~olafvdspek/drizzle/refactor3

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_lex.cc
232
232
  lex->expr_allows_subselect= true;
233
233
  lex->use_only_table_context= false;
234
234
 
235
 
  lex->name.str= 0;
236
 
  lex->name.length= 0;
 
235
  lex->name.assign(NULL, 0);
237
236
  lex->nest_level=0 ;
238
237
  lex->allow_sum_func= 0;
239
238
  lex->in_sum_func= NULL;
295
294
/* make a copy of token before ptr and set yytoklen */
296
295
static lex_string_t get_token(Lex_input_stream *lip, uint32_t skip, uint32_t length)
297
296
{
 
297
  lip->yyUnget();                       // ptr points now after last token char
 
298
  lip->yytoklen= length;
298
299
  lex_string_t tmp;
299
 
  lip->yyUnget();                       // ptr points now after last token char
300
 
  tmp.length=lip->yytoklen=length;
301
 
  tmp.str= lip->m_session->mem.strdup(lip->get_tok_start() + skip, tmp.length);
302
 
 
 
300
  tmp.assign(lip->m_session->mem.strdup(lip->get_tok_start() + skip, length), length);
303
301
  lip->m_cpp_text_start= lip->get_cpp_tok_start() + skip;
304
 
  lip->m_cpp_text_end= lip->m_cpp_text_start + tmp.length;
305
 
 
 
302
  lip->m_cpp_text_end= lip->m_cpp_text_start + tmp.size();
306
303
  return tmp;
307
304
}
308
305
 
316
313
                                   uint32_t skip,
317
314
                                   uint32_t length, char quote)
318
315
{
 
316
  lip->yyUnget();                       // ptr points now after last token char
 
317
  lip->yytoklen= length;
319
318
  lex_string_t tmp;
320
 
  lip->yyUnget();                       // ptr points now after last token char
321
 
  tmp.length= lip->yytoklen=length;
322
 
  tmp.str=(char*) lip->m_session->mem.alloc(tmp.length+1);
 
319
  tmp.assign((char*)lip->m_session->mem.alloc(length + 1), length);
323
320
  const char* from= lip->get_tok_start() + skip;
324
 
  char* to= (char*)tmp.str;
 
321
  char* to= (char*)tmp.data();
325
322
  const char* end= to+length;
326
323
 
327
324
  lip->m_cpp_text_start= lip->get_cpp_tok_start() + skip;
346
343
*/
347
344
static char *get_text(Lex_input_stream *lip, int pre_skip, int post_skip)
348
345
{
349
 
  unsigned char c,sep;
350
346
  bool found_escape= false;
351
 
  const charset_info_st * const cs= lip->m_session->charset();
 
347
  const charset_info_st* const cs= lip->m_session->charset();
352
348
 
353
349
  lip->tok_bitmap= 0;
354
 
  sep= lip->yyGetLast();                        // String should end with this
355
 
  while (! lip->eof())
 
350
  unsigned char sep= lip->yyGetLast();                        // String should end with this
 
351
  while (not lip->eof())
356
352
  {
357
 
    c= lip->yyGet();
 
353
    unsigned char c= lip->yyGet();
358
354
    lip->tok_bitmap|= c;
359
355
    {
360
356
      if (use_mb(cs))
657
653
    case MY_LEX_ESCAPE:
658
654
      if (lip->yyGet() == 'N')
659
655
      {                                 // Allow \N as shortcut for NULL
660
 
        yylval->lex_str.str=(char*) "\\N";
661
 
        yylval->lex_str.length=2;
 
656
        yylval->lex_str.assign("\\N", 2);
662
657
        return NULL_SYM;
663
658
      }
664
659
    case MY_LEX_CHAR:                   // Unknown or single char token
766
761
      return(result_state);                     // IDENT or IDENT_QUOTED
767
762
 
768
763
    case MY_LEX_IDENT_SEP:              // Found ident and now '.'
769
 
      yylval->lex_str.str= (char*) lip->get_ptr();
770
 
      yylval->lex_str.length= 1;
 
764
      yylval->lex_str.assign(lip->get_ptr(), 1);
771
765
      c= lip->yyGet();                  // should be '.'
772
766
      lip->next_state= MY_LEX_IDENT_START;// Next is an ident (not a keyword)
773
767
      if (!ident_map[(uint8_t)lip->yyPeek()])            // Probably ` or "
900
894
      if (c != '.')
901
895
      {                                 // Found complete integer number.
902
896
        yylval->lex_str=get_token(lip, 0, lip->yyLength());
903
 
        return int_token(yylval->lex_str.str,yylval->lex_str.length);
 
897
        return int_token(yylval->lex_str.data(), yylval->lex_str.size());
904
898
      }
905
899
      // fall through
906
900
    case MY_LEX_REAL:                   // Incomplete real number
930
924
        return(ABORT_SYM);              // Illegal hex constant
931
925
      lip->yySkip();                    // Accept closing '
932
926
      length= lip->yyLength();          // Length of hexnum+3
933
 
      if ((length % 2) == 0)
934
 
        return(ABORT_SYM);              // odd number of hex digits
 
927
      if (length % 2 == 0)
 
928
        return ABORT_SYM;               // odd number of hex digits
935
929
      yylval->lex_str=get_token(lip,
936
930
                                2,          // skip x'
937
931
                                length-3);  // don't count x' and last '
996
990
      }
997
991
      /* " used for strings */
998
992
    case MY_LEX_STRING:                 // Incomplete text string
999
 
      if (!(yylval->lex_str.str = get_text(lip, 1, 1)))
 
993
      if (!(yylval->lex_str.str_ = get_text(lip, 1, 1)))
1000
994
      {
1001
995
        state= MY_LEX_CHAR;             // Read char by char
1002
996
        break;
1003
997
      }
1004
 
      yylval->lex_str.length=lip->yytoklen;
 
998
      yylval->lex_str.assign(yylval->lex_str.data(), lip->yytoklen);
1005
999
 
1006
1000
      lip->body_utf8_append(lip->m_cpp_text_start);
1007
 
 
1008
1001
      lip->body_utf8_append_literal(&yylval->lex_str, lip->m_cpp_text_end);
1009
1002
 
1010
1003
      lex->text_string_is_7bit= (lip->tok_bitmap & 0x80) ? 0 : 1;
1195
1188
        lip->next_state=MY_LEX_HOSTNAME;
1196
1189
        break;
1197
1190
      }
1198
 
      yylval->lex_str.str=(char*) lip->get_ptr();
1199
 
      yylval->lex_str.length=1;
1200
 
      return((int) '@');
 
1191
      yylval->lex_str.assign(lip->get_ptr(), 1);
 
1192
      return '@';
1201
1193
 
1202
1194
    case MY_LEX_HOSTNAME:               // end '@' of user@hostname
1203
1195
      for (c=lip->yyGet() ;
1207
1199
      return(LEX_HOSTNAME);
1208
1200
 
1209
1201
    case MY_LEX_SYSTEM_VAR:
1210
 
      yylval->lex_str.str=(char*) lip->get_ptr();
1211
 
      yylval->lex_str.length=1;
 
1202
      yylval->lex_str.assign(lip->get_ptr(), 1);
1212
1203
      lip->yySkip();                                    // Skip '@'
1213
1204
      lip->next_state= (state_map[(uint8_t)lip->yyPeek()] ==
1214
1205
                        MY_LEX_USER_VARIABLE_DELIMITER ?