diff options
Diffstat (limited to 'mysys/typelib.c')
-rw-r--r-- | mysys/typelib.c | 399 |
1 files changed, 399 insertions, 0 deletions
diff --git a/mysys/typelib.c b/mysys/typelib.c new file mode 100644 index 00000000..03f3609b --- /dev/null +++ b/mysys/typelib.c @@ -0,0 +1,399 @@ +/* Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved. + Copyright (c) 2009, 2013, Monty Program Ab. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; version 2 of the License. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */ + +/* Functions to handle typelib */ + +#include "mysys_priv.h" +#include <m_string.h> +#include <m_ctype.h> + + +#define is_field_separator(F, X) \ + ((F & FIND_TYPE_COMMA_TERM) && ((X) == ',' || (X) == '=')) + +int find_type_with_warning(const char *x, TYPELIB *typelib, const char *option) +{ + int res; + const char **ptr; + + if ((res= find_type((char *) x, typelib, FIND_TYPE_BASIC)) <= 0) + { + ptr= typelib->type_names; + if (!*x) + fprintf(stderr, "No option given to %s\n", option); + else + fprintf(stderr, "Unknown option to %s: %s\n", option, x); + fprintf(stderr, "Alternatives are: '%s'", *ptr); + while (*++ptr) + fprintf(stderr, ",'%s'", *ptr); + fprintf(stderr, "\n"); + } + return res; +} + + +/** + Search after a string in a list of strings. Endspace in x is not compared. + + @param x pointer to string to find + (not necessarily zero-terminated). + by return it'll be advanced to point to the terminator. + @param typelib TYPELIB (struct of pointer to values + count) + @param flags flags to tune behaviour: a combination of + FIND_TYPE_NO_PREFIX + FIND_TYPE_COMMA_TERM. + @param eol a pointer to the end of the string. + + @retval + -1 Too many matching values + @retval + 0 No matching value + @retval + >0 Offset+1 in typelib for matched string +*/ + + +static int find_type_eol(const char **x, const TYPELIB *typelib, uint flags, + const char *eol) +{ + int find,pos; + int UNINIT_VAR(findpos); /* guarded by find */ + const char *UNINIT_VAR(termptr); + const char *i; + const char *j; + CHARSET_INFO *cs= &my_charset_latin1; + DBUG_ENTER("find_type_eol"); + DBUG_PRINT("enter",("x: '%s' lib: %p", *x, typelib)); + + DBUG_ASSERT(!(flags & ~(FIND_TYPE_NO_PREFIX | FIND_TYPE_COMMA_TERM))); + + if (!typelib->count) + { + DBUG_PRINT("exit",("no count")); + DBUG_RETURN(0); + } + find=0; + for (pos=0 ; (j=typelib->type_names[pos]) ; pos++) + { + for (i=*x ; + i < eol && !is_field_separator(flags, *i) && + my_toupper(cs, *i) == my_toupper(cs, *j) ; i++, j++) ; + if (! *j) + { + while (i < eol && *i == ' ') + i++; /* skip_end_space */ + if (i >= eol || is_field_separator(flags, *i)) + { + *x= i; + DBUG_RETURN(pos+1); + } + } + if ((i >= eol && !is_field_separator(flags, *i)) && + (!*j || !(flags & FIND_TYPE_NO_PREFIX))) + { + find++; + findpos=pos; + termptr=i; + } + } + if (find == 0 || *x == eol) + { + DBUG_PRINT("exit",("Couldn't find type")); + DBUG_RETURN(0); + } + else if (find != 1 || (flags & FIND_TYPE_NO_PREFIX)) + { + DBUG_PRINT("exit",("Too many possibilities")); + DBUG_RETURN(-1); + } + *x= termptr; + DBUG_RETURN(findpos+1); +} /* find_type_eol */ + + +/** + Search after a string in a list of strings. Endspace in x is not compared. + + Same as find_type_eol, but for zero-terminated strings, + and without advancing the pointer. +*/ +int find_type(const char *x, const TYPELIB *typelib, uint flags) +{ + return find_type_eol(&x, typelib, flags, x + strlen(x)); +} + +/** + Get name of type nr + + @note + first type is 1, 0 = empty field +*/ + +void make_type(register char * to, register uint nr, + register TYPELIB *typelib) +{ + DBUG_ENTER("make_type"); + if (!nr) + to[0]=0; + else + (void) strmov(to,get_type(typelib,nr-1)); + DBUG_VOID_RETURN; +} /* make_type */ + + +/** + Get type + + @note + first type is 0 +*/ + +const char *get_type(TYPELIB *typelib, uint nr) +{ + if (nr < (uint) typelib->count && typelib->type_names) + return(typelib->type_names[nr]); + return "?"; +} + + +/** + Create an integer value to represent the supplied comma-separated + string where each string in the TYPELIB denotes a bit position. + + @param x string to decompose + @param lib TYPELIB (struct of pointer to values + count) + @param err index (not char position) of string element which was not + found or 0 if there was no error + + @retval + a integer representation of the supplied string +*/ + +my_ulonglong find_typeset(const char *x, TYPELIB *lib, int *err) +{ + my_ulonglong result; + int find; + const char *i; + DBUG_ENTER("find_set"); + DBUG_PRINT("enter",("x: '%s' lib: %p", x, lib)); + + if (!lib->count) + { + DBUG_PRINT("exit",("no count")); + DBUG_RETURN(0); + } + result= 0; + *err= 0; + while (*x) + { + (*err)++; + i= x; + while (*x && *x != ',') + x++; + if (x[0] && x[1]) /* skip separator if found */ + x++; + if ((find= find_type(i, lib, FIND_TYPE_COMMA_TERM) - 1) < 0) + DBUG_RETURN(0); + result|= (1ULL << find); + } + *err= 0; + DBUG_RETURN(result); +} /* find_set */ + + +/** + Create a copy of a specified TYPELIB structure. + + @param root pointer to a MEM_ROOT object for allocations + @param from pointer to a source TYPELIB structure + + @retval + pointer to the new TYPELIB structure on successful copy + @retval + NULL otherwise +*/ + +TYPELIB *copy_typelib(MEM_ROOT *root, const TYPELIB *from) +{ + TYPELIB *to; + uint i; + + if (!from) + return NULL; + + if (!(to= (TYPELIB*) alloc_root(root, sizeof(TYPELIB)))) + return NULL; + + if (!(to->type_names= (const char **) + alloc_root(root, (sizeof(char *) + sizeof(int)) * (from->count + 1)))) + return NULL; + to->type_lengths= (unsigned int *)(to->type_names + from->count + 1); + to->count= from->count; + if (from->name) + { + if (!(to->name= strdup_root(root, from->name))) + return NULL; + } + else + to->name= NULL; + + for (i= 0; i < from->count; i++) + { + if (!(to->type_names[i]= strmake_root(root, from->type_names[i], + from->type_lengths[i]))) + return NULL; + to->type_lengths[i]= from->type_lengths[i]; + } + to->type_names[to->count]= NULL; + to->type_lengths[to->count]= 0; + + return to; +} + + +static const char *on_off_default_names[]= { "off","on","default", 0}; +static TYPELIB on_off_default_typelib= {array_elements(on_off_default_names)-1, + "", on_off_default_names, 0}; + +/** + Parse a TYPELIB name from the buffer + + @param lib Set of names to scan for. + @param strpos INOUT Start of the buffer (updated to point to the next + character after the name) + @param end End of the buffer + + @note + The buffer is assumed to contain one of the names specified in the TYPELIB, + followed by comma, '=', or end of the buffer. + + @retval + 0 No matching name + @retval + >0 Offset+1 in typelib for matched name +*/ + +static uint parse_name(const TYPELIB *lib, const char **pos, const char *end) +{ + uint find= find_type_eol(pos, lib, + FIND_TYPE_COMMA_TERM | FIND_TYPE_NO_PREFIX, end); + return find; +} + +/** + Parse and apply a set of flag assingments + + @param lib Flag names + @param default_name Number of "default" in the typelib + @param cur_set Current set of flags (start from this state) + @param default_set Default set of flags (use this for assign-default + keyword and flag=default assignments) + @param str String to be parsed + @param length Length of the string + @param err_pos OUT If error, set to point to start of wrong set string + NULL on success + @param err_len OUT If error, set to the length of wrong set string + + @details + Parse a set of flag assignments, that is, parse a string in form: + + param_name1=value1,param_name2=value2,... + + where the names are specified in the TYPELIB, and each value can be + either 'on','off', or 'default'. Setting the same name twice is not + allowed. + + Besides param=val assignments, we support the "default" keyword (keyword + #default_name in the typelib). It can be used one time, if specified it + causes us to build the new set over the default_set rather than cur_set + value. + + @note + it's not charset aware + + @retval + Parsed set value if (*errpos == NULL), otherwise undefined +*/ + +my_ulonglong find_set_from_flags(const TYPELIB *lib, uint default_name, + my_ulonglong cur_set, my_ulonglong default_set, + const char *str, uint length, + char **err_pos, uint *err_len) +{ + const char *end= str + length; + my_ulonglong flags_to_set= 0, flags_to_clear= 0, res; + my_bool set_defaults= 0; + + *err_pos= 0; /* No error yet */ + if (str != end) + { + const char *start= str; + for (;;) + { + const char *pos= start; + uint flag_no, value; + + if (!(flag_no= parse_name(lib, &pos, end))) + goto err; + + if (flag_no == default_name) + { + /* Using 'default' twice isn't allowed. */ + if (set_defaults) + goto err; + set_defaults= TRUE; + } + else + { + my_ulonglong bit= (1ULL << (flag_no - 1)); + /* parse the '=on|off|default' */ + if ((flags_to_clear | flags_to_set) & bit || + pos >= end || *pos++ != '=' || + !(value= parse_name(&on_off_default_typelib, &pos, end))) + goto err; + + if (value == 1) /* this is '=off' */ + flags_to_clear|= bit; + else if (value == 2) /* this is '=on' */ + flags_to_set|= bit; + else /* this is '=default' */ + { + if (default_set & bit) + flags_to_set|= bit; + else + flags_to_clear|= bit; + } + } + if (pos >= end) + break; + + if (*pos++ != ',') + goto err; + + start=pos; + continue; + err: + *err_pos= (char*)start; + *err_len= (uint)(end - start); + break; + } + } + res= set_defaults? default_set : cur_set; + res|= flags_to_set; + res&= ~flags_to_clear; + return res; +} + |