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

ascii_parse: simplify cookie function

Browse Source
This commit is contained in:
Hugues Delorme 2014-01-27 22:57:10 +01:00
parent 013e57e0ff
commit 340ed4f117
3 changed files with 101 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
src/internal/ascii_parse.c
View File

@ -4,10 +4,20 @@
#include <errno.h> #include <errno.h>
#include <stdlib.h> #include <stdlib.h>
void foug_ascii_stream_fwd_iterator_init(foug_ascii_stream_fwd_iterator_t *it)
{
/* Trick: declaring the buffer exhausted will actually trigger the first call to
* foug_stream_read() inside foug_next_char()
*/
it->buffer.len = 0;
it->buffer_pos = it->buffer.max_len;
foug_next_char(it);
}
char *foug_current_char(foug_ascii_stream_fwd_iterator_t *it) char *foug_current_char(foug_ascii_stream_fwd_iterator_t *it)
{ {
if (it != NULL && it->buffer_offset < it->buffer_size) if (it != NULL && it->buffer_pos < it->buffer.len)
return it->buffer + it->buffer_offset; return it->buffer.ptr + it->buffer_pos;
return NULL; return NULL;
} }
@ -16,35 +26,25 @@ char *foug_next_char(foug_ascii_stream_fwd_iterator_t *it)
if (it == NULL) if (it == NULL)
return NULL; return NULL;
if ((it->buffer_offset + 1) < it->buffer_size) { if ((it->buffer_pos + 1) < it->buffer.len) {
++(it->buffer_offset); ++(it->buffer_pos);
return it->buffer + it->buffer_offset; return it->buffer.ptr + it->buffer_pos;
} }
else { else {
size_t char_count_read;
if (foug_stream_error(it->stream) != 0 || foug_stream_at_end(it->stream)) if (foug_stream_error(it->stream) != 0 || foug_stream_at_end(it->stream))
return NULL; return NULL;
/* Read next chunk of data */ /* Read next chunk of data */
char_count_read = foug_stream_read(it->stream, it->buffer, sizeof(char), it->buffer_size); it->buffer_pos = 0;
if (foug_stream_error(it->stream) != 0) { it->buffer.len = foug_stream_read(it->stream, it->buffer.ptr, sizeof(char), it->buffer.max_len);
return NULL; if (foug_stream_error(it->stream) == 0) {
}
else {
it->buffer_offset = 0;
it->buffer_size = char_count_read;
if (it->stream_read_hook != NULL) if (it->stream_read_hook != NULL)
it->stream_read_hook(it->cookie, it->buffer, it->buffer_size); it->stream_read_hook(it->cookie, &it->buffer);
return it->buffer; return it->buffer.ptr;
}
} }
} }
void foug_stream_fwd_iterator_init(foug_ascii_stream_fwd_iterator_t *it) return NULL;
{
it->buffer_offset = it->buffer_size; /* This will cause the first call to foug_stream_read() */
foug_next_char(it);
} }
void foug_skip_spaces(foug_ascii_stream_fwd_iterator_t *it) void foug_skip_spaces(foug_ascii_stream_fwd_iterator_t *it)
@ -54,31 +54,31 @@ void foug_skip_spaces(foug_ascii_stream_fwd_iterator_t *it)
curr_char = foug_next_char(it); curr_char = foug_next_char(it);
} }
int foug_eat_string(foug_ascii_stream_fwd_iterator_t *it, foug_ascii_string_buffer_t *str_buffer) int foug_eat_word(foug_ascii_stream_fwd_iterator_t *it, foug_ascii_string_buffer_t *buffer)
{ {
const char* stream_curr_char = NULL; const char* stream_curr_char = NULL;
int isspace_res = 0; int isspace_res = 0;
size_t i = 0; size_t i = 0;
if (str_buffer == NULL || str_buffer->data == NULL || str_buffer->max_len == 0) if (buffer == NULL || buffer->ptr == NULL)
return -1; return -1;
str_buffer->len = 0; buffer->len = 0;
foug_skip_spaces(it); foug_skip_spaces(it);
stream_curr_char = foug_current_char(it); stream_curr_char = foug_current_char(it);
while (i < str_buffer->max_len && stream_curr_char != NULL && isspace_res == 0) { while (i < buffer->max_len && stream_curr_char != NULL && isspace_res == 0) {
isspace_res = isspace(*stream_curr_char); isspace_res = isspace(*stream_curr_char);
if (isspace_res == 0) { if (isspace_res == 0) {
str_buffer->data[i] = *stream_curr_char; buffer->ptr[i] = *stream_curr_char;
stream_curr_char = foug_next_char(it); stream_curr_char = foug_next_char(it);
++i; ++i;
} }
} }
if (i < str_buffer->max_len) { if (i < buffer->max_len) {
str_buffer->data[i] = 0; /* End string with null terminator */ buffer->ptr[i] = 0; /* End string with terminating null byte */
str_buffer->len = i ; buffer->len = i;
if (stream_curr_char != NULL || foug_stream_at_end(it->stream)) if (stream_curr_char != NULL || foug_stream_at_end(it->stream))
return 0; return 0;
return -2; return -2;

25
src/internal/ascii_parse.h
View File

@ -6,27 +6,26 @@
typedef struct typedef struct
{ {
foug_stream_t* stream; char* ptr; /*!< Buffer contents */
char* buffer; size_t len; /*!< Size(length) of current contents */
uint32_t buffer_offset; size_t max_len; /*!< Maximum contents size(length) */
uint32_t buffer_size; } foug_ascii_string_buffer_t;
void* cookie;
void (*stream_read_hook)(void*, const char*, uint32_t);
} foug_ascii_stream_fwd_iterator_t;
typedef struct typedef struct
{ {
char* data; foug_stream_t* stream;
size_t max_len; foug_ascii_string_buffer_t buffer;
size_t len; size_t buffer_pos; /*!< Position indicator in buffer */
} foug_ascii_string_buffer_t;
void* cookie;
void (*stream_read_hook)(void*, const foug_ascii_string_buffer_t*);
} foug_ascii_stream_fwd_iterator_t;
void foug_ascii_stream_fwd_iterator_init(foug_ascii_stream_fwd_iterator_t* it); void foug_ascii_stream_fwd_iterator_init(foug_ascii_stream_fwd_iterator_t* it);
char* foug_current_char(foug_ascii_stream_fwd_iterator_t* it); char* foug_current_char(foug_ascii_stream_fwd_iterator_t* it);
char* foug_next_char(foug_ascii_stream_fwd_iterator_t* it); char* foug_next_char(foug_ascii_stream_fwd_iterator_t* it);
void foug_skip_spaces(foug_ascii_stream_fwd_iterator_t* it); void foug_skip_spaces(foug_ascii_stream_fwd_iterator_t* it);
int foug_eat_string(foug_ascii_stream_fwd_iterator_t* it, foug_ascii_string_buffer_t* str_buffer); int foug_eat_word(foug_ascii_stream_fwd_iterator_t* it, foug_ascii_string_buffer_t* buffer);
int foug_get_real32(const char* str, foug_real32_t* value_ptr); int foug_get_real32(const char* str, foug_real32_t* value_ptr);
#endif /* FOUG_INTERNAL_ASCII_PARSE_H */ #endif /* FOUG_INTERNAL_ASCII_PARSE_H */

108
src/libstl/stla_read.c
View File

@ -4,6 +4,7 @@
#include "../internal/ascii_parse.h" #include "../internal/ascii_parse.h"
#include <ctype.h> #include <ctype.h>
#include <stdlib.h>
#include <string.h> #include <string.h>
/* /*
@ -59,7 +60,7 @@ typedef struct
size_t stream_data_size; size_t stream_data_size;
size_t stream_offset; size_t stream_offset;
foug_bool_t is_stop_requested; foug_bool_t is_stop_requested;
} foug_stream_fwd_iterator_stla_cookie_t; } _internal_foug_fwd_iterator_cookie_t;
/* foug_stla_token */ /* foug_stla_token */
typedef enum typedef enum
@ -84,20 +85,19 @@ typedef struct
foug_stla_token_t token; foug_stla_token_t token;
foug_bool_t error; foug_bool_t error;
foug_ascii_stream_fwd_iterator_t stream_iterator; foug_ascii_stream_fwd_iterator_t stream_iterator;
foug_stream_fwd_iterator_stla_cookie_t stream_iterator_cookie; _internal_foug_fwd_iterator_cookie_t stream_iterator_cookie;
foug_ascii_string_buffer_t string_buffer; foug_ascii_string_buffer_t string_buffer;
foug_stla_geom_input_t* geom; foug_stla_geom_input_t* geom;
} foug_stla_parse_data_t; } foug_stla_parse_data_t;
static void foug_stream_fwd_iterator_stla_read_hook(void* cookie, static void foug_stream_fwd_iterator_stla_read_hook(void* cookie,
const char* buffer, const foug_ascii_string_buffer_t* buffer)
uint32_t buffer_len)
{ {
foug_stream_fwd_iterator_stla_cookie_t* tcookie = (foug_stream_fwd_iterator_stla_cookie_t*)(cookie); _internal_foug_fwd_iterator_cookie_t* tcookie = (_internal_foug_fwd_iterator_cookie_t*)(cookie);
if (tcookie != NULL) { if (tcookie != NULL) {
const uint8_t progress_pc = foug_percentage(0, tcookie->stream_data_size, tcookie->stream_offset); const uint8_t progress_pc = foug_percentage(0, tcookie->stream_data_size, tcookie->stream_offset);
tcookie->is_stop_requested = !foug_task_control_handle_progress(tcookie->task_control, progress_pc); tcookie->is_stop_requested = !foug_task_control_handle_progress(tcookie->task_control, progress_pc);
tcookie->stream_offset += buffer_len; tcookie->stream_offset += buffer->len;
} }
} }
@ -110,13 +110,13 @@ foug_bool_t parsing_can_continue(const foug_stla_parse_data_t* data)
static const char* current_token_as_identifier(const foug_stla_parse_data_t* data) static const char* current_token_as_identifier(const foug_stla_parse_data_t* data)
{ {
return data->token == ID_token ? data->string_buffer.data : ""; return data->token == ID_token ? data->string_buffer.ptr : "";
} }
static int get_current_token_as_real32(const foug_stla_parse_data_t* data, foug_real32_t* value) static int get_current_token_as_real32(const foug_stla_parse_data_t* data, foug_real32_t* value_ptr)
{ {
if (data->token == FLOAT_token) if (data->token == FLOAT_token)
return foug_get_real32(data->string_buffer.data, value); return foug_get_real32(data->string_buffer.ptr, value_ptr);
return -3; return -3;
} }
@ -128,57 +128,57 @@ static void parsing_error(foug_stla_parse_data_t* data)
static void parsing_advance(foug_stla_parse_data_t* data) static void parsing_advance(foug_stla_parse_data_t* data)
{ {
const char* str = data->string_buffer.data; const char* word = data->string_buffer.ptr;
if (!parsing_can_continue(data)) if (!parsing_can_continue(data))
return; return;
data->token = unknown_token; data->token = unknown_token;
if (foug_eat_string(&data->stream_iterator, &data->string_buffer) == 0) { if (foug_eat_word(&data->stream_iterator, &data->string_buffer) == 0) {
const size_t str_len = data->string_buffer.len; const size_t word_len = data->string_buffer.len;
if (str_len >= 7 && strncmp(str, "end", 3) == 0) { /* Might be "end..." token */ if (word_len >= 7 && strncmp(word, "end", 3) == 0) { /* Might be "end..." token */
switch (str[3]) { switch (word[3]) {
case 'f': case 'f':
if (strcmp(str + 4, "acet") == 0) if (strcmp(word + 4, "acet") == 0)
data->token = ENDFACET_token; data->token = ENDFACET_token;
break; break;
case 'l': case 'l':
if (strcmp(str + 4, "oop") == 0) if (strcmp(word + 4, "oop") == 0)
data->token = ENDLOOP_token; data->token = ENDLOOP_token;
break; break;
case 's': case 's':
if (strcmp(str + 4, "olid") == 0) if (strcmp(word + 4, "olid") == 0)
data->token = ENDSOLID_token; data->token = ENDSOLID_token;
break; break;
default: default:
data->token = ID_token; data->token = ID_token;
} /* end switch */ } /* end switch */
} }
else if (str_len >= 4) { else if (word_len >= 4) {
switch (str[0]) { switch (word[0]) {
case 'f': case 'f':
if (strcmp(str + 1, "acet") == 0) if (strcmp(word + 1, "acet") == 0)
data->token = FACET_token; data->token = FACET_token;
break; break;
case 'l': case 'l':
if (strcmp(str + 1, "oop") == 0) if (strcmp(word + 1, "oop") == 0)
data->token = LOOP_token; data->token = LOOP_token;
break; break;
case 'n': case 'n':
if (strcmp(str + 1, "ormal") == 0) if (strcmp(word + 1, "ormal") == 0)
data->token = NORMAL_token; data->token = NORMAL_token;
break; break;
case 'o': case 'o':
if (strcmp(str + 1, "uter") == 0) if (strcmp(word + 1, "uter") == 0)
data->token = OUTER_token; data->token = OUTER_token;
break; break;
case 's': case 's':
if (strcmp(str + 1, "olid") == 0) if (strcmp(word + 1, "olid") == 0)
data->token = SOLID_token; data->token = SOLID_token;
break; break;
case 'v': case 'v':
if (strcmp(str + 1, "ertex") == 0) if (strcmp(word + 1, "ertex") == 0)
data->token = VERTEX_token; data->token = VERTEX_token;
break; break;
default: default:
@ -187,7 +187,7 @@ static void parsing_advance(foug_stla_parse_data_t* data)
} }
if (data->token == unknown_token) { if (data->token == unknown_token) {
if (str[0] == '+' || str[0] == '-' || isdigit(str[0])) /* Try to guess if it's a float */ if (word[0] == '+' || word[0] == '-' || isdigit(word[0])) /* Try to guess if it's a float */
data->token = FLOAT_token; data->token = FLOAT_token;
else else
data->token = ID_token; data->token = ID_token;
@ -302,47 +302,37 @@ static void parse_xyz_coords(foug_stla_parse_data_t* data, foug_stl_coords_t* co
} /* end switch */ } /* end switch */
} }
static void parse_facets(foug_stla_parse_data_t* data, size_t i_facet_offset) static void parse_facet(foug_stla_parse_data_t* data, foug_stl_triangle_t* facet)
{ {
if (!parsing_can_continue(data))
return;
switch (data->token) {
case ENDSOLID_token:
break;
case FACET_token: {
foug_stl_triangle_t facet;
parsing_eat_token(FACET_token, data); parsing_eat_token(FACET_token, data);
parsing_eat_token(NORMAL_token, data); parsing_eat_token(NORMAL_token, data);
parse_xyz_coords(data, &facet.normal); parse_xyz_coords(data, &facet->normal);
parsing_eat_token(OUTER_token, data); parsing_eat_token(OUTER_token, data);
parsing_eat_token(LOOP_token, data); parsing_eat_token(LOOP_token, data);
parsing_eat_token(VERTEX_token, data); parsing_eat_token(VERTEX_token, data);
parse_xyz_coords(data, &facet.v1); parse_xyz_coords(data, &facet->v1);
parsing_eat_token(VERTEX_token, data); parsing_eat_token(VERTEX_token, data);
parse_xyz_coords(data, &facet.v2); parse_xyz_coords(data, &facet->v2);
parsing_eat_token(VERTEX_token, data); parsing_eat_token(VERTEX_token, data);
parse_xyz_coords(data, &facet.v3); parse_xyz_coords(data, &facet->v3);
parsing_eat_token(ENDLOOP_token, data); parsing_eat_token(ENDLOOP_token, data);
parsing_eat_token(ENDFACET_token, data); parsing_eat_token(ENDFACET_token, data);
}
if (parsing_can_continue(data) static void parse_facets(foug_stla_parse_data_t* data)
&& data->geom != NULL
&& data->geom->process_triangle_func != NULL)
{ {
data->geom->process_triangle_func(data->geom->cookie, i_facet_offset, &facet); uint32_t i_facet_offset = 0;
} foug_stl_triangle_t facet;
parse_facets(data, i_facet_offset + 1); while (data->token == FACET_token && parsing_can_continue(data)) {
break; parse_facet(data, &facet);
if (data->geom != NULL && data->geom->process_triangle_func != NULL)
data->geom->process_triangle_func(data->geom->cookie, i_facet_offset, &facet);
++i_facet_offset;
} }
default:
parsing_error(data);
} /* end switch */
} }
static void parse_solid(foug_stla_parse_data_t* data) static void parse_solid(foug_stla_parse_data_t* data)
@ -350,13 +340,12 @@ static void parse_solid(foug_stla_parse_data_t* data)
if (!parsing_can_continue(data)) if (!parsing_can_continue(data))
return; return;
switch (data->token) { if (data->token == SOLID_token) {
case SOLID_token:
parse_beginsolid(data); parse_beginsolid(data);
parse_facets(data, 0); parse_facets(data);
parse_endsolid(data); parse_endsolid(data);
break; }
default: else {
parsing_error(data); parsing_error(data);
} }
} }
@ -386,16 +375,15 @@ int foug_stla_read(foug_stla_geom_input_t* geom,
parse_data.stream_iterator_cookie.is_stop_requested = 0; parse_data.stream_iterator_cookie.is_stop_requested = 0;
parse_data.stream_iterator.stream = &trsf->stream; parse_data.stream_iterator.stream = &trsf->stream;
parse_data.stream_iterator.buffer = trsf->buffer; parse_data.stream_iterator.buffer.ptr = trsf->buffer;
parse_data.stream_iterator.buffer_offset = 0; parse_data.stream_iterator.buffer.max_len = trsf->buffer_size;
parse_data.stream_iterator.buffer_size = trsf->buffer_size;
parse_data.stream_iterator.cookie = &parse_data.stream_iterator_cookie; parse_data.stream_iterator.cookie = &parse_data.stream_iterator_cookie;
parse_data.stream_iterator.stream_read_hook = foug_stream_fwd_iterator_stla_read_hook; parse_data.stream_iterator.stream_read_hook = foug_stream_fwd_iterator_stla_read_hook;
foug_ascii_stream_fwd_iterator_init(&parse_data.stream_iterator); foug_ascii_stream_fwd_iterator_init(&parse_data.stream_iterator);
parse_data.string_buffer.data = fixed_buffer; parse_data.string_buffer.ptr = &fixed_buffer[0];
parse_data.string_buffer.max_len = FOUG_STLA_READ_STRING_BUFFER_LEN;
parse_data.string_buffer.len = 0; parse_data.string_buffer.len = 0;
parse_data.string_buffer.max_len = FOUG_STLA_READ_STRING_BUFFER_LEN;
parse_data.geom = geom; parse_data.geom = geom;