gmio_core/internal: minor optimizations in string_parse

src/gmio_core/internal/string_parse.c

@@ -22,38 +22,38 @@ void gmio_string_stream_fwd_iterator_init(gmio_string_stream_fwd_iterator_t *it)
     /* Trick: declaring the buffer exhausted will actually trigger the first
      * call to gmio_stream_read() inside gmio_next_char()
      */
-    it->buffer.len = 0;
+    it->strbuff.len = 0;
-    it->buffer_pos = it->buffer.max_len;
+    it->strbuff_ptr_end = it->strbuff.ptr;
+    it->strbuff_ptr_at = it->strbuff_ptr_end;
     gmio_next_char(it);
 }
 
 gmio_eat_word_error_t gmio_eat_word(
         gmio_string_stream_fwd_iterator_t *it, gmio_string_t *str)
 {
-    char* str_ptr = str->ptr;
+    char* str_ptr_at = str->ptr + str->len;
-    const size_t str_capacity = str->max_len;
+    const char* str_ptr_end = str->ptr + str->max_len;
     const char* stream_curr_char = NULL;
-    size_t i = str->len;
 
     /* assert(str != NULL && str->ptr != NULL); */
 
     stream_curr_char = gmio_skip_spaces(it);
     if (stream_curr_char == NULL) { /* Empty word */
-        str_ptr[i] = 0;
+        *str_ptr_at = 0;
         return GMIO_EAT_WORD_ERROR_EMPTY;
     }
 
     do {
-        str_ptr[i] = *stream_curr_char;
+        *str_ptr_at = *stream_curr_char;
         stream_curr_char = gmio_next_char(it);
-        ++i;
+        ++str_ptr_at;
-    } while(i < str_capacity
+    } while (stream_curr_char != NULL
-            && stream_curr_char != NULL
+             && !gmio_ascii_isspace(*stream_curr_char)
-            && !gmio_ascii_isspace(*stream_curr_char));
+             && str_ptr_at < str_ptr_end);
 
-    if (i < str_capacity) {
+    if (str_ptr_at < str_ptr_end) {
-        str_ptr[i] = 0; /* End string with terminating null byte */
+        *str_ptr_at = 0; /* End string with null byte */
-        str->len = i;
+        str->len = str_ptr_at - str->ptr;
         return GMIO_EAT_WORD_ERROR_OK;
     }
     return GMIO_EAT_WORD_ERROR_CAPACITY_OVERFLOW;

src/gmio_core/internal/string_parse.h

@@ -40,11 +40,12 @@
 struct gmio_string_stream_fwd_iterator
 {
     gmio_stream_t* stream;
-    gmio_string_t buffer;
+    gmio_string_t strbuff;
-    size_t buffer_pos; /*!< Position indicator in buffer */
+    const char* strbuff_ptr_end; /*!< Position after last char in strbuff */
+    const char* strbuff_ptr_at;  /*!< Position indicator in buffer */
 
     void* cookie;
-    void (*stream_read_hook)(
+    void (*func_stream_read_hook)(
             void* cookie, const gmio_string_t* str_buffer);
 };
 
@@ -111,25 +112,26 @@ GMIO_INLINE int gmio_get_float32(const char* str, gmio_float32_t* value_ptr);
 const char* gmio_current_char(
         const gmio_string_stream_fwd_iterator_t* it)
 {
-      if (it->buffer_pos < it->buffer.len)
+    return it->strbuff_ptr_at < it->strbuff_ptr_end ?
-        return it->buffer.ptr + it->buffer_pos;
+                it->strbuff_ptr_at :
-    return NULL;
+                NULL;
 }
 
 const char *gmio_next_char(gmio_string_stream_fwd_iterator_t *it)
 {
-    ++(it->buffer_pos);
+    ++(it->strbuff_ptr_at);
-    if (it->buffer_pos < it->buffer.len)
+    if (it->strbuff_ptr_at < it->strbuff_ptr_end)
-        return it->buffer.ptr + it->buffer_pos;
+        return it->strbuff_ptr_at;
 
     /* Read next chunk of data */
-    it->buffer_pos = 0;
+    it->strbuff_ptr_at = it->strbuff.ptr;
-    it->buffer.len = gmio_stream_read(
+    it->strbuff.len = gmio_stream_read(
-                it->stream, it->buffer.ptr, sizeof(char), it->buffer.max_len);
+                it->stream, it->strbuff.ptr, sizeof(char), it->strbuff.max_len);
-    if (it->buffer.len > 0) {
+    it->strbuff_ptr_end = it->strbuff.ptr + it->strbuff.len;
-        if (it->stream_read_hook != NULL)
+    if (it->strbuff.len > 0) {
-            it->stream_read_hook(it->cookie, &it->buffer);
+        if (it->func_stream_read_hook != NULL)
-        return it->buffer.ptr;
+            it->func_stream_read_hook(it->cookie, &it->strbuff);
+        return it->strbuff.ptr;
     }
     return NULL;
 }
@@ -169,11 +171,7 @@ int gmio_get_float32(const char* str, gmio_float32_t* value_ptr)
     char* end_ptr = NULL;
     *value_ptr = (gmio_float32_t)strtod(str, &end_ptr);
 #endif
-
+    return (end_ptr == str || errno == ERANGE) ? -1 : 0;
-    if (end_ptr == str || errno == ERANGE)
-        return -1;
-
-    return 0;
 }
 
 #endif /* GMIO_INTERNAL_STRING_PARSE_H */

src/gmio_stl/stla_read.c

@@ -499,10 +499,10 @@ int gmio_stla_read(gmio_transfer_t* trsf, gmio_stl_mesh_creator_t* creator)
     parse_data.stream_iterator_cookie.is_stop_requested = GMIO_FALSE;
 
     parse_data.stream_iterator.stream = &trsf->stream;
-    parse_data.stream_iterator.buffer.ptr = trsf->memblock.ptr;
+    parse_data.stream_iterator.strbuff.ptr = trsf->memblock.ptr;
-    parse_data.stream_iterator.buffer.max_len = trsf->memblock.size;
+    parse_data.stream_iterator.strbuff.max_len = trsf->memblock.size;
     parse_data.stream_iterator.cookie = &parse_data.stream_iterator_cookie;
-    parse_data.stream_iterator.stream_read_hook =
+    parse_data.stream_iterator.func_stream_read_hook =
             gmio_stream_fwd_iterator_stla_read_hook;
     gmio_string_stream_fwd_iterator_init(&parse_data.stream_iterator);
 

tests/test_core_internal.c

@@ -159,8 +159,8 @@ const char* test_internal__string_parse()
         gmio_stream_set_buffer(&stream, &buff);
 
         fwd_it.stream = &stream;
-        fwd_it.buffer.ptr = fwd_it_str;
+        fwd_it.strbuff.ptr = fwd_it_str;
-        fwd_it.buffer.max_len = sizeof(fwd_it_str);
+        fwd_it.strbuff.max_len = sizeof(fwd_it_str);
         gmio_string_stream_fwd_iterator_init(&fwd_it);
 
         copy_strbuff.ptr = copy_str;
@@ -192,8 +192,8 @@ const char* test_internal__string_parse()
 
         /* Test with very small string buffer */
         buff.pos = 0;
-        fwd_it.buffer.ptr = small_fwd_it_str;
+        fwd_it.strbuff.ptr = small_fwd_it_str;
-        fwd_it.buffer.max_len = sizeof(small_fwd_it_str);
+        fwd_it.strbuff.max_len = sizeof(small_fwd_it_str);
         gmio_string_stream_fwd_iterator_init(&fwd_it);
 
         UTEST_ASSERT(*gmio_current_char(&fwd_it) == 'U');
@@ -220,8 +220,8 @@ const char* test_internal__string_parse()
         gmio_stream_set_buffer(&stream, &buff);
 
         fwd_it.stream = &stream;
-        fwd_it.buffer.ptr = fwd_it_str;
+        fwd_it.strbuff.ptr = fwd_it_str;
-        fwd_it.buffer.max_len = sizeof(fwd_it_str);
+        fwd_it.strbuff.max_len = sizeof(fwd_it_str);
         gmio_string_stream_fwd_iterator_init(&fwd_it);
 
         copy_strbuff.ptr = copy_str;