CWE-ou-minkata/Sources/Plasma/NucleusLib/pnUtils/Private/pnUtSubst.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, 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 3 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, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
/*****************************************************************************
*
*   $/Plasma20/Sources/Plasma/NucleusLib/pnUtils/Private/pnUtSubst.cpp
*   
***/

#include "../Pch.h"
#pragma hdrstop

#define SUBST_BLOCK SubstParsedData<chartype>::SubstBlock<chartype>

/*****************************************************************************
*
*   Internal functions
*
***/

//============================================================================
template <typename chartype>
bool IVarSubstitute (
    ARRAY(chartype) *   dst,
    const chartype      src[],
    unsigned            varCount,
    const chartype *    varNames[],   // [varCount]
    const chartype *    varValues[]   // [varCount]
) {
    ASSERT(dst);
    ASSERT(src);
    ASSERT(varNames);
    ASSERT(varValues);

    dst->Reserve(StrLen(src) * 5/4);

    bool result = true;
    while (*src) {
        // Copy non-substituted strings and escape %% symbols
        if ((*src != L'%') || (*++src == L'%')) {
            dst->Push(*src++);
            continue;
        }

        // Find variable definition
        const chartype * varStart   = src;
        const chartype * varEnd     = StrChr(varStart, L'%');
        if (!varEnd) {
            // Skip % character and continue
            result = false;
            continue;
        }

        // Validate variable name length
        chartype varBuffer[256];
        if (varEnd - varStart >= arrsize(varBuffer)) {
            result = false;
            src = varEnd + 1;
            continue;
        }

        // Copy variable name excluding trailing '%'
        StrCopy(varBuffer, varStart, varEnd - varStart + 1);
        src = varEnd + 1;

        // Find the variable value and perform substitution
        bool found = false;
        for (unsigned i = 0; i < varCount; ++i) {
            if (StrCmp(varBuffer, varNames[i]))
                continue;
            dst->Add(varValues[i], StrLen(varValues[i]));
            found = true;
            break;
        }

        // Check that variable definition exists
        result = result && found;
    }

    // Terminate string
    dst->Push(0);
    return result;
}

//============================================================================
template <typename chartype>
bool IParseForSubst (
    SubstParsedData<chartype> *     dest,
    const chartype                  src[]
) {
    const chartype * current = src;
    bool result = true;
    while (*current) {
        // Copy non-substituted strings and escape %% symbols
        if ((*current != L'%') || (*++current == L'%')) {
            current++;
            continue;
        }

        // Find variable definition
        const chartype * varStart   = current;
        const chartype * varEnd     = StrChr(varStart, L'%');
        if (!varEnd) {
            // Skip % character and continue
            result = false;
            continue;
        }

        // We've found a variable, copy the current data to a new object
        if (current != src) {
            int strLen = (current - src) - 1;
            SUBST_BLOCK * block = NEW(SUBST_BLOCK);
            block->isVar    = false;
            block->strLen   = strLen;
            block->data     = (chartype*)ALLOCZERO((strLen + 1) * sizeof(chartype));
            MemCopy(block->data, src, strLen * sizeof(chartype));

            dest->blocks.Add(block);
        }

        // Validate variable name length
        chartype varBuffer[256];
        if (varEnd - varStart >= arrsize(varBuffer)) {
            result = false;
            src = current = varEnd + 1;
            continue;
        }

        // Copy variable name excluding trailing '%'
        int strLen = (varEnd - varStart);
        SUBST_BLOCK * block = NEW(SUBST_BLOCK);
        block->isVar    = true;
        block->strLen   = strLen;
        block->data     = (chartype*)ALLOCZERO((strLen + 1) * sizeof(chartype));
        MemCopy(block->data, varStart, strLen * sizeof(chartype));

        dest->blocks.Add(block);

        src = current = varEnd + 1;
    }

    // Check and see if there's any data remaining
    if (current != src) {
        int strLen = (current - src);
        SUBST_BLOCK * block = NEW(SUBST_BLOCK);
        block->isVar    = false;
        block->strLen   = strLen;
        block->data     = (chartype*)ALLOCZERO((strLen + 1) * sizeof(chartype));
        MemCopy(block->data, src, strLen * sizeof(chartype));

        dest->blocks.Add(block);
    }

    return result;
}

//============================================================================
template <typename chartype>
bool IVarSubstPreParsed (
    ARRAY(chartype) *                   dst,
    const SubstParsedData<chartype> *   src,
    unsigned                            varCount,
    const chartype *                    varNames[],   // [varCount]
    const chartype *                    varValues[]   // [varCount]
) {
    unsigned approxTotalSize = 0;
    for (unsigned i = 0; i < src->blocks.Count(); ++i) {
        approxTotalSize += src->blocks[i]->strLen;
    }

    dst->Reserve(approxTotalSize * 5/4);

    bool foundAll = true;
    for (unsigned blockIndex = 0; blockIndex < src->blocks.Count(); ++blockIndex) {
        SUBST_BLOCK * block = src->blocks[blockIndex];
        if (block->isVar) {
            bool found = false;
            for (unsigned varIndex = 0; varIndex < varCount; ++varIndex) {
                if (StrCmp(block->data, varNames[varIndex])) {
                    continue;
                }

                dst->Add(varValues[varIndex], StrLen(varValues[varIndex]));
                found = true;
                break;
            }

            foundAll &= found;
        }
        else {
            dst->Add(block->data, block->strLen);
        }
    }
    dst->Push(0);

    return foundAll;
}


/*****************************************************************************
*
*   Exports
*
***/

//============================================================================
bool ParseForSubst (
    SubstParsedData<wchar> *    dest,
    const wchar                 src[]
) {
    return IParseForSubst(dest, src);
}

//============================================================================
bool ParseForSubst (
    SubstParsedData<char> *     dest,
    const char                  src[]
) {
    return IParseForSubst(dest, src);
}

//============================================================================
bool VarSubstitute (
    ARRAY(wchar) *  dst,
    const wchar     src[],
    unsigned        varCount,
    const wchar *   varNames[],   // [varCount]
    const wchar *   varValues[]   // [varCount]
) {
    return IVarSubstitute(dst, src, varCount, varNames, varValues);
}

//============================================================================
bool VarSubstitute (
    ARRAY(char) *   dst,
    const char      src[],
    unsigned        varCount,
    const char *    varNames[],    // [varCount]
    const char *    varValues[]    // [varCount]
) {
    return IVarSubstitute(dst, src, varCount, varNames, varValues);
}

//============================================================================
bool VarSubstitute (
    ARRAY(wchar) *                      dst,
    const SubstParsedData<wchar> *      src,
    unsigned                            varCount,
    const wchar *                       varNames[],   // [varCount]
    const wchar *                       varValues[]   // [varCount]
) {
    return IVarSubstPreParsed(dst, src, varCount, varNames, varValues);
}

//============================================================================
bool VarSubstitute (
    ARRAY(char) *                       dst,
    const SubstParsedData<char> *       src,
    unsigned                            varCount,
    const char *                        varNames[],   // [varCount]
    const char *                        varValues[]   // [varCount]
) {
    return IVarSubstPreParsed(dst, src, varCount, varNames, varValues);
}