parse.cpp

Go to the documentation of this file.

/*
All original material Copyright (C) 2002-2020 UFO: Alien Invasion.

Copyright (C) 1997-2001 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#include "parse.h"
#include "defines.h"
#include "ufotypes.h"

static char com_token[4096];
static bool isUnparsedToken;
static Com_TokenType_t type;

void Com_UnParseLastToken (void)
{
    isUnparsedToken = true;
}

const char* Com_GetToken (const char** data_p)
{
    return com_token;
}

Com_TokenType_t Com_GetType (const char** data_p)
{
    return type;
}

Com_TokenType_t Com_NextToken (const char** data_p)
{
    Com_Parse(data_p);
    return type;
}

int Com_CountTokensInBuffer (const char* buffer)
{
    const char* text = buffer;
    int n = 0;
    for (;;) {
        Com_Parse(&text);
        if (!text)
            break;
        n++;
    }
    return n;
}

const char* Com_Parse (const char* data_p[], char* target, size_t size, bool replaceWhitespaces)
{
    char c;
    size_t len;
    const char* data;

    if (!target) {
        target = com_token;
        size = sizeof(com_token);
    }

    if (isUnparsedToken) {
        isUnparsedToken = false;
        return target;
    }

    data = *data_p;
    len = 0;
    target[0] = '\0';

    if (!data) {
        *data_p = nullptr;
        type = TT_EOF;
        return "";
    }

    /* skip whitespace */
skipwhite:
    while ((c = *data) <= ' ') {
        if (c == 0) {
            *data_p = nullptr;
            type = TT_EOF;
            return "";
        }
        data++;
    }

    if (c == '/' && data[1] == '*') {
        int clen = 0;
        data += 2;
        while (!((data[clen] && data[clen] == '*') && (data[clen + 1] && data[clen + 1] == '/'))) {
            clen++;
        }
        data += clen + 2; /* skip end of multiline comment */
        goto skipwhite;
    }

    /* skip // comments */
    if (c == '/' && data[1] == '/') {
        while (*data && *data != '\n')
            data++;
        goto skipwhite;
    }

    /* handle quoted strings specially */
    if (c == '\"') {
        data++;
        for (;;) {
            c = *data++;
            if (c == '\\' && data[0] == 'n') {
                if (replaceWhitespaces) {
                    c = '\n';
                    data++;
                }
            } else if (c == '\\' && data[0] == 't') {
                if (replaceWhitespaces) {
                    c = '\t';
                    data++;
                }
            /* nested quotation */
            } else if (c == '\\' && data[0] == '\"') {
                c = '\"';
                data++;
            } else if (c == '\"' || !c) {
                target[len] = '\0';
                *data_p = data;
                type = TT_QUOTED_WORD;
                return target;
            } else if (c == '\0') {
                // TODO here the token is wrongly formed
                break;
            }

            if (len < size) {
                if (c != '\r') {
                    target[len] = c;
                    len++;
                }
            } else {
                /* exceeded com_token size */
                break;
            }
        }

        if (len == size) {
            len = 0;
        }

        // TODO here the token is wrongly formed
        target[len] = '\0';
        *data_p = data;
        type = TT_QUOTED_WORD;
        return target;
    }

    if (c == '{' || c == '}' || c == '(' || c == ')' || c == ',') {
        data++;
        target[len] = c;
        target[len + 1] = '\0';
        // Com_TokenType_t contains expected values for this set of characters
        type = (Com_TokenType_t) c;
        len++;
        *data_p = data;
        return target;
    }

    /* parse a regular word */
    do {
        if (len < size) {
            target[len] = c;
            len++;
        } else {
            /* exceeded com_token size */
            break;
        }
        data++;
        c = *data;
        if (c == '{' || c == '}' || c == '(' || c == ')' || c == ',')
            break;
    } while (c > ' ');

    if (len == size) {
        len = 0;
    }
    target[len] = '\0';

    *data_p = data;
    type = TT_WORD;
    return target;
}

void Com_SkipBlock (const char** text)
{
    int depth = 1;

    do {
        const char* token = Com_Parse(text);
        if (*token == '{')
            depth++;
        else if (*token == '}')
            depth--;
    } while (depth && *text);
}

int Com_GetBlock (const char** text, const char** start)
{
    const char* token = Com_Parse(text);
    if (*token != '{')
        return -1;
    *start = *text;
    Com_SkipBlock(text);
    const char* end = *text - 1;    /* The pointer to the end of the block */
    return end - *start;
}