The world's most popular open source database

MySQL 5.1: File_parser Class Reference

File_parser Class Reference

#include <parse_file.h>

Inheritance diagram for File_parser:

[legend]Collaboration diagram for File_parser:

[legend]List of all members.


Public Member Functions
	File_parser ()
my_bool	ok ()
LEX_STRING *	type ()
my_bool	parse (gptr base, MEM_ROOT mem_root, struct File_option parameters, uint required, Unknown_key_hook *hook)
Private Attributes
char *	buff
char *	start
char *	end
LEX_STRING	file_type
my_bool	content_ok
Friends
File_parser *	sql_parse_prepare (const LEX_STRING file_name, MEM_ROOT mem_root, bool bad_format_errors)

Detailed Description

Definition at line 90 of file parse_file.h.

Constructor & Destructor Documentation

File_parser::File_parser ( ) [inline]

Definition at line 96 of file parse_file.h.

00096                 :buff(0), start(0), end(0), content_ok(0)
00097     { file_type.str= 0; file_type.length= 0; }

Member Function Documentation

my_bool File_parser::ok ( ) [inline]

Definition at line 99 of file parse_file.h.

References content_ok.

00099 { return content_ok; }

my_bool File_parser::parse	(	gptr	base,
		MEM_ROOT *	mem_root,
		struct File_option *	parameters,
		uint	required,
		Unknown_key_hook *	hook
	)

Definition at line 753 of file parse_file.cc.

References alloc_root(), DBUG_ASSERT, DBUG_ENTER, DBUG_RETURN, end, end_of_list, ER_FPARSER_EOF_IN_COMMENT, ER_FPARSER_ERROR_IN_PARAMETER, FILE_OPTIONS_ESTRING, FILE_OPTIONS_REV, FILE_OPTIONS_STRING, FILE_OPTIONS_STRLIST, FILE_OPTIONS_TIMESTAMP, FILE_OPTIONS_ULLLIST, FILE_OPTIONS_ULONGLONG, get_file_options_ulllist(), LEX_STRING::length, line, list(), memcmp(), memcpy, my_error(), my_strtoll10(), MYF, File_option::name, File_option::offset, parse_escaped_string(), PARSE_FILE_TIMESTAMPLENGTH, parse_quoted_escaped_string(), parse_string(), start, LEX_STRING::str, strchr(), TRUE, and File_option::type.

00756 {
00757   uint first_param= 0, found= 0;
00758   char *ptr= start;
00759   char *eol;
00760   LEX_STRING *str;
00761   List<LEX_STRING> *list;
00762   DBUG_ENTER("File_parser::parse");
00763 
00764   while (ptr < end && found < required)
00765   {
00766     char *line= ptr;
00767     if (*ptr == '#')
00768     {
00769       // it is comment
00770       if (!(ptr= strchr(ptr, '\n')))
00771       {
00772         my_error(ER_FPARSER_EOF_IN_COMMENT, MYF(0), line);
00773         DBUG_RETURN(TRUE);
00774       }
00775       ptr++;
00776     }
00777     else
00778     {
00779       File_option *parameter= parameters+first_param,
00780         *parameters_end= parameters+required;
00781       int len= 0;
00782       for (; parameter < parameters_end; parameter++)
00783       {
00784         len= parameter->name.length;
00785         // check length
00786         if (len < (end-ptr) && ptr[len] != '=')
00787           continue;
00788         // check keyword
00789         if (memcmp(parameter->name.str, ptr, len) == 0)
00790           break;
00791       }
00792 
00793       if (parameter < parameters_end)
00794       {
00795         found++;
00796         /*
00797           if we found first parameter, start search from next parameter
00798           next time.
00799           (this small optimisation should work, because they should be
00800           written in same order)
00801         */
00802         if (parameter == parameters+first_param)
00803           first_param++;
00804 
00805         // get value
00806         ptr+= (len+1);
00807         switch (parameter->type) {
00808         case FILE_OPTIONS_STRING:
00809         {
00810           if (!(ptr= parse_string(ptr, end, mem_root,
00811                                   (LEX_STRING *)(base +
00812                                                  parameter->offset))))
00813           {
00814             my_error(ER_FPARSER_ERROR_IN_PARAMETER, MYF(0),
00815                      parameter->name.str, line);
00816             DBUG_RETURN(TRUE);
00817           }
00818           break;
00819         }
00820         case FILE_OPTIONS_ESTRING:
00821         {
00822           if (!(ptr= parse_escaped_string(ptr, end, mem_root,
00823                                           (LEX_STRING *)
00824                                           (base + parameter->offset))))
00825           {
00826             my_error(ER_FPARSER_ERROR_IN_PARAMETER, MYF(0),
00827                      parameter->name.str, line);
00828             DBUG_RETURN(TRUE);
00829           }
00830           break;
00831         }
00832         case FILE_OPTIONS_ULONGLONG:
00833         case FILE_OPTIONS_REV:
00834           if (!(eol= strchr(ptr, '\n')))
00835           {
00836             my_error(ER_FPARSER_ERROR_IN_PARAMETER, MYF(0),
00837                      parameter->name.str, line);
00838             DBUG_RETURN(TRUE);
00839           }
00840           {
00841             int not_used;
00842             *((ulonglong*)(base + parameter->offset))=
00843               my_strtoll10(ptr, 0, &not_used);
00844           }
00845           ptr= eol+1;
00846           break;
00847         case FILE_OPTIONS_TIMESTAMP:
00848         {
00849           /* string have to be allocated already */
00850           LEX_STRING *val= (LEX_STRING *)(base + parameter->offset);
00851           /* yyyy-mm-dd HH:MM:SS = 19(PARSE_FILE_TIMESTAMPLENGTH) characters */
00852           if (ptr[PARSE_FILE_TIMESTAMPLENGTH] != '\n')
00853           {
00854             my_error(ER_FPARSER_ERROR_IN_PARAMETER, MYF(0),
00855                      parameter->name.str, line);
00856             DBUG_RETURN(TRUE);
00857           }
00858           memcpy(val->str, ptr, PARSE_FILE_TIMESTAMPLENGTH);
00859           val->str[val->length= PARSE_FILE_TIMESTAMPLENGTH]= '\0';
00860           ptr+= (PARSE_FILE_TIMESTAMPLENGTH+1);
00861           break;
00862         }
00863         case FILE_OPTIONS_STRLIST:
00864         {
00865           list= (List<LEX_STRING>*)(base + parameter->offset);
00866 
00867           list->empty();
00868           // list parsing
00869           while (ptr < end)
00870           {
00871             if (!(str= (LEX_STRING*)alloc_root(mem_root,
00872                                                sizeof(LEX_STRING))) ||
00873                 list->push_back(str, mem_root))
00874               goto list_err;
00875             if (!(ptr= parse_quoted_escaped_string(ptr, end, mem_root, str)))
00876               goto list_err_w_message;
00877             switch (*ptr) {
00878             case '\n':
00879               goto end_of_list;
00880             case ' ':
00881               // we cant go over buffer bounds, because we have \0 at the end
00882               ptr++;
00883               break;
00884             default:
00885               goto list_err_w_message;
00886             }
00887           }
00888 
00889 end_of_list:
00890           if (*(ptr++) != '\n')
00891             goto list_err;
00892           break;
00893 
00894 list_err_w_message:
00895           my_error(ER_FPARSER_ERROR_IN_PARAMETER, MYF(0),
00896                    parameter->name.str, line);
00897 list_err:
00898           DBUG_RETURN(TRUE);
00899         }
00900         case FILE_OPTIONS_ULLLIST:
00901           if (get_file_options_ulllist(ptr, end, line, base,
00902                                        parameter, mem_root))
00903             DBUG_RETURN(TRUE);
00904           break;
00905         default:
00906           DBUG_ASSERT(0); // never should happened
00907         }
00908       }
00909       else
00910       {
00911         ptr= line;
00912         if (hook->process_unknown_string(ptr, base, mem_root, end))
00913         {
00914           DBUG_RETURN(TRUE);
00915         }
00916         // skip unknown parameter
00917         if (!(ptr= strchr(ptr, '\n')))
00918         {
00919           my_error(ER_FPARSER_EOF_IN_UNKNOWN_PARAMETER, MYF(0), line);
00920           DBUG_RETURN(TRUE);
00921         }
00922         ptr++;
00923       }
00924     }
00925   }
00926   DBUG_RETURN(FALSE);
00927 }

Here is the call graph for this function:

LEX_STRING* File_parser::type ( ) [inline]

Definition at line 100 of file parse_file.h.

00100 { return &file_type; }

Friends And Related Function Documentation

File_parser* sql_parse_prepare	(	const LEX_STRING *	file_name,
		MEM_ROOT *	mem_root,
		bool	bad_format_errors
	)			`[friend]`

Definition at line 422 of file parse_file.cc.

00424 {
00425   MY_STAT stat_info;
00426   uint len;
00427   char *end, *sign;
00428   File_parser *parser;
00429   File file;
00430   DBUG_ENTER("sql_parse_prepare");
00431 
00432   if (!my_stat(file_name->str, &stat_info, MYF(MY_WME)))
00433   {
00434     DBUG_RETURN(0);
00435   }
00436 
00437   if (stat_info.st_size > INT_MAX-1)
00438   {
00439     my_error(ER_FPARSER_TOO_BIG_FILE, MYF(0), file_name->str);
00440     DBUG_RETURN(0);
00441   }
00442 
00443   if (!(parser= new(mem_root) File_parser))
00444   {
00445     DBUG_RETURN(0);
00446   }
00447 
00448   if (!(parser->buff= alloc_root(mem_root, stat_info.st_size+1)))
00449   {
00450     DBUG_RETURN(0);
00451   }
00452 
00453   if ((file= my_open(file_name->str, O_RDONLY | O_SHARE, MYF(MY_WME))) < 0)
00454   {
00455     DBUG_RETURN(0);
00456   }
00457   
00458   if ((len= my_read(file, (byte *)parser->buff,
00459                     stat_info.st_size, MYF(MY_WME))) ==
00460       MY_FILE_ERROR)
00461   {
00462     my_close(file, MYF(MY_WME));
00463     DBUG_RETURN(0);
00464   }
00465 
00466   if (my_close(file, MYF(MY_WME)))
00467   {
00468     DBUG_RETURN(0);
00469   }
00470 
00471   end= parser->end= parser->buff + len;
00472   *end= '\0'; // barrier for more simple parsing
00473 
00474   // 7 = 5 (TYPE=) + 1 (letter at least of type name) + 1 ('\n')
00475   if (len < 7 ||
00476       parser->buff[0] != 'T' ||
00477       parser->buff[1] != 'Y' ||
00478       parser->buff[2] != 'P' ||
00479       parser->buff[3] != 'E' ||
00480       parser->buff[4] != '=')
00481     goto frm_error;
00482 
00483   // skip signature;
00484   parser->file_type.str= sign= parser->buff + 5;
00485   while (*sign >= 'A' && *sign <= 'Z' && sign < end)
00486     sign++;
00487   if (*sign != '\n')
00488     goto frm_error;
00489   parser->file_type.length= sign - parser->file_type.str;
00490   // EOS for file signature just for safety
00491   *sign= '\0';
00492 
00493   parser->start= sign + 1;
00494   parser->content_ok= 1;
00495 
00496   DBUG_RETURN(parser);
00497 
00498 frm_error:
00499   if (bad_format_errors)
00500   {
00501     my_error(ER_FPARSER_BAD_HEADER, MYF(0), file_name->str);
00502     DBUG_RETURN(0);
00503   }
00504   else
00505     DBUG_RETURN(parser); // upper level have to check parser->ok()
00506 }

Member Data Documentation

char* File_parser::buff [private]

Definition at line 92 of file parse_file.h.

my_bool File_parser::content_ok [private]

Definition at line 94 of file parse_file.h.

Referenced by ok().

char * File_parser::end [private]

Definition at line 92 of file parse_file.h.

Referenced by parse().

LEX_STRING File_parser::file_type [private]

Definition at line 93 of file parse_file.h.

char * File_parser::start [private]

Definition at line 92 of file parse_file.h.

Referenced by parse().

The documentation for this class was generated from the following files:

mysql/src/5.1-dbg/sql/parse_file.h
mysql/src/5.1-dbg/sql/parse_file.cc

Generated on Sat Sep 9 21:07:03 2006 for MySQL 5.1 by

1.4.7

The world's most popular open source database

File_parser Class Reference

Public Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation