stringvarfactory.cpp

Go to the documentation of this file.

/*****************************************************************************
    NumeRe: Framework fuer Numerische Rechnungen
    Copyright (C) 2019  Erik Haenel et al.
 
    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/>.
******************************************************************************/
 
#include "stringvarfactory.hpp"
#include "../../kernel.hpp"
 
using namespace std;
 
namespace NumeRe
{
    bool StringVarFactory::isNumericCandidate(const string& sComponent)
    {
        if (sComponent.front() != '"' && sComponent.find_first_of("+-*/^!&|<>=% ?:,") != string::npos)
        {
            if ((sComponent.front() == '(' || sComponent.front() == '{') && getMatchingParenthesis(sComponent) == sComponent.length()-1)
                return false;
 
            return true;
        }
 
        return false;
    }
 
 
    string StringVarFactory::createStringVectorVar(const vector<string>& vStringVector)
    {
        // Return, if empty (something else went wrong)
        if (!vStringVector.size())
            return "";
 
        string strVectName = "_~STRVECT[" + toString((int)m_mStringVectorVars.size()) + "]";
 
        // Does it already exist?
        if (m_mStringVectorVars.find(strVectName) != m_mStringVectorVars.end())
            throw SyntaxError(SyntaxError::STRING_ERROR, strVectName, SyntaxError::invalid_position);
 
        if (vStringVector.size() == 1 && vStringVector.front().find(strVectName) != std::string::npos)
            throw SyntaxError(SyntaxError::STRING_ERROR, strVectName, SyntaxError::invalid_position);
 
        // save the vector
        m_mStringVectorVars[strVectName] = vStringVector;
 
        return strVectName;
    }
 
 
    bool StringVarFactory::isStringVectorVar(const std::string& sVarName) const
    {
        return m_mStringVectorVars.find(sVarName) != m_mStringVectorVars.end()
            || m_mTempStringVectorVars.find(sVarName) != m_mTempStringVectorVars.end();
    }
 
 
    const StringVector& StringVarFactory::getStringVectorVar(const std::string& sVarName) const
    {
        auto iter = m_mStringVectorVars.find(sVarName);
 
        if (iter != m_mStringVectorVars.end())
            return iter->second;
 
        iter = m_mTempStringVectorVars.find(sVarName);
 
        if (iter != m_mTempStringVectorVars.end())
            return iter->second;
 
        throw std::out_of_range("Could not find " + sVarName + " in the string vectors.");
    }
 
 
    bool StringVarFactory::containsStringVectorVars(const string& sLine)
    {
        // If the command line or the string vector vars are empty return false
        if (!sLine.length() || (!m_mStringVectorVars.size() && !m_mTempStringVectorVars.size()))
            return false;
 
        // Try to find at least one of the known string vector vars
        for (auto iter = m_mTempStringVectorVars.begin(); iter != m_mTempStringVectorVars.end(); ++iter)
        {
            // There's one: return true
            if (sLine.find(iter->first) != string::npos)
                return true;
        }
 
        // Try to find at least one of the known string vector vars
        for (auto iter = m_mStringVectorVars.begin(); iter != m_mStringVectorVars.end(); ++iter)
        {
            // There's one: return true
            if (sLine.find(iter->first) != string::npos)
                return true;
        }
 
        // Nothing found
        return false;
    }
 
 
    StringVector StringVarFactory::evaluateStringVectors(string sLine)
    {
        StringVector vRes;
        const map<string, vector<mu::value_type> >& mNumVectorVars = NumeReKernel::getInstance()->getParser().GetVectors();
        g_logger.info("Evaluating string vector for '" + sLine + "'");
        g_logger.info("Contains vars: " + toString(containsStringVectorVars(sLine)));
        g_logger.info("Contains parser vars: " + toString(NumeReKernel::getInstance()->getParser().ContainsVectorVars(sLine, false)));
 
        // As long as the current vector is not empty
        while (sLine.length())
        {
            // Get-cut the next argument
            string sCurrentComponent = getNextArgument(sLine, true);
 
            // If the current component does not contain any further
            // vectors, push it back.
            // Otherwise expand the contained vectors
            //if (!containsStringVectorVars(sCurrentComponent))
            //    vRes.push_back(sCurrentComponent);
            //else
            {
                // Expand the contained vectors
                size_t nCurrentComponent = 0;
 
                // This while loop is terminated with a break command
                while (true)
                {
                    string currentline = sCurrentComponent;
                    bool bHasComponents = false;
 
                    // Replace all found numerical vectors with their nCurrentComponent-th component
                    for (auto iter = mNumVectorVars.begin(); iter != mNumVectorVars.end(); ++iter)
                    {
                        size_t nMatch = 0;
 
                        // Vector found: replace its occurence with its nCurrentComponent-th value
                        while ((nMatch = currentline.find(iter->first, nMatch)) != string::npos)
                        {
                            // Do not replace vector variables, which are part
                            // of a string
                            if (isInQuotes(currentline, nMatch)
                                || (nMatch && !isDelimiter(currentline[nMatch-1]))
                                || (nMatch + iter->first.length() < currentline.length() && !isDelimiter(currentline[nMatch+iter->first.length()])))
                            {
                                nMatch++;
                                continue;
                            }
 
                            // Handle the size of the current vector correspondingly
                            if ((iter->second).size() > nCurrentComponent)
                            {
                                bHasComponents = true;
                                currentline.replace(nMatch, (iter->first).length(), toCmdString((iter->second)[nCurrentComponent]));
                            }
                            else if ((iter->second).size() == 1)
                                currentline.replace(nMatch, (iter->first).length(), toCmdString((iter->second)[0]));
                            else
                                currentline.replace(nMatch, (iter->first).length(), "nan");
                        }
                    }
 
                    // Replace all internal vectors
                    replaceStringVectorVars(m_mStringVectorVars, currentline, nCurrentComponent, bHasComponents);
 
                    // Replace all temporary vectors
                    replaceStringVectorVars(m_mTempStringVectorVars, currentline, nCurrentComponent, bHasComponents);
 
                    // Break the loop, if there are no further vector components
                    if (!bHasComponents)
                        break;
 
                    // Push back the current line and increment the component
                    vRes.push_generic(currentline);
                    nCurrentComponent++;
                }
            }
        }
 
        return vRes;
    }
 
 
    StringVector StringVarFactory::expandStringVectorComponents(std::vector<StringVector>& vStringVector)
    {
        // If the vector contains only one element,
        // then return it directly
        if (vStringVector.size() == 1)
            return vStringVector.front();
 
        // Concatenate all embedded vectors to a single component
        StringVector vRet = vStringVector.front();
 
        for (size_t i = 1; i < vStringVector.size(); i++)
        {
            vRet.insert(vRet.end(), vStringVector[i].begin(), vStringVector[i].end());
        }
 
        // Return the concatenated result
        return vRet;
    }
 
 
    void StringVarFactory::removeStringVectorVars()
    {
        if (m_mStringVectorVars.size())
            m_mStringVectorVars.clear();
    }
 
 
    string StringVarFactory::createTempStringVectorVar(const vector<string>& vStringVector)
    {
        // Return, if empty (something else went wrong)
        if (!vStringVector.size())
            return "";
 
        // Does it already exist?
        string strVectName = findVectorInMap(m_mTempStringVectorVars, vStringVector);
 
        if (strVectName.length())
            return strVectName;
 
        strVectName = "_~TEMPSTRVECT[" + toString((int)m_mTempStringVectorVars.size()) + "]";
 
        // save the vector
        m_mTempStringVectorVars[strVectName] = vStringVector;
 
        return strVectName;
    }
 
 
    void StringVarFactory::removeTempStringVectorVars()
    {
        if (m_mTempStringVectorVars.size())
            m_mTempStringVectorVars.clear();
    }
 
 
    bool StringVarFactory::checkStringvarDelimiter(const string& sToken) const
    {
        static const string sDELIMITER = "+-*/ ()={}^&|!<>,\\%#[]?:\";";
 
        // The opening parenthesis at the end indicates a function.
        // This is obviously not a string variable
        if (sToken.back() == '(')
            return false;
 
        // If the first and the last character are part of the
        // delimiter list (or the last character is a dot), then
        // we indicate the current token as delimited.
        return sDELIMITER.find(sToken.front()) != string::npos && (sDELIMITER.find(sToken.back()) != string::npos || sToken.back() == '.');
    }
 
 
    void StringVarFactory::replaceStringVectorVars(map<string,StringVector>& mVectorVarMap, string& currentline, size_t nCurrentComponent, bool& bHasComponents)
    {
        // Replace all found vectors with their nCurrentComponent-th component
        for (auto iter = mVectorVarMap.begin(); iter != mVectorVarMap.end(); ++iter)
        {
            size_t nMatch = 0;
 
            // Vector found: replace its occurence with its nCurrentComponent-th value
            while ((nMatch = currentline.find(iter->first)) != string::npos)
            {
                // Handle the size of the current vector correspondingly
                if ((iter->second).size() > nCurrentComponent)
                {
                    bHasComponents = true;
 
                    if (!iter->second.is_string(nCurrentComponent))
                        currentline.replace(nMatch, (iter->first).length(), "(" + (iter->second).getMasked(nCurrentComponent) + ")");
                    else
                        currentline.replace(nMatch, (iter->first).length(), (iter->second).getMasked(nCurrentComponent));
                }
                else if ((iter->second).size() == 1)
                {
                    if (!iter->second.is_string(0))
                        currentline.replace(nMatch, (iter->first).length(), "(" + (iter->second).getMasked(0) + ")");
                    else
                        currentline.replace(nMatch, (iter->first).length(), (iter->second).getMasked(0));
                }
                else
                    currentline.replace(nMatch, (iter->first).length(), "\"\"");
            }
        }
    }
 
 
    string StringVarFactory::findVectorInMap(const map<string,StringVector>& mVectorVarMap, const vector<string>& vStringVector)
    {
        // Go through the map
        for (auto iter = mVectorVarMap.begin(); iter != mVectorVarMap.end(); ++iter)
        {
            // Compare first size and the first component
            if (iter->second.size() == vStringVector.size() && iter->second[0] == vStringVector[0])
            {
                // If both appear similar, compare every
                // component
                for (size_t i = 1; i < vStringVector.size(); i++)
                {
                    // Break if a component is not equal
                    if (vStringVector[i] != iter->second.at(i))
                        break;
 
                    // Return the vector name, if all components
                    // appear equal
                    if (i == vStringVector.size()-1)
                        return iter->first;
                }
            }
        }
 
        // Return an empty string, if nothing was found
        return "";
    }
 
 
    bool StringVarFactory::containsStringVars(const string& _sLine) const
    {
        // Do nothing, if no string variables were declared
        if (!m_mStringVars.size())
            return false;
 
        // Add whitespaces for safety
        string sLine = " " + _sLine + " ";
 
        // Search for the first match of all declared string variables
        for (auto iter = m_mStringVars.begin(); iter != m_mStringVars.end(); ++iter)
        {
            size_t pos = 0;
 
            // Examine all possible candidates for string variables,
            // because the first one might be a false-positive
            while ((pos = sLine.find(iter->first, pos)) != std::string::npos)
            {
                // Compare the located match to the delimiters and return
                // true, if the match is delimited on both sides
                if (sLine[pos+(iter->first).length()] != '('
                    && checkStringvarDelimiter(sLine.substr(pos-1, (iter->first).length()+2))
                    )
                    return true;
 
                pos++;
            }
        }
 
        // No match found
        return false;
    }
 
 
    bool StringVarFactory::isStringVar(const std::string& sVarName) const
    {
        return m_mStringVars.find(sVarName) != m_mStringVars.end();
    }
 
 
    void StringVarFactory::getStringValuesAsInternalVar(std::string& sLine, unsigned int nPos)
    {
        // Do nothing, if no string variables were declared
        if (!m_mStringVars.size())
            return;
 
        unsigned int __nPos;
        sLine += " ";
 
        // Try to find every string variable into the passed string and
        // replace it correspondingly
        for (auto iter = m_mStringVars.begin(); iter != m_mStringVars.end(); ++iter)
        {
            __nPos = nPos;
            std::string sVectVar;
 
            // Examine all occurences of the current variable in the
            // string
            while ((__nPos = sLine.find(iter->first, __nPos)) != string::npos)
            {
                __nPos++;
 
                // Appended opening parenthesis indicates a function
                if (sLine[__nPos+(iter->first).length()-1] == '('
                    || sLine[__nPos+(iter->first).length()-1] == '{')
                    continue;
 
                // Only create the variable, if it is actually needed
                if (!sVectVar.length())
                    sVectVar = createStringVectorVar(std::vector<std::string>(1, "\""+iter->second+"\""));
                    //sVectVar = "\""+iter->second+"\"";
 
                // Check, whether the found occurence is correctly
                // delimited and replace it. If the match is at the
                // beginning of the command line, it serves a special
                // treatment
                if (__nPos == 1)
                {
                    // Check with delimiter
                    if (checkStringvarDelimiter(" " + sLine.substr(0, (iter->first).length()+1))
                        && !isInQuotes(sLine, 0, true))
                    {
                        // Replace it with standard function signature or its value
                        if (sLine[(iter->first).length()] == '.')
                            replaceStringMethod(sLine, 0, (iter->first).length(), sVectVar);
                        else
                            sLine.replace(0, (iter->first).length(), sVectVar);
                    }
 
                    continue;
                }
 
                // Check with delimiter
                if (checkStringvarDelimiter(sLine.substr(__nPos-2, (iter->first).length()+2))
                    && !isInQuotes(sLine, __nPos-1, true))
                {
                    // Replace it with standard function signature or its value
                    if (sLine[__nPos+(iter->first).length()-1] == '.')
                        replaceStringMethod(sLine, __nPos-1, (iter->first).length(), sVectVar);
                    else
                        sLine.replace(__nPos-1, (iter->first).length(), sVectVar);
                }
            }
        }
    }
 
 
    void StringVarFactory::getStringValues(std::string& sLine)
    {
        // Do nothing, if no string variables were declared
        if (!m_mStringVars.size())
            return;
 
        unsigned int __nPos;
        sLine += " ";
 
        // Try to find every string variable into the passed string and
        // replace it correspondingly
        for (auto iter = m_mStringVars.begin(); iter != m_mStringVars.end(); ++iter)
        {
            __nPos = 0;
            std::string sVectVar;
 
            // Examine all occurences of the current variable in the
            // string
            while ((__nPos = sLine.find(iter->first, __nPos)) != string::npos)
            {
                __nPos++;
 
                // Appended opening parenthesis indicates a function
                if (sLine[__nPos+(iter->first).length()-1] == '('
                    || sLine[__nPos+(iter->first).length()-1] == '{')
                    continue;
 
                // Only create the variable, if it is actually needed
                if (!sVectVar.length())
                    sVectVar = "\""+iter->second+"\"";
 
                // Check, whether the found occurence is correctly
                // delimited and replace it. If the match is at the
                // beginning of the command line, it serves a special
                // treatment
                if (__nPos == 1)
                {
                    // Check with delimiter
                    if (checkStringvarDelimiter(" " + sLine.substr(0, (iter->first).length()+1))
                        && !isInQuotes(sLine, 0, true))
                    {
                        // Replace it with standard function signature or its value
                        if (sLine[(iter->first).length()] == '.')
                            replaceStringMethod(sLine, 0, (iter->first).length(), sVectVar);
                        else
                            sLine.replace(0, (iter->first).length(), sVectVar);
                    }
 
                    continue;
                }
 
                // Check with delimiter
                if (checkStringvarDelimiter(sLine.substr(__nPos-2, (iter->first).length()+2))
                    && !isInQuotes(sLine, __nPos-1, true))
                {
                    // Replace it with standard function signature or its value
                    if (sLine[__nPos+(iter->first).length()-1] == '.')
                        replaceStringMethod(sLine, __nPos-1, (iter->first).length(), sVectVar);
                    else
                        sLine.replace(__nPos-1, (iter->first).length(), sVectVar);
                }
            }
        }
    }
 
 
    std::string StringVarFactory::getStringValue(const std::string& sVar) const
    {
        auto iter = m_mStringVars.find(sVar);
 
        if (iter == m_mStringVars.end())
            return "";
 
        return iter->second;
    }
 
 
    void StringVarFactory::setStringValue(const string& sVar, const string& sValue)
    {
        static const string sVALIDCHARACTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_1234567890~";
 
        // Variable names cannot start with a number
        if (sVar[0] >= '0' && sVar[0] <= '9')
            throw SyntaxError(SyntaxError::STRINGVARS_MUSTNT_BEGIN_WITH_A_NUMBER, "", SyntaxError::invalid_position, sVar);
 
        // Compare every character to the list of valid characters,
        // to ensure that the name is absolutly valid
        for (unsigned int i = 0; i < sVar.length(); i++)
        {
            if (sVALIDCHARACTERS.find(sVar[i]) == string::npos)
                throw SyntaxError(SyntaxError::STRINGVARS_MUSTNT_CONTAIN, "", SyntaxError::invalid_position, sVar.substr(i,1));
        }
 
        // Create or update the variable name with the passed value.
        // Omit the surrounding quotation marks
        if (sValue[0] == '"' && sValue[sValue.length()-1] == '"')
            m_mStringVars[sVar] = sValue.substr(1,sValue.length()-2);
        else
            m_mStringVars[sVar] = sValue;
    }
 
 
    void StringVarFactory::removeStringVar(const string& sVar)
    {
        // Do nothing, if no string variables were declared
        if (!m_mStringVars.size())
            return;
 
        // Delete the string variable, if it exists
        auto iter = m_mStringVars.find(sVar);
        if (iter != m_mStringVars.end())
            m_mStringVars.erase(iter);
    }
 
}