MySQL 5.1: mysql/src/5.1-dbg/libmysql/ctype-simple.c File Reference

mysql/src/5.1-dbg/libmysql/ctype-simple.c File Reference

#include <my_global.h>
#include "m_string.h"
#include "m_ctype.h"
#include <errno.h>
#include "stdarg.h"

Include dependency graph for ctype-simple.c:


Classes
struct	uni_idx
Defines
#define	likeconv(s, A) (uchar) (s)->sort_order[(uchar) (A)]
#define	INC_PTR(cs, A, B) (A)++
#define	PLANE_SIZE 0x100
#define	PLANE_NUM 0x100
#define	PLANE_NUMBER(x) (((x)>>8) % PLANE_NUM)
Functions
uint	my_strnxfrmlen_simple (CHARSET_INFO *cs, uint len)
int	my_strnxfrm_simple (CHARSET_INFO cs, uchar dest, uint len, const uchar *src, uint srclen)
int	my_strnncoll_simple (CHARSET_INFO cs, const uchar s, uint slen, const uchar *t, uint tlen, my_bool t_is_prefix)
int	my_strnncollsp_simple (CHARSET_INFO cs, const uchar a, uint a_length, const uchar *b, uint b_length, my_bool diff_if_only_endspace_difference)
void	my_caseup_str_8bit (CHARSET_INFO cs, char str)
void	my_casedn_str_8bit (CHARSET_INFO cs, char str)
uint	my_caseup_8bit (CHARSET_INFO cs, char src, uint srclen, char *dst __attribute__((unused)), uint dstlen __attribute__((unused)))
uint	my_casedn_8bit (CHARSET_INFO cs, char src, uint srclen, char *dst __attribute__((unused)), uint dstlen __attribute__((unused)))
int	my_strcasecmp_8bit (CHARSET_INFO cs, const char s, const char *t)
int	my_mb_wc_8bit (CHARSET_INFO cs, my_wc_t wc, const unsigned char str, const unsigned char end __attribute__((unused)))
int	my_wc_mb_8bit (CHARSET_INFO cs, my_wc_t wc, unsigned char str, unsigned char *end __attribute__((unused)))
int	my_snprintf_8bit (CHARSET_INFO cs __attribute__((unused)), char to, uint n __attribute__((unused)), const char *fmt,...)
void	my_hash_sort_simple (CHARSET_INFO cs, const uchar key, uint len, ulong nr1, ulong nr2)
long	my_strntol_8bit (CHARSET_INFO cs, const char nptr, uint l, int base, char *endptr, int err)
ulong	my_strntoul_8bit (CHARSET_INFO cs, const char nptr, uint l, int base, char *endptr, int err)
longlong	my_strntoll_8bit (CHARSET_INFO cs __attribute__((unused)), const char nptr, uint l, int base, char *endptr, int err)
ulonglong	my_strntoull_8bit (CHARSET_INFO cs, const char nptr, uint l, int base, char *endptr, int err)
double	my_strntod_8bit (CHARSET_INFO cs __attribute__((unused)), char str, uint length, char *end, int err)
int	my_long10_to_str_8bit (CHARSET_INFO cs __attribute__((unused)), char dst, uint len, int radix, long int val)
int	my_longlong10_to_str_8bit (CHARSET_INFO cs __attribute__((unused)), char dst, uint len, int radix, longlong val)
int	my_wildcmp_8bit (CHARSET_INFO cs, const char str, const char str_end, const char wildstr, const char *wildend, int escape, int w_one, int w_many)
my_bool	my_like_range_simple (CHARSET_INFO cs, const char ptr, uint ptr_length, pbool escape, pbool w_one, pbool w_many, uint res_length, char min_str, char max_str, uint min_length, uint max_length)
ulong	my_scan_8bit (CHARSET_INFO cs, const char str, const char *end, int sq)
void	my_fill_8bit (CHARSET_INFO cs __attribute__((unused)), char s, uint l, int fill)
uint	my_numchars_8bit (CHARSET_INFO cs __attribute__((unused)), const char b, const char *e)
uint	my_numcells_8bit (CHARSET_INFO cs __attribute__((unused)), const char b, const char *e)
uint	my_charpos_8bit (CHARSET_INFO cs __attribute__((unused)), const char b __attribute__((unused)), const char *e __attribute__((unused)), uint pos)
uint	my_well_formed_len_8bit (CHARSET_INFO cs __attribute__((unused)), const char start, const char end, uint nchars, int error)
uint	my_lengthsp_8bit (CHARSET_INFO cs __attribute__((unused)), const char ptr, uint length)
uint	my_instr_simple (CHARSET_INFO cs, const char b, uint b_length, const char s, uint s_length, my_match_t match, uint nmatch)
static int	pcmp (const void f, const void s)
static my_bool	create_fromuni (CHARSET_INFO cs, void (*alloc)(uint))
static my_bool	my_cset_init_8bit (CHARSET_INFO cs, void (*alloc)(uint))
static void	set_max_sort_char (CHARSET_INFO *cs)
static my_bool	my_coll_init_simple (CHARSET_INFO cs, void (*alloc)(uint) __attribute__((unused)))
longlong	my_strtoll10_8bit (CHARSET_INFO cs __attribute__((unused)), const char nptr, char *endptr, int error)
int	my_mb_ctype_8bit (CHARSET_INFO cs, int ctype, const unsigned char s, const unsigned char e)
my_bool	my_propagate_simple (CHARSET_INFO cs __attribute__((unused)), const uchar str __attribute__((unused)), uint length __attribute__((unused)))
my_bool	my_propagate_complex (CHARSET_INFO cs __attribute__((unused)), const uchar str __attribute__((unused)), uint length __attribute__((unused)))
Variables
MY_CHARSET_HANDLER	my_charset_8bit_handler
MY_COLLATION_HANDLER	my_collation_8bit_simple_ci_handler

Define Documentation

#define INC_PTR	(	cs,
		A,
		B	)	(A)++

Definition at line 931 of file ctype-simple.c.

#define likeconv	(	s,
		A		)	(uchar) (s)->sort_order[(uchar) (A)]

Definition at line 928 of file ctype-simple.c.

#define PLANE_NUM 0x100

Definition at line 1222 of file ctype-simple.c.

Referenced by create_fromuni().

#define PLANE_NUMBER ( x ) (((x)>>8) % PLANE_NUM)

Definition at line 1223 of file ctype-simple.c.

Referenced by create_fromuni().

#define PLANE_SIZE 0x100

Definition at line 1221 of file ctype-simple.c.

Referenced by create_fromuni().

Function Documentation

static my_bool create_fromuni	(	CHARSET_INFO *	cs,
		void ()(uint)	alloc
	)			`[static]`

Definition at line 1236 of file ctype-simple.c.

References bzero, n, pcmp(), PLANE_NUM, PLANE_NUMBER, PLANE_SIZE, qsort(), charset_info_st::tab_to_uni, and TRUE.

Referenced by my_cset_init_8bit().

01237 {
01238   uni_idx       idx[PLANE_NUM];
01239   int           i,n;
01240   
01241   /*
01242     Check that Unicode map is loaded.
01243     It can be not loaded when the collation is
01244     listed in Index.xml but not specified
01245     in the character set specific XML file.
01246   */
01247   if (!cs->tab_to_uni)
01248     return TRUE;
01249   
01250   /* Clear plane statistics */
01251   bzero(idx,sizeof(idx));
01252   
01253   /* Count number of characters in each plane */
01254   for (i=0; i< 0x100; i++)
01255   {
01256     uint16 wc=cs->tab_to_uni[i];
01257     int pl= PLANE_NUMBER(wc);
01258     
01259     if (wc || !i)
01260     {
01261       if (!idx[pl].nchars)
01262       {
01263         idx[pl].uidx.from=wc;
01264         idx[pl].uidx.to=wc;
01265       }else
01266       {
01267         idx[pl].uidx.from=wc<idx[pl].uidx.from?wc:idx[pl].uidx.from;
01268         idx[pl].uidx.to=wc>idx[pl].uidx.to?wc:idx[pl].uidx.to;
01269       }
01270       idx[pl].nchars++;
01271     }
01272   }
01273   
01274   /* Sort planes in descending order */
01275   qsort(&idx,PLANE_NUM,sizeof(uni_idx),&pcmp);
01276   
01277   for (i=0; i < PLANE_NUM; i++)
01278   {
01279     int ch,numchars;
01280     
01281     /* Skip empty plane */
01282     if (!idx[i].nchars)
01283       break;
01284     
01285     numchars=idx[i].uidx.to-idx[i].uidx.from+1;
01286     if (!(idx[i].uidx.tab=(uchar*) alloc(numchars * sizeof(*idx[i].uidx.tab))))
01287       return TRUE;
01288     
01289     bzero(idx[i].uidx.tab,numchars*sizeof(*idx[i].uidx.tab));
01290     
01291     for (ch=1; ch < PLANE_SIZE; ch++)
01292     {
01293       uint16 wc=cs->tab_to_uni[ch];
01294       if (wc >= idx[i].uidx.from && wc <= idx[i].uidx.to && wc)
01295       {
01296         int ofs= wc - idx[i].uidx.from;
01297         idx[i].uidx.tab[ofs]= ch;
01298       }
01299     }
01300   }
01301   
01302   /* Allocate and fill reverse table for each plane */
01303   n=i;
01304   if (!(cs->tab_from_uni= (MY_UNI_IDX*) alloc(sizeof(MY_UNI_IDX)*(n+1))))
01305     return TRUE;
01306 
01307   for (i=0; i< n; i++)
01308     cs->tab_from_uni[i]= idx[i].uidx;
01309   
01310   /* Set end-of-list marker */
01311   bzero(&cs->tab_from_uni[i],sizeof(MY_UNI_IDX));
01312   return FALSE;
01313 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint my_casedn_8bit	(	CHARSET_INFO *	cs,
		char *	src,
		uint	srclen,
		char *dst	__attribute__((unused)),
		uint dstlen	__attribute__((unused))
	)

Definition at line 216 of file ctype-simple.c.

References DBUG_ASSERT, map, and charset_info_st::to_lower.

00219 {
00220   uint srclen0= srclen;
00221   register uchar *map=cs->to_lower;
00222   DBUG_ASSERT(src == dst && srclen == dstlen);
00223   for ( ; srclen > 0 ; srclen--, src++)
00224     *src= (char) map[(uchar) *src];
00225   return srclen0;
00226 }

void my_casedn_str_8bit	(	CHARSET_INFO *	cs,
		char *	str
	)

Definition at line 197 of file ctype-simple.c.

References map, and charset_info_st::to_lower.

00198 {
00199   register uchar *map=cs->to_lower;
00200   while ((*str = (char) map[(uchar)*str]) != 0)
00201     str++;
00202 }

uint my_caseup_8bit	(	CHARSET_INFO *	cs,
		char *	src,
		uint	srclen,
		char *dst	__attribute__((unused)),
		uint dstlen	__attribute__((unused))
	)

Definition at line 204 of file ctype-simple.c.

References DBUG_ASSERT, map, and charset_info_st::to_upper.

00207 {
00208   uint srclen0= srclen;
00209   register uchar *map= cs->to_upper;
00210   DBUG_ASSERT(src == dst && srclen == dstlen);
00211   for ( ; srclen > 0 ; srclen--, src++)
00212     *src= (char) map[(uchar) *src];
00213   return srclen0;
00214 }

void my_caseup_str_8bit	(	CHARSET_INFO *	cs,
		char *	str
	)

Definition at line 190 of file ctype-simple.c.

References map, and charset_info_st::to_upper.

00191 {
00192   register uchar *map=cs->to_upper;
00193   while ((*str = (char) map[(uchar) *str]) != 0)
00194     str++;
00195 }

uint my_charpos_8bit	(	CHARSET_INFO *cs	__attribute__((unused)),
		const char *b	__attribute__((unused)),
		const char *e	__attribute__((unused)),
		uint	pos
	)

Definition at line 1126 of file ctype-simple.c.

01130 {
01131   return pos;
01132 }

static my_bool my_coll_init_simple	(	CHARSET_INFO *	cs,
		void *	(*)(uint) __attribute__ alloc((unused))
	)			`[static]`

Definition at line 1342 of file ctype-simple.c.

References FALSE, and set_max_sort_char().

01344 {
01345   set_max_sort_char(cs);
01346   return FALSE;
01347 }

Here is the call graph for this function:

static my_bool my_cset_init_8bit	(	CHARSET_INFO *	cs,
		void ()(uint)	alloc
	)			`[static]`

Definition at line 1315 of file ctype-simple.c.

References charset_info_st::casedn_multiply, charset_info_st::caseup_multiply, create_fromuni(), and charset_info_st::pad_char.

01316 {
01317   cs->caseup_multiply= 1;
01318   cs->casedn_multiply= 1;
01319   cs->pad_char= ' ';
01320   return create_fromuni(cs, alloc);
01321 }

Here is the call graph for this function:

void my_fill_8bit	(	CHARSET_INFO *cs	__attribute__((unused)),
		char *	s,
		uint	l,
		int	fill
	)

Definition at line 1105 of file ctype-simple.c.

References bfill.

01107 {
01108   bfill(s,l,fill);
01109 }

void my_hash_sort_simple	(	CHARSET_INFO *	cs,
		const uchar *	key,
		uint	len,
		ulong *	nr1,
		ulong *	nr2
	)

Definition at line 289 of file ctype-simple.c.

References charset_info_st::sort_order, and sort_order.

00292 {
00293   register uchar *sort_order=cs->sort_order;
00294   const uchar *end= key + len;
00295   
00296   /*
00297     Remove end space. We have to do this to be able to compare
00298     'A ' and 'A' as identical
00299   */
00300   while (end > key && end[-1] == ' ')
00301     end--;
00302   
00303   for (; key < (uchar*) end ; key++)
00304   {
00305     nr1[0]^=(ulong) ((((uint) nr1[0] & 63)+nr2[0]) * 
00306              ((uint) sort_order[(uint) *key])) + (nr1[0] << 8);
00307     nr2[0]+=3;
00308   }
00309 }

uint my_instr_simple	(	CHARSET_INFO *	cs,
		const char *	b,
		uint	b_length,
		const char *	s,
		uint	s_length,
		my_match_t *	match,
		uint	nmatch
	)

Definition at line 1155 of file ctype-simple.c.

References my_match_t::beg, my_match_t::end, my_match_t::mblen, search_end(), skip(), and charset_info_st::sort_order.

01159 {
01160   register const uchar *str, *search, *end, *search_end;
01161   
01162   if (s_length <= b_length)
01163   {
01164     if (!s_length)
01165     {
01166       if (nmatch)
01167       {
01168         match->beg= 0;
01169         match->end= 0;
01170         match->mblen= 0;
01171       }
01172       return 1;         /* Empty string is always found */
01173     }
01174     
01175     str= (const uchar*) b;
01176     search= (const uchar*) s;
01177     end= (const uchar*) b+b_length-s_length+1;
01178     search_end= (const uchar*) s + s_length;
01179     
01180 skip:
01181     while (str != end)
01182     {
01183       if (cs->sort_order[*str++] == cs->sort_order[*search])
01184       {
01185         register const uchar *i,*j;
01186         
01187         i= str; 
01188         j= search+1;
01189         
01190         while (j != search_end)
01191           if (cs->sort_order[*i++] != cs->sort_order[*j++]) 
01192             goto skip;
01193         
01194         if (nmatch > 0)
01195         {
01196           match[0].beg= 0;
01197           match[0].end= (uint) (str- (const uchar*)b-1);
01198           match[0].mblen= match[0].end;
01199           
01200           if (nmatch > 1)
01201           {
01202             match[1].beg= match[0].end;
01203             match[1].end= match[0].end+s_length;
01204             match[1].mblen= match[1].end-match[1].beg;
01205           }
01206         }
01207         return 2;
01208       }
01209     }
01210   }
01211   return 0;
01212 }

Here is the call graph for this function:

uint my_lengthsp_8bit	(	CHARSET_INFO *cs	__attribute__((unused)),
		const char *	ptr,
		uint	length
	)

Definition at line 1145 of file ctype-simple.c.

01147 {
01148   const char *end= ptr+length;
01149   while (end > ptr && end[-1] == ' ')
01150     end--;
01151   return (uint) (end-ptr);
01152 }

my_bool my_like_range_simple	(	CHARSET_INFO *	cs,
		const char *	ptr,
		uint	ptr_length,
		pbool	escape,
		pbool	w_one,
		pbool	w_many,
		uint	res_length,
		char *	min_str,
		char *	max_str,
		uint *	min_length,
		uint *	max_length
	)

Definition at line 1030 of file ctype-simple.c.

References charset_info_st::max_sort_char, charset_info_st::mbmaxlen, MY_CS_BINSORT, and charset_info_st::state.

01036 {
01037   const char *end= ptr + ptr_length;
01038   char *min_org=min_str;
01039   char *min_end=min_str+res_length;
01040   uint charlen= res_length / cs->mbmaxlen;
01041 
01042   for (; ptr != end && min_str != min_end && charlen > 0 ; ptr++, charlen--)
01043   {
01044     if (*ptr == escape && ptr+1 != end)
01045     {
01046       ptr++;                                    /* Skip escape */
01047       *min_str++= *max_str++ = *ptr;
01048       continue;
01049     }
01050     if (*ptr == w_one)                          /* '_' in SQL */
01051     {
01052       *min_str++='\0';                          /* This should be min char */
01053       *max_str++= (char) cs->max_sort_char;
01054       continue;
01055     }
01056     if (*ptr == w_many)                         /* '%' in SQL */
01057     {
01058       /* Calculate length of keys */
01059       *min_length= ((cs->state & MY_CS_BINSORT) ? (uint) (min_str - min_org) :
01060                     res_length);
01061       *max_length= res_length;
01062       do
01063       {
01064         *min_str++= 0;
01065         *max_str++= (char) cs->max_sort_char;
01066       } while (min_str != min_end);
01067       return 0;
01068     }
01069     *min_str++= *max_str++ = *ptr;
01070   }
01071 
01072  *min_length= *max_length = (uint) (min_str - min_org);
01073   while (min_str != min_end)
01074     *min_str++= *max_str++ = ' ';      /* Because if key compression */
01075   return 0;
01076 }

int my_long10_to_str_8bit	(	CHARSET_INFO *cs	__attribute__((unused)),
		char *	dst,
		uint	len,
		int	radix,
		long int	val
	)

Definition at line 827 of file ctype-simple.c.

References buffer, e, memcpy, min, and p.

00829 {
00830   char buffer[66];
00831   register char *p, *e;
00832   long int new_val;
00833   uint sign=0;
00834 
00835   e = p = &buffer[sizeof(buffer)-1];
00836   *p= 0;
00837   
00838   if (radix < 0)
00839   {
00840     if (val < 0)
00841     {
00842       val= -val;
00843       *dst++= '-';
00844       len--;
00845       sign= 1;
00846     }
00847   }
00848   
00849   new_val = (long) ((unsigned long int) val / 10);
00850   *--p    = '0'+ (char) ((unsigned long int) val - (unsigned long) new_val * 10);
00851   val     = new_val;
00852   
00853   while (val != 0)
00854   {
00855     new_val=val/10;
00856     *--p = '0' + (char) (val-new_val*10);
00857     val= new_val;
00858   }
00859   
00860   len= min(len, (uint) (e-p));
00861   memcpy(dst, p, len);
00862   return (int) len+sign;
00863 }

int my_longlong10_to_str_8bit	(	CHARSET_INFO *cs	__attribute__((unused)),
		char *	dst,
		uint	len,
		int	radix,
		longlong	val
	)

Definition at line 866 of file ctype-simple.c.

References buffer, e, memcpy, min, and p.

00868 {
00869   char buffer[65];
00870   register char *p, *e;
00871   long long_val;
00872   uint sign= 0;
00873   
00874   if (radix < 0)
00875   {
00876     if (val < 0)
00877     {
00878       val = -val;
00879       *dst++= '-';
00880       len--;
00881       sign= 1;
00882     }
00883   }
00884   
00885   e = p = &buffer[sizeof(buffer)-1];
00886   *p= 0;
00887   
00888   if (val == 0)
00889   {
00890     *--p= '0';
00891     len= 1;
00892     goto cnv;
00893   }
00894   
00895   while ((ulonglong) val > (ulonglong) LONG_MAX)
00896   {
00897     ulonglong quo=(ulonglong) val/(uint) 10;
00898     uint rem= (uint) (val- quo* (uint) 10);
00899     *--p = '0' + rem;
00900     val= quo;
00901   }
00902   
00903   long_val= (long) val;
00904   while (long_val != 0)
00905   {
00906     long quo= long_val/10;
00907     *--p = (char) ('0' + (long_val - quo*10));
00908     long_val= quo;
00909   }
00910   
00911   len= min(len, (uint) (e-p));
00912 cnv:
00913   memcpy(dst, p, len);
00914   return len+sign;
00915 }

int my_mb_ctype_8bit	(	CHARSET_INFO *	cs,
		int *	ctype,
		const unsigned char *	s,
		const unsigned char *	e
	)

Definition at line 1357 of file ctype-simple.c.

References charset_info_st::ctype, and MY_CS_TOOSMALL.

01359 {
01360   if (s >= e)
01361   {
01362     *ctype= 0;
01363     return MY_CS_TOOSMALL;
01364   }
01365   *ctype= cs->ctype[*s + 1];
01366   return 1;
01367 }

int my_mb_wc_8bit	(	CHARSET_INFO *	cs,
		my_wc_t *	wc,
		const unsigned char *	str,
		const unsigned char *end	__attribute__((unused))
	)

Definition at line 237 of file ctype-simple.c.

References MY_CS_TOOSMALL, and charset_info_st::tab_to_uni.

00240 {
00241   if (str >= end)
00242     return MY_CS_TOOSMALL;
00243   
00244   *wc=cs->tab_to_uni[*str];
00245   return (!wc[0] && str[0]) ? -1 : 1;
00246 }

uint my_numcells_8bit	(	CHARSET_INFO *cs	__attribute__((unused)),
		const char *	b,
		const char *	e
	)

Definition at line 1119 of file ctype-simple.c.

01121 {
01122   return (uint) (e - b);
01123 }

uint my_numchars_8bit	(	CHARSET_INFO *cs	__attribute__((unused)),
		const char *	b,
		const char *	e
	)

Definition at line 1112 of file ctype-simple.c.

01114 {
01115   return (uint) (e - b);
01116 }

my_bool my_propagate_complex	(	CHARSET_INFO *cs	__attribute__((unused)),
		const uchar *str	__attribute__((unused)),
		uint length	__attribute__((unused))
	)

Definition at line 1416 of file ctype-simple.c.

01419 {
01420   return 0;
01421 }

my_bool my_propagate_simple	(	CHARSET_INFO *cs	__attribute__((unused)),
		const uchar *str	__attribute__((unused)),
		uint length	__attribute__((unused))
	)

Definition at line 1408 of file ctype-simple.c.

01411 {
01412   return 1;
01413 }

ulong my_scan_8bit	(	CHARSET_INFO *	cs,
		const char *	str,
		const char *	end,
		int	sq
	)

Definition at line 1079 of file ctype-simple.c.

References my_isspace, MY_SEQ_INTTAIL, and MY_SEQ_SPACES.

01080 {
01081   const char *str0= str;
01082   switch (sq)
01083   {
01084   case MY_SEQ_INTTAIL:
01085     if (*str == '.')
01086     {
01087       for(str++ ; str != end && *str == '0' ; str++);
01088       return (ulong) (str - str0);
01089     }
01090     return 0;
01091 
01092   case MY_SEQ_SPACES:
01093     for ( ; str < end ; str++)
01094     {
01095       if (!my_isspace(cs,*str))
01096         break;
01097     }
01098     return (ulong) (str - str0);
01099   default:
01100     return 0;
01101   }
01102 }

int my_snprintf_8bit	(	CHARSET_INFO *cs	__attribute__((unused)),
		char *	to,
		uint n	__attribute__((unused)),
		const char *	fmt,
			...
	)

Definition at line 276 of file ctype-simple.c.

References args, my_vsnprintf(), and n.

00279 {
00280   va_list args;
00281   int result;
00282   va_start(args,fmt);
00283   result= my_vsnprintf(to, n, fmt, args);
00284   va_end(args);
00285   return result;
00286 }

Here is the call graph for this function:

int my_strcasecmp_8bit	(	CHARSET_INFO *	cs,
		const char *	s,
		const char *	t
	)

Definition at line 228 of file ctype-simple.c.

References map, and charset_info_st::to_upper.

00229 {
00230   register uchar *map=cs->to_upper;
00231   while (map[(uchar) *s] == map[(uchar) *t++])
00232     if (!*s++) return 0;
00233   return ((int) map[(uchar) s[0]] - (int) map[(uchar) t[-1]]);
00234 }

int my_strnncoll_simple

mysql/src/5.1-dbg/libmysql/ctype-simple.c File Reference

Classes

Defines

Functions

Variables

Define Documentation

Function Documentation