int ParseConf()

in lsvmutils/conf.c [78:212]
97 lines of code
20 McCabe index (conditional complexity)

int ParseConf(
    const char* text,
    unsigned long textSize,
    ConfCallback callback,
    void* callbackData,
    unsigned int* errorLine,
    Error* err)
{
    int status = 0;
    const char* line;
    const char* textEnd;
    unsigned int lineNum = 0;
    char* namePtr = NULL;
    char* valuePtr = NULL;

    /* Check parameters */
    if (!text || !textSize || !errorLine || !err)
    {
        SetErr(err, TCS("invalid parameter"));
        status = -1;
        goto done;
    }

    /* Set pointer to the end of the text */
    textEnd = text + textSize;

    /* Clear error state */
    *errorLine = 0;
    ClearErr(err);

    /* Process lines of the format NAME=SHA1:SHA256 */
    while ((line = _GetLine(&text, textEnd)))
    {
        const char* p = line;
        const char* end = text;
        const char* name = NULL;
        UINTN nameLen = 0;
        const char* value = NULL;
        UINTN valueLen = 0;

        /* Increment the line number */
        lineNum++;

        /* Strip horizontal whitespace */
        p = _SkipWhitespace(p, end);

        /* Skip blank lines and comment lines */
        if (p == end || *p == '#')
            continue;

        /* Remove trailing whitespace */
        while (end != p && Isspace(end[-1]))
            end--;

        /* Recognize the name: [A-Za-z_][A-Za-z_0-9] */
        {
            const char* start = p;

            p = _SkipIdentifier(p, end);

            if (p == start)
            {
                SetErr(err, TCS("expected name"));
                status = -1;
                goto done;
            }

            /* Save the name */
            name = start;
            nameLen = p - start;
        }

        /* Expect a '=' */
        {
            p = _SkipWhitespace(p, end);

            if (p == end || *p++ != '=')
            {
                SetErr(err, TCS("syntax error: expected '='"));
                status = -1;
                goto done;
            }

            p = _SkipWhitespace(p, end);
        }

        /* Get the value */
        {
            value = p;
            valueLen = end - p;
        }

        /* Invoke the callback */
        if (callback)
        {
            if (!(namePtr = Strndup(name, nameLen)))
            {
                SetErr(err, TCS("out of memory"));
                status = -1;
                goto done;
            }

            if (!(valuePtr = Strndup(value, valueLen)))
            {
                SetErr(err, TCS("out of memory"));
                status = -1;
                goto done;
            }

            if ((*callback)(namePtr, valuePtr, callbackData, err) != 0)
            {
                status = -1;
                goto done;
            }

            Free(namePtr);
            namePtr = NULL;
            Free(valuePtr);
            valuePtr = NULL;
        }
    }

done:

    if (status != 0)
        *errorLine = lineNum;

    if (namePtr)
        Free(namePtr);

    if (valuePtr)
        Free(valuePtr);

    return status;
}