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

Fix code style issue

Browse Source
This commit is contained in:
Hugues Delorme 2015-12-03 18:17:42 +01:00
parent d9f143d7d3
commit 9d08aa82ca
5 changed files with 113 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
src/gmio_core/internal/stringstream.c
View File

@ -17,19 +17,20 @@
#include "helper_stream.h" #include "helper_stream.h"
void gmio_stringstream_init(struct gmio_stringstream *it) void gmio_stringstream_init(struct gmio_stringstream *sstream)
{ {
/* Trick: declaring the buffer exhausted will actually trigger the first /* Trick: declaring the buffer exhausted will actually trigger the first
* call to gmio_stream_read() inside gmio_next_char() * call to gmio_stream_read() inside gmio_next_char()
*/ */
it->strbuff.len = 0; sstream->strbuff.len = 0;
it->strbuff_end = it->strbuff.ptr; sstream->strbuff_end = sstream->strbuff.ptr;
it->strbuff_at = it->strbuff_end; sstream->strbuff_at = sstream->strbuff_end;
gmio_stringstream_next_char(it); gmio_stringstream_next_char(sstream);
} }
enum gmio_eat_word_error gmio_stringstream_eat_word( enum gmio_eat_word_error gmio_stringstream_eat_word(
struct gmio_stringstream *it, struct gmio_string *str) struct gmio_stringstream *sstream,
struct gmio_string *str)
{ {
char* str_ptr_at = str->ptr + str->len; char* str_ptr_at = str->ptr + str->len;
const char* str_ptr_end = str->ptr + str->max_len; const char* str_ptr_end = str->ptr + str->max_len;
@ -37,7 +38,7 @@ enum gmio_eat_word_error gmio_stringstream_eat_word(
/* assert(str != NULL && str->ptr != NULL); */ /* assert(str != NULL && str->ptr != NULL); */
stream_curr_char = gmio_stringstream_skip_ascii_spaces(it); stream_curr_char = gmio_stringstream_skip_ascii_spaces(sstream);
if (stream_curr_char == NULL) { /* Empty word */ if (stream_curr_char == NULL) { /* Empty word */
*str_ptr_at = 0; *str_ptr_at = 0;
return GMIO_EAT_WORD_ERROR_EMPTY; return GMIO_EAT_WORD_ERROR_EMPTY;
@ -45,7 +46,7 @@ enum gmio_eat_word_error gmio_stringstream_eat_word(
do { do {
*str_ptr_at = *stream_curr_char; *str_ptr_at = *stream_curr_char;
stream_curr_char = gmio_stringstream_next_char(it); stream_curr_char = gmio_stringstream_next_char(sstream);
++str_ptr_at; ++str_ptr_at;
} while (stream_curr_char != NULL } while (stream_curr_char != NULL
&& !gmio_ascii_isspace(*stream_curr_char) && !gmio_ascii_isspace(*stream_curr_char)
@ -61,14 +62,14 @@ enum gmio_eat_word_error gmio_stringstream_eat_word(
#if 0 #if 0
gmio_bool_t gmio_stringstream_checked_next_chars( gmio_bool_t gmio_stringstream_checked_next_chars(
struct gmio_stringstream *it, const char *str) struct gmio_stringstream *sstream, const char *str)
{ {
size_t pos = 0; size_t pos = 0;
const char* curr_char = gmio_stringstream_current_char(it); const char* curr_char = gmio_stringstream_current_char(sstream);
gmio_bool_t same = curr_char != NULL && *curr_char == *str; gmio_bool_t same = curr_char != NULL && *curr_char == *str;
while (same) { while (same) {
curr_char = gmio_stringstream_next_char(it); curr_char = gmio_stringstream_next_char(sstream);
same = curr_char != NULL && *curr_char == str[++pos]; same = curr_char != NULL && *curr_char == str[++pos];
} }

76
src/gmio_core/internal/stringstream.h
View File

@ -39,28 +39,28 @@ struct gmio_stringstream
}; };
/*! Initializes iterator */ /*! Initializes iterator */
void gmio_stringstream_init(struct gmio_stringstream* it); void gmio_stringstream_init(struct gmio_stringstream* sstream);
/*! Returns the char where the iterator is currently pointing at */ /*! Returns the char where the iterator is currently pointing at */
GMIO_INLINE const char* gmio_stringstream_current_char( GMIO_INLINE const char* gmio_stringstream_current_char(
const struct gmio_stringstream* it); const struct gmio_stringstream* sstream);
/*! Moves on next char in stream */ /*! Moves on next char in stream */
GMIO_INLINE const char* gmio_stringstream_next_char( GMIO_INLINE const char* gmio_stringstream_next_char(
struct gmio_stringstream *it); struct gmio_stringstream* sstream);
/*! Moves on next char in stream */ /*! Moves on next char in stream */
GMIO_INLINE struct gmio_stringstream* gmio_stringstream_move_next_char( GMIO_INLINE struct gmio_stringstream* gmio_stringstream_move_next_char(
struct gmio_stringstream *it); struct gmio_stringstream* sstream);
/*! Advances iterator until the first non-space char */ /*! Advances iterator until the first non-space char */
GMIO_INLINE const char* gmio_stringstream_skip_ascii_spaces( GMIO_INLINE const char* gmio_stringstream_skip_ascii_spaces(
struct gmio_stringstream* it); struct gmio_stringstream* sstream);
/*! Advances iterator until the first non-space char and copies in \p str any /*! Advances iterator until the first non-space char and copies in \p str any
* space found */ * space found */
GMIO_INLINE void gmio_stringstream_copy_ascii_spaces( GMIO_INLINE void gmio_stringstream_copy_ascii_spaces(
struct gmio_stringstream* it, struct gmio_string* str); struct gmio_stringstream* sstream, struct gmio_string* str);
/*! Error codes returned by gmio_eat_word() */ /*! Error codes returned by gmio_eat_word() */
enum gmio_eat_word_error enum gmio_eat_word_error
@ -72,7 +72,7 @@ enum gmio_eat_word_error
/*! Advances iterator so that next word is extracted into \p str */ /*! Advances iterator so that next word is extracted into \p str */
enum gmio_eat_word_error gmio_stringstream_eat_word( enum gmio_eat_word_error gmio_stringstream_eat_word(
struct gmio_stringstream* it, struct gmio_string* str); struct gmio_stringstream* sstream, struct gmio_string* str);
#if 0 #if 0
/*! Iterate over stream while it matches input string \p str /*! Iterate over stream while it matches input string \p str
@ -80,12 +80,12 @@ enum gmio_eat_word_error gmio_stringstream_eat_word(
* Returns GMIO_TRUE if \p str was fully matched * Returns GMIO_TRUE if \p str was fully matched
*/ */
gmio_bool_t gmio_stringstream_checked_next_chars( gmio_bool_t gmio_stringstream_checked_next_chars(
struct gmio_stringstream* it, const char* str); struct gmio_stringstream* sstream, const char* str);
#endif #endif
/*! Parses float from string iterator \p it */ /*! Parses float from stringstream \p sstream */
GMIO_INLINE gmio_float32_t gmio_stringstream_parse_float32( GMIO_INLINE gmio_float32_t gmio_stringstream_parse_float32(
struct gmio_stringstream* it); struct gmio_stringstream* sstream);
/*! Converts C string \p str to float /*! Converts C string \p str to float
* *
@ -118,57 +118,59 @@ GMIO_INLINE gmio_float32_t gmio_to_float32(const char* str);
#include <errno.h> #include <errno.h>
#include <stdlib.h> #include <stdlib.h>
const char* gmio_stringstream_current_char(const struct gmio_stringstream* it) const char* gmio_stringstream_current_char(
const struct gmio_stringstream* sstream)
{ {
return it->strbuff_at < it->strbuff_end ? return sstream->strbuff_at < sstream->strbuff_end ?
it->strbuff_at : sstream->strbuff_at :
NULL; NULL;
} }
const char *gmio_stringstream_next_char(struct gmio_stringstream *it) const char *gmio_stringstream_next_char(struct gmio_stringstream *sstream)
{ {
++(it->strbuff_at); ++(sstream->strbuff_at);
if (it->strbuff_at < it->strbuff_end) if (sstream->strbuff_at < sstream->strbuff_end)
return it->strbuff_at; return sstream->strbuff_at;
/* Read next chunk of data */ /* Read next chunk of data */
it->strbuff_at = it->strbuff.ptr; sstream->strbuff_at = sstream->strbuff.ptr;
it->strbuff.len = sstream->strbuff.len =
gmio_stream_read( gmio_stream_read(
&it->stream, it->strbuff.ptr, 1, it->strbuff.max_len); &sstream->stream, sstream->strbuff.ptr, 1, sstream->strbuff.max_len);
it->strbuff_end = it->strbuff.ptr + it->strbuff.len; sstream->strbuff_end = sstream->strbuff.ptr + sstream->strbuff.len;
if (it->strbuff.len > 0) { if (sstream->strbuff.len > 0) {
if (it->func_stream_read_hook != NULL) if (sstream->func_stream_read_hook != NULL)
it->func_stream_read_hook(it->cookie, &it->strbuff); sstream->func_stream_read_hook(sstream->cookie, &sstream->strbuff);
return it->strbuff.ptr; return sstream->strbuff.ptr;
} }
return NULL; return NULL;
} }
struct gmio_stringstream* gmio_stringstream_move_next_char(struct gmio_stringstream *it) struct gmio_stringstream* gmio_stringstream_move_next_char(
struct gmio_stringstream *sstream)
{ {
gmio_stringstream_next_char(it); gmio_stringstream_next_char(sstream);
return it; return sstream;
} }
const char* gmio_stringstream_skip_ascii_spaces(struct gmio_stringstream* it) const char* gmio_stringstream_skip_ascii_spaces(struct gmio_stringstream* sstream)
{ {
const char* curr_char = gmio_stringstream_current_char(it); const char* curr_char = gmio_stringstream_current_char(sstream);
while (curr_char != NULL && gmio_ascii_isspace(*curr_char)) while (curr_char != NULL && gmio_ascii_isspace(*curr_char))
curr_char = gmio_stringstream_next_char(it); curr_char = gmio_stringstream_next_char(sstream);
return curr_char; return curr_char;
} }
void gmio_stringstream_copy_ascii_spaces( void gmio_stringstream_copy_ascii_spaces(
struct gmio_stringstream* it, struct gmio_string* str) struct gmio_stringstream* sstream, struct gmio_string* str)
{ {
const char* curr_char = gmio_stringstream_current_char(it); const char* curr_char = gmio_stringstream_current_char(sstream);
while (curr_char != NULL while (curr_char != NULL
&& gmio_ascii_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;
curr_char = gmio_stringstream_next_char(it); curr_char = gmio_stringstream_next_char(sstream);
++str->len; ++str->len;
} }
} }
@ -199,14 +201,14 @@ gmio_float32_t gmio_to_float32(const char* str)
#endif #endif
} }
gmio_float32_t gmio_stringstream_parse_float32(struct gmio_stringstream* it) gmio_float32_t gmio_stringstream_parse_float32(struct gmio_stringstream* sstream)
{ {
#if defined(GMIO_STRINGSTREAM_USE_FAST_ATOF) #if defined(GMIO_STRINGSTREAM_USE_FAST_ATOF)
return gmio_stringstream_fast_atof(it); return gmio_stringstream_fast_atof(sstream);
#else #else
char strbuff_ptr[64]; char strbuff_ptr[64];
struct gmio_string strbuff = { &strbuff_ptr[0], 0, sizeof(strbuff_ptr) }; struct gmio_string strbuff = { &strbuff_ptr[0], 0, sizeof(strbuff_ptr) };
gmio_stringstream_eat_word(it, &strbuff); gmio_stringstream_eat_word(sstream, &strbuff);
return (gmio_float32_t)atof(strbuff_ptr); return (gmio_float32_t)atof(strbuff_ptr);
#endif #endif
} }

44
src/gmio_core/internal/stringstream_fast_atof.h
View File

@ -12,28 +12,30 @@
#include "fast_atof.h" #include "fast_atof.h"
#include "stringstream.h" #include "stringstream.h"
GMIO_INLINE uint32_t gmio_stringstream_strtoul10(struct gmio_stringstream* it) GMIO_INLINE uint32_t gmio_stringstream_strtoul10(
struct gmio_stringstream* sstream)
{ {
unsigned int value = 0; unsigned int value = 0;
const char* in = gmio_stringstream_current_char(it); const char* in = gmio_stringstream_current_char(sstream);
for (; for (;
in != NULL && gmio_ascii_isdigit(*in); in != NULL && gmio_ascii_isdigit(*in);
in = gmio_stringstream_next_char(it)) in = gmio_stringstream_next_char(sstream))
{ {
value = (value * 10) + (*in - '0'); value = (value * 10) + (*in - '0');
} }
return value; return value;
} }
GMIO_INLINE int32_t gmio_stringstream_strtol10(struct gmio_stringstream* it) GMIO_INLINE int32_t gmio_stringstream_strtol10(
struct gmio_stringstream* sstream)
{ {
const char* in = gmio_stringstream_current_char(it); const char* in = gmio_stringstream_current_char(sstream);
const gmio_bool_t inv = (*in == '-'); const gmio_bool_t inv = (*in == '-');
int value = 0; int value = 0;
if (inv || *in == '+') if (inv || *in == '+')
in = gmio_stringstream_next_char(it); in = gmio_stringstream_next_char(sstream);
value = gmio_stringstream_strtoul10(it); value = gmio_stringstream_strtoul10(sstream);
if (inv) if (inv)
value = -value; value = -value;
return value; return value;
@ -46,9 +48,9 @@ struct gmio_stringstream_strtof10_result
}; };
GMIO_INLINE struct gmio_stringstream_strtof10_result GMIO_INLINE struct gmio_stringstream_strtof10_result
gmio_stringstream_strtof10(struct gmio_stringstream* it) gmio_stringstream_strtof10(struct gmio_stringstream* sstream)
{ {
const char* in = gmio_stringstream_current_char(it); const char* in = gmio_stringstream_current_char(sstream);
const uint32_t MAX_SAFE_U32_VALUE = UINT_MAX / 10 - 10; const uint32_t MAX_SAFE_U32_VALUE = UINT_MAX / 10 - 10;
uint32_t int_val = 0; uint32_t int_val = 0;
float float_val = 0.f; float float_val = 0.f;
@ -59,7 +61,7 @@ GMIO_INLINE struct gmio_stringstream_strtof10_result
* precision */ * precision */
for (; for (;
in != NULL && gmio_ascii_isdigit(*in) && int_val < MAX_SAFE_U32_VALUE; in != NULL && gmio_ascii_isdigit(*in) && int_val < MAX_SAFE_U32_VALUE;
in = gmio_stringstream_next_char(it)) in = gmio_stringstream_next_char(sstream))
{ {
int_val = (int_val * 10) + (*in - '0'); int_val = (int_val * 10) + (*in - '0');
++char_diff; ++char_diff;
@ -69,7 +71,7 @@ GMIO_INLINE struct gmio_stringstream_strtof10_result
* arithmetic from here */ * arithmetic from here */
for (; for (;
in != NULL && gmio_ascii_isdigit(*in) && float_val <= FLT_MAX; in != NULL && gmio_ascii_isdigit(*in) && float_val <= FLT_MAX;
in = gmio_stringstream_next_char(it)) in = gmio_stringstream_next_char(sstream))
{ {
float_val = (float_val * 10) + (*in - '0'); float_val = (float_val * 10) + (*in - '0');
++char_diff; ++char_diff;
@ -79,35 +81,35 @@ GMIO_INLINE struct gmio_stringstream_strtof10_result
return result; return result;
} }
GMIO_INLINE float gmio_stringstream_fast_atof(struct gmio_stringstream* it) GMIO_INLINE float gmio_stringstream_fast_atof(struct gmio_stringstream* sstream)
{ {
const char* in = gmio_stringstream_current_char(it); const char* in = gmio_stringstream_current_char(sstream);
const gmio_bool_t negative = ('-' == *in); const gmio_bool_t negative = ('-' == *in);
float value = 0.f; float value = 0.f;
/* Please run the regression test when making any modifications to this /* Please run the regression test when making any modifications to this
* function. */ * function. */
if (negative || ('+' == *in)) if (negative || ('+' == *in))
in = gmio_stringstream_next_char(it); in = gmio_stringstream_next_char(sstream);
value = gmio_stringstream_strtof10(it).val; value = gmio_stringstream_strtof10(sstream).val;
in = gmio_stringstream_current_char(it); in = gmio_stringstream_current_char(sstream);
if (is_local_decimal_point(*in)) { if (is_local_decimal_point(*in)) {
const struct gmio_stringstream_strtof10_result decimal = const struct gmio_stringstream_strtof10_result decimal =
gmio_stringstream_strtof10( gmio_stringstream_strtof10(
gmio_stringstream_move_next_char(it)); gmio_stringstream_move_next_char(sstream));
value += decimal.val * fast_atof_table[decimal.char_diff]; value += decimal.val * fast_atof_table[decimal.char_diff];
in = gmio_stringstream_current_char(it); in = gmio_stringstream_current_char(sstream);
} }
if (in != NULL && ('e' == *in || 'E' == *in)) { if (in != NULL && ('e' == *in || 'E' == *in)) {
in = gmio_stringstream_next_char(it); in = gmio_stringstream_next_char(sstream);
/* Assume that the exponent is a whole number. /* Assume that the exponent is a whole number.
* strtol10() will deal with both + and - signs, * strtol10() will deal with both + and - signs,
* but calculate as float to prevent overflow at FLT_MAX */ * but calculate as float to prevent overflow at FLT_MAX */
value *= value *=
#ifdef GMIO_HAVE_POWF_FUNC #ifdef GMIO_HAVE_POWF_FUNC
powf(10.f, (float)gmio_stringstream_strtol10(it)); powf(10.f, (float)gmio_stringstream_strtol10(sstream));
#else #else
(float)pow(10., (double)gmio_stringstream_strtol10(it)); (float)pow(10., (double)gmio_stringstream_strtol10(sstream));
#endif #endif
} }
return negative ? -value : value; return negative ? -value : value;

64
src/gmio_stl/stla_read.c
View File

@ -117,8 +117,8 @@ struct gmio_stla_parse_data
{ {
enum gmio_stla_token token; enum gmio_stla_token token;
gmio_bool_t error; gmio_bool_t error;
struct gmio_stringstream stream_iterator; struct gmio_stringstream strstream;
struct gmio_stringstream_stla_cookie stream_iterator_cookie; struct gmio_stringstream_stla_cookie strstream_cookie;
struct gmio_string string_buffer; struct gmio_string string_buffer;
struct gmio_stl_mesh_creator* creator; struct gmio_stl_mesh_creator* creator;
}; };
@ -161,19 +161,19 @@ int gmio_stla_read(
parse_data.token = unknown_token; parse_data.token = unknown_token;
parse_data.error = GMIO_FALSE; parse_data.error = GMIO_FALSE;
parse_data.stream_iterator_cookie.rwargs = args; parse_data.strstream_cookie.rwargs = args;
parse_data.stream_iterator_cookie.stream_offset = 0; parse_data.strstream_cookie.stream_offset = 0;
parse_data.stream_iterator_cookie.stream_size = parse_data.strstream_cookie.stream_size =
gmio_stream_size(&args->stream); gmio_stream_size(&args->stream);
parse_data.stream_iterator_cookie.is_stop_requested = GMIO_FALSE; parse_data.strstream_cookie.is_stop_requested = GMIO_FALSE;
parse_data.stream_iterator.stream = args->stream; parse_data.strstream.stream = args->stream;
parse_data.stream_iterator.strbuff.ptr = args->memblock.ptr; parse_data.strstream.strbuff.ptr = args->memblock.ptr;
parse_data.stream_iterator.strbuff.max_len = args->memblock.size; parse_data.strstream.strbuff.max_len = args->memblock.size;
parse_data.stream_iterator.cookie = &parse_data.stream_iterator_cookie; parse_data.strstream.cookie = &parse_data.strstream_cookie;
parse_data.stream_iterator.func_stream_read_hook = parse_data.strstream.func_stream_read_hook =
gmio_stringstream_stla_read_hook; gmio_stringstream_stla_read_hook;
gmio_stringstream_init(&parse_data.stream_iterator); gmio_stringstream_init(&parse_data.strstream);
parse_data.string_buffer.ptr = &fixed_buffer[0]; parse_data.string_buffer.ptr = &fixed_buffer[0];
parse_data.string_buffer.len = 0; parse_data.string_buffer.len = 0;
@ -185,7 +185,7 @@ int gmio_stla_read(
if (parse_data.error) if (parse_data.error)
return GMIO_STL_ERROR_PARSING; return GMIO_STL_ERROR_PARSING;
if (parse_data.stream_iterator_cookie.is_stop_requested) if (parse_data.strstream_cookie.is_stop_requested)
return GMIO_ERROR_TRANSFER_STOPPED; return GMIO_ERROR_TRANSFER_STOPPED;
return GMIO_ERROR_OK; return GMIO_ERROR_OK;
} }
@ -461,7 +461,7 @@ int stla_eat_next_token(
enum gmio_eat_word_error eat_error; enum gmio_eat_word_error eat_error;
strbuff->len = 0; strbuff->len = 0;
eat_error = gmio_stringstream_eat_word(&data->stream_iterator, strbuff); eat_error = gmio_stringstream_eat_word(&data->strstream, strbuff);
if (eat_error == GMIO_EAT_WORD_ERROR_OK) { if (eat_error == GMIO_EAT_WORD_ERROR_OK) {
const char* expected_token_str = stla_token_to_string(expected_token); const char* expected_token_str = stla_token_to_string(expected_token);
if (gmio_ascii_stricmp(strbuff->ptr, expected_token_str) == 0) { if (gmio_ascii_stricmp(strbuff->ptr, expected_token_str) == 0) {
@ -484,13 +484,13 @@ int stla_eat_next_token_inplace(
struct gmio_stla_parse_data* data, struct gmio_stla_parse_data* data,
enum gmio_stla_token expected_token) enum gmio_stla_token expected_token)
{ {
struct gmio_stringstream* it = &data->stream_iterator; struct gmio_stringstream* sstream = &data->strstream;
const char* stream_char = NULL; const char* stream_char = NULL;
const char* expected_token_str = stla_token_to_string(expected_token); const char* expected_token_str = stla_token_to_string(expected_token);
gmio_bool_t error = GMIO_FALSE; gmio_bool_t error = GMIO_FALSE;
data->token = unknown_token; data->token = unknown_token;
stream_char = gmio_stringstream_skip_ascii_spaces(it); stream_char = gmio_stringstream_skip_ascii_spaces(sstream);
while (!error) { while (!error) {
if (stream_char == NULL || gmio_ascii_isspace(*stream_char)) { if (stream_char == NULL || gmio_ascii_isspace(*stream_char)) {
if (*expected_token_str == 0) { if (*expected_token_str == 0) {
@ -504,7 +504,7 @@ int stla_eat_next_token_inplace(
{ {
error = GMIO_TRUE; error = GMIO_TRUE;
} }
stream_char = gmio_stringstream_next_char(it); stream_char = gmio_stringstream_next_char(sstream);
++expected_token_str; ++expected_token_str;
} }
@ -519,7 +519,7 @@ int stla_eat_until_token(
struct gmio_stla_parse_data* data, const enum gmio_stla_token* end_tokens) struct gmio_stla_parse_data* data, const enum gmio_stla_token* end_tokens)
{ {
if (!stla_token_match_candidate(data->token, end_tokens)) { if (!stla_token_match_candidate(data->token, end_tokens)) {
struct gmio_stringstream* stream_it = &data->stream_iterator; struct gmio_stringstream* sstream = &data->strstream;
struct gmio_string* strbuff = &data->string_buffer; struct gmio_string* strbuff = &data->string_buffer;
gmio_bool_t end_token_found = GMIO_FALSE; gmio_bool_t end_token_found = GMIO_FALSE;
@ -529,10 +529,10 @@ int stla_eat_until_token(
const char* next_word = NULL; /* Pointer on next word string */ const char* next_word = NULL; /* Pointer on next word string */
size_t next_word_len = 0; /* Length of next word string */ size_t next_word_len = 0; /* Length of next word string */
gmio_stringstream_copy_ascii_spaces(stream_it, strbuff); gmio_stringstream_copy_ascii_spaces(sstream, strbuff);
/* Next word */ /* Next word */
next_word = strbuff->ptr + strbuff->len; next_word = strbuff->ptr + strbuff->len;
eat_word_err = gmio_stringstream_eat_word(stream_it, strbuff); eat_word_err = gmio_stringstream_eat_word(sstream, strbuff);
next_word_len = (strbuff->ptr + strbuff->len) - next_word; next_word_len = (strbuff->ptr + strbuff->len) - next_word;
/* Qualify token */ /* Qualify token */
data->token = data->token =
@ -560,7 +560,7 @@ int stla_eat_until_token(
gmio_bool_t stla_parsing_can_continue(const struct gmio_stla_parse_data* data) gmio_bool_t stla_parsing_can_continue(const struct gmio_stla_parse_data* data)
{ {
return !data->error && !data->stream_iterator_cookie.is_stop_requested; return !data->error && !data->strstream_cookie.is_stop_requested;
} }
/* -------------------------------------------------------------------------- /* --------------------------------------------------------------------------
@ -598,7 +598,7 @@ int parse_beginsolid(struct gmio_stla_parse_data* data)
if (parse_solidname_beg(data) == 0) { if (parse_solidname_beg(data) == 0) {
gmio_stl_mesh_creator_ascii_begin_solid( gmio_stl_mesh_creator_ascii_begin_solid(
data->creator, data->creator,
data->stream_iterator_cookie.stream_size, data->strstream_cookie.stream_size,
data->string_buffer.ptr); data->string_buffer.ptr);
return 0; return 0;
} }
@ -633,20 +633,20 @@ GMIO_INLINE int is_float_char(const char* str)
int parse_xyz_coords(struct gmio_stla_parse_data* data, struct gmio_stl_coords* coords) int parse_xyz_coords(struct gmio_stla_parse_data* data, struct gmio_stl_coords* coords)
{ {
int errc = 0; int errc = 0;
struct gmio_stringstream* it = &data->stream_iterator; struct gmio_stringstream* sstream = &data->strstream;
const char* strbuff = NULL; const char* strbuff = NULL;
strbuff = gmio_stringstream_skip_ascii_spaces(it); strbuff = gmio_stringstream_skip_ascii_spaces(sstream);
errc += !is_float_char(strbuff); errc += !is_float_char(strbuff);
coords->x = gmio_stringstream_parse_float32(it); coords->x = gmio_stringstream_parse_float32(sstream);
strbuff = gmio_stringstream_skip_ascii_spaces(it); strbuff = gmio_stringstream_skip_ascii_spaces(sstream);
errc += !is_float_char(strbuff); errc += !is_float_char(strbuff);
coords->y = gmio_stringstream_parse_float32(it); coords->y = gmio_stringstream_parse_float32(sstream);
strbuff = gmio_stringstream_skip_ascii_spaces(it); strbuff = gmio_stringstream_skip_ascii_spaces(sstream);
errc += !is_float_char(strbuff); errc += !is_float_char(strbuff);
coords->z = gmio_stringstream_parse_float32(it); coords->z = gmio_stringstream_parse_float32(sstream);
data->string_buffer.len = 0; data->string_buffer.len = 0;
data->token = unknown_token; data->token = unknown_token;
@ -654,7 +654,9 @@ int parse_xyz_coords(struct gmio_stla_parse_data* data, struct gmio_stl_coords*
return errc; return errc;
} }
int parse_facet(struct gmio_stla_parse_data* data, struct gmio_stl_triangle* facet) int parse_facet(
struct gmio_stla_parse_data* data,
struct gmio_stl_triangle* facet)
{ {
int errc = 0; int errc = 0;
if (data->token != FACET_token) if (data->token != FACET_token)
@ -696,7 +698,7 @@ void parse_facets(struct gmio_stla_parse_data* data)
func_add_triangle(creator_cookie, i_facet, &facet); func_add_triangle(creator_cookie, i_facet, &facet);
/* Eat next unknown token */ /* Eat next unknown token */
strbuff->len = 0; strbuff->len = 0;
gmio_stringstream_eat_word(&data->stream_iterator, strbuff); gmio_stringstream_eat_word(&data->strstream, strbuff);
data->token = stla_find_token_from_string(strbuff); data->token = stla_find_token_from_string(strbuff);
++i_facet; ++i_facet;
} }

12
tests/test_core_internal.c
View File

@ -131,16 +131,16 @@ const char* test_internal__gmio_fast_atof()
{ {
char strbuff[2048] = {0}; char strbuff[2048] = {0};
struct gmio_stringstream it = {0}; struct gmio_stringstream sstream = {0};
gmio_ro_buffer_t streambuff = { fstr, sizeof(fstr) - 1, 0 }; gmio_ro_buffer_t streambuff = { fstr, sizeof(fstr) - 1, 0 };
float f2; float f2;
it.stream = gmio_istream_buffer(&streambuff); sstream.stream = gmio_istream_buffer(&streambuff);
it.strbuff.ptr = &strbuff[0]; sstream.strbuff.ptr = &strbuff[0];
it.strbuff.max_len = sizeof(strbuff) - 1; sstream.strbuff.max_len = sizeof(strbuff) - 1;
gmio_stringstream_init(&it); gmio_stringstream_init(&sstream);
f2 = gmio_stringstream_fast_atof(&it); f2 = gmio_stringstream_fast_atof(&sstream);
UTEST_ASSERT(gmio_float32_equals_by_ulp(f1, f2, 1)); UTEST_ASSERT(gmio_float32_equals_by_ulp(f1, f2, 1));
} }