ucx/properties.c

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2024 Mike Becker, Olaf Wintermann All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include "cx/properties.h"

#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>

const CxPropertiesConfig cx_properties_config_default = {
    '=',
    '#',
    '\0',
    '\0',
    '\\',
};

void cxPropertiesInit(
        CxProperties *prop,
        CxPropertiesConfig config
) {
    memset(prop, 0, sizeof(CxProperties));
    prop->config = config;
}

void cxPropertiesDestroy(CxProperties *prop) {
    cxBufferDestroy(&prop->input);
    cxBufferDestroy(&prop->buffer);
}

void cxPropertiesReset(CxProperties *prop) {
    CxPropertiesConfig config = prop->config;
    cxPropertiesDestroy(prop);
    cxPropertiesInit(prop, config);
}

int cxPropertiesFilln(
        CxProperties *prop,
        const char *buf,
        size_t len
) {
    if (cxBufferEof(&prop->input)) {
        // destroy a possible previously initialized buffer
        cxBufferDestroy(&prop->input);
        cxBufferInit(&prop->input, NULL, (void*) buf,
                     len, 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
) {
    cxBufferInit(&prop->buffer, NULL, buf, capacity, CX_BUFFER_COPY_ON_EXTEND);
}

CxPropertiesStatus cxPropertiesNext(
        CxProperties *prop,
        cxstring *key,
        cxstring *value
) {
    // check if we have a text buffer
    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;
    
    char comment1 = prop->config.comment1;
    char comment2 = prop->config.comment2;
    char comment3 = prop->config.comment3;
    char delimiter = prop->config.delimiter;
    char continuation = prop->config.continuation;
    
    // check if we have rescued data
    if (!cxBufferEof(&prop->buffer)) {
        // check if we can now get a complete line
        cxstring input = cx_strn(prop->input.space + prop->input.pos,
            prop->input.size - prop->input.pos);
        cxstring nl = cx_strchr(input, '\n');
        while (nl.length > 0) {
            // check for line continuation
            char previous = nl.ptr > input.ptr ? nl.ptr[-1] : prop->buffer.space[prop->buffer.size-1];
            if (previous == continuation) {
                // this nl is a line continuation, check the next newline
                nl = cx_strchr(cx_strsubs(nl, 1), '\n');
            } else {
                break;
            }
        }
        
        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 - input.ptr) + 1;

            if (cxBufferAppend(input.ptr, 1,
                len_until_nl, &prop->buffer) < len_until_nl) {
                return CX_PROPERTIES_BUFFER_ALLOC_FAILED;
            }

            // advance the position in the input buffer
            prop->input.pos += len_until_nl;

            // we now want to read from the rescue buffer
            current_buffer = &prop->buffer;
        } else {
            // still not enough data, copy input buffer to internal buffer
            if (cxBufferAppend(input.ptr, 1,
                input.length, &prop->buffer) < input.length) {
                return CX_PROPERTIES_BUFFER_ALLOC_FAILED; // LCOV_EXCL_LINE
            }
            // reset the input buffer (make way for a re-fill)
            cxBufferReset(&prop->input);
            return CX_PROPERTIES_INCOMPLETE_DATA;
        }
    }
   
    // get one line and parse it
    while (!cxBufferEof(current_buffer)) {
        const char *buf = current_buffer->space + current_buffer->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
         */
        size_t delimiter_index = 0;
        size_t comment_index = 0;
        bool has_comment = false;
        bool has_continuation = false;

        size_t i = 0;
        char c = 0;
        for (; i < len; i++) {
            c = buf[i];
            if (c == comment1 || c == comment2 || c == comment3) {
                if (comment_index == 0) {
                    comment_index = i;
                    has_comment = true;
                }
            } else if (c == delimiter) {
                if (delimiter_index == 0 && !has_comment) {
                    delimiter_index = i;
                }
            } else if (delimiter_index > 0 && c == continuation && i+1 < len && buf[i+1] == '\n') {
                has_continuation = true;
                i++;
            } else if (c == '\n') {
                break;
            }
        }

        if (c != '\n') {
            // we don't have enough data for a line, use the rescue buffer
            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, NULL, 256, 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) :
                        cx_strn(buf, i);
        // check line
        if (delimiter_index == 0) {
            // if line is not blank ...
            line = cx_strtrim(line);
            // ... either no delimiter found, or key is empty
            if (line.length > 0) {
                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,
                    line.length - delimiter_index - 1);
            k = cx_strtrim(k);
            val = cx_strtrim(val);
            if (k.length > 0) {
                current_buffer->pos += i + 1; 
                assert(current_buffer->pos <= current_buffer->size);
                assert(current_buffer != &prop->buffer || current_buffer->pos == current_buffer->size);
                
                if (has_continuation) {
                    char *ptr = (char*)val.ptr;
                    if (current_buffer != &prop->buffer) {
                        // move value to the rescue buffer
                        if (prop->buffer.space == NULL) {
                            cxBufferInit(&prop->buffer, NULL, NULL, 256, CX_BUFFER_AUTO_EXTEND);
                        }
                        prop->buffer.size = 0;
                        prop->buffer.pos = 0;
                        if (cxBufferWrite(val.ptr, 1, val.length, &prop->buffer) != val.length) {
                            return CX_PROPERTIES_BUFFER_ALLOC_FAILED;
                        }
                        val.ptr = prop->buffer.space;
                        ptr = prop->buffer.space;
                    }
                    // value.ptr is now inside the rescue buffer and we can
                    // remove the continuation character from the value
                    bool trim = false;
                    size_t x = 0;
                    for(size_t j=0;j<val.length;j++) {
                        c = ptr[j];
                        if (j+1 < val.length && c == '\\' && ptr[j+1] == '\n') {
                            // skip continuation and newline character
                            j++;
                            trim = true; // enable trim in the next line
                            continue;
                        }
                        if (j > x) {
                            if (trim) {
                                if (isspace((unsigned char)c)) {
                                    continue;
                                }
                                trim = false;
                            }
                            ptr[x] = c;
                        }
                        x++;
                    }
                    val.length = x;
                }
                *key = k;
                *value = val;
                
                return CX_PROPERTIES_NO_ERROR;
            } else {
                return CX_PROPERTIES_INVALID_EMPTY_KEY;
            }
        }
    }

    // when we come to this point, all data must have been read
    assert(cxBufferEof(&prop->buffer));
    assert(cxBufferEof(&prop->input));

    return CX_PROPERTIES_NO_DATA;
}

#ifndef CX_PROPERTIES_LOAD_FILL_SIZE
#define CX_PROPERTIES_LOAD_FILL_SIZE 1024
#endif
const unsigned cx_properties_load_fill_size = CX_PROPERTIES_LOAD_FILL_SIZE;
#ifndef CX_PROPERTIES_LOAD_BUF_SIZE
#define CX_PROPERTIES_LOAD_BUF_SIZE 256
#endif
const unsigned cx_properties_load_buf_size = CX_PROPERTIES_LOAD_BUF_SIZE;

CxPropertiesStatus cx_properties_load(const CxAllocator *allocator,
                                      cxstring filename, CxMap *target, CxPropertiesConfig config) {
    if (allocator == NULL) {
        allocator = cxDefaultAllocator;
    }

    // sanity check for the map
    const bool use_cstring = cxCollectionStoresPointers(target);
    if (!use_cstring && cxCollectionElementSize(target) != sizeof(cxmutstr)) {
        return CX_PROPERTIES_MAP_ERROR;
    }

    // create a duplicate to guarantee zero-termination
    cxmutstr fname = cx_strdup(filename);
    if (fname.ptr == NULL) {
        return CX_PROPERTIES_BUFFER_ALLOC_FAILED; // LCOV_EXCL_LINE
    }

    // open the file
    FILE *f = fopen(fname.ptr, "r");
    if (f == NULL) {
        cx_strfree(&fname);
        return CX_PROPERTIES_FILE_ERROR;
    }

    // initialize the parser
    char linebuf[cx_properties_load_buf_size];
    char fillbuf[cx_properties_load_fill_size];
    CxPropertiesStatus status;
    CxProperties parser;
    cxPropertiesInit(&parser, config);
    cxPropertiesUseStack(&parser, linebuf, cx_properties_load_buf_size);

    // read/fill/parse loop
    status = CX_PROPERTIES_NO_DATA;
    size_t keys_found = 0;
    while (true) {
        size_t r = fread(fillbuf, 1, cx_properties_load_fill_size, f);
        if (ferror(f)) {
            status = CX_PROPERTIES_FILE_ERROR;
            break;
        }
        if (r == 0) {
            break;
        }
        if (cxPropertiesFilln(&parser, fillbuf, r)) {
            status = CX_PROPERTIES_BUFFER_ALLOC_FAILED;
            break;
        }
        cxstring key, value;
        while (true) {
            status = cxPropertiesNext(&parser, &key, &value);
            if (status != CX_PROPERTIES_NO_ERROR) {
                break;
            } else {
                cxmutstr v = cx_strdup_a(allocator, value);
                if (v.ptr == NULL) {
                    status = CX_PROPERTIES_MAP_ERROR;
                    break;
                }
                void *mv = use_cstring ? (void*)v.ptr : &v;
                if (cxMapPut(target, key, mv)) {
                    cx_strfree(&v);
                    status = CX_PROPERTIES_MAP_ERROR;
                    break;
                }
                keys_found++;
            }
        }
        if (status > CX_PROPERTIES_OK) {
            break;
        }
    }

    // cleanup and exit
    fclose(f);
    cxPropertiesDestroy(&parser);
    cx_strfree(&fname);
    if (status == CX_PROPERTIES_NO_DATA && keys_found > 0) {
        return CX_PROPERTIES_NO_ERROR;
    } else {
        return status;
    }
}