ucx: comparison src/properties.c

-:06091e067bee
+:8a90552bba29
 #include "cx/properties.h"
 #include <assert.h>
-static const int CX_PROPERTIES_FLAG_USE_STACK = 0x01;
 const CxPropertiesConfig cx_properties_config_default = {
 '=',
 //'\\',
 '#',
 '\0',
 memset(prop, 0, sizeof(CxProperties));
 prop->config = config;
 }
 void cxPropertiesDestroy(CxProperties *prop) {
-if (0 == (prop->flags & CX_PROPERTIES_FLAG_USE_STACK)) {
+cxBufferDestroy(&prop->input);
-free(prop->buf);
+cxBufferDestroy(&prop->buffer);
-}
-prop->buf = NULL;
-prop->buf_capacity = prop->buf_size = 0;
-}
-static int cx_properties_ensure_buf_capacity(CxProperties *prop, size_t cap) {
-if (prop->buf_capacity >= cap) {
-return 0;
-}
-// not enough capacity - are we on the stack right now?
-if ((prop->flags & CX_PROPERTIES_FLAG_USE_STACK) != 0) {
-// move to the heap
-char *newbuf = malloc(cap);
-if (newbuf == NULL) return 1;
-memcpy(newbuf, prop->buf, prop->buf_size);
-prop->buf = newbuf;
-prop->flags &= CX_PROPERTIES_FLAG_USE_STACK;
-} else {
-// we are on the heap already, reallocate
-// this is legit, because realloc() behaves like malloc() when the
-// current pointer is NULL
-char *newbuf = realloc(prop->buf, cap);
-if (newbuf == NULL) return 1;
-prop->buf = newbuf;
-}
-// store new capacity and return
-prop->buf_capacity = cap;
-return 0;
-}
-static int cx_properties_rescuen_input(CxProperties *prop, size_t len) {
-if (cx_properties_ensure_buf_capacity(prop, prop->buf_size + len)) {
-return 1;
-}
-const char *src = prop->text + prop->text_pos;
-char *dest = prop->buf + prop->buf_size;
-memcpy(dest, src, len);
-prop->buf_size += len;
-prop->text_pos += len;
-return 0;
-}
-static int cx_properties_rescue_input(CxProperties *prop) {
-// someone fucked around with our integers, exit immediately
-if (prop->text_pos > prop->text_size) return 0;
-// determine the bytes needed
-size_t len = prop->text_size - prop->text_pos;
-return cx_properties_rescuen_input(prop, len);
 }
 int cxPropertiesFilln(
 CxProperties *prop,
 const char *buf,
 size_t len
 ) {
-if (cx_properties_rescue_input(prop)) return 1;
+if (cxBufferEof(&prop->input)) {
-prop->text = buf;
+// destroy a possible previously initialized buffer
-prop->text_size = len;
+cxBufferDestroy(&prop->input);
-prop->text_pos = 0;
+cxBufferInit(&prop->input, (void*) buf, len,
+NULL, CX_BUFFER_COPY_ON_WRITE | CX_BUFFER_AUTO_EXTEND);
+prop->input.size = len;
+} else {
+if (cxBufferAppend(buf, 1, len, &prop->input) < len) return -1;
+}
 return 0;
 }
 void cxPropertiesUseStack(
 CxProperties *prop,
 char *buf,
 size_t capacity
 ) {
-assert(prop->buf == NULL);
+cxBufferInit(&prop->buffer, buf, capacity, NULL, CX_BUFFER_COPY_ON_EXTEND);
-prop->buf = buf;
-prop->buf_capacity = capacity;
-prop->buf_size = 0;
-prop->flags |= CX_PROPERTIES_FLAG_USE_STACK;
 }
 CxPropertiesStatus cxPropertiesNext(
 CxProperties *prop,
 cxstring *key,
 cxstring *value
 ) {
 // check if we have a text buffer
-if (prop->text == NULL) {
+if (prop->input.space == NULL) {
 return CX_PROPERTIES_NULL_INPUT;
 }
+// a pointer to the buffer we want to read from
+CxBuffer *current_buffer = &prop->input;
 // check if we have rescued data
-if (prop->buf_size > 0) {
+if (!cxBufferEof(&prop->buffer)) {
 // check if we can now get a complete line
-const char *buf = prop->text + prop->text_pos;
+cxstring input = cx_strn(prop->input.space + prop->input.pos,
-size_t len = prop->text_size - prop->text_pos;
+prop->input.size - prop->input.pos);
-cxstring str = cx_strn(buf, len);
+cxstring nl = cx_strchr(input, '\n');
-cxstring nl = cx_strchr(str, '\n');
+if (nl.length > 0) {
-if(nl.length > 0) {
 // we add as much data to the rescue buffer as we need
 // to complete the line
-size_t len_until_nl = (size_t)(nl.ptr - buf) + 1;
+size_t len_until_nl = (size_t)(nl.ptr - input.ptr) + 1;
-if (cx_properties_rescuen_input(prop, len_until_nl)) {
+if (cxBufferAppend(input.ptr, 1,
+len_until_nl, &prop->buffer) < len_until_nl) {
 return CX_PROPERTIES_BUFFER_ALLOC_FAILED;
 }
-// the tmp buffer contains exactly one line now
+// advance the position in the input buffer
-// we use a trick here: we swap the buffers and recurse
+prop->input.pos += len_until_nl;
-const char *orig_text = prop->text;
-size_t orig_size = prop->text_size;
+// we now want to read from the rescue buffer
-prop->text = prop->buf;
+current_buffer = &prop->buffer;
-prop->text_size = prop->buf_size;
-prop->text_pos = 0;
-prop->buf_size = 0;
-CxPropertiesStatus result;
-result = cxPropertiesNext(prop, key, value);
-// restore original buffer
-prop->text = orig_text;
-prop->text_size = orig_size;
-// set the position to after the newline
-prop->text_pos = len_until_nl;
-// check the result
-if (result == CX_PROPERTIES_NO_ERROR) {
-// reset the rescue buffer and return with the result
-prop->buf_size = 0;
-return result;
-} else if (result == CX_PROPERTIES_NO_DATA) {
-// rescue buffer contained only blanks or comments
-// reset the rescue buffer and retry with text buffer
-prop->buf_size = 0;
-return cxPropertiesNext(prop, key, value);
-} else {
-// CX_PROPERTIES_INCOMPLETE_DATA is not possible
-// so it must have been another error
-// do not reset the rescue buffer and return the error
-return result;
-}
 } else {
-// still not enough data
+// still not enough data, copy input buffer to internal buffer
-if (cx_properties_rescue_input(prop)) {
+if (cxBufferAppend(input.ptr, 1,
+input.length, &prop->buffer) < input.length) {
 return CX_PROPERTIES_BUFFER_ALLOC_FAILED;
 }
+// reset the input buffer (make way for a re-fill)
+cxBufferReset(&prop->input);
 return CX_PROPERTIES_INCOMPLETE_DATA;
 }
 }
 char comment1 = prop->config.comment1;
 char comment2 = prop->config.comment2;
 char comment3 = prop->config.comment3;
 char delimiter = prop->config.delimiter;
 // get one line and parse it
-while (prop->text_pos < prop->text_size) {
+while (!cxBufferEof(current_buffer)) {
-const char *buf = prop->text + prop->text_pos;
+const char *buf = current_buffer->space + current_buffer->pos;
-size_t len = prop->text_size - prop->text_pos;
+size_t len = current_buffer->size - current_buffer->pos;
 /*
 * First we check if we have at least one line. We also get indices of
 * delimiter and comment chars
 */
 break;
 }
 }
 if (c != '\n') {
-// we don't have enough data for a line
+// we don't have enough data for a line, use the rescue buffer
-if (cx_properties_rescue_input(prop)) {
+assert(current_buffer != &prop->buffer);
+// make sure that the rescue buffer does not already contain something
+assert(cxBufferEof(&prop->buffer));
+if (prop->buffer.space == NULL) {
+// initialize a rescue buffer, if the user did not provide one
+cxBufferInit(&prop->buffer, NULL, 256, NULL, CX_BUFFER_AUTO_EXTEND);
+} else {
+// from a previous rescue there might be already read data
+// reset the buffer to avoid unnecessary buffer extension
+cxBufferReset(&prop->buffer);
+}
+if (cxBufferAppend(buf, 1, len, &prop->buffer) < len) {
 return CX_PROPERTIES_BUFFER_ALLOC_FAILED;
 }
+// reset the input buffer (make way for a re-fill)
+cxBufferReset(&prop->input);
 return CX_PROPERTIES_INCOMPLETE_DATA;
 }
 cxstring line = has_comment ?
 cx_strn(buf, comment_index) :
 if (line.ptr[0] == delimiter) {
 return CX_PROPERTIES_INVALID_EMPTY_KEY;
 } else {
 return CX_PROPERTIES_INVALID_MISSING_DELIMITER;
 }
+} else {
+// skip blank line
+// if it was the rescue buffer, return to the original buffer
+if (current_buffer == &prop->buffer) {
+// assert that the rescue buffer really does not contain more data
+assert(current_buffer->pos + i + 1 == current_buffer->size);
+// reset the rescue buffer, but don't destroy it!
+cxBufferReset(&prop->buffer);
+// continue with the input buffer
+current_buffer = &prop->input;
+} else {
+// if it was the input buffer already, just advance the position
+current_buffer->pos += i + 1;
+}
+continue;
 }
 } else {
 cxstring k = cx_strn(buf, delimiter_index);
 cxstring val = cx_strn(
 buf + delimiter_index + 1,
 k = cx_strtrim(k);
 val = cx_strtrim(val);
 if (k.length > 0) {
 *key = k;
 *value = val;
-prop->text_pos += i + 1;
+current_buffer->pos += i + 1;
-assert(prop->text_pos <= prop->text_size);
+assert(current_buffer->pos <= current_buffer->size);
 return CX_PROPERTIES_NO_ERROR;
 } else {
 return CX_PROPERTIES_INVALID_EMPTY_KEY;
 }
 }
+// unreachable - either we returned or skipped a blank line
-prop->text_pos += i + 1;
+assert(false);
 }
 // when we come to this point, all data must have been read
-assert(prop->text_pos == prop->text_size);
+assert(cxBufferEof(&prop->buffer));
+assert(cxBufferEof(&prop->input));
 return CX_PROPERTIES_NO_DATA;
 }
 static int cx_properties_sink_map(
 cx_attr_unused CxProperties *prop,
 static int cx_properties_read_string(
 CxProperties *prop,
 CxPropertiesSource *src,
 cxstring *target
 ) {
-if (prop->text == src->src) {
+if (prop->input.space == src->src) {
 // when the input buffer already contains the string
 // we have nothing more to provide
 target->length = 0;
 } else {
 target->ptr = src->src;
 CxPropertiesSource cxPropertiesStringSource(cxstring str) {
 CxPropertiesSource src;
 src.src = (void*) str.ptr;
 src.data_size = str.length;
+src.data_ptr = NULL;
 src.read_func = cx_properties_read_string;
 src.read_init_func = NULL;
 src.read_clean_func = NULL;
 return src;
 }
 CxPropertiesSource cxPropertiesCstrnSource(const char *str, size_t len) {
 CxPropertiesSource src;
 src.src = (void*) str;
 src.data_size = len;
+src.data_ptr = NULL;
 src.read_func = cx_properties_read_string;
 src.read_init_func = NULL;
 src.read_clean_func = NULL;
 return src;
 }
 CxPropertiesSource cxPropertiesCstrSource(const char *str) {
 CxPropertiesSource src;
 src.src = (void*) str;
 src.data_size = strlen(str);
+src.data_ptr = NULL;
 src.read_func = cx_properties_read_string;
 src.read_init_func = NULL;
 src.read_clean_func = NULL;
 return src;
 }
 CxPropertiesSource cxPropertiesFileSource(FILE *file, size_t chunk_size) {
 CxPropertiesSource src;
 src.src = file;
 src.data_size = chunk_size;
+src.data_ptr = NULL;
 src.read_func = cx_properties_read_file;
 src.read_init_func = cx_properties_read_init_file;
 src.read_clean_func = cx_properties_read_clean_file;
 return src;
 }
 status = found ? CX_PROPERTIES_NO_ERROR : CX_PROPERTIES_NO_DATA;
 break;
 }
 // set the input buffer and read the k/v-pairs
-prop->text = input.ptr;
+cxPropertiesFill(prop, input);
-prop->text_size = input.length;
-prop->text_pos = 0;
 CxPropertiesStatus kv_status;
 do {
 cxstring key, value;
 kv_status = cxPropertiesNext(prop, &key, &value);

Mercurial > hg > ucx / file comparison

comparison: src/properties.c

src/properties.c