ucx: comparison src/properties.c

-:71e7e9ba4b97
+:d2d42cb1d59e
 }
 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
 prop->buf_capacity = capacity;
 prop->buf_size = 0;
 prop->flags |= CX_PROPERTIES_FLAG_USE_STACK;
 }
-enum cx_properties_status cxPropertiesNext(
+CxPropertiesStatus cxPropertiesNext(
 CxProperties *prop,
 cxstring *key,
 cxstring *value
 ) {
 // check if we have a text buffer
 prop->text = prop->buf;
 prop->text_size = prop->buf_size;
 prop->text_pos = 0;
 prop->buf_size = 0;
-enum cx_properties_status result;
+CxPropertiesStatus result;
 result = cxPropertiesNext(prop, key, value);
 // restore original buffer
 prop->text = orig_text;
 prop->text_size = orig_size;
 // do not reset the rescue buffer and return the error
 return result;
 }
 } else {
 // still not enough data
+if (cx_properties_rescue_input(prop)) {
+return CX_PROPERTIES_BUFFER_ALLOC_FAILED;
+}
 return CX_PROPERTIES_INCOMPLETE_DATA;
 }
 }
 char comment1 = prop->config.comment1;
 }
 }
 if (c != '\n') {
 // we don't have enough data for a line
+if (cx_properties_rescue_input(prop)) {
+return CX_PROPERTIES_BUFFER_ALLOC_FAILED;
+}
 return CX_PROPERTIES_INCOMPLETE_DATA;
 }
 cxstring line = has_comment ?
 cx_strn(buf, comment_index) :
 // when we come to this point, all data must have been read
 assert(prop->text_pos == prop->text_size);
 return CX_PROPERTIES_NO_DATA;
 }
+static int cx_properties_sink_map(
+__attribute__((__unused__)) CxProperties *prop,
+CxPropertiesSink *sink,
+cxstring key,
+cxstring value
+) {
+CxMap *map = sink->sink;
+CxAllocator *alloc = sink->data;
+cxmutstr v = cx_strdup_a(alloc, value);
+int r = cx_map_put_cxstr(map, key, v.ptr);
+if (r != 0) cx_strfree_a(alloc, &v);
+return r;
+}
+CxPropertiesSink cxPropertiesMapSink(CxMap *map) {
+CxPropertiesSink sink;
+sink.sink = map;
+sink.data = cxDefaultAllocator;
+sink.sink_func = cx_properties_sink_map;
+return sink;
+}
+static int cx_properties_read_string(
+CxProperties *prop,
+CxPropertiesSource *src,
+cxstring *target
+) {
+if (prop->text == src->src) {
+// when the input buffer already contains the string
+// we have nothing more to provide
+target->length = 0;
+} else {
+target->ptr = src->src;
+target->length = src->data_size;
+}
+return 0;
+}
+static int cx_properties_read_file(
+__attribute__((__unused__)) CxProperties *prop,
+CxPropertiesSource *src,
+cxstring *target
+) {
+target->ptr = src->data_ptr;
+target->length = fread(src->data_ptr, 1, src->data_size, src->src);
+return ferror(src->src);
+}
+static int cx_properties_read_init_file(
+__attribute__((__unused__)) CxProperties *prop,
+CxPropertiesSource *src
+) {
+src->data_ptr = malloc(src->data_size);
+if (src->data_ptr == NULL) return 1;
+return 0;
+}
+static void cx_properties_read_clean_file(
+__attribute__((__unused__)) CxProperties *prop,
+CxPropertiesSource *src
+) {
+free(src->data_ptr);
+}
+CxPropertiesSource cxPropertiesStringSource(cxstring str) {
+CxPropertiesSource src;
+src.src = (void*) str.ptr;
+src.data_size = str.length;
+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.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.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.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;
+}
+CxPropertiesStatus cxPropertiesLoad(
+CxProperties *prop,
+CxPropertiesSink sink,
+CxPropertiesSource source
+) {
+assert(source.read_func != NULL);
+assert(sink.sink_func != NULL);
+// initialize reader
+if (source.read_init_func != NULL) {
+if (source.read_init_func(prop, &source)) {
+return CX_PROPERTIES_READ_INIT_FAILED;
+}
+}
+// transfer the data from the source to the sink
+CxPropertiesStatus status;
+bool found = false;
+while (true) {
+// read input
+cxstring input;
+if (source.read_func(prop, &source, &input)) {
+status = CX_PROPERTIES_READ_FAILED;
+break;
+}
+// no more data - break
+if (input.length == 0) {
+status = found ? CX_PROPERTIES_NO_ERROR : CX_PROPERTIES_NO_DATA;
+break;
+}
+// set the input buffer and read the k/v-pairs
+cxPropertiesInput(prop, input.ptr, input.length);
+CxPropertiesStatus kv_status;
+do {
+cxstring key, value;
+kv_status = cxPropertiesNext(prop, &key, &value);
+if (kv_status == CX_PROPERTIES_NO_ERROR) {
+found = true;
+if (sink.sink_func(prop, &sink, key, value)) {
+kv_status = CX_PROPERTIES_SINK_FAILED;
+}
+}
+} while (kv_status == CX_PROPERTIES_NO_ERROR);
+if (kv_status > CX_PROPERTIES_OK) {
+status = kv_status;
+break;
+}
+}
+if (source.read_clean_func != NULL) {
+source.read_clean_func(prop, &source);
+}
+return status;
+}

Mercurial > hg > ucx / file comparison

comparison: src/properties.c

src/properties.c