New ctype functions/macros to support many charsets at a time
client/mysql.cc: new ctypes client/mysqldump.c: new ctypes client/mysqltest.c: new ctypes client/sql_string.cc: new ctypes client/sql_string.h: new ctypes extra/mysql_install.c: new ctypes extra/replace.c: new ctypes extra/resolve_stack_dump.c: new ctypes extra/resolveip.c: new ctypes heap/hp_hash.c: new ctypes include/m_ctype.h: new ctypes include/my_sys.h: new ctypes isam/_key.c: new ctypes isam/_search.c: new ctypes libmysql/Makefile.shared: new ctypes libmysql/libmysql.c: new ctypes myisam/ft_dump.c: new ctypes myisam/ft_parser.c: new ctypes myisam/mi_test1.c: new ctypes mysys/charset.c: new ctypes mysys/default.c: new ctypes mysys/getvar.c: new ctypes mysys/hash.c: new ctypes mysys/mf_casecnv.c: new ctypes mysys/mf_dirname.c: new ctypes mysys/mf_format.c: new ctypes mysys/mf_iocache2.c: new ctypes mysys/mf_soundex.c: new ctypes mysys/mf_wfile.c: new ctypes mysys/my_error.c: new ctypes mysys/my_getwd.c: new ctypes mysys/my_init.c: new ctypes mysys/my_vsnprintf.c: new ctypes mysys/typelib.c: new ctypes sql/convert.cc: new ctypes sql/des_key_file.cc: new ctypes sql/field.cc: new ctypes sql/field.h: new ctypes sql/field_conv.cc: new ctypes sql/filesort.cc: new ctypes sql/ha_innodb.cc: new ctypes sql/hostname.cc: new ctypes sql/init.cc: new ctypes sql/item.cc: new ctypes sql/item_func.cc: new ctypes sql/item_strfunc.cc: new ctypes sql/item_sum.cc: new ctypes sql/item_timefunc.cc: new ctypes sql/key.cc: new ctypes sql/log.cc: new ctypes sql/mysql_priv.h: new ctypes sql/mysqld.cc: new ctypes sql/opt_range.cc: new ctypes sql/procedure.cc: new ctypes sql/slave.cc: new ctypes sql/sql_acl.cc: new ctypes sql/sql_analyse.cc: new ctypes sql/sql_base.cc: new ctypes sql/sql_cache.cc: new ctypes sql/sql_db.cc: new ctypes sql/sql_handler.cc: new ctypes sql/sql_lex.cc: new ctypes sql/sql_parse.cc: new ctypes sql/sql_show.cc: new ctypes sql/sql_string.cc: new ctypes sql/sql_string.h: new ctypes sql/sql_table.cc: new ctypes sql/sql_yacc.yy: new ctypes sql/table.cc: new ctypes sql/time.cc: new ctypes strings/Makefile.am: new ctypes strings/ctype-big5.c: new ctypes strings/ctype-czech.c: new ctypes strings/ctype-gbk.c: new ctypes strings/ctype-latin1_de.c: new ctypes strings/ctype-sjis.c: new ctypes strings/ctype-tis620.c: new ctypes strings/ctype.c: new ctypes strings/str2int.c: new ctypes strings/strto.c: new ctypes tools/mysqlmanager.c: new ctypes
This commit is contained in:
parent
003b294967
commit
68375e0f00
@ -924,14 +924,14 @@ static COMMANDS *find_command (char *name,char cmd_char)
|
||||
}
|
||||
else
|
||||
{
|
||||
while (isspace(*name))
|
||||
while (my_isspace(system_charset_info,*name))
|
||||
name++;
|
||||
if (strchr(name,';') || strstr(name,"\\g"))
|
||||
return ((COMMANDS *) 0);
|
||||
if ((end=strcont(name," \t")))
|
||||
{
|
||||
len=(uint) (end - name);
|
||||
while (isspace(*end))
|
||||
while (my_isspace(system_charset_info,*end))
|
||||
end++;
|
||||
if (!*end)
|
||||
end=0; // no arguments to function
|
||||
@ -943,7 +943,8 @@ static COMMANDS *find_command (char *name,char cmd_char)
|
||||
for (uint i= 0; commands[i].name; i++)
|
||||
{
|
||||
if (commands[i].func &&
|
||||
((name && !my_casecmp(name,commands[i].name,len) &&
|
||||
((name &&
|
||||
!my_strncasecmp(system_charset_info,name,commands[i].name,len) &&
|
||||
!commands[i].name[len] &&
|
||||
(!end || (end && commands[i].takes_params))) ||
|
||||
!name && commands[i].cmd_char == cmd_char))
|
||||
@ -971,7 +972,8 @@ static bool add_line(String &buffer,char *line,char *in_string)
|
||||
|
||||
for (pos=out=line ; (inchar= (uchar) *pos) ; pos++)
|
||||
{
|
||||
if (isspace(inchar) && out == line && buffer.is_empty())
|
||||
if (my_isspace(default_charset_info,inchar) && out == line &&
|
||||
buffer.is_empty())
|
||||
continue;
|
||||
#ifdef USE_MB
|
||||
int l;
|
||||
@ -1039,7 +1041,7 @@ static bool add_line(String &buffer,char *line,char *in_string)
|
||||
}
|
||||
else if (!*in_string && (inchar == '#' ||
|
||||
inchar == '-' && pos[1] == '-' &&
|
||||
isspace(pos[2])))
|
||||
my_isspace(system_charset_info,pos[2])))
|
||||
break; // comment to end of line
|
||||
else
|
||||
{ // Add found char to buffer
|
||||
@ -1439,7 +1441,8 @@ com_go(String *buffer,char *line __attribute__((unused)))
|
||||
(void) com_print(buffer,0);
|
||||
|
||||
if (skip_updates &&
|
||||
(buffer->length() < 4 || my_sortcmp(buffer->ptr(),"SET ",4)))
|
||||
(buffer->length() < 4 || my_sortcmp(system_charset_info,buffer->ptr(),
|
||||
"SET ",4)))
|
||||
{
|
||||
(void) put_info("Ignoring query to other database",INFO_INFO);
|
||||
return 0;
|
||||
@ -1871,7 +1874,7 @@ com_tee(String *buffer, char *line __attribute__((unused)))
|
||||
|
||||
if (status.batch)
|
||||
return 0;
|
||||
while (isspace(*line))
|
||||
while (my_isspace(system_charset_info,*line))
|
||||
line++;
|
||||
if (!(param = strchr(line, ' '))) // if outfile wasn't given, use the default
|
||||
{
|
||||
@ -1884,10 +1887,11 @@ com_tee(String *buffer, char *line __attribute__((unused)))
|
||||
}
|
||||
else
|
||||
{
|
||||
while (isspace(*param))
|
||||
while (my_isspace(system_charset_info,*param))
|
||||
param++;
|
||||
end=strmake(file_name, param, sizeof(file_name)-1);
|
||||
while (end > file_name && (isspace(end[-1]) || iscntrl(end[-1])))
|
||||
while (end > file_name && (my_isspace(system_charset_info,end[-1]) ||
|
||||
my_iscntrl(system_charset_info,end[-1])))
|
||||
end--;
|
||||
end[0]=0;
|
||||
strmov(outfile, file_name);
|
||||
@ -1930,7 +1934,7 @@ com_pager(String *buffer, char *line __attribute__((unused)))
|
||||
if (status.batch)
|
||||
return 0;
|
||||
/* Skip space from file name */
|
||||
while (isspace(*line))
|
||||
while (my_isspace(system_charset_info,*line))
|
||||
line++;
|
||||
if (!(param = strchr(line, ' '))) // if pager was not given, use the default
|
||||
{
|
||||
@ -1946,10 +1950,11 @@ com_pager(String *buffer, char *line __attribute__((unused)))
|
||||
}
|
||||
else
|
||||
{
|
||||
while (isspace(*param))
|
||||
while (my_isspace(system_charset_info,*param))
|
||||
param++;
|
||||
end=strmake(pager_name, param, sizeof(pager_name)-1);
|
||||
while (end > pager_name && (isspace(end[-1]) || iscntrl(end[-1])))
|
||||
while (end > pager_name && (my_isspace(system_charset_info,end[-1]) ||
|
||||
my_iscntrl(system_charset_info,end[-1])))
|
||||
end--;
|
||||
end[0]=0;
|
||||
strmov(pager, pager_name);
|
||||
@ -2083,7 +2088,7 @@ com_connect(String *buffer, char *line)
|
||||
|
||||
if (buffer)
|
||||
{
|
||||
while (isspace(*line))
|
||||
while (my_isspace(system_charset_info,*line))
|
||||
line++;
|
||||
strnmov(buff,line,sizeof(buff)-1); // Don't destroy history
|
||||
if (buff[0] == '\\') // Short command
|
||||
@ -2129,15 +2134,16 @@ static int com_source(String *buffer, char *line)
|
||||
FILE *sql_file;
|
||||
|
||||
/* Skip space from file name */
|
||||
while (isspace(*line))
|
||||
while (my_isspace(system_charset_info,*line))
|
||||
line++;
|
||||
if (!(param = strchr(line, ' '))) // Skip command name
|
||||
return put_info("Usage: \\. <filename> | source <filename>",
|
||||
INFO_ERROR, 0);
|
||||
while (isspace(*param))
|
||||
while (my_isspace(system_charset_info,*param))
|
||||
param++;
|
||||
end=strmake(source_name,param,sizeof(source_name)-1);
|
||||
while (end > source_name && (isspace(end[-1]) || iscntrl(end[-1])))
|
||||
while (end > source_name && (my_isspace(system_charset_info,end[-1]) ||
|
||||
my_iscntrl(system_charset_info,end[-1])))
|
||||
end--;
|
||||
end[0]=0;
|
||||
unpack_filename(source_name,source_name);
|
||||
@ -2178,7 +2184,7 @@ com_use(String *buffer __attribute__((unused)), char *line)
|
||||
char *tmp;
|
||||
char buff[256];
|
||||
|
||||
while (isspace(*line))
|
||||
while (my_isspace(system_charset_info,*line))
|
||||
line++;
|
||||
strnmov(buff,line,sizeof(buff)-1); // Don't destroy history
|
||||
if (buff[0] == '\\') // Short command
|
||||
@ -2463,7 +2469,7 @@ static void remove_cntrl(String &buffer)
|
||||
{
|
||||
char *start,*end;
|
||||
end=(start=(char*) buffer.ptr())+buffer.length();
|
||||
while (start < end && !isgraph(end[-1]))
|
||||
while (start < end && !my_isgraph(system_charset_info,end[-1]))
|
||||
end--;
|
||||
buffer.length((uint) (end-start));
|
||||
}
|
||||
|
@ -600,7 +600,7 @@ static my_bool test_if_special_chars(const char *str)
|
||||
{
|
||||
#if MYSQL_VERSION_ID >= 32300
|
||||
for ( ; *str ; str++)
|
||||
if (!isvar(*str) && *str != '$')
|
||||
if (!my_isvar(system_charset_info,*str) && *str != '$')
|
||||
return 1;
|
||||
#endif
|
||||
return 0;
|
||||
@ -1112,7 +1112,8 @@ static void dumpTable(uint numFields, char *table)
|
||||
/* change any strings ("inf","nan",..) into NULL */
|
||||
char *ptr = row[i];
|
||||
dynstr_append(&extended_row,
|
||||
(!isalpha(*ptr)) ? ptr : "NULL");
|
||||
(!my_isalpha(system_charset_info,*ptr)) ?
|
||||
ptr : "NULL");
|
||||
}
|
||||
}
|
||||
else
|
||||
@ -1144,9 +1145,11 @@ static void dumpTable(uint numFields, char *table)
|
||||
char *ptr = row[i];
|
||||
if (opt_xml)
|
||||
fprintf(md_result_file, "\t\t<%s>%s</%s>\n",
|
||||
field->name,!isalpha(*ptr) ?ptr: "NULL",field->name);
|
||||
field->name,
|
||||
!my_isalpha(system_charset_info,*ptr) ?ptr: "NULL",field->name);
|
||||
else
|
||||
fputs((!isalpha(*ptr)) ? ptr : "NULL", md_result_file);
|
||||
fputs((!my_isalpha(system_charset_info,*ptr)) ?
|
||||
ptr : "NULL", md_result_file);
|
||||
}
|
||||
}
|
||||
else
|
||||
|
@ -456,9 +456,9 @@ void init_parser()
|
||||
|
||||
int hex_val(int c)
|
||||
{
|
||||
if (isdigit(c))
|
||||
if (my_isdigit(system_charset_info,c))
|
||||
return c - '0';
|
||||
else if ((c = tolower(c)) >= 'a' && c <= 'f')
|
||||
else if ((c = my_tolower(system_charset_info,c)) >= 'a' && c <= 'f')
|
||||
return c - 'a' + 10;
|
||||
else
|
||||
return -1;
|
||||
@ -569,7 +569,7 @@ VAR* var_get(const char* var_name, const char** var_name_end, my_bool raw,
|
||||
{
|
||||
const char* save_var_name = var_name, *end;
|
||||
end = (var_name_end) ? *var_name_end : 0;
|
||||
while (isvar(*var_name) && var_name != end)
|
||||
while (my_isvar(system_charset_info,*var_name) && var_name != end)
|
||||
++var_name;
|
||||
if (var_name == save_var_name)
|
||||
{
|
||||
@ -729,7 +729,7 @@ int do_server_op(struct st_query* q,const char* op)
|
||||
com_p=strmov(com_p,"_exec ");
|
||||
if (!*p)
|
||||
die("Missing server name in server_%s\n",op);
|
||||
while (*p && !isspace(*p))
|
||||
while (*p && !my_isspace(system_charset_info,*p))
|
||||
{
|
||||
*com_p++=*p++;
|
||||
}
|
||||
@ -762,7 +762,7 @@ int do_require_version(struct st_query* q)
|
||||
if (!*p)
|
||||
die("Missing version argument in require_version\n");
|
||||
ver_arg = p;
|
||||
while (*p && !isspace(*p))
|
||||
while (*p && !my_isspace(system_charset_info,*p))
|
||||
p++;
|
||||
*p = 0;
|
||||
ver_arg_len = p - ver_arg;
|
||||
@ -792,7 +792,7 @@ int do_source(struct st_query* q)
|
||||
if (!*p)
|
||||
die("Missing file name in source\n");
|
||||
name = p;
|
||||
while (*p && !isspace(*p))
|
||||
while (*p && !my_isspace(system_charset_info,*p))
|
||||
p++;
|
||||
*p = 0;
|
||||
|
||||
@ -1012,11 +1012,11 @@ int do_let(struct st_query* q)
|
||||
if (!*p)
|
||||
die("Missing variable name in let\n");
|
||||
var_name = p;
|
||||
while(*p && (*p != '=' || isspace(*p)))
|
||||
while(*p && (*p != '=' || my_isspace(system_charset_info,*p)))
|
||||
p++;
|
||||
var_name_end = p;
|
||||
if (*p == '=') p++;
|
||||
while(*p && isspace(*p))
|
||||
while(*p && my_isspace(system_charset_info,*p))
|
||||
p++;
|
||||
var_val_start = p;
|
||||
return var_set(var_name, var_name_end, var_val_start, q->end);
|
||||
@ -1047,7 +1047,7 @@ int do_sleep(struct st_query* q)
|
||||
char* p=q->first_argument;
|
||||
struct timeval t;
|
||||
int dec_mul = 1000000;
|
||||
while(*p && isspace(*p)) p++;
|
||||
while(*p && my_isspace(system_charset_info,*p)) p++;
|
||||
if (!*p)
|
||||
die("Missing argument in sleep\n");
|
||||
t.tv_usec = 0;
|
||||
@ -1067,7 +1067,7 @@ int do_sleep(struct st_query* q)
|
||||
else
|
||||
{
|
||||
t.tv_sec = atoi(p);
|
||||
while(*p && *p != '.' && !isspace(*p))
|
||||
while(*p && *p != '.' && !my_isspace(system_charset_info,*p))
|
||||
p++;
|
||||
if (*p == '.')
|
||||
{
|
||||
@ -1099,7 +1099,7 @@ static void get_file_name(char *filename, struct st_query* q)
|
||||
char* p=q->first_argument;
|
||||
strnmov(filename, p, FN_REFLEN);
|
||||
/* Remove end space */
|
||||
while (p > filename && isspace(p[-1]))
|
||||
while (p > filename && my_isspace(system_charset_info,p[-1]))
|
||||
p--;
|
||||
p[0]=0;
|
||||
}
|
||||
@ -1185,7 +1185,7 @@ static char *get_string(char **to_ptr, char **from_ptr,
|
||||
if (*from != ' ' && *from)
|
||||
die("Wrong string argument in %s\n", q->query);
|
||||
|
||||
while (isspace(*from)) /* Point to next string */
|
||||
while (my_isspace(system_charset_info,*from)) /* Point to next string */
|
||||
from++;
|
||||
|
||||
*to =0; /* End of string marker */
|
||||
@ -1243,7 +1243,7 @@ static void get_replace(struct st_query *q)
|
||||
insert_pointer_name(&to_array,to);
|
||||
}
|
||||
for (i=1,pos=word_end_chars ; i < 256 ; i++)
|
||||
if (isspace(i))
|
||||
if (my_isspace(system_charset_info,i))
|
||||
*pos++=i;
|
||||
*pos=0; /* End pointer */
|
||||
if (!(glob_replace=init_replace((char**) from_array.typelib.type_names,
|
||||
@ -1278,7 +1278,7 @@ int select_connection(struct st_query* q)
|
||||
if (!*p)
|
||||
die("Missing connection name in connect\n");
|
||||
name = p;
|
||||
while(*p && !isspace(*p))
|
||||
while(*p && !my_isspace(system_charset_info,*p))
|
||||
p++;
|
||||
*p = 0;
|
||||
|
||||
@ -1304,7 +1304,7 @@ int close_connection(struct st_query* q)
|
||||
if (!*p)
|
||||
die("Missing connection name in connect\n");
|
||||
name = p;
|
||||
while(*p && !isspace(*p))
|
||||
while(*p && !my_isspace(system_charset_info,*p))
|
||||
p++;
|
||||
*p = 0;
|
||||
|
||||
@ -1340,11 +1340,11 @@ int close_connection(struct st_query* q)
|
||||
char* safe_get_param(char* str, char** arg, const char* msg)
|
||||
{
|
||||
DBUG_ENTER("safe_get_param");
|
||||
while (*str && isspace(*str)) str++;
|
||||
while (*str && my_isspace(system_charset_info,*str)) str++;
|
||||
*arg = str;
|
||||
for (; *str && *str != ',' && *str != ')' ; str++)
|
||||
{
|
||||
if (isspace(*str)) *str = 0;
|
||||
if (my_isspace(system_charset_info,*str)) *str = 0;
|
||||
}
|
||||
if (!*str)
|
||||
die(msg);
|
||||
@ -1626,7 +1626,7 @@ int read_line(char* buf, int size)
|
||||
{
|
||||
state = R_COMMENT;
|
||||
}
|
||||
else if (isspace(c))
|
||||
else if (my_isspace(system_charset_info,c))
|
||||
{
|
||||
if (c == '\n')
|
||||
start_lineno= ++*lineno; /* Query hasn't started yet */
|
||||
@ -1752,7 +1752,7 @@ int read_query(struct st_query** q_ptr)
|
||||
{
|
||||
expected_errno = 0;
|
||||
p++;
|
||||
for (;isdigit(*p);p++)
|
||||
for (;my_isdigit(system_charset_info,*p);p++)
|
||||
expected_errno = expected_errno * 10 + *p - '0';
|
||||
q->expected_errno[0] = expected_errno;
|
||||
q->expected_errno[1] = 0;
|
||||
@ -1760,25 +1760,25 @@ int read_query(struct st_query** q_ptr)
|
||||
}
|
||||
}
|
||||
|
||||
while(*p && isspace(*p)) p++ ;
|
||||
while(*p && my_isspace(system_charset_info,*p)) p++ ;
|
||||
if (*p == '@')
|
||||
{
|
||||
p++;
|
||||
p1 = q->record_file;
|
||||
while (!isspace(*p) &&
|
||||
while (!my_isspace(system_charset_info,*p) &&
|
||||
p1 < q->record_file + sizeof(q->record_file) - 1)
|
||||
*p1++ = *p++;
|
||||
*p1 = 0;
|
||||
}
|
||||
}
|
||||
while (*p && isspace(*p)) p++;
|
||||
while (*p && my_isspace(system_charset_info,*p)) p++;
|
||||
if (!(q->query_buf=q->query=my_strdup(p,MYF(MY_WME))))
|
||||
die(NullS);
|
||||
|
||||
/* Calculate first word and first argument */
|
||||
for (p=q->query; *p && !isspace(*p) ; p++) ;
|
||||
for (p=q->query; *p && !my_isspace(system_charset_info,*p) ; p++) ;
|
||||
q->first_word_len = (uint) (p - q->query);
|
||||
while (*p && isspace(*p)) p++;
|
||||
while (*p && my_isspace(system_charset_info,*p)) p++;
|
||||
q->first_argument=p;
|
||||
q->end = strend(q->query);
|
||||
parser.read_lines++;
|
||||
|
@ -234,7 +234,7 @@ bool String::fill(uint32 max_length,char fill_char)
|
||||
|
||||
void String::strip_sp()
|
||||
{
|
||||
while (str_length && isspace(Ptr[str_length-1]))
|
||||
while (str_length && my_isspace(str_charset,Ptr[str_length-1]))
|
||||
str_length--;
|
||||
}
|
||||
|
||||
@ -296,10 +296,10 @@ uint32 String::numchars()
|
||||
register uint32 n=0,mblen;
|
||||
register const char *mbstr=Ptr;
|
||||
register const char *end=mbstr+str_length;
|
||||
if (use_mb(default_charset_info))
|
||||
if (use_mb(str_charset))
|
||||
{
|
||||
while (mbstr < end) {
|
||||
if ((mblen=my_ismbchar(default_charset_info, mbstr,end))) mbstr+=mblen;
|
||||
if ((mblen=my_ismbchar(str_charset, mbstr,end))) mbstr+=mblen;
|
||||
else ++mbstr;
|
||||
++n;
|
||||
}
|
||||
@ -316,11 +316,11 @@ int String::charpos(int i,uint32 offset)
|
||||
register uint32 mblen;
|
||||
register const char *mbstr=Ptr+offset;
|
||||
register const char *end=Ptr+str_length;
|
||||
if (use_mb(default_charset_info))
|
||||
if (use_mb(str_charset))
|
||||
{
|
||||
if (i<=0) return i;
|
||||
while (i && mbstr < end) {
|
||||
if ((mblen=my_ismbchar(default_charset_info, mbstr,end))) mbstr+=mblen;
|
||||
if ((mblen=my_ismbchar(str_charset, mbstr,end))) mbstr+=mblen;
|
||||
else ++mbstr;
|
||||
--i;
|
||||
}
|
||||
@ -361,6 +361,39 @@ skipp:
|
||||
return -1;
|
||||
}
|
||||
|
||||
/*
|
||||
Search after a string without regarding to case
|
||||
This needs to be replaced when we have character sets per string
|
||||
*/
|
||||
|
||||
int String::strstr_case(const String &s,uint32 offset)
|
||||
{
|
||||
if (s.length()+offset <= str_length)
|
||||
{
|
||||
if (!s.length())
|
||||
return ((int) offset); // Empty string is always found
|
||||
|
||||
register const char *str = Ptr+offset;
|
||||
register const char *search=s.ptr();
|
||||
const char *end=Ptr+str_length-s.length()+1;
|
||||
const char *search_end=s.ptr()+s.length();
|
||||
skipp:
|
||||
while (str != end)
|
||||
{
|
||||
if (str_charset->sort_order[*str++] == str_charset->sort_order[*search])
|
||||
{
|
||||
register char *i,*j;
|
||||
i=(char*) str; j=(char*) search+1;
|
||||
while (j != search_end)
|
||||
if (str_charset->sort_order[*i++] !=
|
||||
str_charset->sort_order[*j++])
|
||||
goto skipp;
|
||||
return (int) (str-Ptr) -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
/*
|
||||
** Search string from end. Offset is offset to the end of string
|
||||
@ -428,6 +461,44 @@ bool String::replace(uint32 offset,uint32 arg_length,const String &to)
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
// added by Holyfoot for "geometry" needs
|
||||
int String::reserve(uint32 space_needed, uint32 grow_by)
|
||||
{
|
||||
if (Alloced_length < str_length + space_needed)
|
||||
{
|
||||
if (realloc(Alloced_length + max(space_needed, grow_by) - 1))
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
void String::qs_append(const char *str)
|
||||
{
|
||||
int len = strlen(str);
|
||||
memcpy(Ptr + str_length, str, len + 1);
|
||||
str_length += len;
|
||||
}
|
||||
|
||||
void String::qs_append(double d)
|
||||
{
|
||||
char *buff = Ptr + str_length;
|
||||
sprintf(buff,"%.14g", d);
|
||||
str_length += strlen(buff);
|
||||
}
|
||||
|
||||
void String::qs_append(double *d)
|
||||
{
|
||||
double ld;
|
||||
float8get(ld, d);
|
||||
qs_append(ld);
|
||||
}
|
||||
|
||||
void String::qs_append(const char &c)
|
||||
{
|
||||
Ptr[str_length] = c;
|
||||
str_length += sizeof(c);
|
||||
}
|
||||
|
||||
|
||||
int sortcmp(const String *x,const String *y)
|
||||
{
|
||||
@ -436,15 +507,15 @@ int sortcmp(const String *x,const String *y)
|
||||
uint32 x_len=x->length(),y_len=y->length(),len=min(x_len,y_len);
|
||||
|
||||
#ifdef USE_STRCOLL
|
||||
if (use_strcoll(default_charset_info))
|
||||
if (use_strcoll(x->str_charset))
|
||||
{
|
||||
#ifndef CMP_ENDSPACE
|
||||
while (x_len && isspace(s[x_len-1]))
|
||||
while (x_len && my_isspace(x->str_charset,s[x_len-1]))
|
||||
x_len--;
|
||||
while (y_len && isspace(t[y_len-1]))
|
||||
while (y_len && my_isspace(x->str_charset,t[y_len-1]))
|
||||
y_len--;
|
||||
#endif
|
||||
return my_strnncoll(default_charset_info,
|
||||
return my_strnncoll(x->str_charset,
|
||||
(unsigned char *)s,x_len,(unsigned char *)t,y_len);
|
||||
}
|
||||
else
|
||||
@ -454,9 +525,10 @@ int sortcmp(const String *x,const String *y)
|
||||
y_len-=len;
|
||||
while (len--)
|
||||
{
|
||||
if (my_sort_order[(uchar) *s++] != my_sort_order[(uchar) *t++])
|
||||
return ((int) my_sort_order[(uchar) s[-1]] -
|
||||
(int) my_sort_order[(uchar) t[-1]]);
|
||||
if (x->str_charset->sort_order[(uchar) *s++] !=
|
||||
x->str_charset->sort_order[(uchar) *t++])
|
||||
return ((int) x->str_charset->sort_order[(uchar) s[-1]] -
|
||||
(int) x->str_charset->sort_order[(uchar) t[-1]]);
|
||||
}
|
||||
#ifndef CMP_ENDSPACE
|
||||
/* Don't compare end space in strings */
|
||||
@ -465,14 +537,14 @@ int sortcmp(const String *x,const String *y)
|
||||
{
|
||||
const char *end=t+y_len;
|
||||
for (; t != end ; t++)
|
||||
if (!isspace(*t))
|
||||
if (!my_isspace(x->str_charset,*t))
|
||||
return -1;
|
||||
}
|
||||
else
|
||||
{
|
||||
const char *end=s+x_len;
|
||||
for (; s != end ; s++)
|
||||
if (!isspace(*s))
|
||||
if (!my_isspace(x->str_charset,*s))
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
@ -520,11 +592,10 @@ String *copy_if_not_alloced(String *to,String *from,uint32 from_length)
|
||||
/* Make it easier to handle different charactersets */
|
||||
|
||||
#ifdef USE_MB
|
||||
#define INC_PTR(A,B) A+=((use_mb_flag && \
|
||||
my_ismbchar(default_charset_info,A,B)) ? \
|
||||
my_ismbchar(default_charset_info,A,B) : 1)
|
||||
#define INC_PTR(cs,A,B) A+=((use_mb_flag && \
|
||||
my_ismbchar(cs,A,B)) ? my_ismbchar(cs,A,B) : 1)
|
||||
#else
|
||||
#define INC_PTR(A,B) A++
|
||||
#define INC_PTR(cs,A,B) A++
|
||||
#endif
|
||||
|
||||
/*
|
||||
@ -535,14 +606,14 @@ String *copy_if_not_alloced(String *to,String *from,uint32 from_length)
|
||||
*/
|
||||
|
||||
#ifdef LIKE_CMP_TOUPPER
|
||||
#define likeconv(A) (uchar) toupper(A)
|
||||
#define likeconv(s,A) (uchar) my_toupper(s,A)
|
||||
#else
|
||||
#define likeconv(A) (uchar) my_sort_order[(uchar) (A)]
|
||||
#define likeconv(s,A) (uchar) (s)->sort_order[(uchar) (A)]
|
||||
#endif
|
||||
|
||||
static int wild_case_compare(const char *str,const char *str_end,
|
||||
const char *wildstr,const char *wildend,
|
||||
char escape)
|
||||
int wild_case_compare(CHARSET_INFO *cs, const char *str,const char *str_end,
|
||||
const char *wildstr,const char *wildend,
|
||||
char escape)
|
||||
{
|
||||
int result= -1; // Not found, using wildcards
|
||||
#ifdef USE_MB
|
||||
@ -557,7 +628,7 @@ static int wild_case_compare(const char *str,const char *str_end,
|
||||
#ifdef USE_MB
|
||||
int l;
|
||||
if (use_mb_flag &&
|
||||
(l = my_ismbchar(default_charset_info, wildstr, wildend)))
|
||||
(l = my_ismbchar(cs, wildstr, wildend)))
|
||||
{
|
||||
if (str+l > str_end || memcmp(str, wildstr, l) != 0)
|
||||
return 1;
|
||||
@ -566,7 +637,7 @@ static int wild_case_compare(const char *str,const char *str_end,
|
||||
}
|
||||
else
|
||||
#endif
|
||||
if (str == str_end || likeconv(*wildstr++) != likeconv(*str++))
|
||||
if (str == str_end || likeconv(cs,*wildstr++) != likeconv(cs,*str++))
|
||||
return(1); // No match
|
||||
if (wildstr == wildend)
|
||||
return (str != str_end); // Match if both are at end
|
||||
@ -576,9 +647,9 @@ static int wild_case_compare(const char *str,const char *str_end,
|
||||
{
|
||||
do
|
||||
{
|
||||
if (str == str_end) // Skipp one char if possible
|
||||
if (str == str_end) // Skip one char if possible
|
||||
return (result);
|
||||
INC_PTR(str,str_end);
|
||||
INC_PTR(cs,str,str_end);
|
||||
} while (++wildstr < wildend && *wildstr == wild_one);
|
||||
if (wildstr == wildend)
|
||||
break;
|
||||
@ -595,7 +666,7 @@ static int wild_case_compare(const char *str,const char *str_end,
|
||||
{
|
||||
if (str == str_end)
|
||||
return (-1);
|
||||
INC_PTR(str,str_end);
|
||||
INC_PTR(cs,str,str_end);
|
||||
continue;
|
||||
}
|
||||
break; // Not a wild character
|
||||
@ -613,10 +684,10 @@ static int wild_case_compare(const char *str,const char *str_end,
|
||||
int mblen;
|
||||
LINT_INIT(mblen);
|
||||
if (use_mb_flag)
|
||||
mblen = my_ismbchar(default_charset_info, wildstr, wildend);
|
||||
mblen = my_ismbchar(cs, wildstr, wildend);
|
||||
#endif
|
||||
INC_PTR(wildstr,wildend); // This is compared trough cmp
|
||||
cmp=likeconv(cmp);
|
||||
INC_PTR(cs,wildstr,wildend); // This is compared trough cmp
|
||||
cmp=likeconv(cs,cmp);
|
||||
do
|
||||
{
|
||||
#ifdef USE_MB
|
||||
@ -634,26 +705,26 @@ static int wild_case_compare(const char *str,const char *str_end,
|
||||
break;
|
||||
}
|
||||
}
|
||||
else if (!my_ismbchar(default_charset_info, str, str_end) &&
|
||||
likeconv(*str) == cmp)
|
||||
else if (!my_ismbchar(cs, str, str_end) &&
|
||||
likeconv(cs,*str) == cmp)
|
||||
{
|
||||
str++;
|
||||
break;
|
||||
}
|
||||
INC_PTR(str, str_end);
|
||||
INC_PTR(cs,str, str_end);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
#endif /* USE_MB */
|
||||
while (str != str_end && likeconv(*str) != cmp)
|
||||
while (str != str_end && likeconv(cs,*str) != cmp)
|
||||
str++;
|
||||
if (str++ == str_end) return (-1);
|
||||
#ifdef USE_MB
|
||||
}
|
||||
#endif
|
||||
{
|
||||
int tmp=wild_case_compare(str,str_end,wildstr,wildend,escape);
|
||||
int tmp=wild_case_compare(cs,str,str_end,wildstr,wildend,escape);
|
||||
if (tmp <= 0)
|
||||
return (tmp);
|
||||
}
|
||||
@ -667,17 +738,23 @@ static int wild_case_compare(const char *str,const char *str_end,
|
||||
|
||||
int wild_case_compare(String &match,String &wild, char escape)
|
||||
{
|
||||
return wild_case_compare(match.ptr(),match.ptr()+match.length(),
|
||||
wild.ptr(), wild.ptr()+wild.length(),escape);
|
||||
DBUG_ENTER("wild_case_compare");
|
||||
DBUG_PRINT("enter",("match='%s', wild='%s', escape='%c'"
|
||||
,match.ptr(),wild.ptr(),escape));
|
||||
DBUG_RETURN(wild_case_compare(match.str_charset,match.ptr(),match.ptr()+match.length(),
|
||||
wild.ptr(), wild.ptr()+wild.length(),escape));
|
||||
}
|
||||
|
||||
/*
|
||||
** The following is used when using LIKE on binary strings
|
||||
*/
|
||||
|
||||
static int wild_compare(const char *str,const char *str_end,
|
||||
const char *wildstr,const char *wildend,char escape)
|
||||
int wild_compare(const char *str,const char *str_end,
|
||||
const char *wildstr,const char *wildend,char escape)
|
||||
{
|
||||
DBUG_ENTER("wild_compare");
|
||||
DBUG_PRINT("enter",("str='%s', str_end='%s', wildstr='%s', wildend='%s', escape='%c'"
|
||||
,str,str_end,wildstr,wildend,escape));
|
||||
int result= -1; // Not found, using wildcards
|
||||
while (wildstr != wildend)
|
||||
{
|
||||
@ -686,17 +763,21 @@ static int wild_compare(const char *str,const char *str_end,
|
||||
if (*wildstr == escape && wildstr+1 != wildend)
|
||||
wildstr++;
|
||||
if (str == str_end || *wildstr++ != *str++)
|
||||
return(1);
|
||||
{
|
||||
DBUG_RETURN(1);
|
||||
}
|
||||
if (wildstr == wildend)
|
||||
return (str != str_end); // Match if both are at end
|
||||
{
|
||||
DBUG_RETURN(str != str_end); // Match if both are at end
|
||||
}
|
||||
result=1; // Found an anchor char
|
||||
}
|
||||
if (*wildstr == wild_one)
|
||||
{
|
||||
do
|
||||
{
|
||||
if (str == str_end) // Skipp one char if possible
|
||||
return (result);
|
||||
if (str == str_end) // Skip one char if possible
|
||||
DBUG_RETURN(result);
|
||||
str++;
|
||||
} while (*++wildstr == wild_one && wildstr != wildend);
|
||||
if (wildstr == wildend)
|
||||
@ -713,17 +794,22 @@ static int wild_compare(const char *str,const char *str_end,
|
||||
if (*wildstr == wild_one)
|
||||
{
|
||||
if (str == str_end)
|
||||
return (-1);
|
||||
{
|
||||
DBUG_RETURN(-1);
|
||||
}
|
||||
str++;
|
||||
continue;
|
||||
}
|
||||
break; // Not a wild character
|
||||
}
|
||||
if (wildstr == wildend)
|
||||
return(0); // Ok if wild_many is last
|
||||
{
|
||||
DBUG_RETURN(0); // Ok if wild_many is last
|
||||
}
|
||||
if (str == str_end)
|
||||
return -1;
|
||||
|
||||
{
|
||||
DBUG_RETURN(-1);
|
||||
}
|
||||
char cmp;
|
||||
if ((cmp= *wildstr) == escape && wildstr+1 != wildend)
|
||||
cmp= *++wildstr;
|
||||
@ -732,22 +818,32 @@ static int wild_compare(const char *str,const char *str_end,
|
||||
{
|
||||
while (str != str_end && *str != cmp)
|
||||
str++;
|
||||
if (str++ == str_end) return (-1);
|
||||
if (str++ == str_end)
|
||||
{
|
||||
DBUG_RETURN(-1);
|
||||
}
|
||||
{
|
||||
int tmp=wild_compare(str,str_end,wildstr,wildend,escape);
|
||||
if (tmp <= 0)
|
||||
return (tmp);
|
||||
{
|
||||
DBUG_RETURN(tmp);
|
||||
}
|
||||
}
|
||||
} while (str != str_end && wildstr[0] != wild_many);
|
||||
return(-1);
|
||||
DBUG_RETURN(-1);
|
||||
}
|
||||
}
|
||||
return (str != str_end ? 1 : 0);
|
||||
DBUG_RETURN(str != str_end ? 1 : 0);
|
||||
}
|
||||
|
||||
|
||||
int wild_compare(String &match,String &wild, char escape)
|
||||
{
|
||||
return wild_compare(match.ptr(),match.ptr()+match.length(),
|
||||
wild.ptr(), wild.ptr()+wild.length(),escape);
|
||||
DBUG_ENTER("wild_compare");
|
||||
DBUG_PRINT("enter",("match='%s', wild='%s', escape='%c'"
|
||||
,match.ptr(),wild.ptr(),escape));
|
||||
DBUG_RETURN(wild_compare(match.ptr(),match.ptr()+match.length(),
|
||||
wild.ptr(), wild.ptr()+wild.length(),escape));
|
||||
}
|
||||
|
||||
|
||||
|
@ -24,31 +24,57 @@
|
||||
#define NOT_FIXED_DEC 31
|
||||
#endif
|
||||
|
||||
class String;
|
||||
int sortcmp(const String *a,const String *b);
|
||||
int stringcmp(const String *a,const String *b);
|
||||
String *copy_if_not_alloced(String *a,String *b,uint32 arg_length);
|
||||
int wild_case_compare(String &match,String &wild,char escape);
|
||||
int wild_compare(String &match,String &wild,char escape);
|
||||
|
||||
class String
|
||||
{
|
||||
char *Ptr;
|
||||
uint32 str_length,Alloced_length;
|
||||
bool alloced;
|
||||
CHARSET_INFO *str_charset;
|
||||
public:
|
||||
String()
|
||||
{ Ptr=0; str_length=Alloced_length=0; alloced=0; }
|
||||
{
|
||||
Ptr=0; str_length=Alloced_length=0; alloced=0;
|
||||
str_charset=default_charset_info;
|
||||
}
|
||||
String(uint32 length_arg)
|
||||
{ alloced=0; Alloced_length=0; (void) real_alloc(length_arg); }
|
||||
{
|
||||
alloced=0; Alloced_length=0; (void) real_alloc(length_arg);
|
||||
str_charset=default_charset_info;
|
||||
}
|
||||
String(const char *str)
|
||||
{ Ptr=(char*) str; str_length=(uint) strlen(str); Alloced_length=0; alloced=0;}
|
||||
{
|
||||
Ptr=(char*) str; str_length=(uint) strlen(str); Alloced_length=0; alloced=0;
|
||||
str_charset=default_charset_info;
|
||||
}
|
||||
String(const char *str,uint32 len)
|
||||
{ Ptr=(char*) str; str_length=len; Alloced_length=0; alloced=0;}
|
||||
{
|
||||
Ptr=(char*) str; str_length=len; Alloced_length=0; alloced=0;
|
||||
str_charset=default_charset_info;
|
||||
}
|
||||
String(char *str,uint32 len)
|
||||
{ Ptr=(char*) str; Alloced_length=str_length=len; alloced=0;}
|
||||
{
|
||||
Ptr=(char*) str; Alloced_length=str_length=len; alloced=0;
|
||||
str_charset=default_charset_info;
|
||||
}
|
||||
String(const String &str)
|
||||
{ Ptr=str.Ptr ; str_length=str.str_length ;
|
||||
Alloced_length=str.Alloced_length; alloced=0; }
|
||||
|
||||
{
|
||||
Ptr=str.Ptr ; str_length=str.str_length ;
|
||||
Alloced_length=str.Alloced_length; alloced=0;
|
||||
str_charset=str.str_charset;
|
||||
}
|
||||
static void *operator new(size_t size) { return (void*) sql_alloc((uint) size); }
|
||||
static void operator delete(void *ptr_arg,size_t size) /*lint -e715 */
|
||||
{ sql_element_free(ptr_arg); }
|
||||
~String() { free(); }
|
||||
|
||||
inline CHARSET_INFO *charset() const { return str_charset; }
|
||||
inline uint32 length() const { return str_length;}
|
||||
inline uint32 alloced_length() const { return Alloced_length;}
|
||||
inline char& operator [] (uint32 i) const { return Ptr[i]; }
|
||||
@ -124,7 +150,7 @@ public:
|
||||
char *new_ptr;
|
||||
if (!(new_ptr=(char*) my_realloc(Ptr,arg_length,MYF(0))))
|
||||
{
|
||||
(void) my_free(Ptr,MYF(0));
|
||||
Alloced_length = 0;
|
||||
real_alloc(arg_length);
|
||||
}
|
||||
else
|
||||
@ -153,6 +179,7 @@ public:
|
||||
bool append(const char *s,uint32 arg_length=0);
|
||||
bool append(IO_CACHE* file, uint32 arg_length);
|
||||
int strstr(const String &search,uint32 offset=0); // Returns offset to substring or -1
|
||||
int strstr_case(const String &s,uint32 offset=0);
|
||||
int strrstr(const String &search,uint32 offset=0); // Returns offset to substring or -1
|
||||
bool replace(uint32 offset,uint32 arg_length,const String &to);
|
||||
inline bool append(char chr)
|
||||
@ -171,8 +198,8 @@ public:
|
||||
}
|
||||
bool fill(uint32 max_length,char fill);
|
||||
void strip_sp();
|
||||
inline void caseup() { ::caseup(Ptr,str_length); }
|
||||
inline void casedn() { ::casedn(Ptr,str_length); }
|
||||
inline void caseup() { my_caseup(str_charset,Ptr,str_length); }
|
||||
inline void casedn() { my_casedn(str_charset,Ptr,str_length); }
|
||||
friend int sortcmp(const String *a,const String *b);
|
||||
friend int stringcmp(const String *a,const String *b);
|
||||
friend String *copy_if_not_alloced(String *a,String *b,uint32 arg_length);
|
||||
@ -180,4 +207,49 @@ public:
|
||||
friend int wild_compare(String &match,String &wild,char escape);
|
||||
uint32 numchars();
|
||||
int charpos(int i,uint32 offset=0);
|
||||
|
||||
// added by Holyfoot for "geometry" needs
|
||||
int reserve(uint32 space_needed)
|
||||
{
|
||||
return realloc(str_length + space_needed);
|
||||
}
|
||||
int reserve(uint32 space_needed, uint32 grow_by);
|
||||
|
||||
// these append operations do NOT check alloced memory
|
||||
// q_*** methods writes values of parameters itself
|
||||
// qs_*** methods writes string representation of value
|
||||
void q_append(const char &c)
|
||||
{
|
||||
Ptr[str_length++] = c;
|
||||
}
|
||||
void q_append(const uint32 &n)
|
||||
{
|
||||
int4store(Ptr + str_length, n);
|
||||
str_length += 4;
|
||||
}
|
||||
void q_append(double d)
|
||||
{
|
||||
float8store(Ptr + str_length, d);
|
||||
str_length += 8;
|
||||
}
|
||||
void q_append(double *d)
|
||||
{
|
||||
float8store(Ptr + str_length, *d);
|
||||
str_length += 8;
|
||||
}
|
||||
void q_append(const char *data, uint32 data_len)
|
||||
{
|
||||
memcpy(Ptr + str_length, data, data_len);
|
||||
str_length += data_len;
|
||||
}
|
||||
|
||||
void WriteAtPosition(int position, uint32 value)
|
||||
{
|
||||
int4store(Ptr + position,value);
|
||||
}
|
||||
|
||||
void qs_append(const char *str);
|
||||
void qs_append(double d);
|
||||
void qs_append(double *d);
|
||||
void qs_append(const char &c);
|
||||
};
|
||||
|
@ -155,7 +155,7 @@ static int get_answer(QUESTION_WIDGET* w)
|
||||
char c;
|
||||
if (!fgets(buf,sizeof(buf),w->in))
|
||||
die("Failed fgets on input stream");
|
||||
switch ((c=tolower(*buf)))
|
||||
switch ((c=my_tolower(system_charset_info,*buf)))
|
||||
{
|
||||
case '\n':
|
||||
return w->default_ind;
|
||||
|
@ -113,7 +113,7 @@ char *argv[];
|
||||
exit(1);
|
||||
|
||||
for (i=1,pos=word_end_chars ; i < 256 ; i++)
|
||||
if (isspace(i))
|
||||
if (my_isspace(system_charset_info,i))
|
||||
*pos++=i;
|
||||
*pos=0;
|
||||
if (!(replace=init_replace((char**) from.typelib.type_names,
|
||||
|
@ -178,9 +178,9 @@ trace dump and specify the path to it with -s or --symbols-file");
|
||||
static uchar hex_val(char c)
|
||||
{
|
||||
uchar l;
|
||||
if(isdigit(c))
|
||||
if(my_isdigit(system_charset_info,c))
|
||||
return c - '0';
|
||||
l = tolower(c);
|
||||
l = my_tolower(system_charset_info,c);
|
||||
if(l < 'a' || l > 'f')
|
||||
return HEX_INVALID;
|
||||
return (uchar)10 + ((uchar)c - (uchar)'a');
|
||||
@ -206,10 +206,10 @@ static int init_sym_entry(SYM_ENTRY* se, char* buf)
|
||||
|
||||
if(!se->addr)
|
||||
return -1;
|
||||
while(isspace(*buf++))
|
||||
while ( my_isspace(system_charset_info,*buf++))
|
||||
/* empty */;
|
||||
|
||||
while(isspace(*buf++))
|
||||
while (my_isspace(system_charset_info,*buf++))
|
||||
/* empty - skip more space */;
|
||||
--buf;
|
||||
/* now we are on the symbol */
|
||||
@ -293,7 +293,7 @@ static void do_resolve()
|
||||
while(fgets(buf, sizeof(buf), fp_dump))
|
||||
{
|
||||
p = buf;
|
||||
while(isspace(*p))
|
||||
while(my_isspace(system_charset_info,*p))
|
||||
++p;
|
||||
/* skip space */;
|
||||
|
||||
|
@ -128,7 +128,7 @@ int main(int argc, char **argv)
|
||||
{
|
||||
ip = *argv++;
|
||||
|
||||
if (isdigit(ip[0]))
|
||||
if (my_isdigit(system_charset_info,ip[0]))
|
||||
{
|
||||
taddr = inet_addr(ip);
|
||||
if (taddr == htonl(INADDR_BROADCAST))
|
||||
|
@ -173,7 +173,7 @@ ulong _hp_hashnr(register HP_KEYDEF *keydef, register const byte *key)
|
||||
for (; pos < (uchar*) key ; pos++)
|
||||
{
|
||||
nr^=(ulong) ((((uint) nr & 63)+nr2) *
|
||||
((uint) my_sort_order[(uint) *pos])) + (nr << 8);
|
||||
((uint) default_charset_info->sort_order[(uint) *pos])) + (nr << 8);
|
||||
nr2+=3;
|
||||
}
|
||||
}
|
||||
@ -212,7 +212,7 @@ ulong _hp_rec_hashnr(register HP_KEYDEF *keydef, register const byte *rec)
|
||||
for (; pos < end ; pos++)
|
||||
{
|
||||
nr^=(ulong) ((((uint) nr & 63)+nr2)*
|
||||
((uint) my_sort_order[(uint) *pos]))+ (nr << 8);
|
||||
((uint) default_charset_info->sort_order[(uint) *pos]))+ (nr << 8);
|
||||
nr2+=3;
|
||||
}
|
||||
}
|
||||
@ -343,7 +343,7 @@ int _hp_rec_key_cmp(HP_KEYDEF *keydef, const byte *rec1, const byte *rec2)
|
||||
}
|
||||
if (seg->type == HA_KEYTYPE_TEXT)
|
||||
{
|
||||
if (my_sortcmp(rec1+seg->start,rec2+seg->start,seg->length))
|
||||
if (my_sortcmp(default_charset_info,rec1+seg->start,rec2+seg->start,seg->length))
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
@ -375,7 +375,12 @@ int _hp_key_cmp(HP_KEYDEF *keydef, const byte *rec, const byte *key)
|
||||
}
|
||||
if (seg->type == HA_KEYTYPE_TEXT)
|
||||
{
|
||||
if (my_sortcmp(rec+seg->start,key,seg->length))
|
||||
/*
|
||||
BAR TODO: this will not use default_charset_info
|
||||
I need Ram to apply his HEAP patches with
|
||||
CHARSET_INFO field in HP segments
|
||||
*/
|
||||
if (my_sortcmp(default_charset_info,rec+seg->start,key,seg->length))
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
|
@ -39,11 +39,12 @@ typedef struct charset_info_st
|
||||
uchar *sort_order;
|
||||
|
||||
uint strxfrm_multiply;
|
||||
int (*strcoll)(const uchar *, const uchar *);
|
||||
int (*strxfrm)(uchar *, const uchar *, int);
|
||||
int (*strnncoll)(const uchar *, int, const uchar *, int);
|
||||
int (*strnxfrm)(uchar *, const uchar *, int, int);
|
||||
my_bool (*like_range)(const char *, uint, pchar, uint,
|
||||
int (*strnncoll)(struct charset_info_st *,
|
||||
const uchar *, uint, const uchar *, uint);
|
||||
int (*strnxfrm)(struct charset_info_st *,
|
||||
uchar *, uint, const uchar *, uint);
|
||||
my_bool (*like_range)(struct charset_info_st *,
|
||||
const char *, uint, pchar, uint,
|
||||
char *, char *, uint *, uint *);
|
||||
|
||||
uint mbmaxlen;
|
||||
@ -52,19 +53,21 @@ typedef struct charset_info_st
|
||||
int (*mbcharlen)(uint);
|
||||
|
||||
/* Functions for case convertion */
|
||||
void (*caseup_str)(struct charset_info_st *, uchar *);
|
||||
void (*casedn_str)(struct charset_info_st *, uchar *);
|
||||
void (*caseup)(struct charset_info_st *, uchar *, uint);
|
||||
void (*casedn)(struct charset_info_st *, uchar *, uint);
|
||||
void (*caseup_str)(struct charset_info_st *, char *);
|
||||
void (*casedn_str)(struct charset_info_st *, char *);
|
||||
void (*caseup)(struct charset_info_st *, char *, uint);
|
||||
void (*casedn)(struct charset_info_st *, char *, uint);
|
||||
|
||||
/* Functions for case comparison */
|
||||
int (*strcasecmp)(struct charset_info_st *, const uchar *, const uchar *);
|
||||
int (*strncasecmp)(struct charset_info_st *, const uchar *, const uchar *, uint);
|
||||
int (*strcasecmp)(struct charset_info_st *, const char *, const char *);
|
||||
int (*strncasecmp)(struct charset_info_st *, const char *, const char *, uint);
|
||||
|
||||
char max_sort_char; /* For LIKE otimization */
|
||||
} CHARSET_INFO;
|
||||
|
||||
/* strings/ctype.c */
|
||||
extern CHARSET_INFO *default_charset_info;
|
||||
extern CHARSET_INFO *system_charset_info;
|
||||
extern CHARSET_INFO *find_compiled_charset(uint cs_number);
|
||||
extern CHARSET_INFO *find_compiled_charset_by_name(const char *name);
|
||||
extern CHARSET_INFO compiled_charsets[];
|
||||
@ -75,34 +78,32 @@ extern const char *compiled_charset_name(uint charset_number);
|
||||
#define MY_CHARSET_CURRENT (default_charset_info->number)
|
||||
|
||||
/* declarations for simple charsets */
|
||||
extern int my_strnxfrm_simple(CHARSET_INFO *, uchar *, const uchar *, int, int);
|
||||
extern int my_strnncoll_simple(CHARSET_INFO *, const uchar *, int, const uchar *, int);
|
||||
extern int my_strnxfrm_simple(CHARSET_INFO *, char *, uint, const char *, uint);
|
||||
extern int my_strnncoll_simple(CHARSET_INFO *, const char *, uint, const char *, uint);
|
||||
|
||||
/* Functions for 8bit */
|
||||
extern void my_caseup_str_8bit(CHARSET_INFO *, uchar *);
|
||||
extern void my_casedn_str_8bit(CHARSET_INFO *, uchar *);
|
||||
extern void my_caseup_8bit(CHARSET_INFO *, uchar *, uint);
|
||||
extern void my_casedn_8bit(CHARSET_INFO *, uchar *, uint);
|
||||
extern void my_caseup_str_8bit(CHARSET_INFO *, char *);
|
||||
extern void my_casedn_str_8bit(CHARSET_INFO *, char *);
|
||||
extern void my_caseup_8bit(CHARSET_INFO *, char *, uint);
|
||||
extern void my_casedn_8bit(CHARSET_INFO *, char *, uint);
|
||||
|
||||
extern int my_strcasecmp_8bit(CHARSET_INFO * cs, const uchar *, const uchar *);
|
||||
extern int my_strncasecmp_8bit(CHARSET_INFO * cs, const uchar *, const uchar *, uint);
|
||||
extern int my_strcasecmp_8bit(CHARSET_INFO * cs, const char *, const char *);
|
||||
extern int my_strncasecmp_8bit(CHARSET_INFO * cs, const char *, const char *, uint);
|
||||
|
||||
/* Functions for multibyte charsets */
|
||||
extern void my_caseup_str_mb(CHARSET_INFO *, uchar *);
|
||||
extern void my_casedn_str_mb(CHARSET_INFO *, uchar *);
|
||||
extern void my_caseup_mb(CHARSET_INFO *, uchar *, uint);
|
||||
extern void my_casedn_mb(CHARSET_INFO *, uchar *, uint);
|
||||
extern void my_caseup_str_mb(CHARSET_INFO *, char *);
|
||||
extern void my_casedn_str_mb(CHARSET_INFO *, char *);
|
||||
extern void my_caseup_mb(CHARSET_INFO *, char *, uint);
|
||||
extern void my_casedn_mb(CHARSET_INFO *, char *, uint);
|
||||
|
||||
extern int my_strcasecmp_mb(CHARSET_INFO * cs,const uchar *, const uchar *);
|
||||
extern int my_strncasecmp_mb(CHARSET_INFO * cs,const uchar *, const uchar *t, uint);
|
||||
extern int my_strcasecmp_mb(CHARSET_INFO * cs,const char *, const char *);
|
||||
extern int my_strncasecmp_mb(CHARSET_INFO * cs,const char *, const char *t, uint);
|
||||
|
||||
/* declarations for the big5 character set */
|
||||
extern uchar ctype_big5[], to_lower_big5[], to_upper_big5[], sort_order_big5[];
|
||||
extern int my_strcoll_big5(const uchar *, const uchar *);
|
||||
extern int my_strxfrm_big5(uchar *, const uchar *, int);
|
||||
extern int my_strnncoll_big5(const uchar *, int, const uchar *, int);
|
||||
extern int my_strnxfrm_big5(uchar *, const uchar *, int, int);
|
||||
extern my_bool my_like_range_big5(const char *, uint, pchar, uint,
|
||||
extern int my_strnncoll_big5(CHARSET_INFO *,const uchar *, uint, const uchar *, uint);
|
||||
extern int my_strnxfrm_big5(CHARSET_INFO *,uchar *, uint, const uchar *, uint);
|
||||
extern my_bool my_like_range_big5(CHARSET_INFO *,const char *, uint, pchar, uint,
|
||||
char *, char *, uint *, uint *);
|
||||
extern int ismbchar_big5(const char *, const char *);
|
||||
extern my_bool ismbhead_big5(uint);
|
||||
@ -110,11 +111,10 @@ extern int mbcharlen_big5(uint);
|
||||
|
||||
/* declarations for the czech character set */
|
||||
extern uchar ctype_czech[], to_lower_czech[], to_upper_czech[], sort_order_czech[];
|
||||
extern int my_strcoll_czech(const uchar *, const uchar *);
|
||||
extern int my_strxfrm_czech(uchar *, const uchar *, int);
|
||||
extern int my_strnncoll_czech(const uchar *, int, const uchar *, int);
|
||||
extern int my_strnxfrm_czech(uchar *, const uchar *, int, int);
|
||||
extern my_bool my_like_range_czech(const char *, uint, pchar, uint,
|
||||
extern int my_strnncoll_czech(CHARSET_INFO *, const uchar *, uint, const uchar *, uint);
|
||||
extern int my_strnxfrm_czech(CHARSET_INFO *, uchar *, uint, const uchar *, uint);
|
||||
extern my_bool my_like_range_czech(CHARSET_INFO *,
|
||||
const char *, uint, pchar, uint,
|
||||
char *, char *, uint *, uint *);
|
||||
|
||||
/* declarations for the euc_kr character set */
|
||||
@ -131,11 +131,9 @@ extern int mbcharlen_gb2312(uint);
|
||||
|
||||
/* declarations for the gbk character set */
|
||||
extern uchar ctype_gbk[], to_lower_gbk[], to_upper_gbk[], sort_order_gbk[];
|
||||
extern int my_strcoll_gbk(const uchar *, const uchar *);
|
||||
extern int my_strxfrm_gbk(uchar *, const uchar *, int);
|
||||
extern int my_strnncoll_gbk(const uchar *, int, const uchar *, int);
|
||||
extern int my_strnxfrm_gbk(uchar *, const uchar *, int, int);
|
||||
extern my_bool my_like_range_gbk(const char *, uint, pchar, uint,
|
||||
extern int my_strnncoll_gbk(CHARSET_INFO *, const uchar *, uint, const uchar *, uint);
|
||||
extern int my_strnxfrm_gbk(CHARSET_INFO *, uchar *, uint, const uchar *, uint);
|
||||
extern my_bool my_like_range_gbk(CHARSET_INFO *, const char *, uint, pchar, uint,
|
||||
char *, char *, uint *, uint *);
|
||||
extern int ismbchar_gbk(const char *, const char *);
|
||||
extern my_bool ismbhead_gbk(uint);
|
||||
@ -143,20 +141,16 @@ extern int mbcharlen_gbk(uint);
|
||||
|
||||
/* declarations for the latin1_de character set */
|
||||
extern uchar ctype_latin1_de[], to_lower_latin1_de[], to_upper_latin1_de[], sort_order_latin1_de[];
|
||||
extern int my_strcoll_latin1_de(const uchar *, const uchar *);
|
||||
extern int my_strxfrm_latin1_de(uchar *, const uchar *, int);
|
||||
extern int my_strnncoll_latin1_de(const uchar *, int, const uchar *, int);
|
||||
extern int my_strnxfrm_latin1_de(uchar *, const uchar *, int, int);
|
||||
extern my_bool my_like_range_latin1_de(const char *, uint, pchar, uint,
|
||||
extern int my_strnncoll_latin1_de(CHARSET_INFO *, const uchar *, uint, const uchar *, uint);
|
||||
extern int my_strnxfrm_latin1_de(CHARSET_INFO *, uchar *, uint, const uchar *, uint);
|
||||
extern my_bool my_like_range_latin1_de(CHARSET_INFO *, const char *, uint, pchar, uint,
|
||||
char *, char *, uint *, uint *);
|
||||
|
||||
/* declarations for the sjis character set */
|
||||
extern uchar ctype_sjis[], to_lower_sjis[], to_upper_sjis[], sort_order_sjis[];
|
||||
extern int my_strcoll_sjis(const uchar *, const uchar *);
|
||||
extern int my_strxfrm_sjis(uchar *, const uchar *, int);
|
||||
extern int my_strnncoll_sjis(const uchar *, int, const uchar *, int);
|
||||
extern int my_strnxfrm_sjis(uchar *, const uchar *, int, int);
|
||||
extern my_bool my_like_range_sjis(const char *, uint, pchar, uint,
|
||||
extern int my_strnncoll_sjis(CHARSET_INFO *, const uchar *, uint, const uchar *, uint);
|
||||
extern int my_strnxfrm_sjis(CHARSET_INFO *, uchar *, uint, const uchar *, uint);
|
||||
extern my_bool my_like_range_sjis(CHARSET_INFO *, const char *, uint, pchar, uint,
|
||||
char *, char *, uint *, uint *);
|
||||
extern int ismbchar_sjis(const char *, const char *);
|
||||
extern my_bool ismbhead_sjis(uint);
|
||||
@ -164,11 +158,9 @@ extern int mbcharlen_sjis(uint);
|
||||
|
||||
/* declarations for the tis620 character set */
|
||||
extern uchar ctype_tis620[], to_lower_tis620[], to_upper_tis620[], sort_order_tis620[];
|
||||
extern int my_strcoll_tis620(const uchar *, const uchar *);
|
||||
extern int my_strxfrm_tis620(uchar *, const uchar *, int);
|
||||
extern int my_strnncoll_tis620(const uchar *, int, const uchar *, int);
|
||||
extern int my_strnxfrm_tis620(uchar *, const uchar *, int, int);
|
||||
extern my_bool my_like_range_tis620(const char *, uint, pchar, uint,
|
||||
extern int my_strnncoll_tis620(CHARSET_INFO *, const uchar *, uint, const uchar *, uint);
|
||||
extern int my_strnxfrm_tis620(CHARSET_INFO *, uchar *, uint, const uchar *, uint);
|
||||
extern my_bool my_like_range_tis620(CHARSET_INFO *, const char *, uint, pchar, uint,
|
||||
char *, char *, uint *, uint *);
|
||||
|
||||
/* declarations for the ujis character set */
|
||||
@ -214,32 +206,11 @@ extern int mbcharlen_ujis(uint);
|
||||
#define _B 0100 /* Blank */
|
||||
#define _X 0200 /* heXadecimal digit */
|
||||
|
||||
#ifndef HIDE_OLD_CTYPE
|
||||
#define my_ctype (default_charset_info->ctype)
|
||||
#define my_to_upper (default_charset_info->to_upper)
|
||||
#define my_to_lower (default_charset_info->to_lower)
|
||||
#define my_sort_order (default_charset_info->sort_order)
|
||||
|
||||
#define _toupper(c) (char) my_to_upper[(uchar) (c)]
|
||||
#define _tolower(c) (char) my_to_lower[(uchar) (c)]
|
||||
#define toupper(c) (char) my_to_upper[(uchar) (c)]
|
||||
#define tolower(c) (char) my_to_lower[(uchar) (c)]
|
||||
|
||||
#define isalpha(c) ((my_ctype+1)[(uchar) (c)] & (_U | _L))
|
||||
#define isupper(c) ((my_ctype+1)[(uchar) (c)] & _U)
|
||||
#define islower(c) ((my_ctype+1)[(uchar) (c)] & _L)
|
||||
#define isdigit(c) ((my_ctype+1)[(uchar) (c)] & _N)
|
||||
#define isxdigit(c) ((my_ctype+1)[(uchar) (c)] & _X)
|
||||
#define isalnum(c) ((my_ctype+1)[(uchar) (c)] & (_U | _L | _N))
|
||||
#define isspace(c) ((my_ctype+1)[(uchar) (c)] & _S)
|
||||
#define ispunct(c) ((my_ctype+1)[(uchar) (c)] & _P)
|
||||
#define isprint(c) ((my_ctype+1)[(uchar) (c)] & (_P | _U | _L | _N | _B))
|
||||
#define isgraph(c) ((my_ctype+1)[(uchar) (c)] & (_P | _U | _L | _N))
|
||||
#define iscntrl(c) ((my_ctype+1)[(uchar) (c)] & _C)
|
||||
#endif
|
||||
|
||||
#define isascii(c) (!((c) & ~0177))
|
||||
#define toascii(c) ((c) & 0177)
|
||||
#define tocntrl(c) ((c) & 31)
|
||||
#define toprint(c) ((c) | 64)
|
||||
|
||||
#ifdef ctype
|
||||
#undef ctype
|
||||
@ -259,26 +230,28 @@ extern int mbcharlen_ujis(uint);
|
||||
#define my_isgraph(s, c) (((s)->ctype+1)[(uchar) (c)] & (_P | _U | _L | _N))
|
||||
#define my_iscntrl(s, c) (((s)->ctype+1)[(uchar) (c)] & _C)
|
||||
|
||||
#define use_strcoll(s) ((s)->strcoll != NULL)
|
||||
#define MY_STRXFRM_MULTIPLY (default_charset_info->strxfrm_multiply)
|
||||
#define my_strnxfrm(s, a, b, c, d) ((s)->strnxfrm((a), (b), (c), (d)))
|
||||
#define my_strnncoll(s, a, b, c, d) ((s)->strnncoll((a), (b), (c), (d)))
|
||||
#define my_strxfrm(s, a, b, c, d) ((s)->strnxfrm((a), (b), (c)))
|
||||
#define my_strcoll(s, a, b) ((s)->strcoll((a), (b)))
|
||||
/* Some macros that should be cleaned up a little */
|
||||
#define my_isvar(s,c) (my_isalnum(s,c) || (c) == '_')
|
||||
#define my_isvar_start(s,c) (my_isalpha(s,c) || (c) == '_')
|
||||
|
||||
#define use_strcoll(s) ((s)->strnncoll != NULL)
|
||||
#define my_strnxfrm(s, a, b, c, d) ((s)->strnxfrm((s), (a), (b), (c), (d)))
|
||||
#define my_strnncoll(s, a, b, c, d) ((s)->strnncoll((s), (a), (b), (c), (d)))
|
||||
#define my_like_range(s, a, b, c, d, e, f, g, h) \
|
||||
((s)->like_range((a), (b), (c), (d), (e), (f), (g), (h)))
|
||||
((s)->like_range((s), (a), (b), (c), (d), (e), (f), (g), (h)))
|
||||
|
||||
#define use_mb(s) ((s)->ismbchar != NULL)
|
||||
#define MBMAXLEN (default_charset_info->mbmaxlen)
|
||||
#define my_ismbchar(s, a, b) ((s)->ismbchar((a), (b)))
|
||||
#define my_ismbhead(s, a) ((s)->ismbhead((a)))
|
||||
#define my_mbcharlen(s, a) ((s)->mbcharlen((a)))
|
||||
|
||||
/* Some macros that should be cleaned up a little */
|
||||
#define isvar(c) (isalnum(c) || (c) == '_')
|
||||
#define isvar_start(c) (isalpha(c) || (c) == '_')
|
||||
#define tocntrl(c) ((c) & 31)
|
||||
#define toprint(c) ((c) | 64)
|
||||
#define my_caseup(s, a, l) ((s)->caseup((s), (a), (l)))
|
||||
#define my_casedn(s, a, l) ((s)->casedn((s), (a), (l)))
|
||||
#define my_caseup_str(s, a) ((s)->caseup_str((s), (a)))
|
||||
#define my_casedn_str(s, a) ((s)->casedn_str((s), (a)))
|
||||
#define my_strcasecmp(s, a, b) ((s)->strcasecmp((s), (a), (b)))
|
||||
#define my_strncasecmp(s, a, b, l) ((s)->strncasecmp((s), (a), (b), (l)))
|
||||
|
||||
|
||||
/* XXX: still need to take care of this one */
|
||||
#ifdef MY_CHARSET_TIS620
|
||||
|
@ -563,11 +563,7 @@ extern void allow_break(void);
|
||||
#endif
|
||||
|
||||
extern void my_remember_signal(int signal_number,sig_handler (*func)(int));
|
||||
extern void caseup(my_string str,uint length);
|
||||
extern void casedn(my_string str,uint length);
|
||||
extern void caseup_str(my_string str);
|
||||
extern void casedn_str(my_string str);
|
||||
extern void case_sort(my_string str,uint length);
|
||||
extern void case_sort(CHARSET_INFO *cs, my_string str,uint length);
|
||||
extern uint dirname_part(my_string to,const char *name);
|
||||
extern uint dirname_length(const char *name);
|
||||
#define base_name(A) (A+dirname_length(A))
|
||||
@ -592,18 +588,14 @@ extern my_string my_path(my_string to,const char *progname,
|
||||
extern my_string my_load_path(my_string to, const char *path,
|
||||
const char *own_path_prefix);
|
||||
extern int wild_compare(const char *str,const char *wildstr);
|
||||
extern my_string my_strcasestr(const char *src,const char *suffix);
|
||||
extern int my_strcasecmp(const char *s,const char *t);
|
||||
extern int my_strsortcmp(const char *s,const char *t);
|
||||
extern int my_casecmp(const char *s,const char *t,uint length);
|
||||
extern int my_sortcmp(const char *s,const char *t,uint length);
|
||||
extern int my_sortncmp(const char *s,uint s_len, const char *t,uint t_len);
|
||||
extern int my_sortcmp(CHARSET_INFO *cs, const char *s,const char *t,uint length);
|
||||
extern int my_sortncmp(CHARSET_INFO *cs, const char *s,uint s_len, const char *t,uint t_len);
|
||||
extern WF_PACK *wf_comp(my_string str);
|
||||
extern int wf_test(struct wild_file_pack *wf_pack,const char *name);
|
||||
extern void wf_end(struct wild_file_pack *buffer);
|
||||
extern size_s stripp_sp(my_string str);
|
||||
extern void get_date(my_string to,int timeflag,time_t use_time);
|
||||
extern void soundex(my_string out_pntr, my_string in_pntr,pbool remove_garbage);
|
||||
extern void soundex(CHARSET_INFO *, my_string out_pntr, my_string in_pntr,pbool remove_garbage);
|
||||
extern int init_record_cache(RECORD_CACHE *info,uint cachesize,File file,
|
||||
uint reclength,enum cache_type type,
|
||||
pbool use_async_io);
|
||||
|
@ -58,7 +58,7 @@ uint _nisam_make_key(register N_INFO *info, uint keynr, uchar *key, const char *
|
||||
#endif
|
||||
{
|
||||
if (type == HA_KEYTYPE_TEXT)
|
||||
case_sort((byte*) key,length);
|
||||
case_sort(default_charset_info,(byte*) key,length);
|
||||
}
|
||||
key+=length;
|
||||
}
|
||||
@ -71,7 +71,7 @@ uint _nisam_make_key(register N_INFO *info, uint keynr, uchar *key, const char *
|
||||
#endif
|
||||
{
|
||||
if (type == HA_KEYTYPE_TEXT)
|
||||
case_sort((byte*) key,(uint) keyseg->base.length);
|
||||
case_sort(default_charset_info,(byte*) key,(uint) keyseg->base.length);
|
||||
}
|
||||
#ifdef NAN_TEST
|
||||
else if (type == HA_KEYTYPE_FLOAT)
|
||||
@ -154,7 +154,7 @@ uint _nisam_pack_key(register N_INFO *info, uint keynr, uchar *key, uchar *old,
|
||||
#endif
|
||||
{
|
||||
if (type == HA_KEYTYPE_TEXT)
|
||||
case_sort((byte*) key,length);
|
||||
case_sort(default_charset_info,(byte*) key,length);
|
||||
}
|
||||
key+= length;
|
||||
}
|
||||
|
@ -515,11 +515,13 @@ int _nisam_key_cmp(register N_KEYSEG *keyseg, register uchar *a, register uchar
|
||||
if (*a++ != *b++)
|
||||
{
|
||||
a--; b--;
|
||||
if (isdigit((char) *a) && isdigit((char) *b))
|
||||
if (my_isdigit(default_charset_info, (char) *a) &&
|
||||
my_isdigit(default_charset_info, (char) *b))
|
||||
return ((int) *a - (int) *b);
|
||||
if (*a == '-' || isdigit((char) *b))
|
||||
if (*a == '-' || my_isdigit(default_charset_info,(char) *b))
|
||||
return (-1);
|
||||
if (*b == '-' || *b++ == ' ' || isdigit((char) *a))
|
||||
if (*b == '-' || *b++ == ' ' ||
|
||||
my_isdigit(default_charset_info,(char) *a))
|
||||
return (1);
|
||||
if (*a++ == ' ')
|
||||
return (-1);
|
||||
@ -539,11 +541,13 @@ int _nisam_key_cmp(register N_KEYSEG *keyseg, register uchar *a, register uchar
|
||||
if (*a++ != *b++)
|
||||
{
|
||||
a--; b--;
|
||||
if (isdigit((char) *a) && isdigit((char) *b))
|
||||
if (my_isdigit(default_charset_info,(char) *a) &&
|
||||
my_isdigit(default_charset_info,(char) *b))
|
||||
return ((int) *a - (int) *b);
|
||||
if (*a == '-' || isdigit((char) *b))
|
||||
if (*a == '-' || my_isdigit(default_charset_info,(char) *b))
|
||||
return (-1);
|
||||
if (*b == '-' || *b++ == ' ' || isdigit((char) *a))
|
||||
if (*b == '-' || *b++ == ' ' ||
|
||||
my_isdigit(default_charset_info,(char) *a))
|
||||
return (1);
|
||||
if (*a++ == ' ')
|
||||
return -1;
|
||||
|
@ -41,7 +41,7 @@ mystringsobjects = strmov.lo strxmov.lo strxnmov.lo strnmov.lo \
|
||||
strcend.lo bcmp.lo \
|
||||
bchange.lo bmove.lo bmove_upp.lo longlong2str.lo \
|
||||
strtoull.lo strtoll.lo llstr.lo \
|
||||
ctype.lo $(LTCHARSET_OBJS)
|
||||
ctype.lo ctype-simple.lo ctype-mb.lo $(LTCHARSET_OBJS)
|
||||
mystringsextra= strto.c
|
||||
dbugobjects = dbug.lo # IT IS IN SAFEMALLOC.C sanity.lo
|
||||
mysysheaders = mysys_priv.h my_static.h
|
||||
|
@ -1282,8 +1282,8 @@ STDCALL mysql_rpl_query_type(const char* q, int len)
|
||||
for(; q < q_end; ++q)
|
||||
{
|
||||
char c;
|
||||
if (isalpha(c=*q))
|
||||
switch(tolower(c))
|
||||
if (my_isalpha(system_charset_info,c=*q))
|
||||
switch(my_tolower(system_charset_info,c))
|
||||
{
|
||||
case 'i': /* insert */
|
||||
case 'u': /* update or unlock tables */
|
||||
@ -1292,9 +1292,11 @@ STDCALL mysql_rpl_query_type(const char* q, int len)
|
||||
case 'a': /* alter */
|
||||
return MYSQL_RPL_MASTER;
|
||||
case 'c': /* create or check */
|
||||
return tolower(q[1]) == 'h' ? MYSQL_RPL_ADMIN : MYSQL_RPL_MASTER ;
|
||||
return my_tolower(system_charset_info,q[1]) == 'h' ? MYSQL_RPL_ADMIN :
|
||||
MYSQL_RPL_MASTER;
|
||||
case 's': /* select or show */
|
||||
return tolower(q[1]) == 'h' ? MYSQL_RPL_ADMIN : MYSQL_RPL_SLAVE;
|
||||
return my_tolower(system_charset_info,q[1]) == 'h' ? MYSQL_RPL_ADMIN :
|
||||
MYSQL_RPL_SLAVE;
|
||||
case 'f': /* flush */
|
||||
case 'r': /* repair */
|
||||
case 'g': /* grant */
|
||||
|
@ -106,7 +106,7 @@ int main(int argc,char *argv[])
|
||||
#endif
|
||||
|
||||
snprintf(buf,MAX_LEN,"%.*s",(int) keylen,info->lastkey+1);
|
||||
casedn_str(buf);
|
||||
my_casedn_str(default_charset_info,buf);
|
||||
total++;
|
||||
lengths[keylen]++;
|
||||
|
||||
|
@ -107,13 +107,13 @@ FT_WORD * ft_linearize(TREE *wtree)
|
||||
DBUG_RETURN(wlist);
|
||||
}
|
||||
|
||||
#define true_word_char(X) (isalnum(X) || (X)=='_')
|
||||
#define true_word_char(s,X) (my_isalnum(s,X) || (X)=='_')
|
||||
#ifdef HYPHEN_IS_DELIM
|
||||
#define misc_word_char(X) ((X)=='\'')
|
||||
#else
|
||||
#define misc_word_char(X) ((X)=='\'' || (X)=='-')
|
||||
#endif
|
||||
#define word_char(X) (true_word_char(X) || misc_word_char(X))
|
||||
#define word_char(s,X) (true_word_char(s,X) || misc_word_char(s,X))
|
||||
|
||||
|
||||
/* returns:
|
||||
@ -134,7 +134,11 @@ byte ft_get_word(byte **start, byte *end, FT_WORD *word, FTB_PARAM *param)
|
||||
{
|
||||
for (;doc<end;doc++)
|
||||
{
|
||||
if (true_word_char(*doc)) break;
|
||||
/*
|
||||
BAR TODO: discuss with Serge how to remove
|
||||
default_charset_info correctly
|
||||
*/
|
||||
if (true_word_char(default_charset_info,*doc)) break;
|
||||
if (*doc == FTB_LBR || *doc == FTB_RBR)
|
||||
{
|
||||
/* param->prev=' '; */
|
||||
@ -156,7 +160,7 @@ byte ft_get_word(byte **start, byte *end, FT_WORD *word, FTB_PARAM *param)
|
||||
|
||||
mwc=0;
|
||||
for (word->pos=doc; doc<end; doc++)
|
||||
if (true_word_char(*doc))
|
||||
if (true_word_char(default_charset_info,*doc))
|
||||
mwc=0;
|
||||
else if (!misc_word_char(*doc) || mwc++)
|
||||
break;
|
||||
@ -185,12 +189,12 @@ byte ft_simple_get_word(byte **start, byte *end, FT_WORD *word)
|
||||
{
|
||||
for (;doc<end;doc++)
|
||||
{
|
||||
if (true_word_char(*doc)) break;
|
||||
if (true_word_char(default_charset_info,*doc)) break;
|
||||
}
|
||||
|
||||
mwc=0;
|
||||
for(word->pos=doc; doc<end; doc++)
|
||||
if (true_word_char(*doc))
|
||||
if (true_word_char(default_charset_info,*doc))
|
||||
mwc=0;
|
||||
else if (!misc_word_char(*doc) || mwc++)
|
||||
break;
|
||||
|
@ -458,19 +458,19 @@ static void update_record(char *record)
|
||||
ptr=blob_key;
|
||||
memcpy_fixed(pos+4,&ptr,sizeof(char*)); /* Store pointer to new key */
|
||||
if (keyinfo[0].seg[0].type != HA_KEYTYPE_NUM)
|
||||
casedn(blob_key,length);
|
||||
my_casedn(default_charset_info,blob_key,length);
|
||||
pos+=recinfo[1].length;
|
||||
}
|
||||
else if (recinfo[1].type == FIELD_VARCHAR)
|
||||
{
|
||||
uint length=uint2korr(pos);
|
||||
casedn(pos+2,length);
|
||||
my_casedn(default_charset_info,pos+2,length);
|
||||
pos+=recinfo[1].length;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (keyinfo[0].seg[0].type != HA_KEYTYPE_NUM)
|
||||
casedn(pos,keyinfo[0].seg[0].length);
|
||||
my_casedn(default_charset_info,pos,keyinfo[0].seg[0].length);
|
||||
pos+=recinfo[1].length;
|
||||
}
|
||||
|
||||
|
@ -68,7 +68,7 @@ static my_bool get_word(struct simpleconfig_buf_st *fb, char *buf)
|
||||
|
||||
for (;;)
|
||||
{
|
||||
while (isspace(*endptr))
|
||||
while (my_isspace(system_charset_info, *endptr))
|
||||
++endptr;
|
||||
if (*endptr && *endptr != '#') /* Not comment */
|
||||
break; /* Found something */
|
||||
@ -77,7 +77,7 @@ static my_bool get_word(struct simpleconfig_buf_st *fb, char *buf)
|
||||
endptr = fb->buf;
|
||||
}
|
||||
|
||||
while (!isspace(*endptr))
|
||||
while (!my_isspace(system_charset_info, *endptr))
|
||||
*buf++= *endptr++;
|
||||
*buf=0;
|
||||
fb->p = endptr;
|
||||
@ -540,11 +540,9 @@ void _print_csinfo(CHARSET_INFO *cs)
|
||||
printf("to_lower:\n"); _print_array(cs->to_lower, 256);
|
||||
printf("to_upper:\n"); _print_array(cs->to_upper, 256);
|
||||
printf("sort_order:\n"); _print_array(cs->sort_order, 256);
|
||||
printf("collate: %3s (%d, %p, %p, %p, %p, %p)\n",
|
||||
printf("collate: %3s (%d, %p, %p, %p)\n",
|
||||
cs->strxfrm_multiply ? "yes" : "no",
|
||||
cs->strxfrm_multiply,
|
||||
cs->strcoll,
|
||||
cs->strxfrm,
|
||||
cs->strnncoll,
|
||||
cs->strnxfrm,
|
||||
cs->like_range);
|
||||
|
@ -247,7 +247,7 @@ static my_bool search_default_file(DYNAMIC_ARRAY *args, MEM_ROOT *alloc,
|
||||
{
|
||||
line++;
|
||||
/* Ignore comment and empty lines */
|
||||
for (ptr=buff ; isspace(*ptr) ; ptr++ ) ;
|
||||
for (ptr=buff ; my_isspace(system_charset_info,*ptr) ; ptr++ ) ;
|
||||
if (*ptr == '#' || *ptr == ';' || !*ptr)
|
||||
continue;
|
||||
if (*ptr == '[') /* Group name */
|
||||
@ -260,7 +260,7 @@ static my_bool search_default_file(DYNAMIC_ARRAY *args, MEM_ROOT *alloc,
|
||||
name,line);
|
||||
goto err;
|
||||
}
|
||||
for ( ; isspace(end[-1]) ; end--) ; /* Remove end space */
|
||||
for ( ; my_isspace(system_charset_info,end[-1]) ; end--) ;/* Remove end space */
|
||||
end[0]=0;
|
||||
read_values=find_type(ptr,group,3) > 0;
|
||||
continue;
|
||||
@ -276,7 +276,7 @@ static my_bool search_default_file(DYNAMIC_ARRAY *args, MEM_ROOT *alloc,
|
||||
continue;
|
||||
if (!(end=value=strchr(ptr,'=')))
|
||||
end=strend(ptr); /* Option without argument */
|
||||
for ( ; isspace(end[-1]) ; end--) ;
|
||||
for ( ; my_isspace(system_charset_info,end[-1]) ; end--) ;
|
||||
if (!value)
|
||||
{
|
||||
if (!(tmp=alloc_root(alloc,(uint) (end-ptr)+3)))
|
||||
@ -289,9 +289,9 @@ static my_bool search_default_file(DYNAMIC_ARRAY *args, MEM_ROOT *alloc,
|
||||
{
|
||||
/* Remove pre- and end space */
|
||||
char *value_end;
|
||||
for (value++ ; isspace(*value); value++) ;
|
||||
for (value++ ; my_isspace(system_charset_info,*value); value++) ;
|
||||
value_end=strend(value);
|
||||
for ( ; isspace(value_end[-1]) ; value_end--) ;
|
||||
for ( ; my_isspace(system_charset_info,value_end[-1]) ; value_end--) ;
|
||||
if (value_end < value) /* Empty string */
|
||||
value_end=value;
|
||||
if (!(tmp=alloc_root(alloc,(uint) (end-ptr)+3 +
|
||||
|
@ -58,14 +58,15 @@ my_bool set_changeable_var(my_string str,CHANGEABLE_VAR *vars)
|
||||
longlong num;
|
||||
|
||||
/* Skip end space from variable */
|
||||
for (var_end=end ; end > str && isspace(var_end[-1]) ; var_end--) ;
|
||||
for (var_end=end ; end > str && my_isspace(system_charset_info, var_end[-1]) ; var_end--) ;
|
||||
length=(uint) (var_end-str);
|
||||
/* Skip start space from argument */
|
||||
for (end++ ; isspace(*end) ; end++) ;
|
||||
for (end++ ; my_isspace(system_charset_info, *end) ; end++) ;
|
||||
|
||||
for (var=vars,found=0 ; (name=var->name) ; var++)
|
||||
{
|
||||
if (!my_casecmp(name,str,length))
|
||||
/* BAR TODO: remove system_charset_info */
|
||||
if (!my_strncasecmp(system_charset_info,name,str,length))
|
||||
{
|
||||
found=var; found_count++;
|
||||
if (!name[length])
|
||||
@ -93,7 +94,7 @@ my_bool set_changeable_var(my_string str,CHANGEABLE_VAR *vars)
|
||||
num*=1024L*1024L;
|
||||
else if (endchar == 'g' || endchar == 'G')
|
||||
num*=1024L*1024L*1024L;
|
||||
else if (!isdigit(endchar))
|
||||
else if (!my_isdigit(system_charset_info, endchar))
|
||||
{
|
||||
fprintf(stderr,"Unknown prefix used for variable value '%s'\n",str);
|
||||
DBUG_RETURN(1);
|
||||
|
@ -129,7 +129,9 @@ static uint calc_hashnr_caseup(const byte *key,uint length)
|
||||
register uint nr=1, nr2=4;
|
||||
while (length--)
|
||||
{
|
||||
nr^= (((nr & 63)+nr2)*((uint) (uchar) toupper(*key++)))+ (nr << 8);
|
||||
/* BAR TODO: remove default_charset_info */
|
||||
nr^= (((nr & 63)+nr2)*
|
||||
((uint) (uchar) my_toupper(default_charset_info, *key++)))+ (nr << 8);
|
||||
nr2+=3;
|
||||
}
|
||||
return((uint) nr);
|
||||
@ -271,9 +273,10 @@ static int hashcmp(HASH *hash,HASH_LINK *pos,const byte *key,uint length)
|
||||
{
|
||||
uint rec_keylength;
|
||||
byte *rec_key=hash_key(hash,pos->data,&rec_keylength,1);
|
||||
/* BAR TODO: remove default_charset_info */
|
||||
return (length && length != rec_keylength) ||
|
||||
(hash->flags & HASH_CASE_INSENSITIVE ?
|
||||
my_casecmp(rec_key,key,rec_keylength) :
|
||||
my_strncasecmp(default_charset_info, rec_key,key,rec_keylength) :
|
||||
memcmp(rec_key,key,rec_keylength));
|
||||
}
|
||||
|
||||
|
@ -28,234 +28,50 @@
|
||||
#include <m_string.h>
|
||||
#endif
|
||||
|
||||
/* string to uppercase */
|
||||
|
||||
void caseup_str(my_string str)
|
||||
{
|
||||
#ifdef USE_MB
|
||||
if (use_mb(default_charset_info))
|
||||
{
|
||||
register uint32 l;
|
||||
register char *end=str+strlen(str);
|
||||
while (*str)
|
||||
{
|
||||
if ((l=my_ismbchar(default_charset_info, str,end))) str+=l;
|
||||
else *str=toupper(*str),++str;
|
||||
}
|
||||
}
|
||||
else
|
||||
#endif
|
||||
while ((*str = toupper(*str)) != 0)
|
||||
str++;
|
||||
} /* caseup_str */
|
||||
|
||||
/* string to lowercase */
|
||||
|
||||
void casedn_str(my_string str)
|
||||
{
|
||||
#ifdef USE_MB
|
||||
if (use_mb(default_charset_info))
|
||||
{
|
||||
register uint32 l;
|
||||
register char *end=str+strlen(str);
|
||||
while (*str)
|
||||
{
|
||||
if ((l=my_ismbchar(default_charset_info, str,end))) str+=l;
|
||||
else *str=tolower(*str),++str;
|
||||
}
|
||||
}
|
||||
else
|
||||
#endif
|
||||
while ((*str= tolower(*str)) != 0)
|
||||
str++;
|
||||
} /* casedn_str */
|
||||
|
||||
|
||||
/* to uppercase */
|
||||
|
||||
void caseup(my_string str, uint length)
|
||||
{
|
||||
#ifdef USE_MB
|
||||
if (use_mb(default_charset_info))
|
||||
{
|
||||
register uint32 l;
|
||||
register char *end=str+length;
|
||||
while (str<end)
|
||||
{
|
||||
if ((l=my_ismbchar(default_charset_info, str,end))) str+=l;
|
||||
else *str=toupper(*str),++str;
|
||||
}
|
||||
}
|
||||
else
|
||||
#endif
|
||||
for ( ; length>0 ; length--, str++)
|
||||
*str= toupper(*str);
|
||||
} /* caseup */
|
||||
|
||||
/* to lowercase */
|
||||
|
||||
void casedn(my_string str, uint length)
|
||||
{
|
||||
#ifdef USE_MB
|
||||
if (use_mb(default_charset_info))
|
||||
{
|
||||
register uint32 l;
|
||||
register char *end=str+length;
|
||||
while (str<end)
|
||||
{
|
||||
if ((l=my_ismbchar(default_charset_info, str,end))) str+=l;
|
||||
else *str=tolower(*str),++str;
|
||||
}
|
||||
}
|
||||
else
|
||||
#endif
|
||||
for ( ; length>0 ; length--, str++)
|
||||
*str= tolower(*str);
|
||||
} /* casedn */
|
||||
|
||||
/* to sort-string that can be compared to get text in order */
|
||||
|
||||
void case_sort(my_string str, uint length)
|
||||
void case_sort(CHARSET_INFO *cs, my_string str, uint length)
|
||||
{
|
||||
for ( ; length>0 ; length--, str++)
|
||||
*str= (char) my_sort_order[(uchar) *str];
|
||||
*str= (char) cs->sort_order[(uchar) *str];
|
||||
} /* case_sort */
|
||||
|
||||
/* find string in another with no case_sensivity */
|
||||
|
||||
/* ToDo: This function should be modified to support multibyte charset.
|
||||
However it is not used untill 3.23.5.
|
||||
Wei He (hewei@mail.ied.ac.cn)
|
||||
*/
|
||||
|
||||
my_string my_strcasestr(const char *str, const char *search)
|
||||
{
|
||||
uchar *i,*j,*pos;
|
||||
|
||||
pos=(uchar*) str;
|
||||
skipp:
|
||||
while (*pos != '\0')
|
||||
{
|
||||
if (toupper((uchar) *pos++) == toupper((uchar) *search))
|
||||
{
|
||||
i=(uchar*) pos; j=(uchar*) search+1;
|
||||
while (*j)
|
||||
if (toupper(*i++) != toupper(*j++)) goto skipp;
|
||||
return ((char*) pos-1);
|
||||
}
|
||||
}
|
||||
return ((my_string) 0);
|
||||
} /* strcstr */
|
||||
|
||||
|
||||
/* compare strings without regarding to case */
|
||||
|
||||
int my_strcasecmp(const char *s, const char *t)
|
||||
{
|
||||
#ifdef USE_MB
|
||||
if (use_mb(default_charset_info))
|
||||
{
|
||||
register uint32 l;
|
||||
register const char *end=s+strlen(s);
|
||||
while (s<end)
|
||||
{
|
||||
if ((l=my_ismbchar(default_charset_info, s,end)))
|
||||
{
|
||||
while (l--)
|
||||
if (*s++ != *t++) return 1;
|
||||
}
|
||||
else if (my_ismbhead(default_charset_info, *t)) return 1;
|
||||
else if (toupper((uchar) *s++) != toupper((uchar) *t++)) return 1;
|
||||
}
|
||||
return *t;
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
while (toupper((uchar) *s) == toupper((uchar) *t++))
|
||||
if (!*s++) return 0;
|
||||
return ((int) toupper((uchar) s[0]) - (int) toupper((uchar) t[-1]));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int my_casecmp(const char *s, const char *t, uint len)
|
||||
{
|
||||
#ifdef USE_MB
|
||||
if (use_mb(default_charset_info))
|
||||
{
|
||||
register uint32 l;
|
||||
register const char *end=s+len;
|
||||
while (s<end)
|
||||
{
|
||||
if ((l=my_ismbchar(default_charset_info, s,end)))
|
||||
{
|
||||
while (l--)
|
||||
if (*s++ != *t++) return 1;
|
||||
}
|
||||
else if (my_ismbhead(default_charset_info, *t)) return 1;
|
||||
else if (toupper((uchar) *s++) != toupper((uchar) *t++)) return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
while (len-- != 0 && toupper(*s++) == toupper(*t++)) ;
|
||||
return (int) len+1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int my_strsortcmp(const char *s, const char *t)
|
||||
int my_sortcmp(CHARSET_INFO *cs, const char *s, const char *t, uint len)
|
||||
{
|
||||
#ifdef USE_STRCOLL
|
||||
if (use_strcoll(default_charset_info))
|
||||
return my_strcoll(default_charset_info, (uchar *)s, (uchar *)t);
|
||||
else
|
||||
#endif
|
||||
{
|
||||
while (my_sort_order[(uchar) *s] == my_sort_order[(uchar) *t++])
|
||||
if (!*s++) return 0;
|
||||
return ((int) my_sort_order[(uchar) s[0]] -
|
||||
(int) my_sort_order[(uchar) t[-1]]);
|
||||
}
|
||||
}
|
||||
|
||||
int my_sortcmp(const char *s, const char *t, uint len)
|
||||
{
|
||||
#ifdef USE_STRCOLL
|
||||
if (use_strcoll(default_charset_info))
|
||||
return my_strnncoll(default_charset_info,
|
||||
(uchar *)s, len, (uchar *)t, len);
|
||||
if (use_strcoll(cs))
|
||||
return my_strnncoll(cs,(uchar *)s, len, (uchar *)t, len);
|
||||
else
|
||||
#endif
|
||||
{
|
||||
while (len--)
|
||||
{
|
||||
if (my_sort_order[(uchar) *s++] != my_sort_order[(uchar) *t++])
|
||||
return ((int) my_sort_order[(uchar) s[-1]] -
|
||||
(int) my_sort_order[(uchar) t[-1]]);
|
||||
if (cs->sort_order[(uchar) *s++] != cs->sort_order[(uchar) *t++])
|
||||
return ((int) cs->sort_order[(uchar) s[-1]] -
|
||||
(int) cs->sort_order[(uchar) t[-1]]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
int my_sortncmp(const char *s, uint s_len, const char *t, uint t_len)
|
||||
int my_sortncmp(CHARSET_INFO *cs,
|
||||
const char *s, uint s_len,
|
||||
const char *t, uint t_len)
|
||||
{
|
||||
#ifdef USE_STRCOLL
|
||||
if (use_strcoll(default_charset_info))
|
||||
return my_strnncoll(default_charset_info,
|
||||
(uchar *)s, s_len, (uchar *)t, t_len);
|
||||
if (use_strcoll(cs))
|
||||
return my_strnncoll(cs, (uchar *)s, s_len, (uchar *)t, t_len);
|
||||
else
|
||||
#endif
|
||||
{
|
||||
uint len= min(s_len,t_len);
|
||||
while (len--)
|
||||
{
|
||||
if (my_sort_order[(uchar) *s++] != my_sort_order[(uchar) *t++])
|
||||
return ((int) my_sort_order[(uchar) s[-1]] -
|
||||
(int) my_sort_order[(uchar) t[-1]]);
|
||||
if (cs->sort_order[(uchar) *s++] != cs->sort_order[(uchar) *t++])
|
||||
return ((int) cs->sort_order[(uchar) s[-1]] -
|
||||
(int) cs->sort_order[(uchar) t[-1]]);
|
||||
}
|
||||
return (int) (s_len - t_len);
|
||||
}
|
||||
|
@ -108,11 +108,5 @@ char *convert_dirname(char *to, const char *from, const char *from_end)
|
||||
*to++=FN_LIBCHAR;
|
||||
*to=0;
|
||||
}
|
||||
#ifdef FN_UPPER_CASE
|
||||
caseup_str(to_org);
|
||||
#endif
|
||||
#ifdef FN_LOWER_CASE
|
||||
casedn_str(to_org);
|
||||
#endif
|
||||
return to; /* Pointer to end of dir */
|
||||
} /* convert_dirname */
|
||||
|
@ -91,12 +91,6 @@ my_string fn_format(my_string to, const char *name, const char *dir,
|
||||
name=buff;
|
||||
}
|
||||
pos=strmake(strmov(to,dev),name,length);
|
||||
#ifdef FN_UPPER_CASE
|
||||
caseup_str(to);
|
||||
#endif
|
||||
#ifdef FN_LOWER_CASE
|
||||
casedn_str(to);
|
||||
#endif
|
||||
(void) strmov(pos,ext); /* Don't convert extension */
|
||||
}
|
||||
/*
|
||||
|
@ -249,7 +249,7 @@ uint my_b_vprintf(IO_CACHE *info, const char* fmt, va_list args)
|
||||
/* Found one '%' */
|
||||
}
|
||||
/* Skipp if max size is used (to be compatible with printf) */
|
||||
while (isdigit(*fmt) || *fmt == '.' || *fmt == '-')
|
||||
while (my_isdigit(system_charset_info, *fmt) || *fmt == '.' || *fmt == '-')
|
||||
fmt++;
|
||||
if (*fmt == 's') /* String parameter */
|
||||
{
|
||||
|
@ -34,12 +34,12 @@
|
||||
#include <m_ctype.h>
|
||||
#include "my_static.h"
|
||||
|
||||
static char get_scode(char **ptr,pbool remove_garbage);
|
||||
static char get_scode(CHARSET_INFO * cs, char **ptr,pbool remove_garbage);
|
||||
|
||||
/* outputed string is 4 byte long */
|
||||
/* out_pntr can be == in_pntr */
|
||||
|
||||
void soundex(register my_string out_pntr, my_string in_pntr,
|
||||
void soundex(CHARSET_INFO * cs,register my_string out_pntr, my_string in_pntr,
|
||||
pbool remove_garbage)
|
||||
{
|
||||
char ch,last_ch;
|
||||
@ -47,11 +47,11 @@ void soundex(register my_string out_pntr, my_string in_pntr,
|
||||
|
||||
if (remove_garbage)
|
||||
{
|
||||
while (*in_pntr && isspace(*in_pntr)) /* Skipp pre-space */
|
||||
while (*in_pntr && my_isspace(cs,*in_pntr)) /* Skipp pre-space */
|
||||
in_pntr++;
|
||||
}
|
||||
*out_pntr++ = toupper(*in_pntr); /* Copy first letter */
|
||||
last_ch = get_scode(&in_pntr,0); /* code of the first letter */
|
||||
*out_pntr++ = my_toupper(cs,*in_pntr);/* Copy first letter */
|
||||
last_ch = get_scode(cs,&in_pntr,0); /* code of the first letter */
|
||||
/* for the first 'double-letter */
|
||||
/* check. */
|
||||
end=out_pntr+3; /* Loop on input letters until */
|
||||
@ -59,7 +59,7 @@ void soundex(register my_string out_pntr, my_string in_pntr,
|
||||
/* letter code count = 3 */
|
||||
|
||||
in_pntr++;
|
||||
while (out_pntr < end && (ch = get_scode(&in_pntr,remove_garbage)) != 0)
|
||||
while (out_pntr < end && (ch = get_scode(cs,&in_pntr,remove_garbage)) != 0)
|
||||
{
|
||||
in_pntr++;
|
||||
if ((ch != '0') && (ch != last_ch)) /* if not skipped or double */
|
||||
@ -81,19 +81,19 @@ void soundex(register my_string out_pntr, my_string in_pntr,
|
||||
else return 0
|
||||
*/
|
||||
|
||||
static char get_scode(char **ptr, pbool remove_garbage)
|
||||
static char get_scode(CHARSET_INFO * cs,char **ptr, pbool remove_garbage)
|
||||
{
|
||||
uchar ch;
|
||||
|
||||
if (remove_garbage)
|
||||
{
|
||||
while (**ptr && !isalpha(**ptr))
|
||||
while (**ptr && !my_isalpha(cs,**ptr))
|
||||
(*ptr)++;
|
||||
}
|
||||
ch=toupper(**ptr);
|
||||
ch=my_toupper(cs,**ptr);
|
||||
if (ch < 'A' || ch > 'Z')
|
||||
{
|
||||
if (isalpha(ch)) /* If exetended alfa (country spec) */
|
||||
if (my_isalpha(cs,ch)) /* If exetended alfa (country spec) */
|
||||
return '0'; /* threat as vokal */
|
||||
return 0; /* Can't map */
|
||||
}
|
||||
|
@ -54,13 +54,6 @@ WF_PACK *wf_comp(my_string str)
|
||||
for (pos=str ; *pos ; pos++)
|
||||
ant+= test(*pos == ' ' || *pos == ',');
|
||||
|
||||
#ifdef FN_UPPER_CASE
|
||||
caseup(str,(int) (pos-str));
|
||||
#endif
|
||||
#ifdef FN_LOWER_CASE
|
||||
casedn(str,(int) (pos-str));
|
||||
#endif
|
||||
|
||||
if ((ret= (WF_PACK*) my_malloc((uint) ant*(sizeof(my_string*)+2)+
|
||||
sizeof(WF_PACK)+ (uint) strlen(str)+1,
|
||||
MYF(MY_WME)))
|
||||
|
@ -62,7 +62,7 @@ int my_error(int nr,myf MyFlags, ...)
|
||||
else
|
||||
{
|
||||
/* Skipp if max size is used (to be compatible with printf) */
|
||||
while (isdigit(*tpos) || *tpos == '.' || *tpos == '-')
|
||||
while (my_isdigit(system_charset_info, *tpos) || *tpos == '.' || *tpos == '-')
|
||||
tpos++;
|
||||
if (*tpos == 'l') /* Skipp 'l' argument */
|
||||
tpos++;
|
||||
|
@ -109,7 +109,8 @@ int my_setwd(const char *dir, myf MyFlags)
|
||||
uint drive,drives;
|
||||
|
||||
pos++; /* Skipp FN_DEVCHAR */
|
||||
drive=(uint) (toupper(dir[0])-'A'+1); drives= (uint) -1;
|
||||
drive=(uint) (my_toupper(system_charset_info,dir[0])-'A'+1);
|
||||
drives= (uint) -1;
|
||||
if ((pos-(byte*) dir) == 2 && drive > 0 && drive < 32)
|
||||
{
|
||||
#ifdef OS2
|
||||
|
@ -17,7 +17,6 @@
|
||||
#include "mysys_priv.h"
|
||||
#include "my_static.h"
|
||||
#include "mysys_err.h"
|
||||
#include "m_ctype.h"
|
||||
#include <m_string.h>
|
||||
#include <m_ctype.h>
|
||||
#ifdef THREAD
|
||||
@ -50,7 +49,7 @@ my_bool my_init_done=0;
|
||||
static ulong atoi_octal(const char *str)
|
||||
{
|
||||
long int tmp;
|
||||
while (*str && isspace(*str))
|
||||
while (*str && my_isspace(system_charset_info, *str))
|
||||
str++;
|
||||
str2int(str,
|
||||
(*str == '0' ? 8 : 10), /* Octalt or decimalt */
|
||||
|
@ -41,7 +41,7 @@ int my_vsnprintf(char *to, size_t n, const char* fmt, va_list ap)
|
||||
}
|
||||
/* Skipp if max size is used (to be compatible with printf) */
|
||||
fmt++;
|
||||
while (isdigit(*fmt) || *fmt == '.' || *fmt == '-')
|
||||
while (my_isdigit(system_charset_info,*fmt) || *fmt == '.' || *fmt == '-')
|
||||
fmt++;
|
||||
if (*fmt == 'l')
|
||||
fmt++;
|
||||
|
@ -47,7 +47,9 @@ int find_type(my_string x, TYPELIB *typelib, uint full_name)
|
||||
find=0;
|
||||
for (pos=0 ; (j=typelib->type_names[pos]) ; pos++)
|
||||
{
|
||||
for (i=x ; *i && toupper(*i) == toupper(*j) ; i++, j++) ;
|
||||
for (i=x ;
|
||||
*i && my_toupper(system_charset_info,*i) ==
|
||||
my_toupper(system_charset_info,*j) ; i++, j++) ;
|
||||
if (! *j)
|
||||
{
|
||||
while (*i == ' ')
|
||||
|
@ -433,7 +433,17 @@ CONVERT *get_convert_set(const char *name)
|
||||
{
|
||||
for (CONVERT **ptr=convert_tables ; *ptr ; ptr++)
|
||||
{
|
||||
if (!my_strcasecmp((*ptr)->name,name))
|
||||
/*
|
||||
BAR TODO: Monty's comments:
|
||||
Why is this using system_charset_info ?
|
||||
Isn't the character-set string given in the users default charset?
|
||||
Please add a TODO note to the code that this has to be fixed when the user
|
||||
will be able to cast strings to different character sets...
|
||||
The current code will also not work if/when we introduce support for
|
||||
16 bit characters...
|
||||
(I know that there is a LOT of changes to do if we ever want do this...)
|
||||
*/
|
||||
if (!my_strcasecmp(system_charset_info,(*ptr)->name,name))
|
||||
return (*ptr);
|
||||
}
|
||||
return 0;
|
||||
|
@ -70,9 +70,10 @@ load_des_key_file(const char *file_name)
|
||||
{
|
||||
offset=(char) (offset - '0');
|
||||
// Remove newline and possible other control characters
|
||||
for (start=buf+1 ; isspace(*start) ; start++) ;
|
||||
for (start=buf+1 ; my_isspace(system_charset_info, *start) ; start++) ;
|
||||
end=buf+length;
|
||||
for (end=strend(buf) ; end > start && !isgraph(end[-1]) ; end--) ;
|
||||
for (end=strend(buf) ;
|
||||
end > start && !my_isgraph(system_charset_info, end[-1]) ; end--) ;
|
||||
|
||||
if (start != end)
|
||||
{
|
||||
|
114
sql/field.cc
114
sql/field.cc
@ -68,7 +68,8 @@ const char field_separator=',';
|
||||
*/
|
||||
|
||||
static bool
|
||||
number_dec(struct st_decstr *sdec, const char *str, const char *end)
|
||||
number_dec(CHARSET_INFO *cs, struct st_decstr *sdec,
|
||||
const char *str, const char *end)
|
||||
{
|
||||
sdec->sign=sdec->extra=0;
|
||||
if (str == end)
|
||||
@ -86,7 +87,7 @@ number_dec(struct st_decstr *sdec, const char *str, const char *end)
|
||||
str++;
|
||||
}
|
||||
const char *start=str;
|
||||
while (str != end && isdigit(*str))
|
||||
while (str != end && my_isdigit(cs,*str))
|
||||
str++;
|
||||
if (!(sdec->nr_length=(uint) (str-start)))
|
||||
sdec->extra=1; // We must put one 0 before .
|
||||
@ -95,13 +96,13 @@ number_dec(struct st_decstr *sdec, const char *str, const char *end)
|
||||
{
|
||||
str++;
|
||||
start=str;
|
||||
while (str != end && isdigit(*str))
|
||||
while (str != end && my_isdigit(cs,*str))
|
||||
str++;
|
||||
}
|
||||
sdec->nr_dec=(uint) (str-start);
|
||||
if (current_thd->count_cuted_fields)
|
||||
{
|
||||
while (str != end && isspace(*str))
|
||||
while (str != end && my_isspace(cs,*str))
|
||||
str++; /* purecov: inspected */
|
||||
if (str != end)
|
||||
{
|
||||
@ -135,7 +136,8 @@ bool test_if_int(const char *str,int length)
|
||||
{
|
||||
const char *end=str+length;
|
||||
|
||||
while (str != end && isspace(*str)) // Allow start space
|
||||
// Allow start space
|
||||
while (str != end && my_isspace(system_charset_info,*str))
|
||||
str++; /* purecov: inspected */
|
||||
if (str != end && (*str == '-' || *str == '+'))
|
||||
str++;
|
||||
@ -143,7 +145,7 @@ bool test_if_int(const char *str,int length)
|
||||
return 0; // Error: Empty string
|
||||
for ( ; str != end ; str++)
|
||||
{
|
||||
if (!isdigit(*str))
|
||||
if (!my_isdigit(system_charset_info,*str))
|
||||
{
|
||||
if (*str == '.')
|
||||
{ // Allow '.0000'
|
||||
@ -151,10 +153,10 @@ bool test_if_int(const char *str,int length)
|
||||
if (str == end)
|
||||
return 1;
|
||||
}
|
||||
if (!isspace(*str))
|
||||
if (!my_isspace(system_charset_info,*str))
|
||||
return 0;
|
||||
for (str++ ; str != end ; str++)
|
||||
if (!isspace(*str))
|
||||
if (!my_isspace(system_charset_info,*str))
|
||||
return 0;
|
||||
return 1;
|
||||
}
|
||||
@ -165,7 +167,7 @@ bool test_if_int(const char *str,int length)
|
||||
|
||||
static bool test_if_real(const char *str,int length)
|
||||
{
|
||||
while (length && isspace(*str))
|
||||
while (length && my_isspace(system_charset_info,*str))
|
||||
{ // Allow start space
|
||||
length--; str++;
|
||||
}
|
||||
@ -174,10 +176,10 @@ static bool test_if_real(const char *str,int length)
|
||||
if (*str == '+' || *str == '-')
|
||||
{
|
||||
length--; str++;
|
||||
if (!length || !(isdigit(*str) || *str == '.'))
|
||||
if (!length || !(my_isdigit(system_charset_info,*str) || *str == '.'))
|
||||
return 0;
|
||||
}
|
||||
while (length && isdigit(*str))
|
||||
while (length && my_isdigit(system_charset_info,*str))
|
||||
{
|
||||
length--; str++;
|
||||
}
|
||||
@ -186,7 +188,7 @@ static bool test_if_real(const char *str,int length)
|
||||
if (*str == '.')
|
||||
{
|
||||
length--; str++;
|
||||
while (length && isdigit(*str))
|
||||
while (length && my_isdigit(system_charset_info,*str))
|
||||
{
|
||||
length--; str++;
|
||||
}
|
||||
@ -195,18 +197,19 @@ static bool test_if_real(const char *str,int length)
|
||||
return 1;
|
||||
if (*str == 'E' || *str == 'e')
|
||||
{
|
||||
if (length < 3 || (str[1] != '+' && str[1] != '-') || !isdigit(str[2]))
|
||||
if (length < 3 || (str[1] != '+' && str[1] != '-') ||
|
||||
!my_isdigit(system_charset_info,str[2]))
|
||||
return 0;
|
||||
length-=3;
|
||||
str+=3;
|
||||
while (length && isdigit(*str))
|
||||
while (length && my_isdigit(system_charset_info,*str))
|
||||
{
|
||||
length--; str++;
|
||||
}
|
||||
}
|
||||
for ( ; length ; length--, str++)
|
||||
{ // Allow end space
|
||||
if (!isspace(*str))
|
||||
if (!my_isspace(system_charset_info,*str))
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
@ -405,7 +408,7 @@ void Field_decimal::store(const char *from,uint len)
|
||||
|
||||
if ((tmp_dec= dec))
|
||||
tmp_dec++; // Calculate pos of '.'
|
||||
while (from != end && isspace(*from))
|
||||
while (from != end && my_isspace(system_charset_info,*from))
|
||||
from++;
|
||||
if (zerofill)
|
||||
{
|
||||
@ -416,7 +419,7 @@ void Field_decimal::store(const char *from,uint len)
|
||||
}
|
||||
else
|
||||
fyllchar=' ';
|
||||
error=number_dec(&decstr,from,end);
|
||||
error=number_dec(system_charset_info,&decstr,from,end);
|
||||
if (decstr.sign)
|
||||
{
|
||||
from++;
|
||||
@ -479,7 +482,7 @@ void Field_decimal::store(const char *from,uint len)
|
||||
{
|
||||
if (*from != '0')
|
||||
{
|
||||
if (!isspace(*from)) // Space is ok
|
||||
if (!my_isspace(system_charset_info,*from)) // Space is ok
|
||||
current_thd->cuted_fields++;
|
||||
break;
|
||||
}
|
||||
@ -603,8 +606,10 @@ int Field_decimal::cmp(const char *a_ptr,const char *b_ptr)
|
||||
for (end=a_ptr+field_length;
|
||||
a_ptr != end &&
|
||||
(*a_ptr == *b_ptr ||
|
||||
((isspace(*a_ptr) || *a_ptr == '+' || *a_ptr == '0') &&
|
||||
(isspace(*b_ptr) || *b_ptr == '+' || *b_ptr == '0')));
|
||||
((my_isspace(system_charset_info,*a_ptr) || *a_ptr == '+' ||
|
||||
*a_ptr == '0') &&
|
||||
(my_isspace(system_charset_info,*b_ptr) || *b_ptr == '+' ||
|
||||
*b_ptr == '0')));
|
||||
a_ptr++,b_ptr++)
|
||||
{
|
||||
if (*a_ptr == '-') // If both numbers are negative
|
||||
@ -631,7 +636,7 @@ void Field_decimal::sort_string(char *to,uint length)
|
||||
char *str,*end;
|
||||
for (str=ptr,end=ptr+length;
|
||||
str != end &&
|
||||
((isspace(*str) || *str == '+' || *str == '0')) ;
|
||||
((my_isspace(system_charset_info,*str) || *str == '+' || *str == '0')) ;
|
||||
|
||||
str++)
|
||||
*to++=' ';
|
||||
@ -643,7 +648,7 @@ void Field_decimal::sort_string(char *to,uint length)
|
||||
*to++=1; // Smaller than any number
|
||||
str++;
|
||||
while (str != end)
|
||||
if (isdigit(*str))
|
||||
if (my_isdigit(system_charset_info,*str))
|
||||
*to++= (char) ('9' - *str++);
|
||||
else
|
||||
*to++= *str++;
|
||||
@ -1265,7 +1270,7 @@ void Field_medium::sql_type(String &res) const
|
||||
|
||||
void Field_long::store(const char *from,uint len)
|
||||
{
|
||||
while (len && isspace(*from))
|
||||
while (len && my_isspace(system_charset_info,*from))
|
||||
{
|
||||
len--; from++;
|
||||
}
|
||||
@ -1493,7 +1498,7 @@ void Field_long::sql_type(String &res) const
|
||||
|
||||
void Field_longlong::store(const char *from,uint len)
|
||||
{
|
||||
while (len && isspace(*from))
|
||||
while (len && my_isspace(system_charset_info,*from))
|
||||
{ // For easy error check
|
||||
len--; from++;
|
||||
}
|
||||
@ -3306,7 +3311,7 @@ void Field_string::store(const char *from,uint length)
|
||||
const char *end=from+length;
|
||||
for (from+=field_length ; from != end ; from++)
|
||||
{
|
||||
if (!isspace(*from))
|
||||
if (!my_isspace(field_charset,*from))
|
||||
{
|
||||
current_thd->cuted_fields++;
|
||||
break;
|
||||
@ -3377,7 +3382,7 @@ int Field_string::cmp(const char *a_ptr, const char *b_ptr)
|
||||
if (binary_flag)
|
||||
return memcmp(a_ptr,b_ptr,field_length);
|
||||
else
|
||||
return my_sortcmp(a_ptr,b_ptr,field_length);
|
||||
return my_sortcmp(field_charset,a_ptr,b_ptr,field_length);
|
||||
}
|
||||
|
||||
void Field_string::sort_string(char *to,uint length)
|
||||
@ -3387,17 +3392,17 @@ void Field_string::sort_string(char *to,uint length)
|
||||
else
|
||||
{
|
||||
#ifdef USE_STRCOLL
|
||||
if (use_strcoll(default_charset_info)) {
|
||||
uint tmp=my_strnxfrm(default_charset_info,
|
||||
(unsigned char *)to, (unsigned char *) ptr,
|
||||
length, field_length);
|
||||
if (use_strcoll(field_charset)) {
|
||||
uint tmp=my_strnxfrm(field_charset,
|
||||
(unsigned char *)to, length,
|
||||
(unsigned char *) ptr, field_length);
|
||||
if (tmp < length)
|
||||
bzero(to + tmp, length - tmp);
|
||||
}
|
||||
else
|
||||
#endif
|
||||
for (char *from=ptr,*end=ptr+length ; from != end ;)
|
||||
*to++=(char) my_sort_order[(uint) (uchar) *from++];
|
||||
*to++=(char) field_charset->sort_order[(uint) (uchar) *from++];
|
||||
}
|
||||
}
|
||||
|
||||
@ -3446,7 +3451,7 @@ int Field_string::pack_cmp(const char *a, const char *b, uint length)
|
||||
int cmp= memcmp(a,b,min(a_length,b_length));
|
||||
return cmp ? cmp : (int) (a_length - b_length);
|
||||
}
|
||||
return my_sortncmp(a,a_length, b,b_length);
|
||||
return my_sortncmp(field_charset, a,a_length, b,b_length);
|
||||
}
|
||||
|
||||
|
||||
@ -3463,7 +3468,7 @@ int Field_string::pack_cmp(const char *b, uint length)
|
||||
int cmp= memcmp(ptr,b,min(a_length,b_length));
|
||||
return cmp ? cmp : (int) (a_length - b_length);
|
||||
}
|
||||
return my_sortncmp(ptr,a_length, b, b_length);
|
||||
return my_sortncmp(field_charset, ptr,a_length, b, b_length);
|
||||
}
|
||||
|
||||
|
||||
@ -3568,7 +3573,7 @@ int Field_varstring::cmp(const char *a_ptr, const char *b_ptr)
|
||||
if (binary_flag)
|
||||
diff=memcmp(a_ptr+2,b_ptr+2,min(a_length,b_length));
|
||||
else
|
||||
diff=my_sortcmp(a_ptr+2,b_ptr+2,min(a_length,b_length));
|
||||
diff=my_sortcmp(field_charset, a_ptr+2,b_ptr+2,min(a_length,b_length));
|
||||
return diff ? diff : (int) (a_length - b_length);
|
||||
}
|
||||
|
||||
@ -3580,10 +3585,10 @@ void Field_varstring::sort_string(char *to,uint length)
|
||||
else
|
||||
{
|
||||
#ifdef USE_STRCOLL
|
||||
if (use_strcoll(default_charset_info))
|
||||
tot_length=my_strnxfrm(default_charset_info,
|
||||
(unsigned char *) to, (unsigned char *)ptr+2,
|
||||
length, tot_length);
|
||||
if (use_strcoll(field_charset))
|
||||
tot_length=my_strnxfrm(field_charset,
|
||||
(unsigned char *) to, length,
|
||||
(unsigned char *)ptr+2, tot_length);
|
||||
else
|
||||
{
|
||||
#endif
|
||||
@ -3591,7 +3596,7 @@ void Field_varstring::sort_string(char *to,uint length)
|
||||
if (tot_length > length)
|
||||
tot_length=length;
|
||||
for (char *from=ptr+2,*end=from+tot_length ; from != end ;)
|
||||
*tmp++=(char) my_sort_order[(uint) (uchar) *from++];
|
||||
*tmp++=(char) field_charset->sort_order[(uint) (uchar) *from++];
|
||||
#ifdef USE_STRCOLL
|
||||
}
|
||||
#endif
|
||||
@ -3662,7 +3667,7 @@ int Field_varstring::pack_cmp(const char *a, const char *b, uint key_length)
|
||||
int cmp= memcmp(a,b,min(a_length,b_length));
|
||||
return cmp ? cmp : (int) (a_length - b_length);
|
||||
}
|
||||
return my_sortncmp(a,a_length, b,b_length);
|
||||
return my_sortncmp(field_charset, a,a_length, b,b_length);
|
||||
}
|
||||
|
||||
int Field_varstring::pack_cmp(const char *b, uint key_length)
|
||||
@ -3683,7 +3688,7 @@ int Field_varstring::pack_cmp(const char *b, uint key_length)
|
||||
int cmp= memcmp(a,b,min(a_length,b_length));
|
||||
return cmp ? cmp : (int) (a_length - b_length);
|
||||
}
|
||||
return my_sortncmp(a,a_length, b,b_length);
|
||||
return my_sortncmp(field_charset, a,a_length, b,b_length);
|
||||
}
|
||||
|
||||
uint Field_varstring::packed_col_length(const char *ptr, uint length)
|
||||
@ -3906,7 +3911,7 @@ int Field_blob::cmp(const char *a,uint32 a_length, const char *b,
|
||||
if (binary_flag)
|
||||
diff=memcmp(a,b,min(a_length,b_length));
|
||||
else
|
||||
diff=my_sortcmp(a,b,min(a_length,b_length));
|
||||
diff=my_sortcmp(field_charset, a,b,min(a_length,b_length));
|
||||
return diff ? diff : (int) (a_length - b_length);
|
||||
}
|
||||
|
||||
@ -4063,11 +4068,11 @@ void Field_blob::sort_string(char *to,uint length)
|
||||
else
|
||||
{
|
||||
#ifdef USE_STRCOLL
|
||||
if (use_strcoll(default_charset_info))
|
||||
if (use_strcoll(field_charset))
|
||||
{
|
||||
blob_length=my_strnxfrm(default_charset_info,
|
||||
(unsigned char *)to,(unsigned char *)blob,
|
||||
length,blob_org_length);
|
||||
blob_length=my_strnxfrm(field_charset,
|
||||
(unsigned char *)to, length,
|
||||
(unsigned char *)blob, blob_org_length);
|
||||
if (blob_length >= length)
|
||||
return;
|
||||
to+=blob_length;
|
||||
@ -4075,7 +4080,7 @@ void Field_blob::sort_string(char *to,uint length)
|
||||
else
|
||||
#endif
|
||||
for (char *end=blob+blob_length ; blob != end ;)
|
||||
*to++=(char) my_sort_order[(uint) (uchar) *blob++];
|
||||
*to++=(char) field_charset->sort_order[(uint) (uchar) *blob++];
|
||||
}
|
||||
bzero(to,length-blob_length);
|
||||
}
|
||||
@ -4153,7 +4158,7 @@ int Field_blob::pack_cmp(const char *a, const char *b, uint key_length)
|
||||
int cmp= memcmp(a,b,min(a_length,b_length));
|
||||
return cmp ? cmp : (int) (a_length - b_length);
|
||||
}
|
||||
return my_sortncmp(a,a_length, b,b_length);
|
||||
return my_sortncmp(field_charset, a,a_length, b,b_length);
|
||||
}
|
||||
|
||||
|
||||
@ -4179,7 +4184,7 @@ int Field_blob::pack_cmp(const char *b, uint key_length)
|
||||
int cmp= memcmp(a,b,min(a_length,b_length));
|
||||
return cmp ? cmp : (int) (a_length - b_length);
|
||||
}
|
||||
return my_sortncmp(a,a_length, b,b_length);
|
||||
return my_sortncmp(field_charset, a,a_length, b,b_length);
|
||||
}
|
||||
|
||||
/* Create a packed key that will be used for storage from a MySQL row */
|
||||
@ -4290,14 +4295,16 @@ void Field_enum::store_type(ulonglong value)
|
||||
uint find_enum(TYPELIB *lib,const char *x, uint length)
|
||||
{
|
||||
const char *end=x+length;
|
||||
while (end > x && isspace(end[-1]))
|
||||
while (end > x && my_isspace(system_charset_info,end[-1]))
|
||||
end--;
|
||||
|
||||
const char *i;
|
||||
const char *j;
|
||||
for (uint pos=0 ; (j=lib->type_names[pos]) ; pos++)
|
||||
{
|
||||
for (i=x ; i != end && toupper(*i) == toupper(*j) ; i++, j++) ;
|
||||
for (i=x ; i != end &&
|
||||
my_toupper(system_charset_info,*i) ==
|
||||
my_toupper(system_charset_info,*j) ; i++, j++) ;
|
||||
if (i == end && ! *j)
|
||||
return(pos+1);
|
||||
}
|
||||
@ -4474,7 +4481,7 @@ void Field_enum::sql_type(String &res) const
|
||||
ulonglong find_set(TYPELIB *lib,const char *x,uint length)
|
||||
{
|
||||
const char *end=x+length;
|
||||
while (end > x && isspace(end[-1]))
|
||||
while (end > x && my_isspace(system_charset_info, end[-1]))
|
||||
end--;
|
||||
|
||||
ulonglong found=0;
|
||||
@ -4600,7 +4607,8 @@ bool Field_enum::eq_def(Field *field)
|
||||
if (typelib->count < from_lib->count)
|
||||
return 0;
|
||||
for (uint i=0 ; i < from_lib->count ; i++)
|
||||
if (my_strcasecmp(typelib->type_names[i],from_lib->type_names[i]))
|
||||
if (my_strcasecmp(field_charset,
|
||||
typelib->type_names[i],from_lib->type_names[i]))
|
||||
return 0;
|
||||
return 1;
|
||||
}
|
||||
|
19
sql/field.h
19
sql/field.h
@ -145,12 +145,7 @@ public:
|
||||
virtual void set_key_image(char *buff,uint length)
|
||||
{ set_image(buff,length); }
|
||||
inline int cmp_image(char *buff,uint length)
|
||||
{
|
||||
if (binary())
|
||||
return memcmp(ptr,buff,length);
|
||||
else
|
||||
return my_casecmp(ptr,buff,length);
|
||||
}
|
||||
{ return memcmp(ptr,buff,length); }
|
||||
inline longlong val_int_offset(uint row_offset)
|
||||
{
|
||||
ptr+=row_offset;
|
||||
@ -241,6 +236,8 @@ public:
|
||||
|
||||
|
||||
class Field_str :public Field {
|
||||
protected:
|
||||
CHARSET_INFO *field_charset;
|
||||
public:
|
||||
Field_str(char *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
|
||||
uchar null_bit_arg, utype unireg_check_arg,
|
||||
@ -248,12 +245,20 @@ public:
|
||||
struct st_table *table_arg)
|
||||
:Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
|
||||
unireg_check_arg, field_name_arg, table_arg)
|
||||
{}
|
||||
{ field_charset=default_charset_info; }
|
||||
Item_result result_type () const { return STRING_RESULT; }
|
||||
uint decimals() const { return NOT_FIXED_DEC; }
|
||||
friend class create_field;
|
||||
void make_field(Send_field *);
|
||||
uint size_of() const { return sizeof(*this); }
|
||||
inline int cmp_image(char *buff,uint length)
|
||||
{
|
||||
if (binary())
|
||||
return memcmp(ptr,buff,length);
|
||||
else
|
||||
return my_strncasecmp(field_charset,ptr,buff,length);
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
@ -276,7 +276,7 @@ static void do_cut_string(Copy_field *copy)
|
||||
ptr != end ;
|
||||
ptr++)
|
||||
{
|
||||
if (!isspace(*ptr))
|
||||
if (!my_isspace(system_charset_info, *ptr))
|
||||
{
|
||||
current_thd->cuted_fields++; // Give a warning
|
||||
break;
|
||||
|
@ -513,9 +513,8 @@ static void make_sortkey(register SORTPARAM *param,
|
||||
from=param->tmp_buffer;
|
||||
}
|
||||
uint tmp_length=my_strnxfrm(default_charset_info,
|
||||
to,(unsigned char *) from,
|
||||
sort_field->length,
|
||||
length);
|
||||
to,sort_field->length,
|
||||
(unsigned char *) from, length);
|
||||
if (tmp_length < sort_field->length)
|
||||
bzero((char*) to+tmp_length,sort_field->length-tmp_length);
|
||||
}
|
||||
@ -527,7 +526,7 @@ static void make_sortkey(register SORTPARAM *param,
|
||||
memcpy(to,res->ptr(),length);
|
||||
bzero((char *)to+length,diff);
|
||||
if (!item->binary)
|
||||
case_sort((char*) to,length);
|
||||
case_sort(default_charset_info, (char*) to,length);
|
||||
#ifdef USE_STRCOLL
|
||||
}
|
||||
#endif
|
||||
@ -925,7 +924,7 @@ sortlength(SORT_FIELD *sortorder, uint s_length)
|
||||
sortorder->length=sortorder->field->pack_length();
|
||||
#ifdef USE_STRCOLL
|
||||
if (use_strcoll(default_charset_info) && !sortorder->field->binary())
|
||||
sortorder->length= sortorder->length*MY_STRXFRM_MULTIPLY;
|
||||
sortorder->length= sortorder->length*default_charset_info->strxfrm_multiply;
|
||||
#endif
|
||||
}
|
||||
if (sortorder->field->maybe_null())
|
||||
@ -938,7 +937,7 @@ sortlength(SORT_FIELD *sortorder, uint s_length)
|
||||
sortorder->length=sortorder->item->max_length;
|
||||
#ifdef USE_STRCOLL
|
||||
if (use_strcoll(default_charset_info) && !sortorder->item->binary)
|
||||
sortorder->length= sortorder->length*MY_STRXFRM_MULTIPLY;
|
||||
sortorder->length= sortorder->length*default_charset_info->strxfrm_multiply;
|
||||
#endif
|
||||
break;
|
||||
case INT_RESULT:
|
||||
|
@ -1194,7 +1194,10 @@ innobase_mysql_cmp(
|
||||
|
||||
case FIELD_TYPE_STRING:
|
||||
case FIELD_TYPE_VAR_STRING:
|
||||
ret = my_sortncmp((const char*) a, a_length,
|
||||
// BAR TODO: Discuss with heikki.tuuri@innodb.com
|
||||
// so that he sends CHARSET_INFO for the field to this function.
|
||||
ret = my_sortncmp(default_charset_info,
|
||||
(const char*) a, a_length,
|
||||
(const char*) b, b_length);
|
||||
if (ret < 0) {
|
||||
return(-1);
|
||||
|
@ -213,10 +213,10 @@ my_string ip_to_hostname(struct in_addr *in, uint *errors)
|
||||
|
||||
/* Don't accept hostnames that starts with digits because they may be
|
||||
false ip:s */
|
||||
if (isdigit(name[0]))
|
||||
if (my_isdigit(system_charset_info,name[0]))
|
||||
{
|
||||
char *pos;
|
||||
for (pos= name+1 ; isdigit(*pos); pos++) ;
|
||||
for (pos= name+1 ; my_isdigit(system_charset_info,*pos); pos++) ;
|
||||
if (*pos == '.')
|
||||
{
|
||||
DBUG_PRINT("error",("mysqld doesn't accept hostnames that starts with a number followed by a '.'"));
|
||||
|
14
sql/init.cc
14
sql/init.cc
@ -24,6 +24,7 @@ void unireg_init(ulong options)
|
||||
{
|
||||
uint i;
|
||||
double nr;
|
||||
CHARSET_INFO *cs;
|
||||
DBUG_ENTER("unireg_init");
|
||||
|
||||
MYSYS_PROGRAM_DONT_USE_CURSES();
|
||||
@ -54,13 +55,16 @@ void unireg_init(ulong options)
|
||||
|
||||
// The following is needed because of like optimization in select.cc
|
||||
|
||||
uchar max_char=my_sort_order[(uchar) max_sort_char];
|
||||
for (i = 0; i < 256; i++)
|
||||
for (cs=compiled_charsets; cs->number; cs++)
|
||||
{
|
||||
if ((uchar) my_sort_order[i] > max_char)
|
||||
uchar max_char=cs->sort_order[(uchar) cs->max_sort_char];
|
||||
for (i = 0; i < 256; i++)
|
||||
{
|
||||
max_char=(uchar) my_sort_order[i];
|
||||
max_sort_char= (char) i;
|
||||
if ((uchar) cs->sort_order[i] > max_char)
|
||||
{
|
||||
max_char=(uchar) cs->sort_order[i];
|
||||
cs->max_sort_char= (char) i;
|
||||
}
|
||||
}
|
||||
}
|
||||
thread_stack_min=thread_stack - STACK_MIN_SIZE;
|
||||
|
@ -50,7 +50,7 @@ void Item::set_name(char *str,uint length)
|
||||
name=str; // Used by AS
|
||||
else
|
||||
{
|
||||
while (length && !isgraph(*str))
|
||||
while (length && !my_isgraph(system_charset_info,*str))
|
||||
{ // Fix problem with yacc
|
||||
length--;
|
||||
str++;
|
||||
@ -62,7 +62,7 @@ void Item::set_name(char *str,uint length)
|
||||
bool Item::eq(const Item *item) const // Only doing this on conds
|
||||
{
|
||||
return type() == item->type() && name && item->name &&
|
||||
!my_strcasecmp(name,item->name);
|
||||
!my_strcasecmp(system_charset_info,name,item->name);
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -991,7 +991,8 @@ longlong Item_func_find_in_set::val_int()
|
||||
const char *pos= f_pos;
|
||||
while (pos != f_end)
|
||||
{
|
||||
if (toupper(*str) != toupper(*pos))
|
||||
if (my_toupper(find->charset(),*str) !=
|
||||
my_toupper(find->charset(),*pos))
|
||||
goto not_found;
|
||||
str++;
|
||||
pos++;
|
||||
|
@ -42,7 +42,7 @@ uint nr_of_decimals(const char *str)
|
||||
if ((str=strchr(str,'.')))
|
||||
{
|
||||
const char *start= ++str;
|
||||
for ( ; isdigit(*str) ; str++) ;
|
||||
for ( ; my_isdigit(system_charset_info,*str) ; str++) ;
|
||||
return (uint) (str-start);
|
||||
}
|
||||
return 0;
|
||||
@ -1268,9 +1268,9 @@ extern "C" {
|
||||
extern const char *soundex_map; // In mysys/static.c
|
||||
}
|
||||
|
||||
static char get_scode(char *ptr)
|
||||
static char get_scode(CHARSET_INFO *cs,char *ptr)
|
||||
{
|
||||
uchar ch=toupper(*ptr);
|
||||
uchar ch=my_toupper(cs,*ptr);
|
||||
if (ch < 'A' || ch > 'Z')
|
||||
{
|
||||
// Thread extended alfa (country spec)
|
||||
@ -1292,21 +1292,21 @@ String *Item_func_soundex::val_str(String *str)
|
||||
char *to= (char *) tmp_value.ptr();
|
||||
char *from= (char *) res->ptr(), *end=from+res->length();
|
||||
|
||||
while (from != end && isspace(*from)) // Skip pre-space
|
||||
while (from != end && my_isspace(str->charset(),*from)) // Skip pre-space
|
||||
from++; /* purecov: inspected */
|
||||
if (from == end)
|
||||
return &empty_string; // No alpha characters.
|
||||
*to++ = toupper(*from); // Copy first letter
|
||||
last_ch = get_scode(from); // code of the first letter
|
||||
*to++ = my_toupper(str->charset(),*from);// Copy first letter
|
||||
last_ch = get_scode(str->charset(),from);// code of the first letter
|
||||
// for the first 'double-letter check.
|
||||
// Loop on input letters until
|
||||
// end of input (null) or output
|
||||
// letter code count = 3
|
||||
for (from++ ; from < end ; from++)
|
||||
{
|
||||
if (!isalpha(*from))
|
||||
if (!my_isalpha(str->charset(),*from))
|
||||
continue;
|
||||
ch=get_scode(from);
|
||||
ch=get_scode(str->charset(),from);
|
||||
if ((ch != '0') && (ch != last_ch)) // if not skipped or double
|
||||
{
|
||||
*to++ = ch; // letter, copy to output
|
||||
|
@ -864,7 +864,8 @@ static int simple_raw_key_cmp(void* arg, byte* key1, byte* key2)
|
||||
|
||||
static int simple_str_key_cmp(void* arg, byte* key1, byte* key2)
|
||||
{
|
||||
return my_sortcmp((char*) key1, (char*) key2, *(uint*) arg);
|
||||
/* BAR TODO: remove default_charset_info */
|
||||
return my_sortcmp(default_charset_info,(char*) key1, (char*) key2, *(uint*) arg);
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -49,16 +49,16 @@ bool get_interval_info(const char *str,uint length,uint count,
|
||||
{
|
||||
const char *end=str+length;
|
||||
uint i;
|
||||
while (str != end && !isdigit(*str))
|
||||
while (str != end && !my_isdigit(system_charset_info,*str))
|
||||
str++;
|
||||
|
||||
for (i=0 ; i < count ; i++)
|
||||
{
|
||||
long value;
|
||||
for (value=0; str != end && isdigit(*str) ; str++)
|
||||
for (value=0; str != end && my_isdigit(system_charset_info,*str) ; str++)
|
||||
value=value*10L + (long) (*str - '0');
|
||||
values[i]= value;
|
||||
while (str != end && !isdigit(*str))
|
||||
while (str != end && !my_isdigit(system_charset_info,*str))
|
||||
str++;
|
||||
if (str == end && i != count-1)
|
||||
{
|
||||
@ -289,7 +289,7 @@ static bool get_interval_value(Item *args,interval_type int_type,
|
||||
/* record negative intervalls in t->neg */
|
||||
str=res->ptr();
|
||||
const char *end=str+res->length();
|
||||
while (str != end && isspace(*str))
|
||||
while (str != end && my_isspace(system_charset_info,*str))
|
||||
str++;
|
||||
if (str != end && *str == '-')
|
||||
{
|
||||
|
@ -192,8 +192,9 @@ int key_cmp(TABLE *table,const byte *key,uint idx,uint key_length)
|
||||
if (!(key_part->key_type & (FIELDFLAG_NUMBER+FIELDFLAG_BINARY+
|
||||
FIELDFLAG_PACK)))
|
||||
{
|
||||
if (my_sortcmp((char*) key,(char*) table->record[0]+key_part->offset,
|
||||
length))
|
||||
/* BAR TODO: I'm not sure this should be system_charset_info */
|
||||
if (my_sortcmp(system_charset_info,(char*) key,
|
||||
(char*) table->record[0]+key_part->offset,length))
|
||||
return 1;
|
||||
}
|
||||
else if (memcmp(key,table->record[0]+key_part->offset,length))
|
||||
|
@ -1208,7 +1208,7 @@ static bool test_if_number(register const char *str,
|
||||
while (*str++ == ' ') ;
|
||||
if (*--str == '-' || *str == '+')
|
||||
str++;
|
||||
while (isdigit(*str) || (allow_wildcards &&
|
||||
while (my_isdigit(system_charset_info,*str) || (allow_wildcards &&
|
||||
(*str == wild_many || *str == wild_one)))
|
||||
{
|
||||
flag=1;
|
||||
@ -1217,7 +1217,7 @@ static bool test_if_number(register const char *str,
|
||||
if (*str == '.')
|
||||
{
|
||||
for (str++ ;
|
||||
isdigit(*str) ||
|
||||
my_isdigit(system_charset_info,*str) ||
|
||||
(allow_wildcards && (*str == wild_many || *str == wild_one)) ;
|
||||
str++, flag=1) ;
|
||||
}
|
||||
|
@ -549,7 +549,7 @@ void open_log(MYSQL_LOG *log, const char *hostname,
|
||||
|
||||
extern uint32 server_id;
|
||||
extern char *mysql_data_home,server_version[SERVER_VERSION_LENGTH],
|
||||
max_sort_char, mysql_real_data_home[];
|
||||
mysql_real_data_home[];
|
||||
extern my_string mysql_tmpdir;
|
||||
extern const char *first_keyword, *localhost, *delayed_user;
|
||||
extern ulong refresh_version,flush_version, thread_id,query_id,opened_tables,
|
||||
@ -708,10 +708,10 @@ bool check_db_name(const char *db);
|
||||
bool check_column_name(const char *name);
|
||||
bool check_table_name(const char *name, uint length);
|
||||
char *get_field(MEM_ROOT *mem,TABLE *table,uint fieldnr);
|
||||
int wild_case_compare(const char *str,const char *wildstr);
|
||||
int wild_case_compare(CHARSET_INFO *cs, const char *str,const char *wildstr);
|
||||
int wild_compare(const char *str,const char *str_end,
|
||||
const char *wildstr,const char *wildend,char escape);
|
||||
int wild_case_compare(const char *str,const char *str_end,
|
||||
int wild_case_compare(CHARSET_INFO *cs, const char *str,const char *str_end,
|
||||
const char *wildstr,const char *wildend,char escape);
|
||||
|
||||
/* from hostname.cc */
|
||||
|
@ -863,7 +863,7 @@ static void set_user(const char *user)
|
||||
{
|
||||
// allow a numeric uid to be used
|
||||
const char *pos;
|
||||
for (pos=user; isdigit(*pos); pos++) ;
|
||||
for (pos=user; my_isdigit(system_charset_info,*pos); pos++) ;
|
||||
if (*pos) // Not numeric id
|
||||
{
|
||||
fprintf(stderr,"Fatal error: Can't change to run as user '%s' ; Please check that the user exists!\n",user);
|
||||
@ -3769,7 +3769,7 @@ static void get_options(int argc,char **argv)
|
||||
exit(1);
|
||||
}
|
||||
val = p--;
|
||||
while(isspace(*p) && p > optarg) *p-- = 0;
|
||||
while(my_isspace(system_charset_info,*p) && p > optarg) *p-- = 0;
|
||||
if(p == optarg)
|
||||
{
|
||||
fprintf(stderr,
|
||||
@ -3778,7 +3778,7 @@ static void get_options(int argc,char **argv)
|
||||
}
|
||||
*val = 0;
|
||||
val += 2;
|
||||
while(*val && isspace(*val)) *val++;
|
||||
while(*val && my_isspace(system_charset_info,*val)) *val++;
|
||||
if (!*val)
|
||||
{
|
||||
fprintf(stderr,
|
||||
@ -3937,7 +3937,7 @@ static void get_options(int argc,char **argv)
|
||||
have_symlink=SHOW_OPTION_DISABLED;
|
||||
break;
|
||||
case (int) OPT_BIND_ADDRESS:
|
||||
if (optarg && isdigit(optarg[0]))
|
||||
if (optarg && my_isdigit(system_charset_info,optarg[0]))
|
||||
{
|
||||
my_bind_addr = (ulong) inet_addr(optarg);
|
||||
}
|
||||
@ -4409,7 +4409,8 @@ static ulong find_bit_type(const char *x, TYPELIB *bit_lib)
|
||||
j=pos;
|
||||
while (j != end)
|
||||
{
|
||||
if (toupper(*i++) != toupper(*j++))
|
||||
if (my_toupper(system_charset_info,*i++) !=
|
||||
my_toupper(system_charset_info,*j++))
|
||||
goto skipp;
|
||||
}
|
||||
found_int=bit;
|
||||
|
@ -985,7 +985,8 @@ get_mm_leaf(PARAM *param, Field *field, KEY_PART *key_part,
|
||||
like_error=like_range(res->ptr(),res->length(),wild_prefix,
|
||||
field_length,
|
||||
min_str+offset,max_str+offset,
|
||||
max_sort_char,&min_length,&max_length);
|
||||
default_charset_info->max_sort_char,
|
||||
&min_length,&max_length);
|
||||
}
|
||||
if (like_error) // Can't optimize with LIKE
|
||||
DBUG_RETURN(0);
|
||||
|
@ -57,7 +57,8 @@ setup_procedure(THD *thd,ORDER *param,select_result *result,
|
||||
DBUG_RETURN(0);
|
||||
for (i=0 ; i < array_elements(sql_procs) ; i++)
|
||||
{
|
||||
if (!my_strcasecmp((*param->item)->name,sql_procs[i].name))
|
||||
if (!my_strcasecmp(system_charset_info,
|
||||
(*param->item)->name,sql_procs[i].name))
|
||||
{
|
||||
Procedure *proc=(*sql_procs[i].init)(thd,param,result,field_list);
|
||||
*error= !proc;
|
||||
|
@ -237,9 +237,9 @@ void init_slave_skip_errors(char* arg)
|
||||
exit(1);
|
||||
}
|
||||
use_slave_mask = 1;
|
||||
for (;isspace(*arg);++arg)
|
||||
for (;my_isspace(system_charset_info,*arg);++arg)
|
||||
/* empty */;
|
||||
if (!my_casecmp(arg,"all",3))
|
||||
if (!my_strncasecmp(system_charset_info,arg,"all",3))
|
||||
{
|
||||
bitmap_set_all(&slave_error_mask);
|
||||
return;
|
||||
@ -251,7 +251,7 @@ void init_slave_skip_errors(char* arg)
|
||||
break;
|
||||
if (err_code < MAX_SLAVE_ERROR)
|
||||
bitmap_set_bit(&slave_error_mask,(uint)err_code);
|
||||
while (!isdigit(*p) && *p)
|
||||
while (!my_isdigit(system_charset_info,*p) && *p)
|
||||
p++;
|
||||
}
|
||||
}
|
||||
@ -492,7 +492,8 @@ static TABLE_RULE_ENT* find_wild(DYNAMIC_ARRAY *a, const char* key, int len)
|
||||
{
|
||||
TABLE_RULE_ENT* e ;
|
||||
get_dynamic(a, (gptr)&e, i);
|
||||
if (!wild_case_compare(key, key_end, (const char*)e->db,
|
||||
if (!wild_case_compare(system_charset_info, key, key_end,
|
||||
(const char*)e->db,
|
||||
(const char*)(e->db + e->key_len),'\\'))
|
||||
return e;
|
||||
}
|
||||
|
@ -381,7 +381,7 @@ static uint get_access(TABLE *form,uint fieldnr)
|
||||
for (pos=form->field+fieldnr,bit=1 ; *pos ; pos++ , bit<<=1)
|
||||
{
|
||||
(*pos)->val_str(&res,&res);
|
||||
if (toupper(res[0]) == 'Y')
|
||||
if (my_toupper(system_charset_info, res[0]) == 'Y')
|
||||
access_bits|=bit;
|
||||
}
|
||||
return access_bits;
|
||||
@ -729,7 +729,7 @@ uint acl_get(const char *host, const char *ip, const char *bin_ip,
|
||||
end=strmov((tmp_db=strmov(key+sizeof(struct in_addr),user)+1),db);
|
||||
if (lower_case_table_names)
|
||||
{
|
||||
casedn_str(tmp_db);
|
||||
my_casedn_str(system_charset_info, tmp_db);
|
||||
db=tmp_db;
|
||||
}
|
||||
key_length=(uint) (end-key);
|
||||
@ -793,7 +793,7 @@ exit:
|
||||
}
|
||||
|
||||
|
||||
int wild_case_compare(const char *str,const char *wildstr)
|
||||
int wild_case_compare(CHARSET_INFO *cs, const char *str,const char *wildstr)
|
||||
{
|
||||
reg3 int flag;
|
||||
DBUG_ENTER("wild_case_compare");
|
||||
@ -804,7 +804,8 @@ int wild_case_compare(const char *str,const char *wildstr)
|
||||
{
|
||||
if (*wildstr == wild_prefix && wildstr[1])
|
||||
wildstr++;
|
||||
if (toupper(*wildstr++) != toupper(*str++)) DBUG_RETURN(1);
|
||||
if (my_toupper(cs, *wildstr++) !=
|
||||
my_toupper(cs, *str++)) DBUG_RETURN(1);
|
||||
}
|
||||
if (! *wildstr ) DBUG_RETURN (*str != 0);
|
||||
if (*wildstr++ == wild_one)
|
||||
@ -822,12 +823,12 @@ int wild_case_compare(const char *str,const char *wildstr)
|
||||
char cmp;
|
||||
if ((cmp= *wildstr) == wild_prefix && wildstr[1])
|
||||
cmp=wildstr[1];
|
||||
cmp=toupper(cmp);
|
||||
while (*str && toupper(*str) != cmp)
|
||||
cmp=my_toupper(cs, cmp);
|
||||
while (*str && my_toupper(cs, *str) != cmp)
|
||||
str++;
|
||||
if (!*str) DBUG_RETURN (1);
|
||||
}
|
||||
if (wild_case_compare(str,wildstr) == 0) DBUG_RETURN (0);
|
||||
if (wild_case_compare(cs, str,wildstr) == 0) DBUG_RETURN (0);
|
||||
} while (*str++);
|
||||
DBUG_RETURN(1);
|
||||
}
|
||||
@ -862,7 +863,8 @@ static void init_check_host(void)
|
||||
{ // Check if host already exists
|
||||
acl_host_and_ip *acl=dynamic_element(&acl_wild_hosts,j,
|
||||
acl_host_and_ip *);
|
||||
if (!my_strcasecmp(acl_user->host.hostname,acl->hostname))
|
||||
if (!my_strcasecmp(system_charset_info,
|
||||
acl_user->host.hostname, acl->hostname))
|
||||
break; // already stored
|
||||
}
|
||||
if (j == acl_wild_hosts.elements) // If new
|
||||
@ -940,7 +942,8 @@ bool change_password(THD *thd, const char *host, const char *user,
|
||||
new_password[length & 16]=0;
|
||||
|
||||
if (!thd || (!thd->slave_thread && ( strcmp(thd->user,user) ||
|
||||
my_strcasecmp(host,thd->host ? thd->host : thd->ip))))
|
||||
my_strcasecmp(system_charset_info,
|
||||
host, (thd->host ? thd->host : thd->ip)))))
|
||||
{
|
||||
if (check_access(thd, UPDATE_ACL, "mysql",0,1))
|
||||
DBUG_RETURN(1);
|
||||
@ -1061,7 +1064,8 @@ static bool compare_hostname(const acl_host_and_ip *host, const char *hostname,
|
||||
return (tmp & host->ip_mask) == host->ip;
|
||||
}
|
||||
return (!host->hostname ||
|
||||
(hostname && !wild_case_compare(hostname,host->hostname)) ||
|
||||
(hostname && !wild_case_compare(system_charset_info,
|
||||
hostname,host->hostname)) ||
|
||||
(ip && !wild_compare(ip,host->hostname)));
|
||||
}
|
||||
|
||||
@ -1414,8 +1418,8 @@ public:
|
||||
tname= strdup_root(&memex,t);
|
||||
if (lower_case_table_names)
|
||||
{
|
||||
casedn_str(db);
|
||||
casedn_str(tname);
|
||||
my_casedn_str(system_charset_info, db);
|
||||
my_casedn_str(system_charset_info, tname);
|
||||
}
|
||||
key_length =(uint) strlen(d)+(uint) strlen(u)+(uint) strlen(t)+3;
|
||||
hash_key = (char*) alloc_root(&memex,key_length);
|
||||
@ -1440,8 +1444,8 @@ public:
|
||||
}
|
||||
if (lower_case_table_names)
|
||||
{
|
||||
casedn_str(db);
|
||||
casedn_str(tname);
|
||||
my_casedn_str(system_charset_info, db);
|
||||
my_casedn_str(system_charset_info, tname);
|
||||
}
|
||||
key_length = ((uint) strlen(db) + (uint) strlen(user) +
|
||||
(uint) strlen(tname) + 3);
|
||||
@ -1534,8 +1538,10 @@ static GRANT_TABLE *table_hash_search(const char *host,const char* ip,
|
||||
}
|
||||
else
|
||||
{
|
||||
if ((host && !wild_case_compare(host,grant_table->host)) ||
|
||||
(ip && !wild_case_compare(ip,grant_table->host)))
|
||||
if ((host && !wild_case_compare(system_charset_info,
|
||||
host,grant_table->host)) ||
|
||||
(ip && !wild_case_compare(system_charset_info,
|
||||
ip,grant_table->host)))
|
||||
found=grant_table; // Host ok
|
||||
}
|
||||
}
|
||||
@ -2051,7 +2057,7 @@ int mysql_grant (THD *thd, const char *db, List <LEX_USER> &list, uint rights,
|
||||
if (lower_case_table_names && db)
|
||||
{
|
||||
strmov(tmp_db,db);
|
||||
casedn_str(tmp_db);
|
||||
my_casedn_str(system_charset_info, tmp_db);
|
||||
db=tmp_db;
|
||||
}
|
||||
|
||||
@ -2476,8 +2482,10 @@ bool check_grant_db(THD *thd,const char *db)
|
||||
GRANT_TABLE *grant_table = (GRANT_TABLE*) hash_element(&hash_tables,idx);
|
||||
if (len < grant_table->key_length &&
|
||||
!memcmp(grant_table->hash_key,helping,len) &&
|
||||
(thd->host && !wild_case_compare(thd->host,grant_table->host) ||
|
||||
(thd->ip && !wild_case_compare(thd->ip,grant_table->host))))
|
||||
(thd->host && !wild_case_compare(system_charset_info,
|
||||
thd->host,grant_table->host) ||
|
||||
(thd->ip && !wild_case_compare(system_charset_info,
|
||||
thd->ip,grant_table->host))))
|
||||
{
|
||||
error=0; // Found match
|
||||
break;
|
||||
|
@ -163,7 +163,7 @@ bool test_if_number(NUM_INFO *info, const char *str, uint str_len)
|
||||
|
||||
// MySQL removes any endspaces of a string, so we must take care only of
|
||||
// spaces in front of a string
|
||||
for (; str != end && isspace(*str); str++) ;
|
||||
for (; str != end && my_isspace(system_charset_info, *str); str++) ;
|
||||
if (str == end)
|
||||
return 0;
|
||||
|
||||
@ -176,10 +176,10 @@ bool test_if_number(NUM_INFO *info, const char *str, uint str_len)
|
||||
else
|
||||
info->negative = 0;
|
||||
begin = str;
|
||||
for (; str != end && isdigit(*str); str++)
|
||||
for (; str != end && my_isdigit(system_charset_info,*str); str++)
|
||||
{
|
||||
if (!info->integers && *str == '0' && (str + 1) != end &&
|
||||
isdigit(*(str + 1)))
|
||||
my_isdigit(system_charset_info,*(str + 1)))
|
||||
info->zerofill = 1; // could be a postnumber for example
|
||||
info->integers++;
|
||||
}
|
||||
@ -205,7 +205,7 @@ bool test_if_number(NUM_INFO *info, const char *str, uint str_len)
|
||||
str++;
|
||||
if (*str != '-' && *str != '+')
|
||||
return 0;
|
||||
for (str++; str != end && isdigit(*str); str++) ;
|
||||
for (str++; str != end && my_isdigit(system_charset_info,*str); str++) ;
|
||||
if (str == end)
|
||||
{
|
||||
info->is_float = 1; // we can't use variable decimals here
|
||||
@ -220,7 +220,7 @@ bool test_if_number(NUM_INFO *info, const char *str, uint str_len)
|
||||
info->ullval = (ulonglong) strtoull(begin, NULL, 10);
|
||||
return 1;
|
||||
}
|
||||
for (; str != end && isdigit(*str); str++)
|
||||
for (; str != end && my_isdigit(system_charset_info,*str); str++)
|
||||
info->decimals++;
|
||||
if (str == end)
|
||||
{
|
||||
|
@ -50,7 +50,8 @@ static byte *cache_key(const byte *record,uint *length,
|
||||
|
||||
void table_cache_init(void)
|
||||
{
|
||||
VOID(hash_init(&open_cache,table_cache_size+16,0,0,cache_key,
|
||||
VOID(hash_init(&open_cache,
|
||||
table_cache_size+16,0,0,cache_key,
|
||||
(void (*)(void*)) free_cache_entry,0));
|
||||
mysql_rm_tmp_tables();
|
||||
}
|
||||
@ -780,7 +781,7 @@ TABLE *open_table(THD *thd,const char *db,const char *table_name,
|
||||
{
|
||||
if (table->key_length == key_length &&
|
||||
!memcmp(table->table_cache_key,key,key_length) &&
|
||||
!my_strcasecmp(table->table_name,alias))
|
||||
!my_strcasecmp(system_charset_info,table->table_name,alias))
|
||||
goto reset;
|
||||
}
|
||||
my_printf_error(ER_TABLE_NOT_LOCKED,ER(ER_TABLE_NOT_LOCKED),MYF(0),alias);
|
||||
@ -1559,11 +1560,12 @@ Field *find_field_in_table(THD *thd,TABLE *table,const char *name,uint length,
|
||||
Field **ptr=table->field;
|
||||
while ((field = *ptr++))
|
||||
{
|
||||
if (!my_strcasecmp(field->field_name, name))
|
||||
if (!my_strcasecmp(system_charset_info, field->field_name, name))
|
||||
goto found;
|
||||
}
|
||||
}
|
||||
if (allow_rowid && !my_strcasecmp(name,"_rowid") &&
|
||||
if (allow_rowid &&
|
||||
!my_strcasecmp(system_charset_info, name, "_rowid") &&
|
||||
(field=table->rowid_field))
|
||||
goto found;
|
||||
return (Field*) 0;
|
||||
@ -1686,7 +1688,8 @@ find_item_in_list(Item *find,List<Item> &items)
|
||||
{
|
||||
if (field_name && item->type() == Item::FIELD_ITEM)
|
||||
{
|
||||
if (!my_strcasecmp(((Item_field*) item)->name,field_name))
|
||||
if (!my_strcasecmp(system_charset_info,
|
||||
((Item_field*) item)->name,field_name))
|
||||
{
|
||||
if (!table_name)
|
||||
{
|
||||
@ -1709,8 +1712,9 @@ find_item_in_list(Item *find,List<Item> &items)
|
||||
}
|
||||
}
|
||||
else if (!table_name && (item->eq(find) ||
|
||||
find->name &&
|
||||
!my_strcasecmp(item->name,find->name)))
|
||||
find->name &&
|
||||
!my_strcasecmp(system_charset_info,
|
||||
item->name,find->name)))
|
||||
{
|
||||
found=li.ref();
|
||||
break;
|
||||
@ -1938,7 +1942,8 @@ int setup_conds(THD *thd,TABLE_LIST *tables,COND **conds)
|
||||
// TODO: This could be optimized to use hashed names if t2 had a hash
|
||||
for (j=0 ; j < t2->fields ; j++)
|
||||
{
|
||||
if (!my_strcasecmp(t1->field[i]->field_name,
|
||||
if (!my_strcasecmp(system_charset_info,
|
||||
t1->field[i]->field_name,
|
||||
t2->field[j]->field_name))
|
||||
{
|
||||
Item_func_eq *tmp=new Item_func_eq(new Item_field(t1->field[i]),
|
||||
|
@ -896,8 +896,9 @@ Query_cache::send_result_to_client(THD *thd, char *sql, uint query_length)
|
||||
Test if the query is a SELECT
|
||||
(pre-space is removed in dispatch_command)
|
||||
*/
|
||||
if (toupper(sql[0]) != 'S' || toupper(sql[1]) != 'E' ||
|
||||
toupper(sql[2]) !='L')
|
||||
if (my_toupper(system_charset_info, sql[0]) != 'S' ||
|
||||
my_toupper(system_charset_info, sql[1]) != 'E' ||
|
||||
my_toupper(system_charset_info,sql[2]) !='L')
|
||||
{
|
||||
DBUG_PRINT("qcache", ("The statement is not a SELECT; Not cached"));
|
||||
goto err;
|
||||
|
@ -218,7 +218,8 @@ static long mysql_rm_known_files(THD *thd, MY_DIR *dirp, const char *db,
|
||||
DBUG_PRINT("info",("Examining: %s", file->name));
|
||||
|
||||
/* Check if file is a raid directory */
|
||||
if (isdigit(file->name[0]) && isdigit(file->name[1]) &&
|
||||
if (my_isdigit(system_charset_info,file->name[0]) &&
|
||||
my_isdigit(system_charset_info,file->name[1]) &&
|
||||
!file->name[2] && !level)
|
||||
{
|
||||
char newpath[FN_REFLEN];
|
||||
@ -243,7 +244,8 @@ static long mysql_rm_known_files(THD *thd, MY_DIR *dirp, const char *db,
|
||||
continue;
|
||||
}
|
||||
strxmov(filePath,org_path,"/",file->name,NullS);
|
||||
if (db && !my_strcasecmp(fn_ext(file->name), reg_ext))
|
||||
if (db && !my_strcasecmp(system_charset_info,
|
||||
fn_ext(file->name), reg_ext))
|
||||
{
|
||||
/* Drop the table nicely */
|
||||
*fn_ext(file->name)=0; // Remove extension
|
||||
|
@ -270,7 +270,7 @@ static TABLE **find_table_ptr_by_name(THD *thd, const char *db,
|
||||
for (TABLE *table=*ptr; table ; table=*ptr)
|
||||
{
|
||||
if (!memcmp(table->table_cache_key, db, dblen) &&
|
||||
!my_strcasecmp(table->table_name,table_name))
|
||||
!my_strcasecmp(system_charset_info,table->table_name,table_name))
|
||||
break;
|
||||
ptr=&(table->next);
|
||||
}
|
||||
|
@ -92,15 +92,15 @@ void lex_init(void)
|
||||
/* Fill state_map with states to get a faster parser */
|
||||
for (i=0; i < 256 ; i++)
|
||||
{
|
||||
if (isalpha(i))
|
||||
if (my_isalpha(system_charset_info,i))
|
||||
state_map[i]=(uchar) STATE_IDENT;
|
||||
else if (isdigit(i))
|
||||
else if (my_isdigit(system_charset_info,i))
|
||||
state_map[i]=(uchar) STATE_NUMBER_IDENT;
|
||||
#if defined(USE_MB) && defined(USE_MB_IDENT)
|
||||
else if (use_mb(default_charset_info) && my_ismbhead(default_charset_info, i))
|
||||
else if (use_mb(system_charset_info) && my_ismbhead(system_charset_info, i))
|
||||
state_map[i]=(uchar) STATE_IDENT;
|
||||
#endif
|
||||
else if (!isgraph(i))
|
||||
else if (!my_isgraph(system_charset_info,i))
|
||||
state_map[i]=(uchar) STATE_SKIP;
|
||||
else
|
||||
state_map[i]=(uchar) STATE_CHAR;
|
||||
@ -220,8 +220,8 @@ static char *get_text(LEX *lex)
|
||||
c = yyGet();
|
||||
#ifdef USE_MB
|
||||
int l;
|
||||
if (use_mb(default_charset_info) &&
|
||||
(l = my_ismbchar(default_charset_info,
|
||||
if (use_mb(system_charset_info) &&
|
||||
(l = my_ismbchar(system_charset_info,
|
||||
(const char *)lex->ptr-1,
|
||||
(const char *)lex->end_of_query))) {
|
||||
lex->ptr += l-1;
|
||||
@ -265,8 +265,8 @@ static char *get_text(LEX *lex)
|
||||
{
|
||||
#ifdef USE_MB
|
||||
int l;
|
||||
if (use_mb(default_charset_info) &&
|
||||
(l = my_ismbchar(default_charset_info,
|
||||
if (use_mb(system_charset_info) &&
|
||||
(l = my_ismbchar(system_charset_info,
|
||||
(const char *)str, (const char *)end))) {
|
||||
while (l--)
|
||||
*to++ = *str++;
|
||||
@ -471,11 +471,11 @@ int yylex(void *arg)
|
||||
break;
|
||||
}
|
||||
#if defined(USE_MB) && defined(USE_MB_IDENT)
|
||||
if (use_mb(default_charset_info))
|
||||
if (use_mb(system_charset_info))
|
||||
{
|
||||
if (my_ismbhead(default_charset_info, yyGetLast()))
|
||||
if (my_ismbhead(system_charset_info, yyGetLast()))
|
||||
{
|
||||
int l = my_ismbchar(default_charset_info,
|
||||
int l = my_ismbchar(system_charset_info,
|
||||
(const char *)lex->ptr-1,
|
||||
(const char *)lex->end_of_query);
|
||||
if (l == 0) {
|
||||
@ -487,10 +487,10 @@ int yylex(void *arg)
|
||||
while (state_map[c=yyGet()] == STATE_IDENT ||
|
||||
state_map[c] == STATE_NUMBER_IDENT)
|
||||
{
|
||||
if (my_ismbhead(default_charset_info, c))
|
||||
if (my_ismbhead(system_charset_info, c))
|
||||
{
|
||||
int l;
|
||||
if ((l = my_ismbchar(default_charset_info,
|
||||
if ((l = my_ismbchar(system_charset_info,
|
||||
(const char *)lex->ptr-1,
|
||||
(const char *)lex->end_of_query)) == 0)
|
||||
break;
|
||||
@ -533,7 +533,7 @@ int yylex(void *arg)
|
||||
return((int) c);
|
||||
|
||||
case STATE_NUMBER_IDENT: // number or ident which num-start
|
||||
while (isdigit((c = yyGet()))) ;
|
||||
while (my_isdigit(system_charset_info,(c = yyGet()))) ;
|
||||
if (state_map[c] != STATE_IDENT)
|
||||
{ // Can't be identifier
|
||||
state=STATE_INT_OR_REAL;
|
||||
@ -542,12 +542,13 @@ int yylex(void *arg)
|
||||
if (c == 'e' || c == 'E')
|
||||
{
|
||||
// The following test is written this way to allow numbers of type 1e1
|
||||
if (isdigit(yyPeek()) || (c=(yyGet())) == '+' || c == '-')
|
||||
if (my_isdigit(system_charset_info,yyPeek()) ||
|
||||
(c=(yyGet())) == '+' || c == '-')
|
||||
{ // Allow 1E+10
|
||||
if (isdigit(yyPeek())) // Number must have digit after sign
|
||||
if (my_isdigit(system_charset_info,yyPeek())) // Number must have digit after sign
|
||||
{
|
||||
yySkip();
|
||||
while (isdigit(yyGet())) ;
|
||||
while (my_isdigit(system_charset_info,yyGet())) ;
|
||||
yylval->lex_str=get_token(lex,yyLength());
|
||||
return(FLOAT_NUM);
|
||||
}
|
||||
@ -557,7 +558,7 @@ int yylex(void *arg)
|
||||
else if (c == 'x' && (lex->ptr - lex->tok_start) == 2 &&
|
||||
lex->tok_start[0] == '0' )
|
||||
{ // Varbinary
|
||||
while (isxdigit((c = yyGet()))) ;
|
||||
while (my_isxdigit(system_charset_info,(c = yyGet()))) ;
|
||||
if ((lex->ptr - lex->tok_start) >= 4 && state_map[c] != STATE_IDENT)
|
||||
{
|
||||
yylval->lex_str=get_token(lex,yyLength());
|
||||
@ -571,11 +572,11 @@ int yylex(void *arg)
|
||||
// fall through
|
||||
case STATE_IDENT_START: // Incomplete ident
|
||||
#if defined(USE_MB) && defined(USE_MB_IDENT)
|
||||
if (use_mb(default_charset_info))
|
||||
if (use_mb(system_charset_info))
|
||||
{
|
||||
if (my_ismbhead(default_charset_info, yyGetLast()))
|
||||
if (my_ismbhead(system_charset_info, yyGetLast()))
|
||||
{
|
||||
int l = my_ismbchar(default_charset_info,
|
||||
int l = my_ismbchar(system_charset_info,
|
||||
(const char *)lex->ptr-1,
|
||||
(const char *)lex->end_of_query);
|
||||
if (l == 0)
|
||||
@ -588,10 +589,10 @@ int yylex(void *arg)
|
||||
while (state_map[c=yyGet()] == STATE_IDENT ||
|
||||
state_map[c] == STATE_NUMBER_IDENT)
|
||||
{
|
||||
if (my_ismbhead(default_charset_info, c))
|
||||
if (my_ismbhead(system_charset_info, c))
|
||||
{
|
||||
int l;
|
||||
if ((l = my_ismbchar(default_charset_info,
|
||||
if ((l = my_ismbchar(system_charset_info,
|
||||
(const char *)lex->ptr-1,
|
||||
(const char *)lex->end_of_query)) == 0)
|
||||
break;
|
||||
@ -618,15 +619,15 @@ int yylex(void *arg)
|
||||
case STATE_USER_VARIABLE_DELIMITER:
|
||||
lex->tok_start=lex->ptr; // Skip first `
|
||||
#ifdef USE_MB
|
||||
if (use_mb(default_charset_info))
|
||||
if (use_mb(system_charset_info))
|
||||
{
|
||||
while ((c=yyGet()) && state_map[c] != STATE_USER_VARIABLE_DELIMITER &&
|
||||
c != (uchar) NAMES_SEP_CHAR)
|
||||
{
|
||||
if (my_ismbhead(default_charset_info, c))
|
||||
if (my_ismbhead(system_charset_info, c))
|
||||
{
|
||||
int l;
|
||||
if ((l = my_ismbchar(default_charset_info,
|
||||
if ((l = my_ismbchar(system_charset_info,
|
||||
(const char *)lex->ptr-1,
|
||||
(const char *)lex->end_of_query)) == 0)
|
||||
break;
|
||||
@ -651,17 +652,18 @@ int yylex(void *arg)
|
||||
if (prev_state == STATE_OPERATOR_OR_IDENT)
|
||||
{
|
||||
if (c == '-' && yyPeek() == '-' &&
|
||||
(isspace(yyPeek2()) || iscntrl(yyPeek2())))
|
||||
(my_isspace(system_charset_info,yyPeek2()) ||
|
||||
my_iscntrl(system_charset_info,yyPeek2())))
|
||||
state=STATE_COMMENT;
|
||||
else
|
||||
state= STATE_CHAR; // Must be operator
|
||||
break;
|
||||
}
|
||||
if (!isdigit(c=yyGet()) || yyPeek() == 'x')
|
||||
if (!my_isdigit(system_charset_info,c=yyGet()) || yyPeek() == 'x')
|
||||
{
|
||||
if (c != '.')
|
||||
{
|
||||
if (c == '-' && isspace(yyPeek()))
|
||||
if (c == '-' && my_isspace(system_charset_info,yyPeek()))
|
||||
state=STATE_COMMENT;
|
||||
else
|
||||
state = STATE_CHAR; // Return sign as single char
|
||||
@ -669,9 +671,9 @@ int yylex(void *arg)
|
||||
}
|
||||
yyUnget(); // Fix for next loop
|
||||
}
|
||||
while (isdigit(c=yyGet())) ; // Incomplete real or int number
|
||||
while (my_isdigit(system_charset_info,c=yyGet())) ; // Incomplete real or int number
|
||||
if ((c == 'e' || c == 'E') &&
|
||||
(yyPeek() == '+' || yyPeek() == '-' || isdigit(yyPeek())))
|
||||
(yyPeek() == '+' || yyPeek() == '-' || my_isdigit(system_charset_info,yyPeek())))
|
||||
{ // Real number
|
||||
yyUnget();
|
||||
c= '.'; // Fool next test
|
||||
@ -685,19 +687,19 @@ int yylex(void *arg)
|
||||
}
|
||||
// fall through
|
||||
case STATE_REAL: // Incomplete real number
|
||||
while (isdigit(c = yyGet())) ;
|
||||
while (my_isdigit(system_charset_info,c = yyGet())) ;
|
||||
|
||||
if (c == 'e' || c == 'E')
|
||||
{
|
||||
c = yyGet();
|
||||
if (c == '-' || c == '+')
|
||||
c = yyGet(); // Skip sign
|
||||
if (!isdigit(c))
|
||||
if (!my_isdigit(system_charset_info,c))
|
||||
{ // No digit after sign
|
||||
state= STATE_CHAR;
|
||||
break;
|
||||
}
|
||||
while (isdigit(yyGet())) ;
|
||||
while (my_isdigit(system_charset_info,yyGet())) ;
|
||||
yylval->lex_str=get_token(lex,yyLength());
|
||||
return(FLOAT_NUM);
|
||||
}
|
||||
@ -706,7 +708,7 @@ int yylex(void *arg)
|
||||
|
||||
case STATE_HEX_NUMBER: // Found x'hexstring'
|
||||
yyGet(); // Skip '
|
||||
while (isxdigit((c = yyGet()))) ;
|
||||
while (my_isxdigit(system_charset_info,(c = yyGet()))) ;
|
||||
length=(lex->ptr - lex->tok_start); // Length of hexnum+3
|
||||
if (!(length & 1) || c != '\'')
|
||||
{
|
||||
@ -786,7 +788,7 @@ int yylex(void *arg)
|
||||
ulong version=MYSQL_VERSION_ID;
|
||||
yySkip();
|
||||
state=STATE_START;
|
||||
if (isdigit(yyPeek()))
|
||||
if (my_isdigit(system_charset_info,yyPeek()))
|
||||
{ // Version number
|
||||
version=strtol((char*) lex->ptr,(char**) &lex->ptr,10);
|
||||
}
|
||||
@ -841,7 +843,7 @@ int yylex(void *arg)
|
||||
// Actually real shouldn't start
|
||||
// with . but allow them anyhow
|
||||
case STATE_REAL_OR_POINT:
|
||||
if (isdigit(yyPeek()))
|
||||
if (my_isdigit(system_charset_info,yyPeek()))
|
||||
state = STATE_REAL; // Real
|
||||
else
|
||||
{
|
||||
@ -868,7 +870,7 @@ int yylex(void *arg)
|
||||
return((int) '@');
|
||||
case STATE_HOSTNAME: // end '@' of user@hostname
|
||||
for (c=yyGet() ;
|
||||
isalnum(c) || c == '.' || c == '_' || c == '$';
|
||||
my_isalnum(system_charset_info,c) || c == '.' || c == '_' || c == '$';
|
||||
c= yyGet()) ;
|
||||
yylval->lex_str=get_token(lex,yyLength());
|
||||
return(LEX_HOSTNAME);
|
||||
|
@ -692,7 +692,8 @@ pthread_handler_decl(handle_bootstrap,arg)
|
||||
while (fgets(buff, thd->net.max_packet, file))
|
||||
{
|
||||
uint length=(uint) strlen(buff);
|
||||
while (length && (isspace(buff[length-1]) || buff[length-1] == ';'))
|
||||
while (length && (my_isspace(system_charset_info, buff[length-1]) ||
|
||||
buff[length-1] == ';'))
|
||||
length--;
|
||||
buff[length]=0;
|
||||
thd->current_tablenr=0;
|
||||
@ -917,13 +918,14 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
|
||||
{
|
||||
packet_length--; // Remove end null
|
||||
/* Remove garage at start and end of query */
|
||||
while (isspace(packet[0]) && packet_length > 0)
|
||||
while (my_isspace(system_charset_info,packet[0]) && packet_length > 0)
|
||||
{
|
||||
packet++;
|
||||
packet_length--;
|
||||
}
|
||||
char *pos=packet+packet_length; // Point at end null
|
||||
while (packet_length > 0 && (pos[-1] == ';' || isspace(pos[-1])))
|
||||
while (packet_length > 0 &&
|
||||
(pos[-1] == ';' || my_isspace(system_charset_info,pos[-1])))
|
||||
{
|
||||
pos--;
|
||||
packet_length--;
|
||||
@ -2261,7 +2263,8 @@ mysql_execute_command(void)
|
||||
if (user->password.str &&
|
||||
(strcmp(thd->user,user->user.str) ||
|
||||
user->host.str &&
|
||||
my_strcasecmp(user->host.str, thd->host_or_ip)))
|
||||
my_strcasecmp(system_charset_info,
|
||||
user->host.str, thd->host_or_ip)))
|
||||
{
|
||||
if (check_access(thd, UPDATE_ACL, "mysql",0,1))
|
||||
goto error;
|
||||
@ -3112,8 +3115,8 @@ TABLE_LIST *add_table_to_list(Table_ident *table, LEX_STRING *alias,
|
||||
ptr->name=alias_str;
|
||||
if (lower_case_table_names)
|
||||
{
|
||||
casedn_str(ptr->db);
|
||||
casedn_str(table->table.str);
|
||||
my_casedn_str(system_charset_info,ptr->db);
|
||||
my_casedn_str(system_charset_info,table->table.str);
|
||||
}
|
||||
ptr->real_name=table->table.str;
|
||||
ptr->lock_type=flags;
|
||||
|
@ -209,7 +209,7 @@ mysql_find_files(THD *thd,List<char> *files, const char *db,const char *path,
|
||||
else
|
||||
{
|
||||
// Return only .frm files which aren't temp files.
|
||||
if (my_strcasecmp(ext=fn_ext(file->name),reg_ext) ||
|
||||
if (my_strcasecmp(system_charset_info, ext=fn_ext(file->name),reg_ext) ||
|
||||
is_prefix(file->name,tmp_file_prefix))
|
||||
continue;
|
||||
*ext=0;
|
||||
@ -217,7 +217,7 @@ mysql_find_files(THD *thd,List<char> *files, const char *db,const char *path,
|
||||
{
|
||||
if (lower_case_table_names)
|
||||
{
|
||||
if (wild_case_compare(file->name,wild))
|
||||
if (wild_case_compare(system_charset_info,file->name,wild))
|
||||
continue;
|
||||
}
|
||||
else if (wild_compare(file->name,wild))
|
||||
@ -472,7 +472,8 @@ mysqld_show_fields(THD *thd, TABLE_LIST *table_list,const char *wild,
|
||||
String *packet= &thd->packet;
|
||||
for (ptr=table->field; (field= *ptr) ; ptr++)
|
||||
{
|
||||
if (!wild || !wild[0] || !wild_case_compare(field->field_name,wild))
|
||||
if (!wild || !wild[0] ||
|
||||
!wild_case_compare(system_charset_info, field->field_name,wild))
|
||||
{
|
||||
#ifdef NOT_USED
|
||||
if (thd->col_access & TABLE_ACLS ||
|
||||
@ -744,7 +745,8 @@ mysqld_list_fields(THD *thd, TABLE_LIST *table_list, const char *wild)
|
||||
Field **ptr,*field;
|
||||
for (ptr=table->field ; (field= *ptr); ptr++)
|
||||
{
|
||||
if (!wild || !wild[0] || !wild_case_compare(field->field_name,wild))
|
||||
if (!wild || !wild[0] ||
|
||||
!wild_case_compare(system_charset_info, field->field_name,wild))
|
||||
field_list.push_back(new Item_field(field));
|
||||
}
|
||||
restore_record(table,2); // Get empty record
|
||||
|
@ -234,7 +234,7 @@ bool String::fill(uint32 max_length,char fill_char)
|
||||
|
||||
void String::strip_sp()
|
||||
{
|
||||
while (str_length && isspace(Ptr[str_length-1]))
|
||||
while (str_length && my_isspace(str_charset,Ptr[str_length-1]))
|
||||
str_length--;
|
||||
}
|
||||
|
||||
@ -296,10 +296,10 @@ uint32 String::numchars()
|
||||
register uint32 n=0,mblen;
|
||||
register const char *mbstr=Ptr;
|
||||
register const char *end=mbstr+str_length;
|
||||
if (use_mb(default_charset_info))
|
||||
if (use_mb(str_charset))
|
||||
{
|
||||
while (mbstr < end) {
|
||||
if ((mblen=my_ismbchar(default_charset_info, mbstr,end))) mbstr+=mblen;
|
||||
if ((mblen=my_ismbchar(str_charset, mbstr,end))) mbstr+=mblen;
|
||||
else ++mbstr;
|
||||
++n;
|
||||
}
|
||||
@ -316,11 +316,11 @@ int String::charpos(int i,uint32 offset)
|
||||
register uint32 mblen;
|
||||
register const char *mbstr=Ptr+offset;
|
||||
register const char *end=Ptr+str_length;
|
||||
if (use_mb(default_charset_info))
|
||||
if (use_mb(str_charset))
|
||||
{
|
||||
if (i<=0) return i;
|
||||
while (i && mbstr < end) {
|
||||
if ((mblen=my_ismbchar(default_charset_info, mbstr,end))) mbstr+=mblen;
|
||||
if ((mblen=my_ismbchar(str_charset, mbstr,end))) mbstr+=mblen;
|
||||
else ++mbstr;
|
||||
--i;
|
||||
}
|
||||
@ -380,12 +380,14 @@ int String::strstr_case(const String &s,uint32 offset)
|
||||
skipp:
|
||||
while (str != end)
|
||||
{
|
||||
if (my_sort_order[*str++] == my_sort_order[*search])
|
||||
if (str_charset->sort_order[*str++] == str_charset->sort_order[*search])
|
||||
{
|
||||
register char *i,*j;
|
||||
i=(char*) str; j=(char*) search+1;
|
||||
while (j != search_end)
|
||||
if (my_sort_order[*i++] != my_sort_order[*j++]) goto skipp;
|
||||
if (str_charset->sort_order[*i++] !=
|
||||
str_charset->sort_order[*j++])
|
||||
goto skipp;
|
||||
return (int) (str-Ptr) -1;
|
||||
}
|
||||
}
|
||||
@ -505,15 +507,15 @@ int sortcmp(const String *x,const String *y)
|
||||
uint32 x_len=x->length(),y_len=y->length(),len=min(x_len,y_len);
|
||||
|
||||
#ifdef USE_STRCOLL
|
||||
if (use_strcoll(default_charset_info))
|
||||
if (use_strcoll(x->str_charset))
|
||||
{
|
||||
#ifndef CMP_ENDSPACE
|
||||
while (x_len && isspace(s[x_len-1]))
|
||||
while (x_len && my_isspace(x->str_charset,s[x_len-1]))
|
||||
x_len--;
|
||||
while (y_len && isspace(t[y_len-1]))
|
||||
while (y_len && my_isspace(x->str_charset,t[y_len-1]))
|
||||
y_len--;
|
||||
#endif
|
||||
return my_strnncoll(default_charset_info,
|
||||
return my_strnncoll(x->str_charset,
|
||||
(unsigned char *)s,x_len,(unsigned char *)t,y_len);
|
||||
}
|
||||
else
|
||||
@ -523,9 +525,10 @@ int sortcmp(const String *x,const String *y)
|
||||
y_len-=len;
|
||||
while (len--)
|
||||
{
|
||||
if (my_sort_order[(uchar) *s++] != my_sort_order[(uchar) *t++])
|
||||
return ((int) my_sort_order[(uchar) s[-1]] -
|
||||
(int) my_sort_order[(uchar) t[-1]]);
|
||||
if (x->str_charset->sort_order[(uchar) *s++] !=
|
||||
x->str_charset->sort_order[(uchar) *t++])
|
||||
return ((int) x->str_charset->sort_order[(uchar) s[-1]] -
|
||||
(int) x->str_charset->sort_order[(uchar) t[-1]]);
|
||||
}
|
||||
#ifndef CMP_ENDSPACE
|
||||
/* Don't compare end space in strings */
|
||||
@ -534,14 +537,14 @@ int sortcmp(const String *x,const String *y)
|
||||
{
|
||||
const char *end=t+y_len;
|
||||
for (; t != end ; t++)
|
||||
if (!isspace(*t))
|
||||
if (!my_isspace(x->str_charset,*t))
|
||||
return -1;
|
||||
}
|
||||
else
|
||||
{
|
||||
const char *end=s+x_len;
|
||||
for (; s != end ; s++)
|
||||
if (!isspace(*s))
|
||||
if (!my_isspace(x->str_charset,*s))
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
@ -589,11 +592,10 @@ String *copy_if_not_alloced(String *to,String *from,uint32 from_length)
|
||||
/* Make it easier to handle different charactersets */
|
||||
|
||||
#ifdef USE_MB
|
||||
#define INC_PTR(A,B) A+=((use_mb_flag && \
|
||||
my_ismbchar(default_charset_info,A,B)) ? \
|
||||
my_ismbchar(default_charset_info,A,B) : 1)
|
||||
#define INC_PTR(cs,A,B) A+=((use_mb_flag && \
|
||||
my_ismbchar(cs,A,B)) ? my_ismbchar(cs,A,B) : 1)
|
||||
#else
|
||||
#define INC_PTR(A,B) A++
|
||||
#define INC_PTR(cs,A,B) A++
|
||||
#endif
|
||||
|
||||
/*
|
||||
@ -604,12 +606,12 @@ String *copy_if_not_alloced(String *to,String *from,uint32 from_length)
|
||||
*/
|
||||
|
||||
#ifdef LIKE_CMP_TOUPPER
|
||||
#define likeconv(A) (uchar) toupper(A)
|
||||
#define likeconv(s,A) (uchar) my_toupper(s,A)
|
||||
#else
|
||||
#define likeconv(A) (uchar) my_sort_order[(uchar) (A)]
|
||||
#define likeconv(s,A) (uchar) (s)->sort_order[(uchar) (A)]
|
||||
#endif
|
||||
|
||||
int wild_case_compare(const char *str,const char *str_end,
|
||||
int wild_case_compare(CHARSET_INFO *cs, const char *str,const char *str_end,
|
||||
const char *wildstr,const char *wildend,
|
||||
char escape)
|
||||
{
|
||||
@ -626,7 +628,7 @@ int wild_case_compare(const char *str,const char *str_end,
|
||||
#ifdef USE_MB
|
||||
int l;
|
||||
if (use_mb_flag &&
|
||||
(l = my_ismbchar(default_charset_info, wildstr, wildend)))
|
||||
(l = my_ismbchar(cs, wildstr, wildend)))
|
||||
{
|
||||
if (str+l > str_end || memcmp(str, wildstr, l) != 0)
|
||||
return 1;
|
||||
@ -635,7 +637,7 @@ int wild_case_compare(const char *str,const char *str_end,
|
||||
}
|
||||
else
|
||||
#endif
|
||||
if (str == str_end || likeconv(*wildstr++) != likeconv(*str++))
|
||||
if (str == str_end || likeconv(cs,*wildstr++) != likeconv(cs,*str++))
|
||||
return(1); // No match
|
||||
if (wildstr == wildend)
|
||||
return (str != str_end); // Match if both are at end
|
||||
@ -647,7 +649,7 @@ int wild_case_compare(const char *str,const char *str_end,
|
||||
{
|
||||
if (str == str_end) // Skip one char if possible
|
||||
return (result);
|
||||
INC_PTR(str,str_end);
|
||||
INC_PTR(cs,str,str_end);
|
||||
} while (++wildstr < wildend && *wildstr == wild_one);
|
||||
if (wildstr == wildend)
|
||||
break;
|
||||
@ -664,7 +666,7 @@ int wild_case_compare(const char *str,const char *str_end,
|
||||
{
|
||||
if (str == str_end)
|
||||
return (-1);
|
||||
INC_PTR(str,str_end);
|
||||
INC_PTR(cs,str,str_end);
|
||||
continue;
|
||||
}
|
||||
break; // Not a wild character
|
||||
@ -682,10 +684,10 @@ int wild_case_compare(const char *str,const char *str_end,
|
||||
int mblen;
|
||||
LINT_INIT(mblen);
|
||||
if (use_mb_flag)
|
||||
mblen = my_ismbchar(default_charset_info, wildstr, wildend);
|
||||
mblen = my_ismbchar(cs, wildstr, wildend);
|
||||
#endif
|
||||
INC_PTR(wildstr,wildend); // This is compared trough cmp
|
||||
cmp=likeconv(cmp);
|
||||
INC_PTR(cs,wildstr,wildend); // This is compared trough cmp
|
||||
cmp=likeconv(cs,cmp);
|
||||
do
|
||||
{
|
||||
#ifdef USE_MB
|
||||
@ -703,26 +705,26 @@ int wild_case_compare(const char *str,const char *str_end,
|
||||
break;
|
||||
}
|
||||
}
|
||||
else if (!my_ismbchar(default_charset_info, str, str_end) &&
|
||||
likeconv(*str) == cmp)
|
||||
else if (!my_ismbchar(cs, str, str_end) &&
|
||||
likeconv(cs,*str) == cmp)
|
||||
{
|
||||
str++;
|
||||
break;
|
||||
}
|
||||
INC_PTR(str, str_end);
|
||||
INC_PTR(cs,str, str_end);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
#endif /* USE_MB */
|
||||
while (str != str_end && likeconv(*str) != cmp)
|
||||
while (str != str_end && likeconv(cs,*str) != cmp)
|
||||
str++;
|
||||
if (str++ == str_end) return (-1);
|
||||
#ifdef USE_MB
|
||||
}
|
||||
#endif
|
||||
{
|
||||
int tmp=wild_case_compare(str,str_end,wildstr,wildend,escape);
|
||||
int tmp=wild_case_compare(cs,str,str_end,wildstr,wildend,escape);
|
||||
if (tmp <= 0)
|
||||
return (tmp);
|
||||
}
|
||||
@ -739,7 +741,7 @@ int wild_case_compare(String &match,String &wild, char escape)
|
||||
DBUG_ENTER("wild_case_compare");
|
||||
DBUG_PRINT("enter",("match='%s', wild='%s', escape='%c'"
|
||||
,match.ptr(),wild.ptr(),escape));
|
||||
DBUG_RETURN(wild_case_compare(match.ptr(),match.ptr()+match.length(),
|
||||
DBUG_RETURN(wild_case_compare(match.str_charset,match.ptr(),match.ptr()+match.length(),
|
||||
wild.ptr(), wild.ptr()+wild.length(),escape));
|
||||
}
|
||||
|
||||
|
@ -198,8 +198,8 @@ public:
|
||||
}
|
||||
bool fill(uint32 max_length,char fill);
|
||||
void strip_sp();
|
||||
inline void caseup() { ::caseup(Ptr,str_length); }
|
||||
inline void casedn() { ::casedn(Ptr,str_length); }
|
||||
inline void caseup() { my_caseup(str_charset,Ptr,str_length); }
|
||||
inline void casedn() { my_casedn(str_charset,Ptr,str_length); }
|
||||
friend int sortcmp(const String *a,const String *b);
|
||||
friend int stringcmp(const String *a,const String *b);
|
||||
friend String *copy_if_not_alloced(String *a,String *b,uint32 arg_length);
|
||||
|
@ -302,7 +302,9 @@ int mysql_create_table(THD *thd,const char *db, const char *table_name,
|
||||
null_fields++;
|
||||
while ((dup_field=it2++) != sql_field)
|
||||
{
|
||||
if (my_strcasecmp(sql_field->field_name, dup_field->field_name) == 0)
|
||||
if (my_strcasecmp(system_charset_info,
|
||||
sql_field->field_name,
|
||||
dup_field->field_name) == 0)
|
||||
{
|
||||
my_error(ER_DUP_FIELDNAME,MYF(0),sql_field->field_name);
|
||||
DBUG_RETURN(-1);
|
||||
@ -496,7 +498,9 @@ int mysql_create_table(THD *thd,const char *db, const char *table_name,
|
||||
it.rewind();
|
||||
field=0;
|
||||
while ((sql_field=it++) &&
|
||||
my_strcasecmp(column->field_name,sql_field->field_name))
|
||||
my_strcasecmp(system_charset_info,
|
||||
column->field_name,
|
||||
sql_field->field_name))
|
||||
field++;
|
||||
if (!sql_field)
|
||||
{
|
||||
@ -727,7 +731,7 @@ static bool
|
||||
check_if_keyname_exists(const char *name, KEY *start, KEY *end)
|
||||
{
|
||||
for (KEY *key=start ; key != end ; key++)
|
||||
if (!my_strcasecmp(name,key->name))
|
||||
if (!my_strcasecmp(system_charset_info,name,key->name))
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
@ -1235,9 +1239,9 @@ int mysql_alter_table(THD *thd,char *new_db, char *new_name,
|
||||
strmov(new_name_buff,new_name);
|
||||
fn_same(new_name_buff,table_name,3);
|
||||
if (lower_case_table_names)
|
||||
casedn_str(new_name);
|
||||
my_casedn_str(system_charset_info,new_name);
|
||||
if ((lower_case_table_names &&
|
||||
!my_strcasecmp(new_name_buff,table_name)) ||
|
||||
!my_strcasecmp(system_charset_info, new_name_buff,table_name)) ||
|
||||
(!lower_case_table_names &&
|
||||
!strcmp(new_name_buff,table_name)))
|
||||
new_name=table_name; // No. Make later check easier
|
||||
@ -1348,7 +1352,7 @@ int mysql_alter_table(THD *thd,char *new_db, char *new_name,
|
||||
while ((drop=drop_it++))
|
||||
{
|
||||
if (drop->type == Alter_drop::COLUMN &&
|
||||
!my_strcasecmp(field->field_name, drop->name))
|
||||
!my_strcasecmp(system_charset_info,field->field_name, drop->name))
|
||||
{
|
||||
/* Reset auto_increment value if it was dropped */
|
||||
if (MTYP_TYPENR(field->unireg_check) == Field::NEXT_NUMBER &&
|
||||
@ -1369,7 +1373,8 @@ int mysql_alter_table(THD *thd,char *new_db, char *new_name,
|
||||
def_it.rewind();
|
||||
while ((def=def_it++))
|
||||
{
|
||||
if (def->change && !my_strcasecmp(field->field_name, def->change))
|
||||
if (def->change &&
|
||||
!my_strcasecmp(system_charset_info,field->field_name, def->change))
|
||||
break;
|
||||
}
|
||||
if (def)
|
||||
@ -1393,7 +1398,7 @@ int mysql_alter_table(THD *thd,char *new_db, char *new_name,
|
||||
Alter_column *alter;
|
||||
while ((alter=alter_it++))
|
||||
{
|
||||
if (!my_strcasecmp(field->field_name, alter->name))
|
||||
if (!my_strcasecmp(system_charset_info,field->field_name, alter->name))
|
||||
break;
|
||||
}
|
||||
if (alter)
|
||||
@ -1427,7 +1432,7 @@ int mysql_alter_table(THD *thd,char *new_db, char *new_name,
|
||||
find_it.rewind();
|
||||
while ((find=find_it++)) // Add new columns
|
||||
{
|
||||
if (!my_strcasecmp(def->after, find->field_name))
|
||||
if (!my_strcasecmp(system_charset_info,def->after, find->field_name))
|
||||
break;
|
||||
}
|
||||
if (!find)
|
||||
@ -1473,7 +1478,7 @@ int mysql_alter_table(THD *thd,char *new_db, char *new_name,
|
||||
while ((drop=drop_it++))
|
||||
{
|
||||
if (drop->type == Alter_drop::KEY &&
|
||||
!my_strcasecmp(key_name, drop->name))
|
||||
!my_strcasecmp(system_charset_info,key_name, drop->name))
|
||||
break;
|
||||
}
|
||||
if (drop)
|
||||
@ -1495,10 +1500,11 @@ int mysql_alter_table(THD *thd,char *new_db, char *new_name,
|
||||
{
|
||||
if (cfield->change)
|
||||
{
|
||||
if (!my_strcasecmp(key_part_name, cfield->change))
|
||||
if (!my_strcasecmp(system_charset_info,key_part_name, cfield->change))
|
||||
break;
|
||||
}
|
||||
else if (!my_strcasecmp(key_part_name, cfield->field_name))
|
||||
else if (!my_strcasecmp(system_charset_info,
|
||||
key_part_name, cfield->field_name))
|
||||
break;
|
||||
}
|
||||
if (!cfield)
|
||||
@ -1518,7 +1524,8 @@ int mysql_alter_table(THD *thd,char *new_db, char *new_name,
|
||||
if (key_parts.elements)
|
||||
key_list.push_back(new Key(key_info->flags & HA_SPATIAL ? Key::SPATIAL :
|
||||
(key_info->flags & HA_NOSAME ?
|
||||
(!my_strcasecmp(key_name, "PRIMARY") ?
|
||||
(!my_strcasecmp(system_charset_info,
|
||||
key_name, "PRIMARY") ?
|
||||
Key::PRIMARY : Key::UNIQUE) :
|
||||
(key_info->flags & HA_FULLTEXT ?
|
||||
Key::FULLTEXT : Key::MULTIPLE)),
|
||||
|
@ -3654,7 +3654,8 @@ column_list_id:
|
||||
LEX *lex=Lex;
|
||||
while ((point=iter++))
|
||||
{
|
||||
if (!my_strcasecmp(point->column.ptr(),new_str->ptr()))
|
||||
if (!my_strcasecmp(system_charset_info,
|
||||
point->column.ptr(), new_str->ptr()))
|
||||
break;
|
||||
}
|
||||
lex->grant_tot_col|= lex->which_columns;
|
||||
|
14
sql/table.cc
14
sql/table.cc
@ -1067,9 +1067,10 @@ bool check_db_name(const char *name)
|
||||
while (*name)
|
||||
{
|
||||
#if defined(USE_MB) && defined(USE_MB_IDENT)
|
||||
if (use_mb(default_charset_info))
|
||||
if (use_mb(system_charset_info))
|
||||
{
|
||||
int len=my_ismbchar(default_charset_info, name, name+MBMAXLEN);
|
||||
int len=my_ismbchar(system_charset_info, name,
|
||||
name+system_charset_info->mbmaxlen);
|
||||
if (len)
|
||||
{
|
||||
name += len;
|
||||
@ -1099,9 +1100,9 @@ bool check_table_name(const char *name, uint length)
|
||||
while (name != end)
|
||||
{
|
||||
#if defined(USE_MB) && defined(USE_MB_IDENT)
|
||||
if (use_mb(default_charset_info))
|
||||
if (use_mb(system_charset_info))
|
||||
{
|
||||
int len=my_ismbchar(default_charset_info, name, end);
|
||||
int len=my_ismbchar(system_charset_info, name, end);
|
||||
if (len)
|
||||
{
|
||||
name += len;
|
||||
@ -1121,9 +1122,10 @@ bool check_column_name(const char *name)
|
||||
while (*name)
|
||||
{
|
||||
#if defined(USE_MB) && defined(USE_MB_IDENT)
|
||||
if (use_mb(default_charset_info))
|
||||
if (use_mb(system_charset_info))
|
||||
{
|
||||
int len=my_ismbchar(default_charset_info, name, name+MBMAXLEN);
|
||||
int len=my_ismbchar(system_charset_info, name,
|
||||
name+system_charset_info->mbmaxlen);
|
||||
if (len)
|
||||
{
|
||||
name += len;
|
||||
|
53
sql/time.cc
53
sql/time.cc
@ -268,13 +268,13 @@ void find_date(string pos,uint *vek,uint flag)
|
||||
DBUG_PRINT("enter",("pos: '%s' flag: %d",pos,flag));
|
||||
|
||||
bzero((char*) vek,sizeof(int)*4);
|
||||
while (*pos && !isdigit(*pos))
|
||||
while (*pos && !my_isdigit(system_charset_info,*pos))
|
||||
pos++;
|
||||
length=(uint) strlen(pos);
|
||||
for (uint i=0 ; i< 3; i++)
|
||||
{
|
||||
start=pos; value=0;
|
||||
while (isdigit(pos[0]) &&
|
||||
while (my_isdigit(system_charset_info,pos[0]) &&
|
||||
((pos-start) < 2 || ((pos-start) < 4 && length >= 8 &&
|
||||
!(flag & 3))))
|
||||
{
|
||||
@ -282,7 +282,8 @@ void find_date(string pos,uint *vek,uint flag)
|
||||
pos++;
|
||||
}
|
||||
vek[flag & 3]=value; flag>>=2;
|
||||
while (*pos && (ispunct(*pos) || isspace(*pos)))
|
||||
while (*pos && (my_ispunct(system_charset_info,*pos) ||
|
||||
my_isspace(system_charset_info,*pos)))
|
||||
pos++;
|
||||
}
|
||||
DBUG_PRINT("exit",("year: %d month: %d day: %d",vek[0],vek[1],vek[2]));
|
||||
@ -434,7 +435,8 @@ str_to_TIME(const char *str, uint length, TIME *l_time,bool fuzzy_date)
|
||||
DBUG_ENTER("str_to_TIME");
|
||||
DBUG_PRINT("enter",("str: %.*s",length,str));
|
||||
|
||||
for (; str != end && !isdigit(*str) ; str++) ; // Skip garbage
|
||||
// Skip garbage
|
||||
for (; str != end && !my_isdigit(system_charset_info, *str) ; str++) ;
|
||||
if (str == end)
|
||||
DBUG_RETURN(TIMESTAMP_NONE);
|
||||
/*
|
||||
@ -442,14 +444,14 @@ str_to_TIME(const char *str, uint length, TIME *l_time,bool fuzzy_date)
|
||||
** If length= 8 or >= 14 then year is of format YYYY.
|
||||
(YYYY-MM-DD, YYYYMMDD, YYYYYMMDDHHMMSS)
|
||||
*/
|
||||
for (pos=str; pos != end && isdigit(*pos) ; pos++) ;
|
||||
for (pos=str; pos != end && my_isdigit(system_charset_info,*pos) ; pos++) ;
|
||||
digits= (uint) (pos-str);
|
||||
year_length= (digits == 4 || digits == 8 || digits >= 14) ? 4 : 2;
|
||||
field_length=year_length-1;
|
||||
for (i=0 ; i < 6 && str != end && isdigit(*str) ; i++)
|
||||
for (i=0 ; i < 6 && str != end && my_isdigit(system_charset_info,*str) ; i++)
|
||||
{
|
||||
uint tmp_value=(uint) (uchar) (*str++ - '0');
|
||||
while (str != end && isdigit(str[0]) && field_length--)
|
||||
while (str != end && my_isdigit(system_charset_info,str[0]) && field_length--)
|
||||
{
|
||||
tmp_value=tmp_value*10 + (uint) (uchar) (*str - '0');
|
||||
str++;
|
||||
@ -459,10 +461,12 @@ str_to_TIME(const char *str, uint length, TIME *l_time,bool fuzzy_date)
|
||||
str++; // ISO8601: CCYYMMDDThhmmss
|
||||
else if ( i != 5 ) // Skip inter-field delimiters
|
||||
{
|
||||
while (str != end && (ispunct(*str) || isspace(*str)))
|
||||
while (str != end &&
|
||||
(my_ispunct(system_charset_info,*str) ||
|
||||
my_isspace(system_charset_info,*str)))
|
||||
{
|
||||
// Only allow space between days and hours
|
||||
if (isspace(*str) && i != 2)
|
||||
if (my_isspace(system_charset_info,*str) && i != 2)
|
||||
DBUG_RETURN(TIMESTAMP_NONE);
|
||||
str++;
|
||||
}
|
||||
@ -470,12 +474,13 @@ str_to_TIME(const char *str, uint length, TIME *l_time,bool fuzzy_date)
|
||||
field_length=1; // Rest fields can only be 2
|
||||
}
|
||||
/* Handle second fractions */
|
||||
if (i == 6 && (uint) (end-str) >= 2 && *str == '.' && isdigit(str[1]))
|
||||
if (i == 6 && (uint) (end-str) >= 2 && *str == '.' &&
|
||||
my_isdigit(system_charset_info,str[1]))
|
||||
{
|
||||
str++;
|
||||
uint tmp_value=(uint) (uchar) (*str - '0');
|
||||
field_length=3;
|
||||
while (str++ != end && isdigit(str[0]) && field_length--)
|
||||
while (str++ != end && my_isdigit(system_charset_info,str[0]) && field_length--)
|
||||
tmp_value=tmp_value*10 + (uint) (uchar) (*str - '0');
|
||||
date[6]=tmp_value;
|
||||
}
|
||||
@ -498,7 +503,7 @@ str_to_TIME(const char *str, uint length, TIME *l_time,bool fuzzy_date)
|
||||
{
|
||||
for ( ; str != end ; str++)
|
||||
{
|
||||
if (!isspace(*str))
|
||||
if (!my_isspace(system_charset_info,*str))
|
||||
{
|
||||
current_thd->cuted_fields++;
|
||||
break;
|
||||
@ -559,7 +564,8 @@ bool str_to_time(const char *str,uint length,TIME *l_time)
|
||||
uint state;
|
||||
|
||||
l_time->neg=0;
|
||||
for (; str != end && !isdigit(*str) && *str != '-' ; str++)
|
||||
for (; str != end &&
|
||||
!my_isdigit(system_charset_info,*str) && *str != '-' ; str++)
|
||||
length--;
|
||||
if (str != end && *str == '-')
|
||||
{
|
||||
@ -578,7 +584,7 @@ bool str_to_time(const char *str,uint length,TIME *l_time)
|
||||
}
|
||||
|
||||
/* Not a timestamp. Try to get this as a DAYS_TO_SECOND string */
|
||||
for (value=0; str != end && isdigit(*str) ; str++)
|
||||
for (value=0; str != end && my_isdigit(system_charset_info,*str) ; str++)
|
||||
value=value*10L + (long) (*str - '0');
|
||||
|
||||
if (*str == ' ')
|
||||
@ -589,14 +595,16 @@ bool str_to_time(const char *str,uint length,TIME *l_time)
|
||||
|
||||
LINT_INIT(state);
|
||||
found_days=found_hours=0;
|
||||
if ((uint) (end-str) > 1 && (*str == ' ' && isdigit(str[1])))
|
||||
if ((uint) (end-str) > 1 && (*str == ' ' &&
|
||||
my_isdigit(system_charset_info,str[1])))
|
||||
{ // days !
|
||||
date[0]=value;
|
||||
state=1; // Assume next is hours
|
||||
found_days=1;
|
||||
str++; // Skip space;
|
||||
}
|
||||
else if ((end-str) > 1 && *str == ':' && isdigit(str[1]))
|
||||
else if ((end-str) > 1 && *str == ':' &&
|
||||
my_isdigit(system_charset_info,str[1]))
|
||||
{
|
||||
date[0]=0; // Assume we found hours
|
||||
date[1]=value;
|
||||
@ -618,10 +626,11 @@ bool str_to_time(const char *str,uint length,TIME *l_time)
|
||||
/* Read hours, minutes and seconds */
|
||||
for (;;)
|
||||
{
|
||||
for (value=0; str != end && isdigit(*str) ; str++)
|
||||
for (value=0; str != end && my_isdigit(system_charset_info,*str) ; str++)
|
||||
value=value*10L + (long) (*str - '0');
|
||||
date[state++]=value;
|
||||
if (state == 4 || (end-str) < 2 || *str != ':' || !isdigit(str[1]))
|
||||
if (state == 4 || (end-str) < 2 || *str != ':' ||
|
||||
!my_isdigit(system_charset_info,str[1]))
|
||||
break;
|
||||
str++; // Skip ':'
|
||||
}
|
||||
@ -641,11 +650,13 @@ bool str_to_time(const char *str,uint length,TIME *l_time)
|
||||
|
||||
fractional:
|
||||
/* Get fractional second part */
|
||||
if ((end-str) >= 2 && *str == '.' && isdigit(str[1]))
|
||||
if ((end-str) >= 2 && *str == '.' && my_isdigit(system_charset_info,str[1]))
|
||||
{
|
||||
uint field_length=3;
|
||||
str++; value=(uint) (uchar) (*str - '0');
|
||||
while (++str != end && isdigit(str[0]) && field_length--)
|
||||
while (++str != end &&
|
||||
my_isdigit(system_charset_info,str[0]) &&
|
||||
field_length--)
|
||||
value=value*10 + (uint) (uchar) (*str - '0');
|
||||
date[4]=value;
|
||||
}
|
||||
@ -670,7 +681,7 @@ bool str_to_time(const char *str,uint length,TIME *l_time)
|
||||
{
|
||||
do
|
||||
{
|
||||
if (!isspace(*str))
|
||||
if (!my_isspace(system_charset_info,*str))
|
||||
{
|
||||
current_thd->cuted_fields++;
|
||||
break;
|
||||
|
@ -22,19 +22,19 @@ pkglib_LIBRARIES = libmystrings.a
|
||||
# Exact one of ASSEMBLER_X
|
||||
if ASSEMBLER_x86
|
||||
ASRCS = strings-x86.s longlong2str-x86.s
|
||||
CSRCS = bfill.c bmove.c bmove512.c bchange.c strxnmov.c int2str.c str2int.c r_strinstr.c atof.c bcmp.c strtol.c strtoul.c strtoll.c strtoull.c llstr.c ctype.c strnlen.c
|
||||
CSRCS = bfill.c bmove.c bmove512.c bchange.c strxnmov.c int2str.c str2int.c r_strinstr.c atof.c bcmp.c strtol.c strtoul.c strtoll.c strtoull.c llstr.c ctype.c ctype-simple.c ctype-mb.c strnlen.c
|
||||
else
|
||||
if ASSEMBLER_sparc
|
||||
# These file MUST all be on the same line!! Otherwise automake
|
||||
# generats a very broken makefile
|
||||
ASRCS = bmove_upp-sparc.s strappend-sparc.s strend-sparc.s strinstr-sparc.s strmake-sparc.s strmov-sparc.s strnmov-sparc.s strstr-sparc.s strxmov-sparc.s
|
||||
CSRCS = strcont.c strfill.c strcend.c is_prefix.c longlong2str.c bfill.c bmove.c bmove512.c bchange.c strxnmov.c int2str.c str2int.c r_strinstr.c atof.c bcmp.c strtol.c strtoul.c strtoll.c strtoull.c llstr.c ctype.c strnlen.c
|
||||
CSRCS = strcont.c strfill.c strcend.c is_prefix.c longlong2str.c bfill.c bmove.c bmove512.c bchange.c strxnmov.c int2str.c str2int.c r_strinstr.c atof.c bcmp.c strtol.c strtoul.c strtoll.c strtoull.c llstr.c ctype.c ctype-simple.c ctype-mb.c strnlen.c
|
||||
else
|
||||
#no assembler
|
||||
ASRCS =
|
||||
# These file MUST all be on the same line!! Otherwise automake
|
||||
# generats a very broken makefile
|
||||
CSRCS = strxmov.c bmove_upp.c strappend.c strcont.c strend.c strfill.c strcend.c is_prefix.c strstr.c strinstr.c strmake.c strnmov.c strmov.c longlong2str.c bfill.c bmove.c bmove512.c bchange.c strxnmov.c int2str.c str2int.c r_strinstr.c atof.c bcmp.c strtol.c strtoul.c strtoll.c strtoull.c llstr.c ctype.c strnlen.c
|
||||
CSRCS = strxmov.c bmove_upp.c strappend.c strcont.c strend.c strfill.c strcend.c is_prefix.c strstr.c strinstr.c strmake.c strnmov.c strmov.c longlong2str.c bfill.c bmove.c bmove512.c bchange.c strxnmov.c int2str.c str2int.c r_strinstr.c atof.c bcmp.c strtol.c strtoul.c strtoll.c strtoull.c llstr.c ctype.c ctype-simple.c ctype-mb.c strnlen.c
|
||||
endif
|
||||
endif
|
||||
|
||||
|
@ -213,7 +213,9 @@ static uint16 big5strokexfrm(uint16 i)
|
||||
return 0xA140;
|
||||
}
|
||||
|
||||
int my_strnncoll_big5(const uchar * s1, int len1, const uchar * s2, int len2)
|
||||
int my_strnncoll_big5(CHARSET_INFO *cs,
|
||||
const uchar * s1, uint len1,
|
||||
const uchar * s2, uint len2)
|
||||
{
|
||||
uint len;
|
||||
|
||||
@ -235,10 +237,11 @@ int my_strnncoll_big5(const uchar * s1, int len1, const uchar * s2, int len2)
|
||||
return (int) (len1-len2);
|
||||
}
|
||||
|
||||
int my_strnxfrm_big5(uchar * dest, const uchar * src, int len, int srclen)
|
||||
int my_strnxfrm_big5(CHARSET_INFO *cs,
|
||||
uchar * dest, uint len,
|
||||
const uchar * src, uint srclen)
|
||||
{
|
||||
uint16 e;
|
||||
/*uchar *d = dest; XXX: unused*/
|
||||
|
||||
len = srclen;
|
||||
while (len--)
|
||||
@ -323,7 +326,8 @@ int my_strxfrm_big5(uchar * dest, const uchar * src, int len)
|
||||
#define wild_one '_'
|
||||
#define wild_many '%'
|
||||
|
||||
my_bool my_like_range_big5(const char *ptr,uint ptr_length,pchar escape,
|
||||
my_bool my_like_range_big5(CHARSET_INFO *cs,
|
||||
const char *ptr,uint ptr_length,pchar escape,
|
||||
uint res_length, char *min_str,char *max_str,
|
||||
uint *min_length,uint *max_length)
|
||||
{
|
||||
|
@ -280,7 +280,9 @@ int my_strxfrm_czech(uchar * dest, const uchar * src, int len)
|
||||
|
||||
/* Function strnncoll, actually strcoll, with Czech sorting, which expect
|
||||
the length of the strings being specified */
|
||||
int my_strnncoll_czech(const uchar * s1, int len1, const uchar * s2, int len2)
|
||||
int my_strnncoll_czech(CHARSET_INFO *cs,
|
||||
const uchar * s1, uint len1,
|
||||
const uchar * s2, uint len2)
|
||||
{
|
||||
int v1, v2;
|
||||
const uchar * p1, * p2, * store1, * store2;
|
||||
@ -292,8 +294,8 @@ int my_strnncoll_czech(const uchar * s1, int len1, const uchar * s2, int len2)
|
||||
|
||||
do
|
||||
{
|
||||
NEXT_CMP_VALUE(s1, p1, store1, pass1, v1, len1);
|
||||
NEXT_CMP_VALUE(s2, p2, store2, pass2, v2, len2);
|
||||
NEXT_CMP_VALUE(s1, p1, store1, pass1, v1, (int)len1);
|
||||
NEXT_CMP_VALUE(s2, p2, store2, pass2, v2, (int)len2);
|
||||
diff = v1 - v2;
|
||||
|
||||
if (diff != 0) return diff;
|
||||
@ -304,7 +306,9 @@ int my_strnncoll_czech(const uchar * s1, int len1, const uchar * s2, int len2)
|
||||
|
||||
/* Function strnxfrm, actually strxfrm, with Czech sorting, which expect
|
||||
the length of the strings being specified */
|
||||
int my_strnxfrm_czech(uchar * dest, const uchar * src, int len, int srclen)
|
||||
int my_strnxfrm_czech(CHARSET_INFO *cs,
|
||||
uchar * dest, uint len,
|
||||
const uchar * src, uint srclen)
|
||||
{
|
||||
int value;
|
||||
const uchar * p, * store;
|
||||
@ -314,8 +318,8 @@ int my_strnxfrm_czech(uchar * dest, const uchar * src, int len, int srclen)
|
||||
|
||||
do
|
||||
{
|
||||
NEXT_CMP_VALUE(src, p, store, pass, value, srclen);
|
||||
ADD_TO_RESULT(dest, len, totlen, value);
|
||||
NEXT_CMP_VALUE(src, p, store, pass, value, (int)srclen);
|
||||
ADD_TO_RESULT(dest, (int)len, totlen, value);
|
||||
}
|
||||
while (value);
|
||||
return totlen;
|
||||
@ -372,7 +376,8 @@ int my_strnxfrm_czech(uchar * dest, const uchar * src, int len, int srclen)
|
||||
|
||||
#define EXAMPLE
|
||||
|
||||
my_bool my_like_range_czech(const char *ptr,uint ptr_length,pchar escape,
|
||||
my_bool my_like_range_czech(CHARSET_INFO *cs,
|
||||
const char *ptr,uint ptr_length,pchar escape,
|
||||
uint res_length, char *min_str,char *max_str,
|
||||
uint *min_length,uint *max_length)
|
||||
{
|
||||
|
@ -2579,7 +2579,9 @@ static uint16 gbksortorder(uint16 i)
|
||||
}
|
||||
|
||||
|
||||
int my_strnncoll_gbk(const uchar * s1, int len1, const uchar * s2, int len2)
|
||||
int my_strnncoll_gbk(CHARSET_INFO *cs,
|
||||
const uchar * s1, uint len1,
|
||||
const uchar * s2, uint len2)
|
||||
{
|
||||
uint len,c1,c2;
|
||||
|
||||
@ -2603,13 +2605,10 @@ int my_strnncoll_gbk(const uchar * s1, int len1, const uchar * s2, int len2)
|
||||
return (int) (len1-len2);
|
||||
}
|
||||
|
||||
int my_strcoll_gbk(const uchar * s1, const uchar * s2)
|
||||
{
|
||||
return my_strnncoll_gbk(s1, (uint) strlen((char*) s1),
|
||||
s2, (uint) strlen((char*) s2));
|
||||
}
|
||||
|
||||
int my_strnxfrm_gbk(uchar * dest, const uchar * src, int len, int srclen)
|
||||
int my_strnxfrm_gbk(CHARSET_INFO *cs,
|
||||
uchar * dest, uint len,
|
||||
const uchar * src, uint srclen)
|
||||
{
|
||||
uint16 e;
|
||||
|
||||
@ -2629,10 +2628,6 @@ int my_strnxfrm_gbk(uchar * dest, const uchar * src, int len, int srclen)
|
||||
return srclen;
|
||||
}
|
||||
|
||||
int my_strxfrm_gbk(uchar * dest, const uchar * src, int len)
|
||||
{
|
||||
return my_strnxfrm_gbk(dest,src,len,(uint) strlen((char*) src));
|
||||
}
|
||||
|
||||
/*
|
||||
** Calculate min_str and max_str that ranges a LIKE string.
|
||||
@ -2655,7 +2650,8 @@ int my_strxfrm_gbk(uchar * dest, const uchar * src, int len)
|
||||
#define wild_one '_'
|
||||
#define wild_many '%'
|
||||
|
||||
extern my_bool my_like_range_gbk(const char *ptr,uint ptr_length,pchar escape,
|
||||
extern my_bool my_like_range_gbk(CHARSET_INFO *cs,
|
||||
const char *ptr,uint ptr_length,pchar escape,
|
||||
uint res_length, char *min_str,char *max_str,
|
||||
uint *min_length,uint *max_length)
|
||||
{
|
||||
|
@ -162,8 +162,9 @@ uchar sort_order_latin1_de[] = {
|
||||
}
|
||||
|
||||
|
||||
int my_strnncoll_latin1_de(const uchar * s1, int len1,
|
||||
const uchar * s2, int len2)
|
||||
int my_strnncoll_latin1_de(CHARSET_INFO *cs,
|
||||
const uchar * s1, uint len1,
|
||||
const uchar * s2, uint len2)
|
||||
{
|
||||
const uchar *e1 = s1 + len1;
|
||||
const uchar *e2 = s2 + len2;
|
||||
@ -235,7 +236,9 @@ int my_strnncoll_latin1_de(const uchar * s1, int len1,
|
||||
}
|
||||
|
||||
|
||||
int my_strnxfrm_latin1_de(uchar * dest, const uchar * src, int len, int srclen)
|
||||
int my_strnxfrm_latin1_de(CHARSET_INFO *cs,
|
||||
uchar * dest, uint len,
|
||||
const uchar * src, uint srclen)
|
||||
{
|
||||
const uchar *dest_orig = dest;
|
||||
const uchar *de = dest + len;
|
||||
@ -274,19 +277,6 @@ int my_strnxfrm_latin1_de(uchar * dest, const uchar * src, int len, int srclen)
|
||||
}
|
||||
|
||||
|
||||
int my_strcoll_latin1_de(const uchar * s1, const uchar * s2)
|
||||
{
|
||||
/* XXX QQ: This should be fixed to not call strlen */
|
||||
return my_strnncoll_latin1_de(s1, strlen((char*) s1),
|
||||
s2, strlen((char*) s2));
|
||||
}
|
||||
|
||||
int my_strxfrm_latin1_de(uchar * dest, const uchar * src, int len)
|
||||
{
|
||||
/* XXX QQ: This should be fixed to not call strlen */
|
||||
return my_strnxfrm_latin1_de(dest, src, len, strlen((char*) src));
|
||||
}
|
||||
|
||||
/*
|
||||
* Calculate min_str and max_str that ranges a LIKE string.
|
||||
* Arguments:
|
||||
@ -311,7 +301,8 @@ int my_strxfrm_latin1_de(uchar * dest, const uchar * src, int len)
|
||||
#define wild_one '_'
|
||||
#define wild_many '%'
|
||||
|
||||
my_bool my_like_range_latin1_de(const char *ptr, uint ptr_length,
|
||||
my_bool my_like_range_latin1_de(CHARSET_INFO *cs,
|
||||
const char *ptr, uint ptr_length,
|
||||
pchar escape, uint res_length,
|
||||
char *min_str, char *max_str,
|
||||
uint *min_length, uint *max_length)
|
||||
|
125
strings/ctype-mb.c
Normal file
125
strings/ctype-mb.c
Normal file
@ -0,0 +1,125 @@
|
||||
/* Copyright (C) 2000 MySQL 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; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
|
||||
|
||||
#include <my_global.h>
|
||||
#include "m_ctype.h"
|
||||
|
||||
void my_caseup_str_mb(CHARSET_INFO * cs, char *str)
|
||||
{
|
||||
register uint32 l;
|
||||
register char *end=str+strlen(str); /* BAR TODO: remove strlen() call */
|
||||
while (*str)
|
||||
{
|
||||
if ((l=my_ismbchar(cs, str,end)))
|
||||
str+=l;
|
||||
else
|
||||
{
|
||||
*str=(char)my_toupper(cs,(uchar)*str);
|
||||
str++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void my_casedn_str_mb(CHARSET_INFO * cs, char *str)
|
||||
{
|
||||
register uint32 l;
|
||||
register char *end=str+strlen(str);
|
||||
while (*str)
|
||||
{
|
||||
if ((l=my_ismbchar(cs, str,end)))
|
||||
str+=l;
|
||||
else
|
||||
{
|
||||
*str=(char)my_tolower(cs,(uchar)*str);
|
||||
str++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void my_caseup_mb(CHARSET_INFO * cs, char *str, uint length)
|
||||
{
|
||||
register uint32 l;
|
||||
register char *end=str+length;
|
||||
while (str<end)
|
||||
{
|
||||
if ((l=my_ismbchar(cs, str,end)))
|
||||
str+=l;
|
||||
else
|
||||
{
|
||||
*str=(char)my_toupper(cs,(uchar)*str);
|
||||
str++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void my_casedn_mb(CHARSET_INFO * cs, char *str, uint length)
|
||||
{
|
||||
register uint32 l;
|
||||
register char *end=str+length;
|
||||
while (str<end)
|
||||
{
|
||||
if ((l=my_ismbchar(cs, str,end)))
|
||||
str+=l;
|
||||
else
|
||||
{
|
||||
*str=(char)my_tolower(cs,(uchar)*str);
|
||||
str++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int my_strcasecmp_mb(CHARSET_INFO * cs,const char *s, const char *t)
|
||||
{
|
||||
register uint32 l;
|
||||
register const char *end=s+strlen(s);
|
||||
while (s<end)
|
||||
{
|
||||
if ((l=my_ismbchar(cs, s,end)))
|
||||
{
|
||||
while (l--)
|
||||
if (*s++ != *t++)
|
||||
return 1;
|
||||
}
|
||||
else if (my_ismbhead(cs, *t))
|
||||
return 1;
|
||||
else if (my_toupper(cs,(uchar) *s++) != my_toupper(cs,(uchar) *t++))
|
||||
return 1;
|
||||
}
|
||||
return *t;
|
||||
}
|
||||
|
||||
|
||||
int my_strncasecmp_mb(CHARSET_INFO * cs,
|
||||
const char *s, const char *t, uint len)
|
||||
{
|
||||
register uint32 l;
|
||||
register const char *end=s+len;
|
||||
while (s<end)
|
||||
{
|
||||
if ((l=my_ismbchar(cs, s,end)))
|
||||
{
|
||||
while (l--)
|
||||
if (*s++ != *t++)
|
||||
return 1;
|
||||
}
|
||||
else if (my_ismbhead(cs, *t))
|
||||
return 1;
|
||||
else if (my_toupper(cs,(uchar) *s++) != my_toupper(cs,(uchar) *t++))
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
87
strings/ctype-simple.c
Normal file
87
strings/ctype-simple.c
Normal file
@ -0,0 +1,87 @@
|
||||
/* Copyright (C) 2000 MySQL 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; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
|
||||
|
||||
#include <my_global.h>
|
||||
#include "m_ctype.h"
|
||||
#include "dbug.h"
|
||||
#include "assert.h"
|
||||
|
||||
int my_strnxfrm_simple(CHARSET_INFO * cs,
|
||||
char *dest, uint len,
|
||||
const char *src, uint srclen)
|
||||
{
|
||||
DBUG_ASSERT(len >= srclen);
|
||||
|
||||
for ( ; len > 0 ; len-- )
|
||||
*dest++= (char) cs->sort_order[(uchar) *src++];
|
||||
return srclen;
|
||||
}
|
||||
|
||||
int my_strnncoll_simple(CHARSET_INFO * cs,const char *s, uint slen,
|
||||
const char *t, uint tlen)
|
||||
{
|
||||
int len = ( slen > tlen ) ? tlen : slen;
|
||||
while (len--)
|
||||
{
|
||||
if (cs->sort_order[(uchar) *s++] != cs->sort_order[(uchar) *t++])
|
||||
return ((int) cs->sort_order[(uchar) s[-1]] -
|
||||
(int) cs->sort_order[(uchar) t[-1]]);
|
||||
}
|
||||
return (int) (slen-tlen);
|
||||
}
|
||||
|
||||
|
||||
void my_caseup_str_8bit(CHARSET_INFO * cs,char *str)
|
||||
{
|
||||
while ((*str = (char) my_toupper(cs,(uchar) *str)) != 0)
|
||||
str++;
|
||||
}
|
||||
|
||||
|
||||
void my_casedn_str_8bit(CHARSET_INFO * cs,char *str)
|
||||
{
|
||||
while ((*str = (char) my_tolower(cs,(uchar)*str)) != 0)
|
||||
str++;
|
||||
}
|
||||
|
||||
|
||||
void my_caseup_8bit(CHARSET_INFO * cs, char *str, uint length)
|
||||
{
|
||||
for ( ; length>0 ; length--, str++)
|
||||
*str= (char) my_toupper(cs,(uchar)*str);
|
||||
}
|
||||
|
||||
void my_casedn_8bit(CHARSET_INFO * cs, char *str, uint length)
|
||||
{
|
||||
for ( ; length>0 ; length--, str++)
|
||||
*str= (char)my_tolower(cs,(uchar) *str);
|
||||
}
|
||||
|
||||
|
||||
int my_strcasecmp_8bit(CHARSET_INFO * cs,const char *s, const char *t)
|
||||
{
|
||||
while (my_toupper(cs,(uchar) *s) == my_toupper(cs,(uchar) *t++))
|
||||
if (!*s++) return 0;
|
||||
return ((int) my_toupper(cs,(uchar) s[0]) - (int) my_toupper(cs,(uchar) t[-1]));
|
||||
}
|
||||
|
||||
|
||||
int my_strncasecmp_8bit(CHARSET_INFO * cs,
|
||||
const char *s, const char *t, uint len)
|
||||
{
|
||||
while (len-- != 0 && my_toupper(cs,(uchar)*s++) == my_toupper(cs,(uchar)*t++)) ;
|
||||
return (int) len+1;
|
||||
}
|
@ -198,7 +198,9 @@ int mbcharlen_sjis(uint c)
|
||||
|
||||
#define sjiscode(c,d) ((((uint) (uchar)(c)) << 8) | (uint) (uchar) (d))
|
||||
|
||||
int my_strnncoll_sjis(const uchar *s1, int len1, const uchar *s2, int len2)
|
||||
int my_strnncoll_sjis(CHARSET_INFO *cs,
|
||||
const uchar *s1, uint len1,
|
||||
const uchar *s2, uint len2)
|
||||
{
|
||||
const uchar *e1 = s1 + len1;
|
||||
const uchar *e2 = s2 + len2;
|
||||
@ -221,13 +223,9 @@ int my_strnncoll_sjis(const uchar *s1, int len1, const uchar *s2, int len2)
|
||||
return len1 - len2;
|
||||
}
|
||||
|
||||
int my_strcoll_sjis(const uchar *s1, const uchar *s2)
|
||||
{
|
||||
return (uint) my_strnncoll_sjis(s1,(uint) strlen((char*) s1),
|
||||
s2,(uint) strlen((char*) s2));
|
||||
}
|
||||
|
||||
int my_strnxfrm_sjis(uchar *dest, const uchar *src, int len, int srclen)
|
||||
int my_strnxfrm_sjis(CHARSET_INFO *cs,
|
||||
uchar *dest, uint len,
|
||||
const uchar *src, uint srclen)
|
||||
{
|
||||
uchar *d_end = dest + len;
|
||||
uchar *s_end = (uchar*) src + srclen;
|
||||
@ -243,12 +241,6 @@ int my_strnxfrm_sjis(uchar *dest, const uchar *src, int len, int srclen)
|
||||
return srclen;
|
||||
}
|
||||
|
||||
int my_strxfrm_sjis(uchar *dest, const uchar *src, int len)
|
||||
{
|
||||
return my_strnxfrm_sjis(dest, src, len, (uint) strlen((char*) src));
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Calculate min_str and max_str that ranges a LIKE string.
|
||||
** Arguments:
|
||||
@ -270,9 +262,10 @@ int my_strxfrm_sjis(uchar *dest, const uchar *src, int len)
|
||||
#define wild_one '_'
|
||||
#define wild_many '%'
|
||||
|
||||
my_bool my_like_range_sjis(const char *ptr,uint ptr_length,pchar escape,
|
||||
uint res_length, char *min_str,char *max_str,
|
||||
uint *min_length,uint *max_length)
|
||||
my_bool my_like_range_sjis(CHARSET_INFO *cs,
|
||||
const char *ptr,uint ptr_length,pchar escape,
|
||||
uint res_length, char *min_str,char *max_str,
|
||||
uint *min_length,uint *max_length)
|
||||
{
|
||||
const char *end=ptr+ptr_length;
|
||||
char *min_org=min_str;
|
||||
|
@ -535,7 +535,9 @@ static uchar* thai2sortable(const uchar * tstr,uint len)
|
||||
Arg: 2 Strings and it compare length
|
||||
Ret: strcmp result
|
||||
*/
|
||||
int my_strnncoll_tis620(const uchar * s1, int len1, const uchar * s2, int len2)
|
||||
int my_strnncoll_tis620(CHARSET_INFO *cs,
|
||||
const uchar * s1, uint len1,
|
||||
const uchar * s2, uint len2)
|
||||
{
|
||||
uchar *tc1, *tc2;
|
||||
int i;
|
||||
@ -551,7 +553,9 @@ int my_strnncoll_tis620(const uchar * s1, int len1, const uchar * s2, int len2)
|
||||
Arg: Destination buffer, source string, dest length and source length
|
||||
Ret: Conveted string size
|
||||
*/
|
||||
int my_strnxfrm_tis620(uchar * dest, const uchar * src, int len, int srclen)
|
||||
int my_strnxfrm_tis620(CHARSET_INFO *cs,
|
||||
uchar * dest, uint len,
|
||||
const uchar * src, uint srclen)
|
||||
{
|
||||
uint bufSize;
|
||||
uchar *tmp;
|
||||
@ -607,7 +611,8 @@ int my_strxfrm_tis620(uchar * dest, const uchar * src, int len)
|
||||
#define wild_one '_'
|
||||
#define wild_many '%'
|
||||
|
||||
my_bool my_like_range_tis620(const char *ptr, uint ptr_length, pchar escape,
|
||||
my_bool my_like_range_tis620(CHARSET_INFO *cs,
|
||||
const char *ptr, uint ptr_length, pchar escape,
|
||||
uint res_length, char *min_str, char *max_str,
|
||||
uint *min_length, uint *max_length)
|
||||
{
|
||||
|
331
strings/ctype.c
331
strings/ctype.c
@ -1967,8 +1967,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_latin1,
|
||||
sort_order_latin1,
|
||||
0, /* strxfrm_multiply */
|
||||
NULL, /* strcoll */
|
||||
NULL, /* strxfrm */
|
||||
NULL, /* strnncoll */
|
||||
NULL, /* strnxfrm */
|
||||
NULL, /* like_range */
|
||||
@ -1976,7 +1974,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
NULL, /* ismbchar */
|
||||
NULL, /* ismbhead */
|
||||
NULL, /* mbcharlen */
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_8bit,
|
||||
my_casedn_str_8bit,
|
||||
my_caseup_8bit,
|
||||
my_casedn_8bit,
|
||||
my_strcasecmp_8bit,
|
||||
my_strncasecmp_8bit,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -1989,8 +1993,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_big5,
|
||||
sort_order_big5,
|
||||
1, /* strxfrm_multiply */
|
||||
my_strcoll_big5,
|
||||
my_strxfrm_big5,
|
||||
my_strnncoll_big5,
|
||||
my_strnxfrm_big5,
|
||||
my_like_range_big5,
|
||||
@ -1998,7 +2000,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
ismbchar_big5,
|
||||
ismbhead_big5,
|
||||
mbcharlen_big5,
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_mb,
|
||||
my_casedn_str_mb,
|
||||
my_caseup_mb,
|
||||
my_casedn_mb,
|
||||
my_strcasecmp_mb,
|
||||
my_strncasecmp_mb,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2011,8 +2019,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_cp1251,
|
||||
sort_order_cp1251,
|
||||
0, /* strxfrm_multiply */
|
||||
NULL, /* strcoll */
|
||||
NULL, /* strxfrm */
|
||||
NULL, /* strnncoll */
|
||||
NULL, /* strnxfrm */
|
||||
NULL, /* like_range */
|
||||
@ -2020,7 +2026,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
NULL, /* ismbchar */
|
||||
NULL, /* ismbhead */
|
||||
NULL, /* mbcharlen */
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_8bit,
|
||||
my_casedn_str_8bit,
|
||||
my_caseup_8bit,
|
||||
my_casedn_8bit,
|
||||
my_strcasecmp_8bit,
|
||||
my_strncasecmp_8bit,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2033,8 +2045,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_cp1257,
|
||||
sort_order_cp1257,
|
||||
0, /* strxfrm_multiply */
|
||||
NULL, /* strcoll */
|
||||
NULL, /* strxfrm */
|
||||
NULL, /* strnncoll */
|
||||
NULL, /* strnxfrm */
|
||||
NULL, /* like_range */
|
||||
@ -2042,7 +2052,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
NULL, /* ismbchar */
|
||||
NULL, /* ismbhead */
|
||||
NULL, /* mbcharlen */
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_8bit,
|
||||
my_casedn_str_8bit,
|
||||
my_caseup_8bit,
|
||||
my_casedn_8bit,
|
||||
my_strcasecmp_8bit,
|
||||
my_strncasecmp_8bit,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2055,8 +2071,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_croat,
|
||||
sort_order_croat,
|
||||
0, /* strxfrm_multiply */
|
||||
NULL, /* strcoll */
|
||||
NULL, /* strxfrm */
|
||||
NULL, /* strnncoll */
|
||||
NULL, /* strnxfrm */
|
||||
NULL, /* like_range */
|
||||
@ -2064,7 +2078,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
NULL, /* ismbchar */
|
||||
NULL, /* ismbhead */
|
||||
NULL, /* mbcharlen */
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_8bit,
|
||||
my_casedn_str_8bit,
|
||||
my_caseup_8bit,
|
||||
my_casedn_8bit,
|
||||
my_strcasecmp_8bit,
|
||||
my_strncasecmp_8bit,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2077,8 +2097,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_czech,
|
||||
sort_order_czech,
|
||||
4, /* strxfrm_multiply */
|
||||
my_strcoll_czech,
|
||||
my_strxfrm_czech,
|
||||
my_strnncoll_czech,
|
||||
my_strnxfrm_czech,
|
||||
my_like_range_czech,
|
||||
@ -2086,7 +2104,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
NULL, /* ismbchar */
|
||||
NULL, /* ismbhead */
|
||||
NULL, /* mbcharlen */
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_8bit,
|
||||
my_casedn_str_8bit,
|
||||
my_caseup_8bit,
|
||||
my_casedn_8bit,
|
||||
my_strcasecmp_8bit,
|
||||
my_strncasecmp_8bit,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2099,8 +2123,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_danish,
|
||||
sort_order_danish,
|
||||
0, /* strxfrm_multiply */
|
||||
NULL, /* strcoll */
|
||||
NULL, /* strxfrm */
|
||||
NULL, /* strnncoll */
|
||||
NULL, /* strnxfrm */
|
||||
NULL, /* like_range */
|
||||
@ -2108,7 +2130,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
NULL, /* ismbchar */
|
||||
NULL, /* ismbhead */
|
||||
NULL, /* mbcharlen */
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_8bit,
|
||||
my_casedn_str_8bit,
|
||||
my_caseup_8bit,
|
||||
my_casedn_8bit,
|
||||
my_strcasecmp_8bit,
|
||||
my_strncasecmp_8bit,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2121,8 +2149,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_dec8,
|
||||
sort_order_dec8,
|
||||
0, /* strxfrm_multiply */
|
||||
NULL, /* strcoll */
|
||||
NULL, /* strxfrm */
|
||||
NULL, /* strnncoll */
|
||||
NULL, /* strnxfrm */
|
||||
NULL, /* like_range */
|
||||
@ -2130,7 +2156,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
NULL, /* ismbchar */
|
||||
NULL, /* ismbhead */
|
||||
NULL, /* mbcharlen */
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_8bit,
|
||||
my_casedn_str_8bit,
|
||||
my_caseup_8bit,
|
||||
my_casedn_8bit,
|
||||
my_strcasecmp_8bit,
|
||||
my_strncasecmp_8bit,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2143,8 +2175,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_dos,
|
||||
sort_order_dos,
|
||||
0, /* strxfrm_multiply */
|
||||
NULL, /* strcoll */
|
||||
NULL, /* strxfrm */
|
||||
NULL, /* strnncoll */
|
||||
NULL, /* strnxfrm */
|
||||
NULL, /* like_range */
|
||||
@ -2152,7 +2182,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
NULL, /* ismbchar */
|
||||
NULL, /* ismbhead */
|
||||
NULL, /* mbcharlen */
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_8bit,
|
||||
my_casedn_str_8bit,
|
||||
my_caseup_8bit,
|
||||
my_casedn_8bit,
|
||||
my_strcasecmp_8bit,
|
||||
my_strncasecmp_8bit,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2165,8 +2201,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_estonia,
|
||||
sort_order_estonia,
|
||||
0, /* strxfrm_multiply */
|
||||
NULL, /* strcoll */
|
||||
NULL, /* strxfrm */
|
||||
NULL, /* strnncoll */
|
||||
NULL, /* strnxfrm */
|
||||
NULL, /* like_range */
|
||||
@ -2174,7 +2208,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
NULL, /* ismbchar */
|
||||
NULL, /* ismbhead */
|
||||
NULL, /* mbcharlen */
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_8bit,
|
||||
my_casedn_str_8bit,
|
||||
my_caseup_8bit,
|
||||
my_casedn_8bit,
|
||||
my_strcasecmp_8bit,
|
||||
my_strncasecmp_8bit,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2187,8 +2227,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_euc_kr,
|
||||
sort_order_euc_kr,
|
||||
0, /* strxfrm_multiply */
|
||||
NULL, /* strcoll */
|
||||
NULL, /* strxfrm */
|
||||
NULL, /* strnncoll */
|
||||
NULL, /* strnxfrm */
|
||||
NULL, /* like_range */
|
||||
@ -2196,7 +2234,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
ismbchar_euc_kr,
|
||||
ismbhead_euc_kr,
|
||||
mbcharlen_euc_kr,
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_mb,
|
||||
my_casedn_str_mb,
|
||||
my_caseup_mb,
|
||||
my_casedn_mb,
|
||||
my_strcasecmp_mb,
|
||||
my_strncasecmp_mb,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2209,8 +2253,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_gb2312,
|
||||
sort_order_gb2312,
|
||||
0, /* strxfrm_multiply */
|
||||
NULL, /* strcoll */
|
||||
NULL, /* strxfrm */
|
||||
NULL, /* strnncoll */
|
||||
NULL, /* strnxfrm */
|
||||
NULL, /* like_range */
|
||||
@ -2218,7 +2260,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
ismbchar_gb2312,
|
||||
ismbhead_gb2312,
|
||||
mbcharlen_gb2312,
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_mb,
|
||||
my_casedn_str_mb,
|
||||
my_caseup_mb,
|
||||
my_casedn_mb,
|
||||
my_strcasecmp_mb,
|
||||
my_strncasecmp_mb,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2231,8 +2279,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_gbk,
|
||||
sort_order_gbk,
|
||||
1, /* strxfrm_multiply */
|
||||
my_strcoll_gbk,
|
||||
my_strxfrm_gbk,
|
||||
my_strnncoll_gbk,
|
||||
my_strnxfrm_gbk,
|
||||
my_like_range_gbk,
|
||||
@ -2240,7 +2286,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
ismbchar_gbk,
|
||||
ismbhead_gbk,
|
||||
mbcharlen_gbk,
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_mb,
|
||||
my_casedn_str_mb,
|
||||
my_caseup_mb,
|
||||
my_casedn_mb,
|
||||
my_strcasecmp_mb,
|
||||
my_strncasecmp_mb,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2253,8 +2305,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_german1,
|
||||
sort_order_german1,
|
||||
0, /* strxfrm_multiply */
|
||||
NULL, /* strcoll */
|
||||
NULL, /* strxfrm */
|
||||
NULL, /* strnncoll */
|
||||
NULL, /* strnxfrm */
|
||||
NULL, /* like_range */
|
||||
@ -2262,7 +2312,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
NULL, /* ismbchar */
|
||||
NULL, /* ismbhead */
|
||||
NULL, /* mbcharlen */
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_8bit,
|
||||
my_casedn_str_8bit,
|
||||
my_caseup_8bit,
|
||||
my_casedn_8bit,
|
||||
my_strcasecmp_8bit,
|
||||
my_strncasecmp_8bit,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2275,8 +2331,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_greek,
|
||||
sort_order_greek,
|
||||
0, /* strxfrm_multiply */
|
||||
NULL, /* strcoll */
|
||||
NULL, /* strxfrm */
|
||||
NULL, /* strnncoll */
|
||||
NULL, /* strnxfrm */
|
||||
NULL, /* like_range */
|
||||
@ -2284,7 +2338,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
NULL, /* ismbchar */
|
||||
NULL, /* ismbhead */
|
||||
NULL, /* mbcharlen */
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_8bit,
|
||||
my_casedn_str_8bit,
|
||||
my_caseup_8bit,
|
||||
my_casedn_8bit,
|
||||
my_strcasecmp_8bit,
|
||||
my_strncasecmp_8bit,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2297,8 +2357,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_hebrew,
|
||||
sort_order_hebrew,
|
||||
0, /* strxfrm_multiply */
|
||||
NULL, /* strcoll */
|
||||
NULL, /* strxfrm */
|
||||
NULL, /* strnncoll */
|
||||
NULL, /* strnxfrm */
|
||||
NULL, /* like_range */
|
||||
@ -2306,7 +2364,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
NULL, /* ismbchar */
|
||||
NULL, /* ismbhead */
|
||||
NULL, /* mbcharlen */
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_8bit,
|
||||
my_casedn_str_8bit,
|
||||
my_caseup_8bit,
|
||||
my_casedn_8bit,
|
||||
my_strcasecmp_8bit,
|
||||
my_strncasecmp_8bit,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2319,8 +2383,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_hp8,
|
||||
sort_order_hp8,
|
||||
0, /* strxfrm_multiply */
|
||||
NULL, /* strcoll */
|
||||
NULL, /* strxfrm */
|
||||
NULL, /* strnncoll */
|
||||
NULL, /* strnxfrm */
|
||||
NULL, /* like_range */
|
||||
@ -2328,7 +2390,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
NULL, /* ismbchar */
|
||||
NULL, /* ismbhead */
|
||||
NULL, /* mbcharlen */
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_8bit,
|
||||
my_casedn_str_8bit,
|
||||
my_caseup_8bit,
|
||||
my_casedn_8bit,
|
||||
my_strcasecmp_8bit,
|
||||
my_strncasecmp_8bit,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2341,8 +2409,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_hungarian,
|
||||
sort_order_hungarian,
|
||||
0, /* strxfrm_multiply */
|
||||
NULL, /* strcoll */
|
||||
NULL, /* strxfrm */
|
||||
NULL, /* strnncoll */
|
||||
NULL, /* strnxfrm */
|
||||
NULL, /* like_range */
|
||||
@ -2350,7 +2416,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
NULL, /* ismbchar */
|
||||
NULL, /* ismbhead */
|
||||
NULL, /* mbcharlen */
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_8bit,
|
||||
my_casedn_str_8bit,
|
||||
my_caseup_8bit,
|
||||
my_casedn_8bit,
|
||||
my_strcasecmp_8bit,
|
||||
my_strncasecmp_8bit,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2363,8 +2435,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_koi8_ru,
|
||||
sort_order_koi8_ru,
|
||||
0, /* strxfrm_multiply */
|
||||
NULL, /* strcoll */
|
||||
NULL, /* strxfrm */
|
||||
NULL, /* strnncoll */
|
||||
NULL, /* strnxfrm */
|
||||
NULL, /* like_range */
|
||||
@ -2372,7 +2442,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
NULL, /* ismbchar */
|
||||
NULL, /* ismbhead */
|
||||
NULL, /* mbcharlen */
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_8bit,
|
||||
my_casedn_str_8bit,
|
||||
my_caseup_8bit,
|
||||
my_casedn_8bit,
|
||||
my_strcasecmp_8bit,
|
||||
my_strncasecmp_8bit,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2385,8 +2461,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_koi8_ukr,
|
||||
sort_order_koi8_ukr,
|
||||
0, /* strxfrm_multiply */
|
||||
NULL, /* strcoll */
|
||||
NULL, /* strxfrm */
|
||||
NULL, /* strnncoll */
|
||||
NULL, /* strnxfrm */
|
||||
NULL, /* like_range */
|
||||
@ -2394,7 +2468,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
NULL, /* ismbchar */
|
||||
NULL, /* ismbhead */
|
||||
NULL, /* mbcharlen */
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_8bit,
|
||||
my_casedn_str_8bit,
|
||||
my_caseup_8bit,
|
||||
my_casedn_8bit,
|
||||
my_strcasecmp_8bit,
|
||||
my_strncasecmp_8bit,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2407,8 +2487,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_latin1_de,
|
||||
sort_order_latin1_de,
|
||||
2, /* strxfrm_multiply */
|
||||
my_strcoll_latin1_de,
|
||||
my_strxfrm_latin1_de,
|
||||
my_strnncoll_latin1_de,
|
||||
my_strnxfrm_latin1_de,
|
||||
my_like_range_latin1_de,
|
||||
@ -2416,7 +2494,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
NULL, /* ismbchar */
|
||||
NULL, /* ismbhead */
|
||||
NULL, /* mbcharlen */
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_8bit,
|
||||
my_casedn_str_8bit,
|
||||
my_caseup_8bit,
|
||||
my_casedn_8bit,
|
||||
my_strcasecmp_8bit,
|
||||
my_strncasecmp_8bit,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2429,8 +2513,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_latin2,
|
||||
sort_order_latin2,
|
||||
0, /* strxfrm_multiply */
|
||||
NULL, /* strcoll */
|
||||
NULL, /* strxfrm */
|
||||
NULL, /* strnncoll */
|
||||
NULL, /* strnxfrm */
|
||||
NULL, /* like_range */
|
||||
@ -2438,7 +2520,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
NULL, /* ismbchar */
|
||||
NULL, /* ismbhead */
|
||||
NULL, /* mbcharlen */
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_8bit,
|
||||
my_casedn_str_8bit,
|
||||
my_caseup_8bit,
|
||||
my_casedn_8bit,
|
||||
my_strcasecmp_8bit,
|
||||
my_strncasecmp_8bit,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2451,8 +2539,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_latin5,
|
||||
sort_order_latin5,
|
||||
0, /* strxfrm_multiply */
|
||||
NULL, /* strcoll */
|
||||
NULL, /* strxfrm */
|
||||
NULL, /* strnncoll */
|
||||
NULL, /* strnxfrm */
|
||||
NULL, /* like_range */
|
||||
@ -2460,7 +2546,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
NULL, /* ismbchar */
|
||||
NULL, /* ismbhead */
|
||||
NULL, /* mbcharlen */
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_8bit,
|
||||
my_casedn_str_8bit,
|
||||
my_caseup_8bit,
|
||||
my_casedn_8bit,
|
||||
my_strcasecmp_8bit,
|
||||
my_strncasecmp_8bit,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2473,8 +2565,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_sjis,
|
||||
sort_order_sjis,
|
||||
1, /* strxfrm_multiply */
|
||||
my_strcoll_sjis,
|
||||
my_strxfrm_sjis,
|
||||
my_strnncoll_sjis,
|
||||
my_strnxfrm_sjis,
|
||||
my_like_range_sjis,
|
||||
@ -2482,7 +2572,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
ismbchar_sjis,
|
||||
ismbhead_sjis,
|
||||
mbcharlen_sjis,
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_8bit,
|
||||
my_casedn_str_8bit,
|
||||
my_caseup_8bit,
|
||||
my_casedn_8bit,
|
||||
my_strcasecmp_8bit,
|
||||
my_strncasecmp_8bit,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2495,8 +2591,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_swe7,
|
||||
sort_order_swe7,
|
||||
0, /* strxfrm_multiply */
|
||||
NULL, /* strcoll */
|
||||
NULL, /* strxfrm */
|
||||
NULL, /* strnncoll */
|
||||
NULL, /* strnxfrm */
|
||||
NULL, /* like_range */
|
||||
@ -2504,7 +2598,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
NULL, /* ismbchar */
|
||||
NULL, /* ismbhead */
|
||||
NULL, /* mbcharlen */
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_8bit,
|
||||
my_casedn_str_8bit,
|
||||
my_caseup_8bit,
|
||||
my_casedn_8bit,
|
||||
my_strcasecmp_8bit,
|
||||
my_strncasecmp_8bit,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2517,8 +2617,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_tis620,
|
||||
sort_order_tis620,
|
||||
4, /* strxfrm_multiply */
|
||||
my_strcoll_tis620,
|
||||
my_strxfrm_tis620,
|
||||
my_strnncoll_tis620,
|
||||
my_strnxfrm_tis620,
|
||||
my_like_range_tis620,
|
||||
@ -2526,7 +2624,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
NULL, /* ismbchar */
|
||||
NULL, /* ismbhead */
|
||||
NULL, /* mbcharlen */
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_8bit,
|
||||
my_casedn_str_8bit,
|
||||
my_caseup_8bit,
|
||||
my_casedn_8bit,
|
||||
my_strcasecmp_8bit,
|
||||
my_strncasecmp_8bit,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2539,8 +2643,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_ujis,
|
||||
sort_order_ujis,
|
||||
0, /* strxfrm_multiply */
|
||||
NULL, /* strcoll */
|
||||
NULL, /* strxfrm */
|
||||
NULL, /* strnncoll */
|
||||
NULL, /* strnxfrm */
|
||||
NULL, /* like_range */
|
||||
@ -2548,7 +2650,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
ismbchar_ujis,
|
||||
ismbhead_ujis,
|
||||
mbcharlen_ujis,
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_mb,
|
||||
my_casedn_str_mb,
|
||||
my_caseup_mb,
|
||||
my_casedn_mb,
|
||||
my_strcasecmp_mb,
|
||||
my_strncasecmp_mb,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2561,8 +2669,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_usa7,
|
||||
sort_order_usa7,
|
||||
0, /* strxfrm_multiply */
|
||||
NULL, /* strcoll */
|
||||
NULL, /* strxfrm */
|
||||
NULL, /* strnncoll */
|
||||
NULL, /* strnxfrm */
|
||||
NULL, /* like_range */
|
||||
@ -2570,7 +2676,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
NULL, /* ismbchar */
|
||||
NULL, /* ismbhead */
|
||||
NULL, /* mbcharlen */
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_8bit,
|
||||
my_casedn_str_8bit,
|
||||
my_caseup_8bit,
|
||||
my_casedn_8bit,
|
||||
my_strcasecmp_8bit,
|
||||
my_strncasecmp_8bit,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2583,8 +2695,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_win1250,
|
||||
sort_order_win1250,
|
||||
0, /* strxfrm_multiply */
|
||||
NULL, /* strcoll */
|
||||
NULL, /* strxfrm */
|
||||
NULL, /* strnncoll */
|
||||
NULL, /* strnxfrm */
|
||||
NULL, /* like_range */
|
||||
@ -2592,7 +2702,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
NULL, /* ismbchar */
|
||||
NULL, /* ismbhead */
|
||||
NULL, /* mbcharlen */
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_8bit,
|
||||
my_casedn_str_8bit,
|
||||
my_caseup_8bit,
|
||||
my_casedn_8bit,
|
||||
my_strcasecmp_8bit,
|
||||
my_strncasecmp_8bit,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2605,8 +2721,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_win1251ukr,
|
||||
sort_order_win1251ukr,
|
||||
0, /* strxfrm_multiply */
|
||||
NULL, /* strcoll */
|
||||
NULL, /* strxfrm */
|
||||
NULL, /* strnncoll */
|
||||
NULL, /* strnxfrm */
|
||||
NULL, /* like_range */
|
||||
@ -2614,7 +2728,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
NULL, /* ismbchar */
|
||||
NULL, /* ismbhead */
|
||||
NULL, /* mbcharlen */
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_8bit,
|
||||
my_casedn_str_8bit,
|
||||
my_caseup_8bit,
|
||||
my_casedn_8bit,
|
||||
my_strcasecmp_8bit,
|
||||
my_strncasecmp_8bit,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2627,8 +2747,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_armscii8,
|
||||
sort_order_armscii8,
|
||||
0, /* strxfrm_multiply */
|
||||
NULL, /* strcoll */
|
||||
NULL, /* strxfrm */
|
||||
NULL, /* strnncoll */
|
||||
NULL, /* strnxfrm */
|
||||
NULL, /* like_range */
|
||||
@ -2636,7 +2754,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
NULL, /* ismbchar */
|
||||
NULL, /* ismbhead */
|
||||
NULL, /* mbcharlen */
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_8bit,
|
||||
my_casedn_str_8bit,
|
||||
my_caseup_8bit,
|
||||
my_casedn_8bit,
|
||||
my_strcasecmp_8bit,
|
||||
my_strncasecmp_8bit,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2649,8 +2773,6 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
to_upper_win1251,
|
||||
sort_order_win1251,
|
||||
0, /* strxfrm_multiply */
|
||||
NULL, /* strcoll */
|
||||
NULL, /* strxfrm */
|
||||
NULL, /* strnncoll */
|
||||
NULL, /* strnxfrm */
|
||||
NULL, /* like_range */
|
||||
@ -2658,7 +2780,13 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
NULL, /* ismbchar */
|
||||
NULL, /* ismbhead */
|
||||
NULL, /* mbcharlen */
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
my_caseup_str_8bit,
|
||||
my_casedn_str_8bit,
|
||||
my_caseup_8bit,
|
||||
my_casedn_8bit,
|
||||
my_strcasecmp_8bit,
|
||||
my_strncasecmp_8bit,
|
||||
0
|
||||
},
|
||||
#endif
|
||||
|
||||
@ -2673,18 +2801,23 @@ CHARSET_INFO compiled_charsets[] = {
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
0,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,NULL,NULL,NULL,NULL,NULL
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
0
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
CHARSET_INFO *default_charset_info = &compiled_charsets[0];
|
||||
CHARSET_INFO *system_charset_info = &compiled_charsets[0];
|
||||
|
||||
CHARSET_INFO *find_compiled_charset(uint cs_number)
|
||||
{
|
||||
|
@ -98,7 +98,7 @@ char *str2int(register const char *src, register int radix, long int lower,
|
||||
converted value (and the scale!) as *negative* numbers,
|
||||
so the sign is the opposite of what you might expect.
|
||||
*/
|
||||
while (isspace(*src)) src++;
|
||||
while (my_isspace(system_charset_info,*src)) src++;
|
||||
sign = -1;
|
||||
if (*src == '+') src++; else
|
||||
if (*src == '-') src++, sign = 1;
|
||||
|
@ -95,7 +95,7 @@ function (const char *nptr,char **endptr,int base)
|
||||
s = nptr;
|
||||
|
||||
/* Skip white space. */
|
||||
while (isspace (*s))
|
||||
while (my_isspace (system_charset_info, *s))
|
||||
++s;
|
||||
if (*s == '\0')
|
||||
{
|
||||
@ -116,7 +116,7 @@ function (const char *nptr,char **endptr,int base)
|
||||
else
|
||||
negative = 0;
|
||||
|
||||
if (base == 16 && s[0] == '0' && toupper (s[1]) == 'X')
|
||||
if (base == 16 && s[0] == '0' && my_toupper (system_charset_info, s[1]) == 'X')
|
||||
s += 2;
|
||||
|
||||
/* If BASE is zero, figure it out ourselves. */
|
||||
@ -124,7 +124,7 @@ function (const char *nptr,char **endptr,int base)
|
||||
{
|
||||
if (*s == '0')
|
||||
{
|
||||
if (toupper (s[1]) == 'X')
|
||||
if (my_toupper (system_charset_into, s[1]) == 'X')
|
||||
{
|
||||
s += 2;
|
||||
base = 16;
|
||||
@ -146,10 +146,10 @@ function (const char *nptr,char **endptr,int base)
|
||||
i = 0;
|
||||
for (c = *s; c != '\0'; c = *++s)
|
||||
{
|
||||
if (isdigit (c))
|
||||
if (my_isdigit (system_charset_info, c))
|
||||
c -= '0';
|
||||
else if (isalpha (c))
|
||||
c = toupper (c) - 'A' + 10;
|
||||
else if (my_isalpha (system_charset_info, c))
|
||||
c = my_toupper (system_charset_into, c) - 'A' + 10;
|
||||
else
|
||||
break;
|
||||
if (c >= base)
|
||||
|
@ -402,8 +402,8 @@ static int exec_line(struct manager_thd* thd,char* buf,char* buf_end)
|
||||
{
|
||||
char* p=buf;
|
||||
struct manager_cmd* cmd;
|
||||
for (;p<buf_end && !isspace(*p);p++)
|
||||
*p=tolower(*p);
|
||||
for (;p<buf_end && !my_isspace(system_charset_info,*p);p++)
|
||||
*p=my_tolower(system_charset_info,*p);
|
||||
log_info("Command '%s'", buf);
|
||||
if (!(cmd=lookup_cmd(buf,(int)(p-buf))))
|
||||
{
|
||||
@ -413,7 +413,7 @@ static int exec_line(struct manager_thd* thd,char* buf,char* buf_end)
|
||||
thd->fatal=1;
|
||||
return 1;
|
||||
}
|
||||
for (;p<buf_end && isspace(*p);p++);
|
||||
for (;p<buf_end && my_isspace(system_charset_info,*p);p++);
|
||||
return cmd->handler_func(thd,p,buf_end);
|
||||
}
|
||||
|
||||
@ -691,7 +691,7 @@ HANDLE_DECL(handle_query)
|
||||
int num_fields,i,ident_len;
|
||||
char* ident,*query;
|
||||
query=ident=args_start;
|
||||
while (!isspace(*query))
|
||||
while (!my_isspace(system_charset_info,*query))
|
||||
query++;
|
||||
if (query == ident)
|
||||
{
|
||||
@ -699,7 +699,7 @@ HANDLE_DECL(handle_query)
|
||||
goto err;
|
||||
}
|
||||
ident_len=(int)(query-ident);
|
||||
while (query<args_end && isspace(*query))
|
||||
while (query<args_end && my_isspace(system_charset_info,*query))
|
||||
query++;
|
||||
if (query == args_end)
|
||||
{
|
||||
@ -976,7 +976,7 @@ static int authenticate(struct manager_thd* thd)
|
||||
for (buf=thd->cmd_buf,p=thd->user,p_end=p+MAX_USER_NAME;
|
||||
buf<buf_end && (c=*buf) && p<p_end; buf++,p++)
|
||||
{
|
||||
if (isspace(c))
|
||||
if (my_isspace(system_charset_info,c))
|
||||
{
|
||||
*p=0;
|
||||
break;
|
||||
@ -989,7 +989,7 @@ static int authenticate(struct manager_thd* thd)
|
||||
if (!(u=(struct manager_user*)hash_search(&user_hash,thd->user,
|
||||
(uint)(p-thd->user))))
|
||||
return 1;
|
||||
for (;isspace(*buf) && buf<buf_end;buf++) /* empty */;
|
||||
for (;my_isspace(system_charset_info,*buf) && buf<buf_end;buf++) /* empty */;
|
||||
|
||||
my_MD5Init(&context);
|
||||
my_MD5Update(&context,(uchar*) buf,(uint)(buf_end-buf));
|
||||
@ -1596,9 +1596,9 @@ static void manager_exec_free(void* e)
|
||||
|
||||
static int hex_val(char c)
|
||||
{
|
||||
if (isdigit(c))
|
||||
if (my_isdigit(system_charset_info,c))
|
||||
return c-'0';
|
||||
c=tolower(c);
|
||||
c=my_tolower(system_charset_info,c);
|
||||
return c-'a'+10;
|
||||
}
|
||||
|
||||
|
Loading…
x
Reference in New Issue
Block a user