caiyu/gmio
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

gmio_core/internal: rename gmio_clocale_xxx() -> gmio_ascii_xxx()

Browse Source
This commit is contained in:
Hugues Delorme 2015-10-29 15:23:21 +01:00
parent e4b7753fea
commit 2f282d6c29
8 changed files with 123 additions and 191 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/gmio_core/internal/fast_atof.h
View File

@ -61,7 +61,7 @@ GMIO_INLINE uint32_t strtoul10(const char* in, const char** out)
gmio_bool_t overflow=GMIO_FALSE; gmio_bool_t overflow=GMIO_FALSE;
uint32_t unsignedValue = 0; uint32_t unsignedValue = 0;
while ( gmio_clocale_isdigit(*in) ) while ( gmio_ascii_isdigit(*in) )
{ {
const uint32_t tmp = ( unsignedValue * 10 ) + ( *in - '0' ); const uint32_t tmp = ( unsignedValue * 10 ) + ( *in - '0' );
if (tmp<unsignedValue) if (tmp<unsignedValue)
@ -150,7 +150,7 @@ GMIO_INLINE uint32_t strtoul16(const char* in, const char** out)
for (;;) for (;;)
{ {
uint32_t tmp = 0; uint32_t tmp = 0;
if (gmio_clocale_isdigit(*in)) if (gmio_ascii_isdigit(*in))
tmp = (unsignedValue << 4u) + (*in - '0'); tmp = (unsignedValue << 4u) + (*in - '0');
else if ((*in >= 'A') && (*in <= 'F')) else if ((*in >= 'A') && (*in <= 'F'))
tmp = (unsignedValue << 4u) + (*in - 'A') + 10; tmp = (unsignedValue << 4u) + (*in - 'A') + 10;
@ -242,7 +242,7 @@ GMIO_INLINE gmio_float32_t strtof10(const char* in, const char** out)
/* Use integer arithmetic for as long as possible, for speed /* Use integer arithmetic for as long as possible, for speed
* and precision. */ * and precision. */
while ( gmio_clocale_isdigit(*in) ) while ( gmio_ascii_isdigit(*in) )
{ {
/* If it looks like we're going to overflow, bail out /* If it looks like we're going to overflow, bail out
now and start using floating point. */ now and start using floating point. */
@ -254,7 +254,7 @@ GMIO_INLINE gmio_float32_t strtof10(const char* in, const char** out)
floatValue = (gmio_float32_t)intValue; floatValue = (gmio_float32_t)intValue;
/* If there are any digits left to parse, then we need to use /* If there are any digits left to parse, then we need to use
* floating point arithmetic from here. */ * floating point arithmetic from here. */
while ( gmio_clocale_isdigit(*in) ) while ( gmio_ascii_isdigit(*in) )
{ {
floatValue = (floatValue * 10.f) + (gmio_float32_t)(*in - '0'); floatValue = (floatValue * 10.f) + (gmio_float32_t)(*in - '0');
++in; ++in;

2
src/gmio_core/internal/string_parse.c
View File

@ -49,7 +49,7 @@ gmio_eat_word_error_t gmio_eat_word(
++i; ++i;
} while(i < str_capacity } while(i < str_capacity
&& stream_curr_char != NULL && stream_curr_char != NULL
&& !gmio_clocale_isspace(*stream_curr_char)); && !gmio_ascii_isspace(*stream_curr_char));
if (i < str_capacity) { if (i < str_capacity) {
str_ptr[i] = 0; /* End string with terminating null byte */ str_ptr[i] = 0; /* End string with terminating null byte */

4
src/gmio_core/internal/string_parse.h
View File

@ -138,7 +138,7 @@ const char* gmio_skip_spaces(
gmio_string_stream_fwd_iterator_t* it) gmio_string_stream_fwd_iterator_t* it)
{ {
const char* curr_char = gmio_current_char(it); const char* curr_char = gmio_current_char(it);
while (curr_char != NULL && gmio_clocale_isspace(*curr_char)) while (curr_char != NULL && gmio_ascii_isspace(*curr_char))
curr_char = gmio_next_char(it); curr_char = gmio_next_char(it);
return curr_char; return curr_char;
} }
@ -148,7 +148,7 @@ void gmio_copy_spaces(
{ {
const char* curr_char = gmio_current_char(it); const char* curr_char = gmio_current_char(it);
while (curr_char != NULL while (curr_char != NULL
&& gmio_clocale_isspace(*curr_char) && gmio_ascii_isspace(*curr_char)
&& str->len < str->max_len) && str->len < str->max_len)
{ {
str->ptr[str->len] = *curr_char; str->ptr[str->len] = *curr_char;

148
src/gmio_core/internal/string_utils.h
View File

@ -18,43 +18,42 @@
#include "../global.h" #include "../global.h"
/*! Returns non-zero if \p c is a space (for C-locale), zero otherwise */ /*! Returns non-zero if \p c is a space, zero otherwise */
GMIO_INLINE int gmio_clocale_isspace(char c); GMIO_INLINE int gmio_ascii_isspace(char c);
/*! Returns non-zero if \p c is a digit (for C-locale), zero otherwise */ /*! Returns non-zero if \p c is a digit, zero otherwise */
GMIO_INLINE int gmio_clocale_isdigit(char c); GMIO_INLINE int gmio_ascii_isdigit(char c);
/*! Returns non-zero if \p c is an uppercase letter (for C-locale), zero /*! Returns non-zero if \p c is an uppercase letter, zero otherwise */
* otherwise */ GMIO_INLINE int gmio_ascii_isupper(char c);
GMIO_INLINE int gmio_clocale_isupper(char c);
/*! Returns non-zero if \p c is a lowercase letter (for C-locale), zero /*! Returns non-zero if \p c is a lowercase letter, zero otherwise */
* otherwise */ GMIO_INLINE int gmio_ascii_islower(char c);
GMIO_INLINE int gmio_clocale_islower(char c);
/*! Returns the lowercase letter converted to uppercase */ /*! Returns the lowercase letter converted to uppercase */
GMIO_INLINE char gmio_clocale_toupper(char c); GMIO_INLINE char gmio_ascii_toupper(char c);
/*! Returns the uppercase letter converted to lowercase */ /*! Returns the uppercase letter converted to lowercase */
GMIO_INLINE char gmio_clocale_tolower(char c); GMIO_INLINE char gmio_ascii_tolower(char c);
/*! Returns true if \p c1 compare equals to \p c2 /*! Returns 0 if \p c1 compare equals to \p c2, non-zero otherwise
* *
* Comparison is case-insensitive * Comparison is case-insensitive
*/ */
GMIO_INLINE gmio_bool_t gmio_clocale_char_iequals(char c1, char c2); GMIO_INLINE gmio_bool_t gmio_ascii_char_iequals(char c1, char c2);
/*! Returns 0 if \p str1 and \p str2 compare equal, non-zero otherwise /*! Returns 0 if \p str1 and \p str2 compare equal, non-zero otherwise
* *
* Comparison is case-insensitive * Comparison is case-insensitive
*/ */
GMIO_INLINE int gmio_stricmp(const char* str1, const char* str2); GMIO_INLINE int gmio_ascii_stricmp(const char* str1, const char* str2);
/*! Returns true if \p str starts with string \p begin /*! Returns true if \p str starts with string \p begin
* *
* Comparison is case-insensitive * Comparison is case-insensitive
*/ */
GMIO_INLINE gmio_bool_t gmio_istarts_with(const char* str, const char* begin); GMIO_INLINE gmio_bool_t gmio_ascii_istarts_with(
const char* str, const char* begin);
@ -68,7 +67,7 @@ GMIO_INLINE gmio_bool_t gmio_istarts_with(const char* str, const char* begin);
# include <ctype.h> # include <ctype.h>
#endif #endif
int gmio_clocale_isspace(char c) int gmio_ascii_isspace(char c)
{ {
/* 0x20 : space (SPC) /* 0x20 : space (SPC)
* 0x09 : horizontal tab (TAB) * 0x09 : horizontal tab (TAB)
@ -79,115 +78,42 @@ int gmio_clocale_isspace(char c)
#if defined(GMIO_STRINGUTILS_DIRECT_TESTS) #if defined(GMIO_STRINGUTILS_DIRECT_TESTS)
/* TODO: eliminate branch */ /* TODO: eliminate branch */
return c == 0x20 || ((uint8_t)(c - 0x09) < 5); return c == 0x20 || ((uint8_t)(c - 0x09) < 5);
#elif defined(GMIO_STRINGUTILS_C_ARRAYS)
static const unsigned char space_chars[] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
return space_chars[c];
#elif defined(GMIO_STRINGUTILS_CTYPE_H) #elif defined(GMIO_STRINGUTILS_CTYPE_H)
return isspace(c); return isspace(c);
#endif #endif
} }
int gmio_clocale_isdigit(char c) int gmio_ascii_isdigit(char c)
{ {
static const unsigned char digit_chars[] = { /* 48 <= c <= 57 */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, #if defined(GMIO_STRINGUTILS_DIRECT_TESTS)
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, return (uint8_t) (c - 48) < 10;
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, #elif defined(GMIO_STRINGUTILS_CTYPE_H)
1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 0, 0, 0, 0, 0, 0, return isdigit(c);
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, #endif
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
return digit_chars[(unsigned char)c];
} }
int gmio_clocale_isupper(char c) int gmio_ascii_isupper(char c)
{ {
/* 65 <= c <= 90; */
#if defined(GMIO_STRINGUTILS_DIRECT_TESTS) #if defined(GMIO_STRINGUTILS_DIRECT_TESTS)
/* TODO: eliminate branch */ return (uint8_t) (c - 65) < 26;
return 65 <= c && c <= 90;
#elif defined(GMIO_STRINGUTILS_C_ARRAYS)
static const unsigned char upper_chars[] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
return upper_chars[c];
#elif defined(GMIO_STRINGUTILS_CTYPE_H) #elif defined(GMIO_STRINGUTILS_CTYPE_H)
return isupper(c); return isupper(c);
#endif #endif
} }
int gmio_clocale_islower(char c) int gmio_ascii_islower(char c)
{ {
/* 97 <= c <= 122; */
#if defined(GMIO_STRINGUTILS_DIRECT_TESTS) #if defined(GMIO_STRINGUTILS_DIRECT_TESTS)
/* TODO: eliminate branch */ return (unsigned) (c - 97) < 26;
return 97 <= c && c <= 122;
#elif defined(GMIO_STRINGUTILS_C_ARRAYS)
static const unsigned char lower_chars[] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
return lower_chars[c];
#elif defined(GMIO_STRINGUTILS_CTYPE_H) #elif defined(GMIO_STRINGUTILS_CTYPE_H)
return islower(c); return islower(c);
#endif #endif
} }
char gmio_clocale_toupper(char c) char gmio_ascii_toupper(char c)
{ {
static const char table_toupper[128] = { static const char table_toupper[128] = {
0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ,0x09,0x0A, 0 , 0 ,0x0D, 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ,0x09,0x0A, 0 , 0 ,0x0D, 0 , 0 ,
@ -202,7 +128,7 @@ char gmio_clocale_toupper(char c)
return table_toupper[(unsigned char)c]; return table_toupper[(unsigned char)c];
} }
char gmio_clocale_tolower(char c) char gmio_ascii_tolower(char c)
{ {
static const char table_tolower[128] = { static const char table_tolower[128] = {
0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ,0x09,0x0A, 0 , 0 ,0x0D, 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ,0x09,0x0A, 0 , 0 ,0x0D, 0 , 0 ,
@ -217,16 +143,16 @@ char gmio_clocale_tolower(char c)
return table_tolower[(unsigned char)c]; return table_tolower[(unsigned char)c];
} }
gmio_bool_t gmio_clocale_char_iequals(char c1, char c2) gmio_bool_t gmio_ascii_char_iequals(char c1, char c2)
{ {
/* TODO: eliminate branch */ /* TODO: eliminate branch */
return c1 == c2 || (gmio_clocale_toupper(c1) == gmio_clocale_toupper(c2)); return c1 == c2 || (gmio_ascii_toupper(c1) == gmio_ascii_toupper(c2));
} }
int gmio_stricmp(const char* str1, const char* str2) int gmio_ascii_stricmp(const char* str1, const char* str2)
{ {
while (*str1 != 0 && *str2 != 0) { while (*str1 != 0 && *str2 != 0) {
if (!gmio_clocale_char_iequals(*str1, *str2)) if (!gmio_ascii_char_iequals(*str1, *str2))
return 1; return 1;
++str1; ++str1;
++str2; ++str2;
@ -234,10 +160,10 @@ int gmio_stricmp(const char* str1, const char* str2)
return *str1 == 0 && *str2 == 0 ? 0 : 1; return *str1 == 0 && *str2 == 0 ? 0 : 1;
} }
gmio_bool_t gmio_istarts_with(const char* str, const char* begin) gmio_bool_t gmio_ascii_istarts_with(const char* str, const char* begin)
{ {
while (*begin != 0) { while (*begin != 0) {
if (*str == 0 || !gmio_clocale_char_iequals(*str, *begin)) if (*str == 0 || !gmio_ascii_char_iequals(*str, *begin))
return GMIO_FALSE; return GMIO_FALSE;
++str; ++str;
++begin; ++begin;

6
src/gmio_stl/stl_format.c
View File

@ -74,13 +74,13 @@ gmio_stl_format_t gmio_stl_get_format(gmio_stream_t *stream)
{ {
/* Skip spaces at beginning */ /* Skip spaces at beginning */
size_t pos = 0; size_t pos = 0;
while (pos < read_size && gmio_clocale_isspace(fixed_buffer[pos])) while (pos < read_size && gmio_ascii_isspace(fixed_buffer[pos]))
++pos; ++pos;
/* Next token (if exists) must match "solid\s" */ /* Next token (if exists) must match "solid\s" */
if ((pos + 6) < read_size if ((pos + 6) < read_size
&& gmio_istarts_with(fixed_buffer + pos, "solid") && gmio_ascii_istarts_with(fixed_buffer + pos, "solid")
&& gmio_clocale_isspace(fixed_buffer[pos + 5])) && gmio_ascii_isspace(fixed_buffer[pos + 5]))
{ {
return GMIO_STL_FORMAT_ASCII; return GMIO_STL_FORMAT_ASCII;
} }

64
src/gmio_stl/stla_read.c
View File

@ -82,21 +82,8 @@
/* Fixed maximum length of any string user in this source file */ /* Fixed maximum length of any string user in this source file */
enum { GMIO_STLA_READ_STRING_MAX_LEN = 1024 }; enum { GMIO_STLA_READ_STRING_MAX_LEN = 1024 };
/* gmio_stream_fwd_iterator_stla_cookie */
typedef struct
{
/* Copy of gmio_stla_read() corresponding argument */
gmio_transfer_t* transfer;
/* Cache for gmio_stream_size(&transfer->stream) */
size_t stream_size;
/* Offset (in bytes) from beginning of stream : current position */
size_t stream_offset;
/* Cache for gmio_transfer::func_is_stop_requested() */
gmio_bool_t is_stop_requested;
} gmio_string_stream_fwd_iterator_cookie_t;
/* gmio_stla_token */ /* gmio_stla_token */
typedef enum enum gmio_stla_token
{ {
null_token = 0, null_token = 0,
ENDFACET_token, ENDFACET_token,
@ -112,7 +99,8 @@ typedef enum
FLOAT_token = ID_token, FLOAT_token = ID_token,
empty_token, empty_token,
unknown_token unknown_token
} gmio_stla_token_t; };
typedef enum gmio_stla_token gmio_stla_token_t;
static const char gmio_stla_tokstr_ENDFACET[] = "endfacet"; static const char gmio_stla_tokstr_ENDFACET[] = "endfacet";
static const char gmio_stla_tokstr_ENDLOOP[] = "endloop"; static const char gmio_stla_tokstr_ENDLOOP[] = "endloop";
@ -124,10 +112,10 @@ static const char gmio_stla_tokstr_OUTER[] = "outer";
static const char gmio_stla_tokstr_SOLID[] = "solid"; static const char gmio_stla_tokstr_SOLID[] = "solid";
static const char gmio_stla_tokstr_VERTEX[] = "vertex"; static const char gmio_stla_tokstr_VERTEX[] = "vertex";
static const gmio_const_string_t gmio_stla_tokstr[] = { static const gmio_const_string_t gmio_stla_tokcstr[] = {
{0}, {0},
GMIO_CONST_STRING_FROM_ARRAY(gmio_stla_tokstr_ENDFACET), GMIO_CONST_STRING_FROM_ARRAY(gmio_stla_tokstr_ENDFACET),
GMIO_CONST_STRING_FROM_ARRAY(gmio_stla_tokstr_ENDLOOP) , GMIO_CONST_STRING_FROM_ARRAY(gmio_stla_tokstr_ENDLOOP),
GMIO_CONST_STRING_FROM_ARRAY(gmio_stla_tokstr_ENDSOLID), GMIO_CONST_STRING_FROM_ARRAY(gmio_stla_tokstr_ENDSOLID),
GMIO_CONST_STRING_FROM_ARRAY(gmio_stla_tokstr_FACET), GMIO_CONST_STRING_FROM_ARRAY(gmio_stla_tokstr_FACET),
GMIO_CONST_STRING_FROM_ARRAY(gmio_stla_tokstr_LOOP), GMIO_CONST_STRING_FROM_ARRAY(gmio_stla_tokstr_LOOP),
@ -135,11 +123,24 @@ static const gmio_const_string_t gmio_stla_tokstr[] = {
GMIO_CONST_STRING_FROM_ARRAY(gmio_stla_tokstr_OUTER), GMIO_CONST_STRING_FROM_ARRAY(gmio_stla_tokstr_OUTER),
GMIO_CONST_STRING_FROM_ARRAY(gmio_stla_tokstr_SOLID), GMIO_CONST_STRING_FROM_ARRAY(gmio_stla_tokstr_SOLID),
GMIO_CONST_STRING_FROM_ARRAY(gmio_stla_tokstr_VERTEX), GMIO_CONST_STRING_FROM_ARRAY(gmio_stla_tokstr_VERTEX),
{ "ID", 2 }, { "ID", 2 }, /* ID_token */
{ "", 0 }, /* empty_token */ { "", 0 }, /* empty_token */
{ "?", 1 } /* unknown_token */ { "?", 1 } /* unknown_token */
}; };
/* gmio_stream_fwd_iterator_stla_cookie */
typedef struct
{
/* Copy of gmio_stla_read() corresponding argument */
gmio_transfer_t* transfer;
/* Cache for gmio_stream_size(&transfer->stream) */
size_t stream_size;
/* Offset (in bytes) from beginning of stream : current position */
size_t stream_offset;
/* Cache for gmio_transfer::func_is_stop_requested() */
gmio_bool_t is_stop_requested;
} gmio_string_stream_fwd_iterator_cookie_t;
/* gmio_stla_parse_data */ /* gmio_stla_parse_data */
typedef struct typedef struct
{ {
@ -173,7 +174,7 @@ GMIO_INLINE gmio_bool_t parsing_can_continue(
GMIO_INLINE const char* token_to_string(gmio_stla_token_t token) GMIO_INLINE const char* token_to_string(gmio_stla_token_t token)
{ {
return gmio_stla_tokstr[token].ptr; return gmio_stla_tokcstr[token].ptr;
} }
GMIO_INLINE void parsing_error_msg( GMIO_INLINE void parsing_error_msg(
@ -218,32 +219,32 @@ static gmio_stla_token_t parsing_find_token(const char* word, size_t word_len)
switch (word[0]) { switch (word[0]) {
case 'f': case 'f':
case 'F': case 'F':
if (gmio_stricmp(word + 1, "acet") == 0) if (gmio_ascii_stricmp(word + 1, "acet") == 0)
return FACET_token; return FACET_token;
break; break;
case 'l': case 'l':
case 'L': case 'L':
if (gmio_stricmp(word + 1, "oop") == 0) if (gmio_ascii_stricmp(word + 1, "oop") == 0)
return LOOP_token; return LOOP_token;
break; break;
case 'n': case 'n':
case 'N': case 'N':
if (gmio_stricmp(word + 1, "ormal") == 0) if (gmio_ascii_stricmp(word + 1, "ormal") == 0)
return NORMAL_token; return NORMAL_token;
break; break;
case 'o': case 'o':
case 'O': case 'O':
if (gmio_stricmp(word + 1, "uter") == 0) if (gmio_ascii_stricmp(word + 1, "uter") == 0)
return OUTER_token; return OUTER_token;
break; break;
case 's': case 's':
case 'S': case 'S':
if (gmio_stricmp(word + 1, "olid") == 0) if (gmio_ascii_stricmp(word + 1, "olid") == 0)
return SOLID_token; return SOLID_token;
break; break;
case 'v': case 'v':
case 'V': case 'V':
if (gmio_stricmp(word + 1, "ertex") == 0) if (gmio_ascii_stricmp(word + 1, "ertex") == 0)
return VERTEX_token; return VERTEX_token;
break; break;
default: default:
@ -252,21 +253,21 @@ static gmio_stla_token_t parsing_find_token(const char* word, size_t word_len)
} }
/* Might be "end..." token */ /* Might be "end..." token */
if (word_len >= 7 && gmio_istarts_with(word, "end") == GMIO_TRUE) { if (word_len >= 7 && gmio_ascii_istarts_with(word, "end")) {
switch (word[3]) { switch (word[3]) {
case 'f': case 'f':
case 'F': case 'F':
if (gmio_stricmp(word + 4, "acet") == 0) if (gmio_ascii_stricmp(word + 4, "acet") == 0)
return ENDFACET_token; return ENDFACET_token;
break; break;
case 'l': case 'l':
case 'L': case 'L':
if (gmio_stricmp(word + 4, "oop") == 0) if (gmio_ascii_stricmp(word + 4, "oop") == 0)
return ENDLOOP_token; return ENDLOOP_token;
break; break;
case 's': case 's':
case 'S': case 'S':
if (gmio_stricmp(word + 4, "olid") == 0) if (gmio_ascii_stricmp(word + 4, "olid") == 0)
return ENDSOLID_token; return ENDSOLID_token;
break; break;
default: default:
@ -286,14 +287,14 @@ GMIO_INLINE gmio_stla_token_t parsing_find_token_from_buff(
static gmio_bool_t parsing_eat_next_token( static gmio_bool_t parsing_eat_next_token(
gmio_stla_token_t next_token, gmio_stla_parse_data_t* data) gmio_stla_token_t next_token, gmio_stla_parse_data_t* data)
{ {
const char* next_token_str = token_to_string(next_token);
gmio_string_t* data_strbuff = &data->string_buffer; gmio_string_t* data_strbuff = &data->string_buffer;
gmio_eat_word_error_t eat_error; gmio_eat_word_error_t eat_error;
data_strbuff->len = 0; data_strbuff->len = 0;
eat_error = gmio_eat_word(&data->stream_iterator, data_strbuff); eat_error = gmio_eat_word(&data->stream_iterator, data_strbuff);
if (eat_error == GMIO_EAT_WORD_ERROR_OK) { if (eat_error == GMIO_EAT_WORD_ERROR_OK) {
if (gmio_stricmp(data_strbuff->ptr, next_token_str) == 0) { const char* next_token_str = token_to_string(next_token);
if (gmio_ascii_stricmp(data_strbuff->ptr, next_token_str) == 0) {
data->token = next_token; data->token = next_token;
return GMIO_TRUE; return GMIO_TRUE;
} }
@ -385,6 +386,7 @@ static gmio_bool_t parse_solidname_beg(gmio_stla_parse_data_t* data)
static gmio_bool_t parse_solidname_end(gmio_stla_parse_data_t* data) static gmio_bool_t parse_solidname_end(gmio_stla_parse_data_t* data)
{ {
GMIO_UNUSED(data);
/* TODO: parse according to retrieved solid name */ /* TODO: parse according to retrieved solid name */
return GMIO_TRUE; return GMIO_TRUE;
} }

2
tests/core_utils.c
View File

@ -46,7 +46,7 @@ void gmio_string_trim_from_end(char *str, size_t len)
if (len > 0) { if (len > 0) {
do { do {
--len; --len;
if (str[len] == 0 || gmio_clocale_isspace(str[len])) if (str[len] == 0 || gmio_ascii_isspace(str[len]))
str[len] = 0; str[len] = 0;
else else
break; break;

80
tests/test_core_internal.c
View File

@ -244,59 +244,63 @@ const char* test_internal__string_utils()
{ {
char c; /* for loop counter */ char c; /* for loop counter */
UTEST_ASSERT(gmio_clocale_isspace(' ')); UTEST_ASSERT(gmio_ascii_isspace(' '));
UTEST_ASSERT(gmio_clocale_isspace('\t')); UTEST_ASSERT(gmio_ascii_isspace('\t'));
UTEST_ASSERT(gmio_clocale_isspace('\n')); UTEST_ASSERT(gmio_ascii_isspace('\n'));
UTEST_ASSERT(gmio_clocale_isspace('\r')); UTEST_ASSERT(gmio_ascii_isspace('\r'));
for (c = 0; c >= 0 && c <= 127; ++c) { for (c = 0; c >= 0 && c <= 127; ++c) {
if (65 <= c && c <= 90) { if (65 <= c && c <= 90) {
UTEST_ASSERT(gmio_clocale_isupper(c)); UTEST_ASSERT(gmio_ascii_isupper(c));
} }
else if (97 <= c && c <= 122) { else if (97 <= c && c <= 122) {
UTEST_ASSERT(gmio_clocale_islower(c)); UTEST_ASSERT(gmio_ascii_islower(c));
} }
else if (c == 0x20 || (0x09 <= c && c <= 0x0d)) { else if (c == 0x20 || (0x09 <= c && c <= 0x0d)) {
UTEST_ASSERT(gmio_clocale_isspace(c)); UTEST_ASSERT(gmio_ascii_isspace(c));
}
else if (48 <= c && c <= 57) {
UTEST_ASSERT(gmio_ascii_isdigit(c));
} }
else { else {
UTEST_ASSERT(!gmio_clocale_isupper(c)); UTEST_ASSERT(!gmio_ascii_isupper(c));
UTEST_ASSERT(!gmio_clocale_islower(c)); UTEST_ASSERT(!gmio_ascii_islower(c));
UTEST_ASSERT(!gmio_clocale_isspace(c)); UTEST_ASSERT(!gmio_ascii_isspace(c));
UTEST_ASSERT(!gmio_ascii_isdigit(c));
} }
} }
UTEST_ASSERT(gmio_clocale_tolower('A') == 'a'); UTEST_ASSERT(gmio_ascii_tolower('A') == 'a');
UTEST_ASSERT(gmio_clocale_tolower('Z') == 'z'); UTEST_ASSERT(gmio_ascii_tolower('Z') == 'z');
UTEST_ASSERT(gmio_clocale_tolower('(') == '('); UTEST_ASSERT(gmio_ascii_tolower('(') == '(');
UTEST_ASSERT(gmio_clocale_toupper('a') == 'A'); UTEST_ASSERT(gmio_ascii_toupper('a') == 'A');
UTEST_ASSERT(gmio_clocale_toupper('z') == 'Z'); UTEST_ASSERT(gmio_ascii_toupper('z') == 'Z');
UTEST_ASSERT(gmio_clocale_toupper('(') == '('); UTEST_ASSERT(gmio_ascii_toupper('(') == '(');
UTEST_ASSERT(gmio_clocale_char_iequals('a', 'a')); UTEST_ASSERT(gmio_ascii_char_iequals('a', 'a'));
UTEST_ASSERT(gmio_clocale_char_iequals('a', 'A')); UTEST_ASSERT(gmio_ascii_char_iequals('a', 'A'));
UTEST_ASSERT(gmio_clocale_char_iequals('A', 'a')); UTEST_ASSERT(gmio_ascii_char_iequals('A', 'a'));
UTEST_ASSERT(gmio_clocale_char_iequals('{', '{')); UTEST_ASSERT(gmio_ascii_char_iequals('{', '{'));
UTEST_ASSERT(!gmio_clocale_char_iequals('{', '[')); UTEST_ASSERT(!gmio_ascii_char_iequals('{', '['));
UTEST_ASSERT(gmio_stricmp("FACET", "facet") == 0); UTEST_ASSERT(gmio_ascii_stricmp("FACET", "facet") == 0);
UTEST_ASSERT(gmio_stricmp("facet", "FACET") == 0); UTEST_ASSERT(gmio_ascii_stricmp("facet", "FACET") == 0);
UTEST_ASSERT(gmio_stricmp("facet", "facet") == 0); UTEST_ASSERT(gmio_ascii_stricmp("facet", "facet") == 0);
UTEST_ASSERT(gmio_stricmp("FACET", "FACET") == 0); UTEST_ASSERT(gmio_ascii_stricmp("FACET", "FACET") == 0);
UTEST_ASSERT(gmio_stricmp("", "") == 0); UTEST_ASSERT(gmio_ascii_stricmp("", "") == 0);
UTEST_ASSERT(gmio_stricmp("", "facet") != 0); UTEST_ASSERT(gmio_ascii_stricmp("", "facet") != 0);
UTEST_ASSERT(gmio_stricmp("facet", "facet_") != 0); UTEST_ASSERT(gmio_ascii_stricmp("facet", "facet_") != 0);
UTEST_ASSERT(gmio_stricmp("facet_", "facet") != 0); UTEST_ASSERT(gmio_ascii_stricmp("facet_", "facet") != 0);
UTEST_ASSERT(gmio_istarts_with("facet", "")); UTEST_ASSERT(gmio_ascii_istarts_with("facet", ""));
UTEST_ASSERT(gmio_istarts_with("facet", "f")); UTEST_ASSERT(gmio_ascii_istarts_with("facet", "f"));
UTEST_ASSERT(gmio_istarts_with("facet", "fa")); UTEST_ASSERT(gmio_ascii_istarts_with("facet", "fa"));
UTEST_ASSERT(gmio_istarts_with("facet", "facet")); UTEST_ASSERT(gmio_ascii_istarts_with("facet", "facet"));
UTEST_ASSERT(!gmio_istarts_with("facet", "a")); UTEST_ASSERT(!gmio_ascii_istarts_with("facet", "a"));
UTEST_ASSERT(!gmio_istarts_with("facet", " facet")); UTEST_ASSERT(!gmio_ascii_istarts_with("facet", " facet"));
UTEST_ASSERT(gmio_istarts_with("facet", "F")); UTEST_ASSERT(gmio_ascii_istarts_with("facet", "F"));
UTEST_ASSERT(gmio_istarts_with("FACET", "f")); UTEST_ASSERT(gmio_ascii_istarts_with("FACET", "f"));
UTEST_ASSERT(gmio_istarts_with("FACET", "fa")); UTEST_ASSERT(gmio_ascii_istarts_with("FACET", "fa"));
return NULL; return NULL;
} }