tools.cpp

Go to the documentation of this file.

/*****************************************************************************
    NumeRe: Framework fuer Numerische Rechnungen
    Copyright (C) 2014  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 "tools.hpp"
#include "../../kernel.hpp"
#include "../io/file.hpp"
#include <cstdlib>
#include <omp.h>
 
 
class ThreadsafeRandGen
{
    private:
        std::vector<std::mt19937> m_randGenArray;
 
    public:
        ThreadsafeRandGen()
        {
            double t = time(0);
 
            for (int i = 0; i < omp_get_max_threads(); i++)
            {
                m_randGenArray.push_back(std::mt19937(t+i));
            }
        }
 
        std::mt19937& getGenerator()
        {
            int threadId = omp_get_thread_num();
 
            if (threadId >= (int)m_randGenArray.size())
                throw std::out_of_range("Requested a random number generator for thread " + std::to_string(threadId)
                                        + ", which is larger than the number of available generators (i.e. "
                                        + std::to_string(m_randGenArray.size()) + ")");
 
            return m_randGenArray[threadId];
        }
 
};
 
 
static ThreadsafeRandGen randGenerator;
 
 
std::mt19937& getRandGenInstance()
{
    return randGenerator.getGenerator();
}
 
using namespace std;
 
int findParameter(const string& sCmd, const string& sParam, const char cFollowing)
{
    // --> Wenn kein '-' im string zu finden ist, ist da auch kein Parameter: FALSE zurueckgeben <--
    if (sCmd.find('-') == string::npos)
        return 0;
    else
    {
        // There's a minus sign.
        // Transform everything to lower case to avoid case sensitivity
        string __sCmd = toLowerCase(sCmd + " ");
        int nQuotes = 0;
        size_t nParamStart = string::npos;
        bool isOptionValue = false;
 
        // Go through the complete string
        for (size_t i = 0; i < __sCmd.length(); i++)
        {
            // Count the quotation marks, so that we're not inside of a string
            if (__sCmd[i] == '"'
                    && (!i || (i && __sCmd[i - 1] != '\\')))
                nQuotes++;
 
            // If all quotation marks are pairs and we found a minus sign, then we're probably at the start of a parameter
            if (!(nQuotes % 2) && __sCmd[i] == '-' && nParamStart == string::npos)
            {
                nParamStart = i;
            }
 
            // Detect option values and force NumeRe to ignore
            // them in this context
            if (nParamStart != string::npos
                && !(nQuotes % 2)
                && !isOptionValue
                && __sCmd[i] == '=')
            {
                isOptionValue = true;
 
                // jump over the following white spaces
                while (i+1 < __sCmd.length() && __sCmd[i+1] == ' ')
                    i++;
            }
            else if (nParamStart != string::npos
                && !(nQuotes % 2)
                && isOptionValue
                && __sCmd[i] == ' ')
                isOptionValue = false;
 
            // If we found a paramter start and the substring with the length of the searched parameter
            // is matching to the searched parameter, then we go into this block
            if (nParamStart != string::npos
                    && !(nQuotes % 2)
                    && !isOptionValue
                    && __sCmd.substr(i, sParam.length()) == toLowerCase(sParam))
            {
                /* --> Pruefe die Zeichen davor und danach (unter Beachtung eines moeglicherweise
                 *     speziell gewaehlten Zeichens) <--
                 * --> Ein Parameter darf auf jeden Fall kein Teil eines anderen, laengeren Wortes
                 *     sein <--
                 */
                if (cFollowing == ' ')
                {
                    // Examine the characters before and after the found parameter match
                    if ((__sCmd[i - 1] == ' '
                            || __sCmd[i - 1] == '-')
                            && (__sCmd[i + sParam.length()] == ' '
                                || __sCmd[i + sParam.length()] == '-'
                                || __sCmd[i + sParam.length()] == '='
                                || __sCmd[i + sParam.length()] == '"')
                       )
                    {
                        // Avoid the identification of an option value as parameter
                        if (__sCmd[i - 1] == ' ' && __sCmd[__sCmd.find_last_not_of(' ', i - 1)] == '=')
                            i += sParam.length() - 1; // Add the parameter length to the loop index and continue
                        else
                            return i + 1;  // i+1 zurueckgeben, wenn Treffer
                    }
                    else
                        i += sParam.length() - 1;  // Positionsindex um die Laenge des Parameters weitersetzen
                }
                else
                {
                    // --> Wenn ein spezielles Zeichen gewaehlt wurde, wird dies hier gesucht <--
                    if ((__sCmd[i - 1] == ' ' || __sCmd[i - 1] == '-')
                            && (__sCmd[i + sParam.length()] == cFollowing))
                    {
                        // The following char matches explicit to the searched character
                        // Avoid the identification of an option value as parameter
                        if (__sCmd[i - 1] == ' ' && __sCmd[__sCmd.find_last_not_of(' ', i - 1)] == '=')
                            i += sParam.length() - 1;
                        else
                            return i + 1;
                    }
                    else if ((__sCmd[i - 1] == ' ' || __sCmd[i - 1] == '-')
                             && (__sCmd[i + sParam.length()] == ' '))
                    {
                        // The following character is a white space. We'll handle that further down
                        // First ensure that we did't find an option value
                        if (__sCmd[i - 1] == ' ' && __sCmd[__sCmd.find_last_not_of(' ', i - 1)] == '=')
                            i += sParam.length() - 1;
                        else
                        {
                            /* --> Fehlertoleranz: Leerzeichen zwischen dem Parameter und cFollowing werden ignoriert
                             *     (wenn cFollowing sowieso ein Leerzeichen sein sollte, wurde das ohnehin vorhin schon abgefangen) <--
                             */
                            int nSkip = 0;
                            while (i + sParam.length() + nSkip < __sCmd.length() && __sCmd[i + sParam.length() + nSkip] == ' ')
                                nSkip++;
                            if (__sCmd[i + sParam.length() + nSkip] == cFollowing)
                                return i + 1 + nSkip; // Wir addieren nSkip, da der Rueckgabewert vorzugsweise zum Navigieren zum Ende des Parameters verwendet wird
                            else
                                i += sParam.length() - 1;
                        }
                    }
                    else
                        i += sParam.length() - 1;
                }
            }
        }
    }
 
    // --> Wenn nichts gefunden wurde, gib' FALSE zurueck <--
    return 0;
}
 
 
bool getStringArgument(const string& sCmd, string& sArgument)
{
    size_t nPos = 0;
 
    // --> Wenn kein '"' oder kein '#' zu finden ist, gibt es auch kein String-Argument: FALSE zurueckgeben <--
    if (!containsStrings(sCmd))
        return false;
 
    if (sCmd.front() != '=')
    {
        // If the first character is not an equal sign, then try to find the first string operation part
        // This block only handles a small set of all available string functions
        nPos = sCmd.find('"');
 
        if (sCmd.find('#') != string::npos && (sCmd.find('#') < nPos || nPos == string::npos))
            nPos = sCmd.find('#');
 
        if (sCmd.find("to_string(") != string::npos && (sCmd.find("to_string(") < nPos || nPos == string::npos))
            nPos = sCmd.find("to_string(");
 
        if (sCmd.find("string(") != string::npos && (sCmd.find("string(") < nPos || nPos == string::npos))
            nPos = sCmd.find("string(");
 
        if (sCmd.find("substr(") != string::npos && (sCmd.find("substr(") < nPos || nPos == string::npos))
            nPos = sCmd.find("substr(");
 
        if (sCmd.find("strlen(") != string::npos && (sCmd.find("strlen(") < nPos || nPos == string::npos))
            nPos = sCmd.find("strlen(");
 
        if (sCmd.find("strfnd(") != string::npos && (sCmd.find("strfnd(") < nPos || nPos == string::npos))
            nPos = sCmd.find("strfnd(");
 
        if (sCmd.find("ascii(") != string::npos && (sCmd.find("ascii(") < nPos || nPos == string::npos))
            nPos = sCmd.find("ascii(");
 
        if (sCmd.find("to_char(") != string::npos && (sCmd.find("to_char(") < nPos || nPos == string::npos))
            nPos = sCmd.find("to_char(");
 
        if (sCmd.find("char(") != string::npos && (sCmd.find("char(") < nPos || nPos == string::npos))
            nPos = sCmd.find("char(");
    }
 
    // Try to find the end of the string block
    // and cut out the identified argument
    sArgument = extractStringToken(sCmd, nPos);
    return true;
}
 
 
string extractStringToken(const string& sCmd, size_t nPos)
{
    // Increment the first position, if the command string begins with an equal sign
    if (sCmd.front() == '=')
        nPos++;
 
    size_t nPos_2 = 0;
    size_t nQuotes = isInQuotes(sCmd, nPos, true);
 
    for (size_t i = nPos; i < sCmd.length(); i++)
    {
        if (sCmd[i] == '"' && (!i || sCmd[i-1] != '\\'))
        {
            nQuotes++;
            continue;
        }
 
        if (nQuotes % 2)
            continue;
 
        // Jump over each parenthesis block
        if (sCmd[i] == '(' || sCmd[i] == '[' || sCmd[i] == '{')
        {
            i += getMatchingParenthesis(sCmd.substr(i));
            continue;
        }
 
        // Handle the variable to string parser
        if (sCmd[i] == '#')
        {
            for (size_t j = i; j < sCmd.length(); j++)
            {
                if (sCmd[j] == ' ')
                {
                    i = j;
                    break;
                }
                // jump over parentheses
                if (sCmd[j] == '(')
                    j += getMatchingParenthesis(sCmd.substr(j));
 
                if (j == sCmd.length() - 1)
                {
                    i = j;
                    break;
                }
            }
        }
 
        // If there's a whitespace
        if (sCmd[i] == ' ')
        {
            // Try to find a trailing plus sign
            if (sCmd.find_first_not_of(' ', i) != string::npos && sCmd[sCmd.find_first_not_of(' ', i)] != '+')
            {
                // None was found - break the loop
                nPos_2 = i - 1;
                break;
            }
            else
            {
                // A plus sign was found
                // Jump over the following whitespaces around the plus sign
                i = sCmd.find_first_not_of(" +", i)-1;
                continue;
            }
        }
 
        // If it's the last character or the current character is a
        // punctuation character
        if (i >= sCmd.length() - 1 || (ispunct(sCmd[i]) && sCmd[i] != '.' && sCmd[i] != '_' && sCmd[i] != '+' && sCmd[i] != '#'))
        {
            if (i == string::npos)
                nPos_2 = sCmd.length();
            else
                nPos_2 = i;
            break;
        }
    }
 
    // Cut out the identified argument
    if (!nPos_2)
        return sCmd.substr(nPos);
 
    return sCmd.substr(nPos, nPos_2 - nPos + 1);
}
 
 
unsigned int getMatchingParenthesis(const StringView& sLine)
{
    size_t pos = sLine.find_first_of("([{");
 
    if (pos == string::npos)
        return pos;
 
    // Get the opening parenthesis
    char cParenthesis = sLine[pos];
    char cClosingParenthesis = 0;
 
    // Depending on the opening parenthesis, determine the closing one
    switch (cParenthesis)
    {
        case '(':
            cClosingParenthesis = ')';
            break;
        case '{':
            cClosingParenthesis = '}';
            break;
        case '[':
            cClosingParenthesis = ']';
            break;
        default:
            // Default case will handle that the user didn't pass a string, which begins with a parenthesis
            cParenthesis = '(';
            cClosingParenthesis = ')';
    }
 
    int nOpenParenthesis = 0;
    size_t nQuotes = 0;
 
    // Go through the string and count the opening and closing parentheses
    // Consider also whether the the current position is part of a larger string
    for (size_t i = 0; i < sLine.length(); i++)
    {
        // Count unmasked quotation marks
        if (sLine[i] == '"' && (!i || sLine[i-1] != '\\'))
            nQuotes++;
 
        if (nQuotes % 2)
            continue;
 
        // Increment the counter at opening paretheses
        if (sLine[i] == cParenthesis)
            nOpenParenthesis++;
 
        // Decrement the counter at closing parentheses
        if (sLine[i] == cClosingParenthesis)
            nOpenParenthesis--;
 
        // All parentheses are closed -> Return the position of this parenthesis
        if (!nOpenParenthesis && i > pos)
            return i;
    }
 
    // --> Falls die Klammer nicht schliesst, gebe -1 zurueck (analog zu string::find()) <--
    return string::npos;
}
 
 
bool isMultiValue(const string& sExpr, bool bIgnoreClosingParenthesis)
{
    // --> Kein Komma? Auf jeden Fall kein Mehrfachausdruck! <--
    if (sExpr.find(',') == string::npos)
        return false;
    else
    {
        size_t nQuotationMarks = 0;
 
        // Go through the string
        for (unsigned int i = 0; i < sExpr.length(); i++)
        {
            // Jump over parentheses
            if ((sExpr[i] == '(' || sExpr[i] == '{' || sExpr[i] == '[') && !(nQuotationMarks % 2))
                i += getMatchingParenthesis(sExpr.substr(i));
 
            // Count quotation marks
            if (sExpr[i] == '"')
                nQuotationMarks++;
 
            if (sExpr[i] == ',' && !(nQuotationMarks % 2))
                return true;
        }
 
        // If the string contains a comma and the "ignore the closing parenthesis" flag is set, enter a recursion
        // This will cut out the argument of the first opening parenthesis
        // If no opening parenthesis is available, then leave this block
        if (sExpr.find_first_of("([{") != string::npos && bIgnoreClosingParenthesis)
            return isMultiValue(sExpr.substr(sExpr.find_first_of("([{")+1), true);
    }
 
    // Nothing found - fallback
    return false;
}
 
 
static std::map<std::string, std::string> getTeXCodePage()
{
    std::map<std::string, std::string> mCodePage;
 
    mCodePage["_pi"] = "\\pi ";
    mCodePage["_hbar"] = "\\hbar ";
    mCodePage["_k_boltz"] = "k_B";
    mCodePage["_2pi"] = "2\\cdot \\pi ";
    mCodePage["_elek_feldkonst"] = "\\varepsilon ";
    mCodePage["_elem_ladung"] = "e";
    mCodePage["_m_elektron"] = "m_{e}";
    mCodePage["_m_neutron"] = "m_{n}";
    mCodePage["_m_proton"] = "m_{p}";
    mCodePage["_m_sonne"] = "m_{Sonne}";
    mCodePage["_m_erde"] = "m_{Erde}";
    mCodePage["_m_muon"] = "m_{\\mu}";
    mCodePage["_m_tau"] = "m_{\\tau}";
    mCodePage["_magn_feldkonst"] = "\\mu ";
    mCodePage["_n_avogadro"] = "N_A";
    mCodePage["_r_erde"] = "r_{Erde}";
    mCodePage["_r_sonne"] = "r_{Sonne}";
    mCodePage["_c"] = "c_{Licht}";
    mCodePage["_e"] = "e";
    mCodePage["_g"] = "g";
    mCodePage["_h"] = "h";
    mCodePage["_R"] = "R";
    mCodePage["_alpha_fs"] = "\\alpha_{FS}";
    mCodePage["_mu_bohr"] = "\\mu_{B}";
    mCodePage["_mu_kern"] = "\\mu_{K}";
    mCodePage["_m_amu"] = "m_u";
    mCodePage["_r_bohr"] = "a_0";
    mCodePage["_G"] = "G";
    mCodePage["_theta_weinberg"] = "\\theta_{W}";
    mCodePage["_mu_e"] = "\\mu_{e}";
    mCodePage["_mu_p"] = "\\mu_{p}";
    mCodePage["_mu_n"] = "\\mu_{n}";
    mCodePage["_gamma_e"] = "\\gamma_{e}";
    mCodePage["_gamma_p"] = "\\gamma_{p}";
    mCodePage["_gamma_n"] = "\\gamma_{n}";
    mCodePage["_stefan_boltzmann"] = "\\sigma ";
    mCodePage["_rydberg"] = "R_{\\infty}";
    mCodePage["_hartree"] = "E_{h}";
    mCodePage["_wien"] = "b_{Energie}";
    mCodePage["_lande_e"] = "g_{e}";
    mCodePage["_feigenbaum_alpha"] = "\\alpha ";
    mCodePage["_feigenbaum_delta"] = "\\delta ";
    mCodePage["inf"] = "\\infty";
    mCodePage["alpha"] = "\\alpha ";
    mCodePage["Alpha"] = "\\Alpha ";
    mCodePage["beta"] = "\\beta ";
    mCodePage["Beta"] = "\\Beta ";
    mCodePage["gamma"] = "\\gamma ";
    mCodePage["Gamma"] = "\\Gamma ";
    mCodePage["delta"] = "\\delta ";
    mCodePage["Delta"] = "\\Delta ";
    mCodePage["epsilon"] = "\\varepsilon ";
    mCodePage["Epsilon"] = "\\Epsilon ";
    mCodePage["zeta"] = "\\zeta ";
    mCodePage["Zeta"] = "\\Zeta ";
    mCodePage["eta"] = "\\eta ";
    mCodePage["Eta"] = "\\Eta ";
    mCodePage["\theta"] = "\\theta ";
    mCodePage["theta"] = "\\vartheta ";
    mCodePage["Theta"] = "\\Theta ";
    mCodePage["iota"] = "\\iota ";
    mCodePage["Iota"] = "\\Iota ";
    mCodePage["kappa"] = "\\kappa ";
    mCodePage["Kappa"] = "\\Kappa ";
    mCodePage["lambda"] = "\\lambda ";
    mCodePage["Lambda"] = "\\Lambda ";
    mCodePage["mu"] = "\\mu";
    mCodePage["Mu"] = "\\Mu ";
    mCodePage["\nu"] = "\\nu ";
    mCodePage["nu"] = "\\nu ";
    mCodePage["Nu"] = "\\Nu ";
    mCodePage["xi"] = "\\xi ";
    mCodePage["Xi"] = "\\Xi ";
    mCodePage["omikron"] = "o ";
    mCodePage["Omikron"] = "O ";
    mCodePage["pi"] = "\\pi ";
    mCodePage["Pi"] = "\\Pi ";
    mCodePage["rho"] = "\\rho ";
    mCodePage["Rho"] = "\\Rho ";
    mCodePage["sigma"] = "\\sigma ";
    mCodePage["Sigma"] = "\\Sigma ";
    mCodePage["\tau"] = "\\tau ";
    mCodePage["tau"] = "\\tau ";
    mCodePage["Tau"] = "\\Tau ";
    mCodePage["ypsilon"] = "\\upsilon ";
    mCodePage["Ypsilon"] = "\\Upsilon ";
    mCodePage["phi"] = "\\varphi ";
    mCodePage["Phi"] = "\\Phi";
    mCodePage["chi"] = "\\chi ";
    mCodePage["Chi"] = "\\Chi ";
    mCodePage["psi"] = "\\psi ";
    mCodePage["Psi"] = "\\Psi ";
    mCodePage["omega"] = "\\omega ";
    mCodePage["Omega"] = "\\Omega ";
    mCodePage["heaviside"] = "\\Theta";
    mCodePage["Li2"] = "Li_2";
    mCodePage["Cl2"] = "Cl_2";
 
    return mCodePage;
}
 
 
static std::map<std::string, std::string> getTeXCodePageSpecial()
{
    std::map<std::string, std::string> mCodePage;
 
    mCodePage["*"] = "\\cdot  ";
    mCodePage["+"] = " + ";
    mCodePage["-"] = " -- ";
    mCodePage[","] = ", ";
    mCodePage["x"] = "{\\i x}";
    mCodePage["y"] = "{\\i y}";
    mCodePage["z"] = "{\\i z}";
    mCodePage["t"] = "{\\i t}";
 
    return mCodePage;
}
 
 
static void handleTeXIndicesAndExponents(std::string& sReturn, const std::map<std::string,std::string>& mCodePage)
{
    static std::string sDelimiter = "+-*/, #()&|!_'";
 
    // Handle the exponents
    for (size_t i = 0; i < sReturn.length() - 1; i++)
    {
        // Insert braces
        if (sReturn[i] == '^' && sReturn[i + 1] != '{' && sReturn[i + 1] != '(')
        {
            i++;
            sReturn = sReturn.substr(0, i) + "{" + sReturn.substr(i);
 
            if (sReturn[i + 1] == '-' || sReturn[i + 1] == '+')
                i++;
 
            i++;
 
            // Find the end of the current brace
            for (size_t j = i + 1; j < sReturn.length(); j++)
            {
                if (sDelimiter.find(sReturn[j]) != std::string::npos)
                {
                    sReturn = sReturn.substr(0, j) + "}" + sReturn.substr(j);
                    break;
                }
                else if (j + 1 == sReturn.length())
                    sReturn += "}";
            }
        }
    }
 
    // Append the exponent operator
    sDelimiter[sDelimiter.length() - 1] = '^';
 
    // Handle the indices
    for (size_t i = 0; i < sReturn.length() - 1; i++)
    {
        // Ignore constants
        if (sReturn[i] == '_' && sReturn[i + 1] != '{')
        {
            for (const auto& iter : mCodePage)
            {
                if (iter.first.front() != '_')
                    break;
 
                if (sReturn.substr(i, iter.first.length()) == iter.first
                    && sDelimiter.find(sReturn[i + iter.first.length()]) != std::string::npos)
                {
                    i++;
                    break;
                }
            }
        }
 
        // Insert braces
        if (sReturn[i] == '_' && sReturn[i + 1] != '{')
        {
            i++;
            sReturn = sReturn.substr(0, i) + "{" + sReturn.substr(i);
            i++;
 
            // Find the end of the current brace
            for (unsigned int j = i + 1; j < sReturn.length(); j++)
            {
                if (sDelimiter.find(sReturn[j]) != std::string::npos)
                {
                    sReturn = sReturn.substr(0, j) + "}" + sReturn.substr(j);
                    break;
                }
                else if (j + 1 == sReturn.length())
                {
                    sReturn += "}";
                }
            }
        }
    }
}
 
 
std::string replaceToTeX(const std::string& sString, bool replaceForTeXFile)
{
    std::string sReturn = " " + sString + " ";            // Rueckgabe-String
    size_t nPos = 0;                           // Positions-Index-Variable
 
    static std::map<std::string, std::string> mCodePage = getTeXCodePage();
    static std::map<std::string, std::string> mSpecialSymbols = getTeXCodePageSpecial();
 
    // --> Ersetze zunaechst die gamma-Funktion <--
    while ((nPos = sReturn.find("gamma(", nPos)) != std::string::npos)
    {
        if (nPos && !isDelimiter(sReturn[nPos-1]))
        {
            nPos++;
            continue;
        }
 
        sReturn.replace(nPos, nPos+6, "\\Gamma(");
        nPos += 7;
    }
 
    // --> Laufe durch alle bekannten Symbole <--
    for (const auto& iter : mCodePage)
    {
        // --> Positions-Indices zuruecksetzen <--
        nPos = 0;
 
        // --> So lange in dem String ab der Position nPos das Token auftritt <--
        while ((nPos = sReturn.find(iter.first, nPos)) != string::npos)
        {
            // --> Falls vor dem Token schon ein '\' ist, wurde das hier schon mal ersetzt <--
            if (sReturn[nPos - 1] == '\\')
            {
                // --> Positionsindex um die Laenge des Tokens weitersetzen <--
                nPos += iter.first.length();
                continue;
            }
 
            if (sReturn[nPos + iter.first.length()] == '_')
            {
                // Wird das Token von '_' abgeschlossen? Pruefen wir, ob es von vorne auch begrenzt ist <--
                if (!isDelimiter(sReturn[nPos-1]))
                {
                    // --> Nein? Den Positionsindex um die Laenge des Tokens weitersetzen <--
                    nPos += iter.first.length();
                    continue;
                }
            }
            else if (!checkDelimiter(sReturn.substr(nPos - 1, iter.first.length() + 2)))
            {
                // --> Pruefen wir auch getrennt den Fall, ob das Token ueberhaupt begrenzt ist ('_' zaehlt nicht zu den Delimitern) <--
                nPos += iter.first.length();
                continue;
            }
 
            sReturn.replace(nPos, iter.first.length(), iter.second);
            nPos += iter.second.length();
        }
    }
 
    for (const auto& iter : mSpecialSymbols)
    {
        // --> Positions-Indices zuruecksetzen <--
        nPos = 0;
 
        // --> So lange in dem String ab der Position nPos das Token auftritt <--
        while ((nPos = sReturn.find(iter.first, nPos)) != string::npos)
        {
            // --> Falls vor dem Token schon ein '\' ist, wurde das hier schon mal ersetzt <--
            if (sReturn[nPos - 1] == '\\')
            {
                // --> Positionsindex um die Laenge des Tokens weitersetzen <--
                nPos += iter.first.length();
                continue;
            }
 
            if (iter.first == "*"
                || (!replaceForTeXFile && !isalpha(iter.first.front())))
            {
                // remove obsolete whitespaces around the operators
                // first in front of the operator
                if (sReturn[nPos - 1] == ' ')
                {
                    size_t nPos_2 = sReturn.find_last_not_of(' ', nPos-1)+1;
                    sReturn.erase(nPos_2, nPos - nPos_2);
                    nPos = nPos_2;
                }
 
                // after the operator
                if (sReturn[nPos + 1] == ' ')
                    sReturn.erase(nPos, sReturn.find_first_not_of(' ', nPos+1) - nPos);
 
                // Identify exponents and ignore them
                if (iter.first == "+" || iter.first == "-")
                {
                    if (sReturn[nPos-1] == 'e' || sReturn[nPos-1] == 'E')
                    {
                        if (isdigit(sReturn[nPos-2]) && isdigit(sReturn[nPos+1]) )
                        {
                            nPos++;
                            continue;
                        }
                    }
 
                    // Don't insert whitespaces directly after opening parentheses and commas
                    if (!nPos
                        || sReturn[nPos-1] == '('
                        || sReturn[nPos-1] == '['
                        || sReturn[nPos-1] == '{'
                        || sReturn[nPos-1] == ',')
                    {
                        if (iter.first == "-")
                        {
                            sReturn.insert(nPos, 1, '-');
                            nPos++;
                        }
 
                        nPos++;
                        continue;
                    }
                }
            }
            else if (sReturn[nPos + iter.first.length()] == '_')
            {
                // Wird das Token von '_' abgeschlossen? Pruefen wir, ob es von vorne auch begrenzt ist <--
                if (!isDelimiter(sReturn[nPos-1]))
                {
                    // --> Nein? Den Positionsindex um die Laenge des Tokens weitersetzen <--
                    nPos += iter.first.length();
                    continue;
                }
            }
            else if (!checkDelimiter(sReturn.substr(nPos - 1, iter.first.length() + 2)))
            {
                // --> Pruefen wir auch getrennt den Fall, ob das Token ueberhaupt begrenzt ist ('_' zaehlt nicht zu den Delimitern) <--
                nPos += iter.first.length();
                continue;
            }
 
            sReturn.replace(nPos, iter.first.length(), iter.second);
            nPos += iter.second.length();
        }
    }
 
    // --> Ersetze nun lange Indices "_INDEX" durch "_{INDEX}" <--
    handleTeXIndicesAndExponents(sReturn, mCodePage);
 
    nPos = 0;
 
    // replace "sqrt()"
    while ((nPos = sReturn.find("sqrt(", nPos)) != string::npos)
    {
        size_t len = getMatchingParenthesis(StringView(sReturn, nPos+4));
        sReturn.replace(nPos, len + 6, "@{\\sqrt{" + sReturn.substr(nPos+5, len) + "}}");
    }
 
    nPos = 0;
 
    // replace "norm()"
    while ((nPos = sReturn.find("norm(", nPos)) != string::npos)
    {
        size_t len = getMatchingParenthesis(StringView(sReturn, nPos+4));
        sReturn.replace(nPos, len + 6, "|" + sReturn.substr(nPos+5, len) + "|");
    }
 
    nPos = 0;
 
    // replace "abs()"
    while ((nPos = sReturn.find("abs(", nPos)) != string::npos)
    {
        size_t len = getMatchingParenthesis(StringView(sReturn, nPos+3));
        sReturn.replace(nPos, len + 5, "|" + sReturn.substr(nPos+4, len) + "|");
    }
 
    nPos = 0;
 
    // Long exponents
    while ((nPos = sReturn.find("^(", nPos)) != string::npos)
    {
        size_t len = getMatchingParenthesis(StringView(sReturn, nPos+1));
        sReturn.replace(nPos+1, len + 2, "{" + sReturn.substr(nPos+2, len) + "}");
    }
 
    // --> Entferne die Leerzeichen am Anfang und Ende und gib sReturn zurueck <--
    StripSpaces(sReturn);
    return sReturn;
}
 
 
static Match findCasualCommand(StringView sCmd)
{
    Match _mMatch;
    _mMatch.sString = "";
    _mMatch.nPos = string::npos;
    size_t nStart = 0;
 
    // Jump over breakpoints
    if (sCmd.subview(0,2) == "|>")
        nStart = 2;
 
    // Go through the complete command line
    for (unsigned int i = nStart; i < sCmd.length(); i++)
    {
        // Break the loop, if one recognizes typical initializers of the parameter list
        if ((sCmd.subview(i, 2) == "--" || sCmd.subview(i, 5) == "-set ") && !isInQuotes(sCmd, i))
            break;
 
        // Jump over some special characters, if one didn't find any command yet
        if ((sCmd[i] == ' ' || sCmd[i] == '\t' || sCmd[i] == '-' || sCmd[i] == '=') && _mMatch.nPos == string::npos)
            continue;
        else if ((sCmd[i] == ' ' || sCmd[i] == '-' || sCmd[i] == ';' || sCmd[i] == ':') && _mMatch.nPos != string::npos)
        {
            // If we found a command start, then we examine these characters further
            if (sCmd[i] != '-' && sCmd.find_first_not_of(' ', i) != string::npos && sCmd[sCmd.find_first_not_of(' ', i)] == '=')
            {
                // This is probably no commmand, because there's a equal sign following it
                // Reset the match position and continue
                _mMatch.nPos = string::npos;
                continue;
            }
 
            // Store the command string
            _mMatch.sString = sCmd.subview(_mMatch.nPos, i - _mMatch.nPos).to_string();
 
            // Ensure that this is not inside of quotation marks
            if (isInQuotes(sCmd, (i - _mMatch.nPos) / 2))
            {
                _mMatch.sString = "";
                _mMatch.nPos = string::npos;
            }
 
            // Return the found match
            return _mMatch;
        }
        else if ((sCmd[i] == '(') && _mMatch.nPos != string::npos)
        {
            // We found an opening parenthesis although we already found a match position
            // Store the command string
            _mMatch.sString = sCmd.subview(_mMatch.nPos, i - _mMatch.nPos).to_string();
 
            // Ensure that this is not inside of quotation marks
            // Also ensure that the found command string is one of the
            // control flow commands (the only ones, which require parentheses)
            if (isInQuotes(sCmd, (i - _mMatch.nPos) / 2)
                    || (_mMatch.sString != "if"
                        && _mMatch.sString != "elseif"
                        && _mMatch.sString != "switch"
                        && _mMatch.sString != "for"
                        && _mMatch.sString != "while"))
            {
                _mMatch.sString = "";
                _mMatch.nPos = string::npos;
            }
 
            // Return the found match
            return _mMatch;
        }
 
        // No other case invoked. The current character
        // is a candidate for a command string match
        if (_mMatch.nPos == string::npos)
            _mMatch.nPos = i;
    }
 
    // Special case: We walked through the complete command line and didn't find
    // the end of the command. Simply use the rest of the command line as the command
    if (_mMatch.nPos != string::npos)
        _mMatch.sString = sCmd.subview(_mMatch.nPos).to_string();
    else
        _mMatch.sString = sCmd.to_string();
 
    // Return the found match
    return _mMatch;
}
 
 
static bool findShortestMatchForCommand(Match& _mMatch, size_t position, char character, StringView sCmd, const std::string& sCommand)
{
    // Store the command string and the match position
    _mMatch.sString = sCmd.subview(position, sCmd.find(character, position + sCommand.length()) - position).to_string();
    _mMatch.nPos = position;
 
    // If there's a whitespace in the match string, erase it end everything after it
    if (_mMatch.sString.find(' ') != string::npos)
        _mMatch.sString.erase(_mMatch.sString.find(' '));
 
    // Ensure that the found command is a single word
    if (!isInQuotes(sCmd, position)
        && isDelimiter(sCmd[position+_mMatch.sString.length()])
        && (!position || isDelimiter(sCmd[position-1])))
    {
        // If the command line is longer than the match position and the length of both strings
        if (sCmd.length() >= sCommand.length() + _mMatch.nPos + _mMatch.sString.length())
        {
            // Try to find the command further back by calling findCommand recursively
            Match _mTemp = findCommand(sCmd.subview(_mMatch.nPos + _mMatch.sString.length()), sCommand);
 
            // If a match was found and it's length is shorter than the current one
            // then use the new match
            if (_mTemp.sString.length()
                    && _mTemp.sString.length() < _mMatch.sString.length())
            {
                _mMatch.nPos += _mTemp.nPos + _mMatch.sString.length();
                _mMatch.sString = _mTemp.sString;
            }
        }
 
        // Return true
        return true;
    }
    else
    {
        // It is not a single word
        // reset the match and return false
        _mMatch.sString = "";
        _mMatch.nPos = string::npos;
        return false;
    }
}
 
 
static Match findCommandWithReturnValue(StringView sCmd, const string& sCommand)
{
    Match _mMatch;
    _mMatch.sString = "";
    _mMatch.nPos = string::npos;
    size_t nStart = 0;
 
    // Jump over breakpoints
    if (sCmd.subview(0,2) == "|>")
        nStart = 2;
 
    // Go through the complete command line
    for (unsigned int i = nStart; i < sCmd.length(); i++)
    {
        // Break the loop, if we find typical parameter string initializers
        if ((sCmd.subview(i, 2) == "--" || sCmd.subview(i, 5) == "-set ") && !isInQuotes(sCmd, i))
            break;
 
        // Jump over some special characters
        if (sCmd[i] == ' ' || sCmd[i] == '\t' || sCmd[i] == '(')
            continue;
 
        // Jump, if this is not our searched command
        if (sCmd.subview(i, sCommand.length()) != sCommand)
            continue;
 
        // This is our command and it is not at the beginning of the line
        if (sCmd.subview(i, sCommand.length()) == sCommand && i)
        {
            // Is the command filling the rest of the command line?
            if (i + sCommand.length() == sCmd.length() - 1)
            {
                // Store the command string with the previous character
                _mMatch.sString = sCmd.subview(i - 1).to_string() + " ";
 
                // Store the position
                _mMatch.nPos = i;
 
                // Ensure that the command is not part of a larger word
                if (checkDelimiter(_mMatch.sString) && !isInQuotes(sCmd, i))
                {
                    // It is not
                    // Remove the additional characters
                    _mMatch.sString = _mMatch.sString.substr(1, _mMatch.sString.length() - 2);
                }
                else
                {
                    // It is
                    // Reset the match
                    _mMatch.sString = "";
                    _mMatch.nPos = string::npos;
                }
 
                // return the found match
                return _mMatch;
            }
 
            // Continue, if the command ends with a parenthesis and there's another match
            // Otherwise reset the match
            if (sCmd[i + sCommand.length()] == '(' && sCmd.find(sCommand, i + 1) != string::npos)
                continue;
            else if (sCmd[i + sCommand.length()] == '(' && sCmd.find(sCommand, i + 1) == string::npos)
            {
                // Reset the match
                _mMatch.sString = "";
                _mMatch.nPos = string::npos;
 
                // Return the resetted match
                return _mMatch;
            }
 
            // There's a minus sign after the command
            if (sCmd.find('-', i + sCommand.length()) != string::npos)
            {
                // If the match is not a single word, continue
                if (!findShortestMatchForCommand(_mMatch, i, '-', sCmd, sCommand))
                    continue;
                return _mMatch;
            }
 
            // There's a whitespace after the command
            if (sCmd.find(' ', i + sCommand.length()) != string::npos)
            {
                // If the match is not a single word, continue
                if (!findShortestMatchForCommand(_mMatch, i, ' ', sCmd, sCommand))
                    continue;
                return _mMatch;
            }
        }
 
        // This is our command and it is at the beginning of the line
        if (sCmd.subview(i, sCommand.length()) == sCommand && !i)
        {
            // If the command lenght and the command line length are nearly the same
            if (sCommand.length() == sCmd.length() - 1)
            {
                // Store string and match position
                // Add surrounding characters
                _mMatch.sString = " " + sCommand.substr(0, sCommand.length() + 1);
                _mMatch.nPos = 0;
 
                // Ensure that the found string is not part of a larger word
                if (checkDelimiter(_mMatch.sString) && !isInQuotes(sCmd, i))
                {
                    // It is not
                    // remove the additional characters
                    _mMatch.sString = _mMatch.sString.substr(1, _mMatch.sString.length() - 2);
                }
                else
                {
                    // It is
                    // Reset the match and continue
                    _mMatch.sString = "";
                    _mMatch.nPos = string::npos;
                    continue;
                }
 
                // Return the found match
                return _mMatch;
            }
 
            // Continue, if the command ends with a parenthesis and there's another match
            // Otherwise reset the match
            if (sCmd[i + sCommand.length()] == '(' && sCmd.find(sCommand, i + 1) != string::npos)
                continue;
            else if (sCmd[i + sCommand.length()] == '(' && sCmd.find(sCommand, i + 1) == string::npos)
            {
                _mMatch.sString = "";
                _mMatch.nPos = string::npos;
                return _mMatch;
            }
 
            // There's a minus sign after the command
            if (sCmd.find('-', i + sCommand.length()) != string::npos)
            {
                // If the match is not a single word, continue
                if (!findShortestMatchForCommand(_mMatch, i, '-', sCmd, sCommand))
                    continue;
                return _mMatch;
            }
 
            // There's a whitespace after the command
            if (sCmd.find(' ', i + sCommand.length()) != string::npos)
            {
                // If the match is not a single word, continue
                if (!findShortestMatchForCommand(_mMatch, i, ' ', sCmd, sCommand))
                    continue;
                return _mMatch;
            }
        }
    }
 
    // Return the found match
    return _mMatch;
}
 
 
Match findCommand(StringView sCmd, const std::string& sCommand)
{
    Match _mMatch;
    _mMatch.sString = "";
    _mMatch.nPos = string::npos;
 
    // There are two possible use cases:
    // If one defines a command, for which this function shall look for,
    // then it will also find commands after other special characters
    if (!sCommand.length())
    {
        // find a causal command
        return findCasualCommand(sCmd);
    }
    else if (sCommand.length() && (sCmd == sCommand || sCmd == sCommand + " "))
    {
        // the command line is identical to the searched command
        _mMatch.sString = sCmd.to_string();
        StripSpaces(_mMatch.sString);
        _mMatch.nPos = 0;
 
        // Return the found match
        return _mMatch;
    }
    else if (sCommand.length()
             && sCmd.find(sCommand) != string::npos
             && sCmd.find(' ', sCmd.find(sCommand)) != string::npos
             && findCommand(sCmd).sString != "help"
             && findCommand(sCmd).sString != "edit"
             && findCommand(sCmd).sString != "new")
    {
        // find a command with a return value
        return findCommandWithReturnValue(sCmd, sCommand);
    }
 
    // Nothing was found
    return _mMatch;
}
 
 
string extractCommandString(const string& sCmd, const Match& _mMatch)
{
    string sCommandString = "";
 
    // if not match was found, return an empty string
    if (_mMatch.nPos == string::npos)
        return "";
 
    // A match is available
    if (_mMatch.nPos)
    {
        // go through the string inversely. Start at the match position
        for (int i = _mMatch.nPos; i >= 0; i--)
        {
            // An opening parenthesis was found, which is not part of a string
            if (sCmd[i] == '(' && !isInQuotes(sCmd, i))
            {
                // Find the matching parenthesis
                if (getMatchingParenthesis(sCmd.substr(i)) != string::npos)
                {
                    // Use the contents of the parenthesis
                    // However, only extract the command and not the characters in front of it
                    sCommandString = sCmd.substr(_mMatch.nPos, getMatchingParenthesis(sCmd.substr(i)) - (_mMatch.nPos - i + 1));
                    break;
                }
                else
                    throw SyntaxError(SyntaxError::UNMATCHED_PARENTHESIS, sCmd, i);
            }
        }
    }
 
    // If the command string length is zero, use the complete command string
    // from the position to the end
    if (!sCommandString.length())
        sCommandString = sCmd.substr(_mMatch.nPos);
 
    // Return the extracted string
    return sCommandString;
}
 
 
void openExternally(const string& sFile)
{
    std::string _sFile;
 
    int nErrorCode = 0;
 
    // Add quotation marks if there are none and convert the string to a character pointer
    if (_sFile[0] != '"')
        _sFile = "\"" + sFile + "\"";
    else
        _sFile = sFile;
 
    replaceAll(_sFile, "/", "\\");
 
    // Invoke the Windows shell
    nErrorCode = (int)ShellExecute(nullptr, "open", sFile.c_str(), nullptr, nullptr, SW_SHOWNORMAL);
 
    // Examine the return value
    if (nErrorCode <= 32)
    {
        if (nErrorCode == SE_ERR_NOASSOC)
            throw SyntaxError(SyntaxError::EXTERNAL_PROGRAM_NOT_FOUND, "", SyntaxError::invalid_position, sFile);
        else
            throw SyntaxError(SyntaxError::CANNOT_READ_FILE, "", SyntaxError::invalid_position, sFile);
    }
}
 
 
void moveFile(const string& sFile, const string& sNewFileName)
{
    // Copy first
    copyFile(sFile, sNewFileName);
 
    // remove old file
    remove(sFile.c_str());
}
 
 
void copyFile(const string& sFile, const string& sTarget)
{
    // Open two file streams to copy the contents
    ifstream File(sFile.c_str(), ios_base::binary);
    ofstream NewFile(sTarget.c_str(), ios_base::binary);
 
    if (!File.good())
        throw SyntaxError(SyntaxError::CANNOT_OPEN_SOURCE, "", SyntaxError::invalid_position, sFile);
 
    if (!NewFile.good())
        throw SyntaxError(SyntaxError::CANNOT_OPEN_TARGET, "", SyntaxError::invalid_position, sTarget);
 
    // Copy the file
    NewFile << File.rdbuf();
}
 
 
// --> Generiert eine TeX-Hauptdatei fuer eine gegebene TikZ-Plot-Datei <--
void writeTeXMain(const string& sTeXFile)
{
    string sTemp = sTeXFile;
 
    // Extract the path
    if (sTemp.find('\\') != string::npos || sTemp.find('/') != string::npos)
    {
        if (sTemp.find('\\') != string::npos)
            sTemp = sTemp.substr(sTemp.rfind('\\') + 1);
        if (sTemp.find('/') != string::npos)
            sTemp = sTemp.substr(sTemp.rfind('/') + 1);
    }
 
    // --> Fuege vor ".tex" den String "main"  ein <--
    ofstream TexMain((sTeXFile.substr(0, sTeXFile.find(".tex")) + "main.tex").c_str());
    if (!TexMain.good())
        throw SyntaxError(SyntaxError::CANNOT_OPEN_TARGET, "", SyntaxError::invalid_position, sTeXFile.substr(0, sTeXFile.find(".tex")) + "main.tex");
 
    // Write the files contents
    TexMain << "\\documentclass{scrartcl}    % KOMA-SCRIPT-KLASSE (Kann durch \"article\" ersetzt werden)" << endl << endl;
    TexMain << "% Ein paar hilfreiche Packages:" << endl;
    TexMain << "\\usepackage[utf8]{inputenc} % Sonderzeichen in der Eingabe" << endl;
    TexMain << "\\usepackage[T1]{fontenc}    % Sonderzeichen in der Ausgabe" << endl;
    TexMain << "\\usepackage[ngerman]{babel} % Deutsch als Dokumentsprache" << endl;
    TexMain << "\\usepackage{mathpazo}       % Palatino als Schriftart (passend zum Plot)" << endl;
    TexMain << "\\usepackage{tikz}           % TikZ fuer die eigentliche Graphik" << endl;
    TexMain << "% Eigentliches Dokument" << endl;
    TexMain << "\\begin{document}" << endl;
    TexMain << "\t% Hier bietet sich ein beschreibender Text an" << endl;
    TexMain << "\t\\input{";
    TexMain << sTemp;
    TexMain << "} % Einbinden des Plots" << endl;
    TexMain << "\t% Mit derselben Syntax wie der vorherigen Zeile koennen auch weitere Plots in diese TeX-Ausgabe eingebunden werden" << endl;
    TexMain << "\\end{document}" << endl;
    TexMain << "% EOF" << endl;
    TexMain.close();
 
    /* --> Die Datei "mglmain.tex" wird bei einem TeX-Export automatisch erstellt (und entspricht in etwa dieser Datei),
     *     allerdings wird diese Datei jedes Mal bei einem TeX-Export ueberschrieben. Daher schreiben wir unsere eigene
     *     und loeschen diese automatische Datei <--
     */
    remove("mglmain.tex");
    return;
}
 
 
static size_t isStringContinuation(const std::string& sCmd, size_t pos)
{
    if (sCmd.substr(pos, 2) == "  ")
        return std::string::npos;
 
    size_t nextChar = sCmd.find_first_not_of(' ', pos+1);
 
    if (nextChar == std::string::npos || sCmd[nextChar] != '+')
        return std::string::npos;
 
    nextChar++;
 
    if (sCmd.length() > nextChar && sCmd[nextChar] != ' ')
        return nextChar;
 
    nextChar++;
 
    if (sCmd.length() > nextChar && sCmd[nextChar] != ' ')
        return nextChar;
 
    return std::string::npos;
}
 
 
static void parseArg(std::string& sArg, int flags)
{
    NumeReKernel* instance = NumeReKernel::getInstance();
 
    // Function call
    if (!instance->getDefinitions().call(sArg))
        throw SyntaxError(SyntaxError::FUNCTION_ERROR, sArg, "");
 
    // Read data
    if (instance->getMemoryManager().containsTablesOrClusters(sArg)
        && !instance->getStringParser().isStringExpression(sArg))
        getDataElements(sArg, instance->getParser(), instance->getMemoryManager(), instance->getSettings());
 
    // String evaluation
    if (instance->getStringParser().isStringExpression(sArg))
    {
        std::string dummy;
 
        NumeRe::StringParser::StringParserRetVal _ret = instance->getStringParser().evalAndFormat(sArg, dummy, true);
 
        if (_ret == NumeRe::StringParser::STRING_SUCCESS)
            return;
    }
 
    if (flags & ARGEXTRACT_ASSTRING)
        return;
 
    // Numerical evaluation
    instance->getParser().SetExpr(sArg);
 
    int results;
    int nPrec = instance->getSettings().getPrecision();
    mu::value_type* v = instance->getParser().Eval(results);
 
    sArg.clear();
 
    for (int i = 0; i < results; i++)
    {
        if (sArg.length())
            sArg += ",";
 
        if (flags & ARGEXTRACT_ASINT)
            sArg += toString(intCast(v[i]));
        else
            sArg += toString(v[i], nPrec);
    }
}
 
 
string getArgAtPos(const string& sCmd, unsigned int nPos, int extraction)
{
    string sArgument = "";
 
    // If the position is greater than the string length
    // return an empty string
    if (nPos >= sCmd.length())
        return "";
 
    // Jump over whitespaces
    while (nPos < sCmd.length() && sCmd[nPos] == ' ')
        nPos++;
 
    // Ensure that the position is smaller than the length of the string
    if (nPos >= sCmd.length())
        return "";
 
    size_t nQuotes = 0;
 
    for (size_t i = nPos; i < sCmd.length(); i++)
    {
        if (sCmd[i] == '"' && (!i || sCmd[i - 1] != '\\'))
            nQuotes++;
 
        if (nQuotes % 2)
            continue;
 
        if (sCmd[i] == '(' || sCmd[i] == '[' || sCmd[i] == '{')
            i += getMatchingParenthesis(sCmd.substr(i));
 
        if (sCmd[i] == ' ')
        {
            size_t cont = isStringContinuation(sCmd, i);
 
            if (cont < sCmd.length() && NumeReKernel::getInstance()->getStringParser().isStringExpression(sCmd.substr(nPos, i-nPos)))
                i = cont-1;
            else
            {
                sArgument = sCmd.substr(nPos, i-nPos);
                break;
            }
        }
        else if (i+1 == sCmd.length())
            sArgument = sCmd.substr(nPos);
    }
 
    // Parse the argument, if necessary
    if (extraction & ARGEXTRACT_PARSED)
        parseArg(sArgument, extraction);
 
    // Strip the argument, if necessary
    if (extraction & ARGEXTRACT_STRIPPED)
    {
        StripSpaces(sArgument);
 
        if (sArgument.front() == '"' && sArgument.back() == '"')
            sArgument = sArgument.substr(1, sArgument.length()-2);
    }
 
    // return the found option value
    return sArgument;
}
 
 
bool isInQuotes(StringView sExpr, unsigned int nPos, bool bIgnoreVarParser /* = false*/)
{
    int nQuotes = 0;
 
    // --> Zaehlt schlicht und einfach die Anfuehrungszeichen <--
    for (size_t i = 0; i < nPos; i++)
    {
        // Parse the special string_cast function
        if (sExpr.subview(i, 12) == "string_cast(" && i + 12 <= nPos)
        {
            // Argument of "string_cast"?
            if (getMatchingParenthesis(sExpr.subview(i + 11)) + i + 11 > nPos)
                return true;
            else
                i += getMatchingParenthesis(sExpr.subview(i + 11)) + 11;
        }
 
        // Count the quotation marks
        if (sExpr[i] == '"' && (!i || sExpr[i-1] != '\\'))
            nQuotes++;
    }
 
    // Simplest case: The number of quotation marks is odd
    // Therefore the position is inside of quotation marks
    if (nQuotes % 2) // nQuotes % 2 == 1, wenn eine ungerade Zahl an Anfuehrungszeichen aufgetreten ist => die Position befindet sich als hinter einem geoeffneten Anfuehrungszeichen.
        return true;
 
    // Shall the variable to string parser be examined, too?
    if (!bIgnoreVarParser)
    {
        // No variable to string parser was found
        if (sExpr.rfind('#', nPos) == string::npos)
            return false;
 
        // Ensure that the variable to string parser is not part of quotation marks itself
        // Do this by calling the function on its position recursively
        if (isInQuotes(sExpr, sExpr.rfind('#', nPos), true))
            return false;
 
        // If it is not part of quotation marks, examine the contents of the
        // variable to string parser (i.e. everything between "#" and the current position)
        for (unsigned int i = sExpr.rfind('#', nPos); i < nPos; i++)
        {
            // Parenthesis is found
            // Jump over it
            if (sExpr[i] == '(')
            {
                // Has no closing parenthesis -> the closing one must be after the current position
                if (getMatchingParenthesis(sExpr.subview(i, nPos - i)) == string::npos)
                    return true;
 
                // Advance the index variabel
                i += getMatchingParenthesis(sExpr.subview(i, nPos - i));
 
                // Probably we're now at the current position. Then
                // this is the closing parenthesis of the variable to string parser
                if (i == nPos)
                    return true;
                continue;
            }
 
            // Whitespaces, commas, string concatenators (plus sign) and closing parentheses
            // are indicators for the end of the variable to string arguments. This means
            // that the current position is not part of any string
            if (sExpr[i] == ' ' || sExpr[i] == '+' || sExpr[i] == ',' || sExpr[i] == ')')
                return false;
        }
 
        // Exclude special characters, which are the terminators of the variable to string parser by themselves
        if (nPos < sExpr.length() - 1 && (sExpr[nPos] == ',' || sExpr[nPos] == '+' || sExpr[nPos] == ' ' || sExpr[nPos] == ')'))
            return false;
        else if (nPos == sExpr.length() - 1 && sExpr[nPos] == ')')
            return false;
        else
            return true;
 
    }
 
    // return false
    return false;
}
 
 
bool isToStringArg(const string& sExpr, unsigned int nPos)
{
    // Ensure that at least one of the three functions is available in the string
    if (sExpr.find("valtostr(") == string::npos && sExpr.find("to_string(") == string::npos && sExpr.find("string_cast(") == string::npos)
        return false;
 
    // Go inversely through the string
    for (int i = nPos; i >= 8; i--)
    {
        // An opening parenthesis was found with its counterpart after the current position
        if (sExpr[i] == '(' && getMatchingParenthesis(sExpr.substr(i)) + i > nPos)
        {
            // Is there one of the three functions left from the current position?
            if (i > 10 && sExpr.substr(i - 11, 12) == "string_cast(")
                return true;
            else if (i > 8 && sExpr.substr(i - 9, 10) == "to_string(")
                return true;
            else if (sExpr.substr(i - 8, 9) == "valtostr(")
                return true;
            else if (isDelimiter(sExpr[i - 1]))
                continue; // There's a delimiter left of the parenthesis, continue
            else
                return false;
        }
    }
 
    // No part of any of the functions' arguments
    return false;
}
 
 
long long int intCast(double number)
{
    // if quite close, use rint
    if (fabs(number - rint(number)) < 1e-7)
        return rint(number);
    // otherwise truncate
    return static_cast<int>(number);
}
 
 
long long int intCast(const std::complex<double>& number)
{
    return intCast(number.real());
}
 
 
bool isInt(const std::complex<double>& number)
{
    return number.imag() == 0.0 && fabs(number.real() - rint(number.real())) < 1e-12;
}
 
 
bool isDelimiter(char c)
{
    // Characters converted to a single logical expression (should be faster in principle)
    return c >= 32 && c <= 125 && c != 36 && c != 39 && c != 46 && (c < 48 || c > 57) && (c < 64 || c > 90) && (c < 95 || c > 122);
    // Only construct the string once
    //static string sDelimiter = "+-*/ ^&|!%<>,=\\#?:;()[]{}\"";
 
    // Try to find the current character
    /*if (sDelimiter.find(cChar) != string::npos)
        return true;
    return false;*/
}
 
 
bool addLegends(string& sExpr)
{
    // Validate the number of parentheses
    if (!validateParenthesisNumber(sExpr))
        throw SyntaxError(SyntaxError::UNMATCHED_PARENTHESIS, sExpr, '(');
 
    EndlessVector<std::string> args = getAllArguments(sExpr);
 
    std::string sTemp;
 
    for (size_t i = 0; i < args.size(); i++)
    {
        /* --> Nun koennte es sein, dass bereits eine Legende angegeben worden ist. Dabei gibt es drei
         *     Moeglichkeiten: entweder durch umschliessende Anfuehrungszeichen, durch eine vorangestellte
         *     Raute '#' oder auch beides. Wir muessen hier diese drei Faelle einzeln behandeln <--
         * --> Ebenfalls ist es natuerlich moeglich, dass gar keine Legende angegeben worden ist. Das behandeln
         *     wir im ELSE-Fall <--
         */
        if (args[i].find('"') != std::string::npos)
        {
            /* --> Hier ist auf jeden Fall '"' vorhanden. Es ist aber nicht gesagt, dass '#' nicht auch
             *     zu finden ist <--
             * --> Speichern wir zunaechst die Position des '"' in nPos <--
             */
            size_t nPos = args[i].find('"') + 1;
 
            // --> Pruefe nun, ob in diesem Stringbereich ein zweites '"' zu finden ist <--
            if (args[i].find('"', nPos) != std::string::npos)
            {
                // --> Ja? Gibt's denn dann eine Raute? <--
                if (args[i].find('#', nPos) != std::string::npos)
                {
                    // --> Ja? Dann muessen wir (zur Vereinfachung an anderer Stelle) noch zwei Anfuehrungszeichen ergaenzen <--
                    sTemp += args[i] + "+\"\"";
                }
                else
                    sTemp += args[i];
            }
            else
                return false;   // Nein? Dann ist irgendwas ganz Falsch: FALSE zurueckgeben!
        }
        else if (args[i].find('#') != string::npos)
        {
            /* --> Hier gibt's nur '#' und keine '"' (werden im ersten Fall schon gefangen). Speichern wir
             *     die Position der Raute in nPos <--
             */
            size_t nPos = args[i].find('#');
 
            /* --> Setze sExpr dann aus dem Teil vor nPos und, wenn noch mindestens Komma ab nPos gefunden werden kann,
             *     dem Teil ab nPos vor dem Komma, dem String '+""' und dem Teil ab dem Komma zusammen, oder, wenn kein
             *     Komma gefunden werden kann, dem Teil nach nPos und dem String '+""' zusammen <--
             * --> An dieser Stelle bietet sich der Ternary (A ? x : y) tatsaechlich einmal an, da er die ganze Sache,
             *     die sonst eine temporaere Variable benoetigt haette, in einem Befehl erledigen kann <--
             */
            for (size_t j = nPos; j < args[i].length(); j++)
            {
                if (args[i][j] == '(')
                    j += getMatchingParenthesis(args[i].substr(j));
 
                if (args[i][j] == ' ')
                {
                    sTemp += args[i].insert(j, "+\"\"");
                    break;
                }
                else if (j+1 == args[i].length())
                {
                    sTemp += args[i] + "+\"\"";
                    break;
                }
            }
        }
        else
        {
            /* --> Hier gibt's weder '"' noch '#'; d.h., wir muessen die Legende selbst ergaenzen <--
             * --> Schneiden wir zunaechst den gesamten Ausdurck zwischen den zwei Kommata heraus <--
             */
            std::string sLabel = args[i];
 
            // --> Entfernen wir ueberzaehlige Leerzeichen <--
            StripSpaces(sLabel);
 
            /* --> Setzen wir den gesamten Ausdruck wieder zusammen, wobei wir den Ausdruck in
             *     Anfuehrungszeichen als Legende einschieben <--
             */
            sTemp += args[i] + " \"" + sLabel + "\"";
        }
 
        if (i+1 < args.size())
            sTemp += ", ";
    }
 
    sExpr = sTemp;
 
    return true;
}
 
 
bool checkDelimiter(const string& sString, bool stringdelim)
{
    // --> Gib die Auswertung dieses logischen Ausdrucks zurueck <--
    return isDelimiter(sString.front()) && (isDelimiter(sString.back()) || (sString.back() == '.' && stringdelim));
}
 
 
std::vector<std::string> splitIntoLines(std::string sOutput, size_t lineWidth, bool bAllowDashBreaks, int nFirstIndent, int nIndent)
{
    // Set the return vector of strings
    std::vector<std::string> outputInLines;
 
    // Variable to store the position of the last line break
    unsigned int nLastLineBreak = 0;
 
    // Convert the output to the system code page
    sOutput = toSystemCodePage(sOutput);
 
    // Check if the output already contains the line starting chars
    if ((sOutput.substr(0, 4) == "|   " || sOutput.substr(0, 4) == "|-> ") && nFirstIndent == 4)
        nFirstIndent = 0;
 
    // Check if string is already shorter than the line length and does not have any new line commands
    if (sOutput.length() < lineWidth - nFirstIndent && sOutput.find('$') == string::npos && sOutput.find("\\n") == string::npos && sOutput.find('\n') == string::npos)
    {
        outputInLines.push_back(sOutput);
        return outputInLines;
    }
 
    // Go through the whole string
    for (unsigned int i = 1; i < sOutput.length(); i++)
    {
        // Check for the '$' sign. If found update the last line break
        if (sOutput[i] == '$' && sOutput[i - 1] != '\\')
            nLastLineBreak = i;
 
        if (sOutput[i] == 'n' && sOutput[i - 1] == '\\')
        {
            if ((i == 1 || sOutput[i - 2] != '\\')
                    && !(sOutput.substr(i, 2) == "nu" && checkDelimiter(sOutput.substr(i - 1, 4)))
                    && !(sOutput.substr(i, 3) == "neq" && checkDelimiter(sOutput.substr(i - 1, 5))))
                nLastLineBreak = i;
            else if (i != 1 && sOutput[i - 2] != '\\')
                sOutput.insert(i, "\\");
        }
        // Check for explicit line break
        if (sOutput[i] == '\n')
        {
            nLastLineBreak = i;
        }
 
        // Check if max line length is reached. In that case, split the string at a fitting position
        if ((i == lineWidth - nFirstIndent && !nLastLineBreak) || (nLastLineBreak && i - nLastLineBreak == lineWidth - nIndent))
        {
            // Go backwards from the current position and look for 1 space or 1 minus sign (if allowed) or the "$"
            for (unsigned int j = i; j > nLastLineBreak; j--)
            {
                if (sOutput[j] == ' ')
                {
                    if (sOutput[j - 1] == '\\')
                    {
                        sOutput.insert(j + 1, "$");
                        nLastLineBreak = j + 1;
                    }
                    else
                    {
                        sOutput[j] = '$';   // Replace " " with a "$"
                        nLastLineBreak = j;
                    }
                    break;
                }
                else if (sOutput[j] == '-' && bAllowDashBreaks && j != i)
                {
                    // Check if a line break is applicable for the "-" used
                    if (j &&
                            (sOutput[j - 1] == ' '
                             || sOutput[j - 1] == '('
                             || sOutput[j + 1] == ')'
                             || sOutput[j - 1] == '['
                             || (sOutput[j + 1] >= '0' && sOutput[j + 1] <= '9')
                             || sOutput[j + 1] == ','
                             || (sOutput[j + 1] == '"' && sOutput[j - 1] == '"')
                            ))
                        continue;
                    sOutput.insert(j + 1, 1, '\n');   // Insert a linebreak
                    nLastLineBreak = j + 1;
                    break;
                }
                else if (sOutput[j] == ',' && bAllowDashBreaks && sOutput[j + 1] != ' ' && j != i)
                {
                    sOutput[j] = '%';
                    nLastLineBreak = j + 1;
                    break;
                }
                else if (sOutput[j] == '$' && sOutput[j - 1] != '\\') // Definitely a line break is required here
                {
                    nLastLineBreak = j;
                    break;
                }
                if (j - 1 == nLastLineBreak)
                {
                    string sDelim = "+-*/";
                    for (unsigned int n = i; n > nLastLineBreak; n--)
                    {
                        if (sDelim.find(sOutput[n]) != string::npos)
                        {
                            sOutput = sOutput.substr(0, n) + '$' + sOutput.substr(n);
                            nLastLineBreak = n;
                            break;
                        }
                        if (n - 1 == nLastLineBreak)
                        {
                            sOutput = sOutput.substr(0, i - 1) + '$' + sOutput.substr(i - 1);
                            nLastLineBreak = i;
                        }
                    }
                }
            }
        }
    }
 
    // Go through the whole string again
    size_t lastBreak = 0;   // lastBreak is the position of the first relevant char for the new line
    for (unsigned int i = 0; i < sOutput.length(); i++)
    {
        if (sOutput[i] == '$' && sOutput[i - 1] != '\\')
        {
            // Split the string at the '$' sign
            outputInLines.push_back(sOutput.substr(lastBreak, i - lastBreak));
            lastBreak = i + 1;
            continue;
        }
        else if (sOutput[i] == '\n')
        {
            outputInLines.push_back(sOutput.substr(lastBreak, i - lastBreak));
            lastBreak = i + 1;
            continue;
        }
        else if (sOutput[i] == 'n' && sOutput[i - 1] == '\\' && sOutput[i - 2] != '\\')
            sOutput = sOutput.substr(0, i - 1) + "\n" + sOutput.substr(i + 1);
        else if (sOutput[i] == 'n' && sOutput[i - 1] == '\\' && sOutput[i - 2] == '\\')
            sOutput.erase(i - 1, 1);
        else if (sOutput[i] == '$' && sOutput[i - 1] == '\\')
            sOutput.erase(i - 1, 1);
        else if (sOutput[i] == '%' && bAllowDashBreaks)
        {
            // Replace '%' with ',' and the indent if allowed
            sOutput = sOutput.substr(0, i) + ",\n" + sOutput.substr(i + 1);
        }
    }
 
    // Add the rest of the string
    outputInLines.push_back(sOutput.substr(lastBreak));
 
    return outputInLines;
}
 
 
std::string outputString(std::vector<std::string> stringInLines, int nFirstIndent, int nIndent)
{
    std::string sOutput = "";
 
    // Check if vector is empty and return empty string if so
    if (!stringInLines.size())
        return sOutput;
 
    // Check if the output already contains the line starting chars
    if ((sOutput.substr(0, 4) == "|   " || sOutput.substr(0, 4) == "|-> ") && nFirstIndent == 4)
        nFirstIndent = 0;
 
    // Add the first line with the corresponding indent
    sOutput.append(stringInLines[0]);
 
    // Prepare the prefix for all strings except the first one
    std::string sIndent = "\n|";
    for (int i = 1; i < nIndent; i++)
        sIndent += " ";
 
    // Add the prefixes and join the strings
    for (size_t i = 1; i < stringInLines.size(); i++)
        sOutput.append(sIndent + stringInLines[i]);
 
    return sOutput;
}
 
 
std::string LineBreak(std::string sOutput, const Settings& _option, bool bAllowDashBreaks, int nFirstIndent, int nIndent)
{
    return outputString(splitIntoLines(sOutput, _option.getWindow(), bAllowDashBreaks, nFirstIndent, nIndent), nFirstIndent, nIndent);
}
 
 
double Linearize(double x_0, double y_0, double x_1, double y_1)
{
    double b = y_0;
    double m = (y_1 - y_0) / (x_1 - x_0);
    // y = m*x + b ==> x = 1/m*(y-b) ==> x = -b/m fuer y = 0.0
    return x_0 - b / m;
}
 
 
static StringView getNextCommandLineToken(StringView& sArgList, char cSep)
{
    if (!sArgList.length())
        return StringView();
 
    size_t nPos = 0;
    size_t nMatching = 0;
    size_t nQuotes = 0;
 
    // Go through the complete string
    for (size_t i = 0; i < sArgList.length(); i++)
    {
        if (sArgList[i] == '"' && (!i || sArgList[i-1] != '\\'))
            nQuotes++;
 
        if (nQuotes % 2)
            continue;
 
        // Jump over parentheses
        if ((sArgList[i] == '(' || sArgList[i] == '[' || sArgList[i] == '{' ) && (nMatching = getMatchingParenthesis(sArgList.subview(i))) != string::npos)
            i += nMatching;
 
        // A comma was found -> break the loop
        if (sArgList[i] == cSep)
        {
            nPos = i;
            break;
        }
    }
 
    // If no comma was found, simply use the complete string
    if (!nPos && sArgList[0] != cSep)
        nPos = sArgList.length();
 
    // If the comma was at the first position, then return nothing
    if (!nPos)
    {
        if (sArgList[0] == cSep)
            sArgList.trim_front(1);
        return StringView();
    }
 
    // Get the first argument
    StringView sArg = sArgList.subview(0, nPos);
    sArg.strip();
 
    sArgList.trim_front(nPos+1);
 
    // return the first argument
    return sArg;
}
 
string getNextArgument(string& sArgList, bool bCut)
{
    StringView argList(sArgList);
    string sArg = getNextCommandLineToken(argList, ',').to_string();
 
    if (bCut)
        sArgList = argList.to_string();
 
    return sArg;
}
 
string getNextIndex(string& sArgList, bool bCut)
{
    StringView argList(sArgList);
    string sArg = getNextCommandLineToken(argList, ':').to_string();
 
    if (bCut)
        sArgList = argList.to_string();
 
    return sArg;
}
 
string getNextSemiColonSeparatedToken(string& sArgList, bool bCut)
{
    StringView argList(sArgList);
    string sArg = getNextCommandLineToken(argList, ';').to_string();
 
    if (bCut)
        sArgList = argList.to_string();
 
    return sArg;
}
 
StringView getNextViewedArgument(StringView& sView)
{
    return getNextCommandLineToken(sView, ',');
}
 
StringView getNextViewedIndex(StringView& sView)
{
    return getNextCommandLineToken(sView, ':');
}
 
 
EndlessVector<StringView> getAllArguments(StringView sArgList)
{
    EndlessVector<StringView> vArgs;
 
    while (sArgList.length())
        vArgs.push_back(getNextViewedArgument(sArgList));
 
    return vArgs;
}
 
 
EndlessVector<string> getAllArguments(string sArgList)
{
    EndlessVector<string> vArgs;
 
    while (sArgList.length())
        vArgs.push_back(getNextArgument(sArgList, true));
 
    return vArgs;
}
 
 
EndlessVector<string> getAllIndices(string sArgList)
{
    EndlessVector<string> vIndices;
 
    while (sArgList.length())
        vIndices.push_back(getNextIndex(sArgList, true));
 
    return vIndices;
}
 
 
EndlessVector<string> getAllSemiColonSeparatedTokens(string sArgList)
{
    EndlessVector<string> vIndices;
 
    while (sArgList.length())
        vIndices.push_back(getNextSemiColonSeparatedToken(sArgList, true));
 
    return vIndices;
}
 
 
void make_progressBar(int nStep, int nFirstStep, int nFinalStep, const string& sType)
{
    NumeReKernel::progressBar(nStep, nFirstStep, nFinalStep, sType);
    return;
}
 
 
static bool containsStringClusters(const string& sLine)
{
    const map<string,NumeRe::Cluster>& mClusterMap = NumeReKernel::getInstance()->getMemoryManager().getClusterMap();
 
    for (auto iter = mClusterMap.begin(); iter != mClusterMap.end(); ++iter)
    {
        if (iter->second.isString())
        {
            size_t pos = sLine.find(iter->first + "{");
 
            if (pos != string::npos && (!pos || isDelimiter(sLine[pos-1])))
                return true;
        }
    }
 
    return false;
}
 
 
bool containsStrings(const string& sLine)
{
    if (!sLine.length())
        return false;
 
    // It's only necessary to check the following functions.
    // All other string functions need strings as input
    if (sLine.find_first_of("\"#") != string::npos
            || sLine.find("string(") != string::npos
            || sLine.find("string_cast(") != string::npos
            || sLine.find("char(") != string::npos
            || sLine.find("getlasterror(") != string::npos
            || sLine.find("getversioninfo(") != string::npos
            || sLine.find("valtostr(") != string::npos
            || sLine.find("weekday(") != string::npos
            || sLine.find("to_tex(") != std::string::npos)
        return true;
 
    return containsStringClusters(sLine);
}
 
 
bool fileExists(const string& sFilename)
{
    if (sFilename.length())
    {
        string _sFile = sFilename;
        _sFile = fromSystemCodePage(_sFile);
 
        // Open the ifstream (ifstream doesn't create a file)
        ifstream ifFile(_sFile.c_str());
        return ifFile.good(); // If the stream is good(), the file exists
    }
    else
        return false;
}
 
 
void eraseToken(string& sExpr, const string& sToken, bool bTokenHasValue)
{
    unsigned int nLength = sToken.length();
 
    // If the option token has a value, then the erase process is a bit more complex
    if (bTokenHasValue)
    {
        // Is the token actually available?
        if (!findParameter(sExpr, sToken, '='))
            return;
 
        // Search for the option value
        for (unsigned int i = findParameter(sExpr, sToken, '=') + nLength - 1; i < sExpr.length(); i++)
        {
            // Assignment operator found
            if (sExpr[i] == '=')
            {
                // Find the end of the option value
                for (unsigned int j = sExpr.find_first_not_of("= ", i); j < sExpr.length(); j++)
                {
                    // jump over parentheses
                    if (!isInQuotes(sExpr, j) && (sExpr[j] == '(' || sExpr[j] == '[' || sExpr[j] == '{'))
                        j += getMatchingParenthesis(sExpr.substr(j));
 
                    // White space found -> end of option value
                    // erase token and its value together
                    if (sExpr[j] == ' ')
                    {
                        sExpr.erase(findParameter(sExpr, sToken, '=') - 1, j - findParameter(sExpr, sToken, '=') + 1);
                        return;
                    }
                }
            }
        }
    }
    else
    {
        // Is the token actually available?
        if (!findParameter(sExpr, sToken))
            return;
 
        // Simply erase the token
        sExpr.erase(findParameter(sExpr, sToken) - 1, nLength);
    }
}
 
 
vector<string> resolveChooseTokens(const string& sDirectory, const Settings& _option)
{
    vector<string> vResolved;
    vResolved.push_back(sDirectory);
    string sToken;
    unsigned int nSize = 0, nth_choose = 0;
    bool bResolvingPath = false;
 
    // Is there at least one pipe in the directory?
    if (sDirectory.find('|') != string::npos)
    {
        // As long as the directory contains pipes
        while (vResolved[0].find('|') != string::npos)
        {
            // no opening angle for the token?
            if (!vResolved[0].rfind('<'))
                break;
 
            // Get the token and remove the remaining part
            sToken = vResolved[0].substr(vResolved[0].rfind('<') + 1);
            sToken.erase(sToken.find('>'));
 
            // Store the current size of the directory tree
            nSize = vResolved.size();
            nth_choose = 0;
 
            // As long as a pipe is found in the token or the token has a length
            while (sToken.find('|') != string::npos || sToken.length())
            {
                // so lange ein "|" in dem Token gefunden wird, muss der Baum dupliziert werden
                if (sToken.find('|') != string::npos)
                {
                    // duplicate the "root" tree
                    for (unsigned int i = 0; i < nSize; i++)
                        vResolved.push_back(vResolved[i + nth_choose * nSize]);
                }
 
                // Replace the tokens with the first of the current tokens
                for (unsigned int i = nth_choose * nSize; i < (nth_choose + 1)*nSize; i++)
                {
                    if (!bResolvingPath && vResolved[i].rfind('/') != string::npos && vResolved[i].rfind('/') > vResolved[i].rfind('>'))
                        bResolvingPath = true;
                    vResolved[i].replace(vResolved[i].rfind('<'), vResolved[i].rfind('>') + 1 - vResolved[i].rfind('<'), sToken.substr(0, sToken.find('|')));
                }
 
                // If we want to resolve a path, then we have to do that with a recursion
                if (bResolvingPath
                        && ((vResolved[nth_choose * nSize].find('*') != string::npos && vResolved[nth_choose * nSize].find('*') < vResolved[nth_choose * nSize].rfind('/'))
                            || (vResolved[nth_choose * nSize].find('?') != string::npos && vResolved[nth_choose * nSize].find('?') < vResolved[nth_choose * nSize].rfind('/'))))
                {
                    // Platzhalter in Pfaden werden mit einer Rekursion geloest.
                    // Resolve the current tree
                    vector<string> vFolderList = getFolderList(vResolved[nth_choose * nSize].substr(0, vResolved[nth_choose * nSize].rfind('/')), _option, 1);
 
                    // Remove obsolete paths (i.e. paths pointing to itself or to one directory further up
                    for (unsigned int j = 0; j < vFolderList.size(); j++)
                    {
                        if ((vFolderList[j].length() >= 3 && vFolderList[j].substr(vFolderList[j].length() - 3) == "/..")
                            || (vFolderList[j].length() >= 2 && vFolderList[j].substr(vFolderList[j].length() - 2) == "/."))
                        {
                            vFolderList.erase(vFolderList.begin() + j);
 
                            // If we erase the current position, we have to decrement the position
                            j--;
                        }
                    }
 
                    // If we didn't get a result, remove the current token from the token list and continue
                    if (!vFolderList.size())
                    {
                        bResolvingPath = false;
                        nth_choose++;
                        if (sToken.find('|') != string::npos)
                            sToken.erase(0, sToken.find('|') + 1);
                        else
                        {
                            sToken.clear();
                            break;
                        }
                        continue;
                    }
 
                    // Copy the obtained tree to the resolved tree
                    for (unsigned int j = 0; j < vFolderList.size(); j++)
                    {
                        // Does the tree need to be duplicated?
                        if (vFolderList.size() > 1 && j < vFolderList.size() - 1)
                        {
                            // ggf. Baum duplizieren
                            if (vResolved.size() > (nth_choose + 1)*nSize)
                            {
                                for (unsigned int k = 0; k < nSize; k++)
                                {
                                    vResolved.push_back(vResolved[k + (nth_choose + 1)*nSize]);
                                    vResolved[k + (nth_choose + 1)*nSize] = vResolved[k + nth_choose * nSize];
                                }
                            }
                            else
                            {
                                for (unsigned int k = 0; k < nSize; k++)
                                {
                                    vResolved.push_back(vResolved[(nth_choose)*nSize]);
                                }
                            }
                        }
 
                        // simply replace the path part of the resolved tree
                        for (unsigned int k = nth_choose * nSize; k < (nth_choose + 1)*nSize; k++)
                        {
                            vResolved[k].replace(0, vResolved[k].rfind('/'), vFolderList[j]);
                        }
 
                        // Increment the choose token counter
                        if (vFolderList.size() > 1 && j < vFolderList.size() - 1)
                            nth_choose++;
                    }
                }
 
                // Erase the current token from the token list and continue
                bResolvingPath = false;
                nth_choose++;
                if (sToken.find('|') != string::npos)
                    sToken.erase(0, sToken.find('|') + 1);
                else
                {
                    sToken.clear();
                    break;
                }
            }
        }
    }
 
    // This is not using path tokens but place holders/wildcards in the path part
    if (vResolved[0].find('/') != string::npos
            && ((vResolved[0].find('*') != string::npos && vResolved[0].find('*') < vResolved[0].rfind('/'))
                || (vResolved[0].find('?') != string::npos && vResolved[0].find('?') < vResolved[0].rfind('/'))))
    {
        // Platzhalter in Pfaden werden mit einer Rekursion geloest.
        vector<string> vFolderList = getFolderList(vResolved[0].substr(0, vResolved[0].rfind('/')), _option, 1);
 
        // store the current tree size
        nSize = vResolved.size();
 
        // Remove obsolete paths (i.e. paths pointing to itself or to one directory further up
        for (unsigned int j = 0; j < vFolderList.size(); j++)
        {
            if ((vFolderList[j].length() >= 3 && vFolderList[j].substr(vFolderList[j].length() - 3) == "/..")
                || (vFolderList[j].length() >= 2 && vFolderList[j].substr(vFolderList[j].length() - 2) == "/."))
            {
                vFolderList.erase(vFolderList.begin() + j);
 
                // If we erase the current position, we have to decrement the position
                j--;
            }
        }
 
        // Return, if no result was found
        if (!vFolderList.size())
            return vResolved;
 
        // Copy the resolved tree, if it is necessary
        for (unsigned int i = 0; i < vFolderList.size() - 1; i++)
        {
            // Don't use paths, which weren't resolved
            if (vFolderList[i].find('*') != string::npos || vFolderList[i].find('?') != string::npos || !vFolderList[i].size())
                continue;
 
            // ggf. Baum duplizieren
            for (unsigned int k = 0; k < nSize; k++)
            {
                vResolved.push_back(vResolved[k]);
            }
 
        }
 
        // Replace the paths with wildcards with the results obtained by recursion
        for (unsigned int j = 0; j < vFolderList.size(); j++)
        {
            // Don't use paths, which weren't resolved
            if (vFolderList[j].find('*') != string::npos || vFolderList[j].find('?') != string::npos || !vFolderList[j].size())
                continue;
 
            // replace the paths in the resolved tree
            for (unsigned int k = j * nSize; k < (j + 1)*nSize; k++)
            {
                vResolved[k].replace(0, vResolved[k].rfind('/'), vFolderList[j]);
            }
        }
    }
 
    // return the resolved tree
    return vResolved;
}
 
 
static HANDLE initializeFileHandle(string& sDir, WIN32_FIND_DATA* FindFileData, const Settings& _option)
{
    HANDLE hFind = INVALID_HANDLE_VALUE;
    string sPath;
 
    // Initialize the Windows structures
    if (sDir[0] == '.')
    {
        // Only a dot -> root path
        hFind = FindFirstFile((_option.getExePath() + "\\" + sDir).c_str(), FindFileData);
        sDir = replacePathSeparator(_option.getExePath() + "/" + sDir);
        sDir.erase(sDir.rfind('/') + 1);
    }
    else if (sDir[0] == '<')
    {
        // Get the default paths
        if (sDir.substr(0, 10) == "<loadpath>")
            sPath = _option.getLoadPath() + sDir.substr(sDir.find('>') + 1);
        else if (sDir.substr(0, 10) == "<savepath>")
            sPath = _option.getSavePath() + sDir.substr(sDir.find('>') + 1);
        else if (sDir.substr(0, 12) == "<scriptpath>")
            sPath = _option.getScriptPath() + sDir.substr(sDir.find('>') + 1);
        else if (sDir.substr(0, 10) == "<plotpath>")
            sPath = _option.getPlotPath() + sDir.substr(sDir.find('>') + 1);
        else if (sDir.substr(0, 10) == "<procpath>")
            sPath = _option.getProcPath() + sDir.substr(sDir.find('>') + 1);
        else if (sDir.substr(0, 2) == "<>")
            sPath = _option.getExePath() + sDir.substr(sDir.find('>') + 1);
        else if (sDir.substr(0, 6) == "<this>")
            sPath = _option.getExePath() + sDir.substr(sDir.find('>') + 1);
        else if (sDir.substr(0, 4) == "<wp>")
            sPath = _option.getWorkPath() + sDir.substr(sDir.find('>') + 1);
 
        // If the path has a length then initialize the file handle
        if (sPath.length())
        {
            hFind = FindFirstFile(sPath.c_str(), FindFileData);
            sDir = replacePathSeparator(sPath);
            sDir.erase(sDir.rfind('/') + 1);
        }
    }
    else
    {
        // an arbitrary path
        hFind = FindFirstFile(sDir.c_str(), FindFileData);
        if (sDir.find('/') != string::npos)
            sDir.erase(sDir.rfind('/') + 1);
    }
 
    // return the initialized file handle
    return hFind;
}
 
 
vector<string> getFileList(const string& sDirectory, const Settings& _option, int nFlags)
{
    vector<string> vFileList;
    vector<string> vDirList;
 
    // Replace the Windows-Style Path separators to Unix-Style
    string sDir = replacePathSeparator(sDirectory);
 
    // Get the resolved tree
    vDirList = resolveChooseTokens(sDir, _option);
 
    // Walk through the resolved tree
    for (unsigned int i = 0; i < vDirList.size(); i++)
    {
        sDir = vDirList[i];
 
        // Append a wildcard, if one is missing
        if (sDir.rfind('.') == string::npos && sDir.find('*') == string::npos && sDir.find('?') == string::npos)
        {
            if (sDir[sDir.find_last_not_of(' ')] != '/')
                sDir += '/';
            sDir += "*";
        }
        else if ((sDir.find('.') == string::npos
                  || (sDir.find('.') != string::npos && sDir.find('/', sDir.rfind('.')) != string::npos))
                 && sDir.back() != '*')
            sDir += "*";
 
        // Declare the Windows structures;
        WIN32_FIND_DATA FindFileData;
        HANDLE hFind = initializeFileHandle(sDir, &FindFileData, _option);
 
        // Ensure that the structures were initialized correctly
        if (hFind == INVALID_HANDLE_VALUE)
            continue;
 
        // As long as the FindNextFile function returns non-zero
        // read the contents of FindFileData
        do
        {
            // Ignore directories
            if (FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
                continue;
 
            // Push back filenames
            if (nFlags & 1)
                vFileList.push_back(sDir + FindFileData.cFileName);
            else
                vFileList.push_back(FindFileData.cFileName);
        }
        while (FindNextFile(hFind, &FindFileData) != 0);
 
        // Close the handle
        FindClose(hFind);
    }
 
    // Return the obtained file list
    return vFileList;
}
 
 
vector<string> getFolderList(const string& sDirectory, const Settings& _option, int nFlags)
{
    vector<string> vFileList;
    vector<string> vDirList;
 
    // Replace the Windows-Style Path separators to Unix-Style
    string sDir = replacePathSeparator(sDirectory);
 
    // Get the resolved tree
    vDirList = resolveChooseTokens(sDir, _option);
 
    // Walk through the resolved tree
    for (unsigned int i = 0; i < vDirList.size(); i++)
    {
        sDir = vDirList[i];
 
        // Append a wildcard, if one is missing
        if (sDir.rfind('.') == string::npos && sDir.find('*') == string::npos && sDir.find('?') == string::npos)
        {
            if (sDir[sDir.find_last_not_of(' ')] != '/')
                sDir += '/';
            sDir += "*";
        }
        else if ((sDir.find('.') == string::npos
                  || (sDir.find('.') != string::npos && sDir.find('/', sDir.rfind('.')) != string::npos))
                 && sDir.back() != '*')
            sDir += "*";
 
        // Declare the Windows structures;
        WIN32_FIND_DATA FindFileData;
        HANDLE hFind = initializeFileHandle(sDir, &FindFileData, _option);
 
        // Ensure that the structures were initialized correctly
        if (hFind == INVALID_HANDLE_VALUE)
            continue;
 
        // As long as the FindNextFile function returns non-zero
        // read the contents of FindFileData
        do
        {
            // USe directories
            if (FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
            {
                // Push back the directories
                if (nFlags & 1)
                    vFileList.push_back(sDir + FindFileData.cFileName);
                else
                    vFileList.push_back(FindFileData.cFileName);
            }
            else // ignore files
                continue;
 
        }
        while (FindNextFile(hFind, &FindFileData) != 0);
 
        // Close the handle
        FindClose(hFind);
    }
 
    // Return the obtained file list
    return vFileList;
}
 
 
void reduceLogFilesize(const string& sFileName)
{
    fstream fFile;
    size_t nLines = 0;
    string sTemp;
    const size_t MAXLINES = 100000;
    const size_t MINLINES = 20000;
 
    // Open the logfile and check, whether the file stream is OK
    fFile.open(sFileName.c_str(), ios_base::binary | ios_base::in);
    if (fFile.fail())
        return;
 
    // Count the lines in the log file
    while (!fFile.eof())
    {
        getline(fFile, sTemp);
        nLines++;
    }
 
    // Clear the file state and return to the first position
    fFile.clear();
    fFile.seekg(0);
 
    // If the number of lines is larger than the predefined lines
    if (nLines >= MAXLINES)
    {
        fstream fTemp;
 
        // Open a temporary file in binary mode and check, whether the file is good
        fTemp.open("$~tempfile.txt", ios_base::binary | ios_base::out);
        if (fTemp.fail())
            return;
 
        // Copy the last 20.000 lines of the log file to the temporary file
        for (unsigned int i = 0; i < nLines; i++)
        {
            getline(fFile, sTemp);
            if (nLines - i > MINLINES)
                continue;
            fTemp << sTemp << endl;
        }
 
        // Close the file streams
        fFile.close();
        fTemp.close();
 
        // Re-open the file streams with exchanged read/write flags
        // and a truncate flag on the log file
        fTemp.open("$~tempfile.txt", ios_base::binary | ios_base::in);
        fFile.open(sFileName.c_str(), ios_base::trunc | ios_base::binary | ios_base::out);
        fTemp.seekg(0);
 
        // Copy the entire content of the temporary file
        // (i.e. the last 20.000 lines of the original log file)
        fFile << fTemp.rdbuf();
 
        // Close the file streams and remove the temporary file
        fFile.close();
        fTemp.close();
        remove("$~tempfile.txt");
    }
}
 
 
static void OprtRplc_setup(map<string, string>& mOprtRplc)
{
    mOprtRplc["("] = "[";
    mOprtRplc[")"] = "]";
    mOprtRplc[":"] = "~c~";
    mOprtRplc[","] = "_";
    mOprtRplc["."] = "_";
    mOprtRplc["+"] = "~p~";
    mOprtRplc["-"] = "~m~";
    mOprtRplc["*"] = "~ml~";
    mOprtRplc["/"] = "~d~";
    mOprtRplc["^"] = "~e~";
    mOprtRplc["{"] = "~ob~";
    mOprtRplc["}"] = "~cb~";
    mOprtRplc["&"] = "~a~";
    mOprtRplc["|"] = "~o~";
    mOprtRplc["%"] = "~md~";
    mOprtRplc["!"] = "~n~";
    mOprtRplc["="] = "~eq~";
    mOprtRplc[">"] = "~g~";
    mOprtRplc["<"] = "~l~";
    mOprtRplc["?"] = "~q~";
}
 
 
string replaceToVectorname(const string& sExpression)
{
    string sVectorName = sExpression;
    static map<string, string> mOprtRplc;
 
    // If the map wasn't initialized do that now
    if (!mOprtRplc.size())
        OprtRplc_setup(mOprtRplc);
 
    // Remove whitespaces
    while (sVectorName.find(' ') != string::npos)
        sVectorName.erase(sVectorName.find(' '), 1);
 
    // Replace mathematical operators
    for (auto iter = mOprtRplc.begin(); iter != mOprtRplc.end(); ++iter)
    {
        while (sVectorName.find(iter->first) != string::npos)
            sVectorName.replace(sVectorName.find(iter->first), (iter->first).length(), iter->second);
    }
 
    if (sVectorName.find('[') == string::npos)
        sVectorName += "[]";
 
    // return the new vector name
    return "_~" + sVectorName;
}
 
 
static bool handleRecursiveOperators(string& sExpr, size_t& nPos, size_t& nArgSepPos)
{
    size_t nLength = 2;
    if (sExpr.substr(nPos, 3) == "**=")
        nLength = 3;
    // Do we find another comma?
    if (sExpr.find(',', nPos) != string::npos)
    {
        int nQuotes = 0;
 
        // Go through the remaining expression and try to find the end
        // of the current expression part
        for (unsigned int j = nPos; j < sExpr.length(); j++)
        {
            // Jump over parentheses
            if (!(nQuotes % 2)
                && (sExpr[j] == '(' || sExpr[j] == '[' || sExpr[j] == '{'))
                j += getMatchingParenthesis(sExpr.substr(j));
 
            // Count the not escaped parentheses
            if (sExpr[j] == '"')
            {
                if (j && sExpr[j - 1] == '\\')
                    continue;
                nQuotes++;
            }
 
            // continue, if we're inside of quotation marks
            if (nQuotes % 2)
                continue;
 
            // Do we find a comma or did we reach the end of the whole expression?
            if (sExpr[j] == ',' || j + 1 == sExpr.length())
            {
                // Do we have a comma now?
                if (j + 1 != sExpr.length())
                {
                    // The comma case
                    if (!nArgSepPos)
                    {
                        sExpr = sExpr.substr(0, nPos)
                                + " = "
                                + sExpr.substr(0, nPos)
                                + sExpr.substr(nPos, nLength-1)
                                + "("
                                + sExpr.substr(nPos + nLength, j - nPos - nLength)
                                + ") "
                                + sExpr.substr(j);
                    }
                    else
                    {
                        sExpr = sExpr.substr(0, nPos)
                                + " = "
                                + sExpr.substr(nArgSepPos + 1, nPos - nArgSepPos - 1)
                                + sExpr.substr(nPos, nLength-1)
                                + "("
                                + sExpr.substr(nPos + nLength, j - nPos - nLength)
                                + ") "
                                + sExpr.substr(j);
                    }
                }
                else
                {
                    // The end-of-expression case
                    if (!nArgSepPos)
                    {
                        sExpr = sExpr.substr(0, nPos)
                                + " = "
                                + sExpr.substr(0, nPos)
                                + sExpr.substr(nPos, nLength-1)
                                + "("
                                + sExpr.substr(nPos + nLength)
                                + ") ";
                    }
                    else
                    {
                        sExpr = sExpr.substr(0, nPos)
                                + " = "
                                + sExpr.substr(nArgSepPos + 1, nPos - nArgSepPos - 1)
                                + sExpr.substr(nPos, nLength-1)
                                + "("
                                + sExpr.substr(nPos + nLength)
                                + ") ";
                    }
 
                    // return false means: this is the end of the expression
                    return false;
                }
 
                // Go through the expression and try to find the next argument separator
                for (unsigned int k = nPos; k < sExpr.length(); k++)
                {
                    // Jump over parentheses
                    if (!(nQuotes % 2)
                        && (sExpr[k] == '(' || sExpr[k] == '[' || sExpr[k] == '{'))
                        k += getMatchingParenthesis(sExpr.substr(k));
 
                    // Count the quotation marks, which are not escaped
                    if (sExpr[k] == '"')
                    {
                        if (k && sExpr[k - 1] == '\\')
                            continue;
                        nQuotes++;
                    }
 
                    // Contine, if we're inside of quotation marks
                    if (nQuotes % 2)
                        continue;
 
                    // Do we find a comma?
                    // Update all index variables and break
                    // the current loop
                    if (sExpr[k] == ',')
                    {
                        nArgSepPos = k;
                        nPos = k;
                        break;
                    }
                }
 
                // break this loop
                break;
            }
        }
    }
    else
    {
        // Simple case: no further comma
        if (!nArgSepPos)
        {
            sExpr = sExpr.substr(0, nPos)
                    + " = "
                    + sExpr.substr(0, nPos)
                    + sExpr.substr(nPos, nLength-1)
                    + "("
                    + sExpr.substr(nPos + nLength)
                    + ")";
        }
        else
        {
            sExpr = sExpr.substr(0, nPos)
                    + " = "
                    + sExpr.substr(nArgSepPos + 1, nPos - nArgSepPos - 1)
                    + sExpr.substr(nPos, nLength-1)
                    + "("
                    + sExpr.substr(nPos + nLength)
                    + ")";
        }
 
        // return false means: was last expression
        return false;
    }
 
    // return true means: continue the detection of recursive expressions
    return true;
}
 
 
static void handleIncAndDecOperators(string& sExpr, size_t nPos, size_t nArgSepPos)
{
    if (!nArgSepPos)
    {
        sExpr = sExpr.substr(0, nPos)
                + " = "
                + sExpr.substr(0, nPos)
                + sExpr[nPos]
                + "1"
                + sExpr.substr(nPos + 2);
    }
    else
    {
        sExpr = sExpr.substr(0, nPos)
                + " = "
                + sExpr.substr(nArgSepPos + 1, nPos - nArgSepPos - 1)
                + sExpr[nPos]
                + "1"
                + sExpr.substr(nPos + 2);
    }
}
 
 
void evalRecursiveExpressions(string& sExpr)
{
    // Ignore flow control blocks
    if (sExpr.substr(0, 3) == "if "
            || sExpr.substr(0, 3) == "if("
            || sExpr.substr(0, 7) == "elseif "
            || sExpr.substr(0, 7) == "elseif("
            || sExpr.substr(0, 5) == "else "
            || sExpr.substr(0, 7) == "switch "
            || sExpr.substr(0, 7) == "switch("
            || sExpr.substr(0, 5) == "case "
            || sExpr.substr(0, 8) == "default:"
            || sExpr.substr(0, 4) == "for "
            || sExpr.substr(0, 4) == "for("
            || sExpr.substr(0, 6) == "while "
            || sExpr.substr(0, 6) == "while(")
        return;
 
    unsigned int nArgSepPos = 0;
    int nQuotes = 0;
    bool bAnswerSuppressor = false;
 
    // Find the trailing semicolon
    if (sExpr.find_last_not_of(" \t") != string::npos && sExpr[sExpr.find_last_not_of(" \t")] == ';')
    {
        sExpr.erase(sExpr.find_last_not_of(" \t"));
        bAnswerSuppressor = true;
    }
 
    // Go through the complete expression
    for (unsigned int i = 0; i < sExpr.length(); i++)
    {
        // Jump over parentheses
        if (!(nQuotes % 2)
            && (sExpr[i] == '(' || sExpr[i] == '{' || sExpr[i] == '['))
        {
            size_t parens = getMatchingParenthesis(sExpr.substr(i));
            if (parens != string::npos)
                i += parens;
        }
 
        // Count the quatation marks, which are not escaped
        if (sExpr[i] == '"')
        {
            if (i && sExpr[i - 1] == '\\')
                continue;
            nQuotes++;
        }
 
        // Continue, if we're inside of quotation marks
        if (nQuotes % 2) // nQuotes % 2 == 1, wenn eine ungerade Zahl an Anfuehrungszeichen aufgetreten ist => die Position befindet sich als hinter einem geoeffneten Anfuehrungszeichen.
            continue;
 
        // If there's a comma, store its position as
        // argument/expression separator and continue
        if (sExpr[i] == ',')
        {
            nArgSepPos = i;
            continue;
        }
 
        // Do we find a recursive expression?
        if (sExpr.substr(i, 2) == "+="
                || sExpr.substr(i, 2) == "-="
                || sExpr.substr(i, 3) == "**="
                || sExpr.substr(i, 2) == "*="
                || sExpr.substr(i, 2) == "/="
                || sExpr.substr(i, 2) == "^=")
        {
            // if the handler returns false, we may break the loop
            if (!handleRecursiveOperators(sExpr, i, nArgSepPos))
                break;
        }
 
        // Do we find a increment or decrement operator?
        if (sExpr.substr(i, 2) == "++" || sExpr.substr(i, 2) == "--")
        {
            // Handle this type of operators
            handleIncAndDecOperators(sExpr, i, nArgSepPos);
        }
    }
 
    // Add the trailing semicolon
    if (bAnswerSuppressor)
        sExpr += ";";
 
    return;
}
 
 
 
string getFileInfo(const string& sFileName)
{
    NumeRe::NumeReDataFile file(sFileName);
    string sFileInfo;
 
    try
    {
        file.readFileInformation();
    }
    catch (...)
    {
        return "";
    }
 
    NumeRe::FileHeaderInfo info = file.getFileHeaderInformation();
 
    sFileInfo = toString(info.timeStamp, 0)
                + " (NDAT v" + toString(info.fileVersion, 5) + ") | "
                + toString(info.nRows) + " x " + toString(info.nCols) + " | \"" + info.sTableName + "()\"";
 
    if (info.sComment.length() > 204)
        sFileInfo += "\n" + info.sComment.substr(0, 200) + "...";
    else if (info.sComment.length())
        sFileInfo += "\n" + info.sComment;
 
    // Return the read file meta information
    return sFileInfo;
}
 
 
string decodeNameSpace(string sCommandLine, const string& sThisNameSpace)
{
    string sNameSpace = "";
 
    if (sCommandLine.find("namespace") != string::npos)
    {
        sCommandLine.erase(0, sCommandLine.find("namespace") + 9);
 
        while (sCommandLine.back() == '\r' || sCommandLine.back() == '\n')
            sCommandLine.pop_back();
 
        StripSpaces(sCommandLine);
 
        if (sCommandLine.substr(0, 5) == "this~" || sCommandLine == "this")
            sCommandLine.replace(0, 4, sThisNameSpace);
 
        while (sCommandLine.back() == '~')
            sCommandLine.pop_back();
 
        if (sCommandLine != "main")
            sNameSpace = sCommandLine;
    }
 
    return sNameSpace;
}
 
 
bool validateParenthesisNumber(const string& sCmd)
{
    int nParCount = 0;
    int nVectCount = 0;
    int nBracketCount = 0;
    int nQuotes = 0;
 
    // Go through the whole string
    for (size_t i = 0; i < sCmd.length(); i++)
    {
        // This function counts the quotation marks by itself
        // because it's much faster
        if (sCmd[i] == '"' && (!i || sCmd[i - 1] != '\\'))
            nQuotes++;
 
        // If we're not in quotation marks
        if (!(nQuotes % 2))
        {
            // Count the opening and closing parentheses
            if (sCmd[i] == '(')
                nParCount++;
            else if (sCmd[i] == ')')
                nParCount--;
            else if (sCmd[i] == '{')
                nVectCount++;
            else if (sCmd[i] == '}')
                nVectCount--;
            else if (sCmd[i] == '[')
                nBracketCount++;
            else if (sCmd[i] == ']')
                nBracketCount--;
        }
    }
 
    // If one of the counters is nonzero, something is wrong
    return !((bool)nParCount || (bool)nVectCount || (bool)nBracketCount);
}
 
 
void addArgumentQuotes(string& sToAdd, const string& sParam)
{
    // Check, whether the parameter exists
    if (findParameter(sToAdd, sParam, '='))
    {
        // Store the position of the equal sign of the parameter token
        addArgumentQuotes(sToAdd, findParameter(sToAdd, sParam, '=') + sParam.length());
    }
}
 
 
void addArgumentQuotes(string& sToAdd, size_t pos)
{
    // Jump over following whitespaces
    while (sToAdd[pos] == ' ')
        pos++;
 
    // Only if the value doesn't contain strings
    if (!containsStrings(sToAdd.substr(pos, sToAdd.find(' ', pos) - pos)))
    {
        // Add surrounding quotation marks
        sToAdd = sToAdd.substr(0, pos)
                 + "\"" + getArgAtPos(sToAdd, pos) + "\""
                 + sToAdd.substr(sToAdd.find(' ', sToAdd.find(getArgAtPos(sToAdd, pos)) + getArgAtPos(sToAdd, pos).length()));
    }
}
 
 
double intPower(double dNumber, int nExponent)
{
    long double dResult = 1.0L;
 
    // An exponent of zero returns always 1
    if (!nExponent)
        return 1.0;
 
    // Calculuate the exponentation
    for (int i = abs(nExponent); i > 0; i--)
    {
        dResult *= (long double)dNumber;
    }
 
    // Apply the sign of the exponent
    if (nExponent > 0)
        return dResult;
    else
        return 1.0 / dResult;
}
 
 
std::complex<double> intPower(const std::complex<double>& dNumber, int nExponent)
{
    if (dNumber.imag() == 0.0)
        return intPower(dNumber.real(), nExponent);
 
    std::complex<double> dResult = 1.0;
 
    // An exponent of zero returns always 1
    if (!nExponent)
        return 1.0;
 
    // Calculuate the exponentation
    for (int i = abs(nExponent); i > 0; i--)
    {
        dResult *= dNumber;
    }
 
    // Apply the sign of the exponent
    if (nExponent > 0)
        return dResult;
    else
        return 1.0 / dResult;
}
 
 
bool isToCmd(const string& sCmd, unsigned int nPos)
{
    // Exclude border cases
    if (nPos < 6 || nPos >= sCmd.length())
        return false;
    if (sCmd.find("to_cmd(") == string::npos || sCmd.find("to_cmd(") > nPos)
        return false;
 
    // Go through the whole string and try to find the functions arguments
    for (int i = nPos - 6; i >= 0; i--)
    {
        if (sCmd.substr(i, 7) == "to_cmd(" && !isInQuotes(sCmd, i))
        {
            // function found -> try to find the matching parenthesis
            // If it is left of the desired position, then return true
            if (getMatchingParenthesis(sCmd.substr(i + 6)) > nPos - i - 6 && getMatchingParenthesis(sCmd.substr(i + 6)) != string::npos)
                return true;
        }
    }
 
    // End was reached -> return false
    return false;
}
 
 
unsigned int countEscapeSymbols(const string& sLine)
{
    unsigned int nCount = 0;
 
    // Go through the line
    for (unsigned int i = 0; i < sLine.length(); i++)
    {
        // If we find a escaped dollar sign, increment the counter
        if (sLine.substr(i, 2) == "\\$")
            nCount++;
    }
 
    // return the number of escaped dollar signs
    return nCount;
}
 
 
static int compareDouble(const void* p1, const void* p2)
{
    if (isnan(*(double*)p1) && isnan(*(double*)p2))
        return 0;
 
    if (isnan(*(double*)p1))
        return 1;
 
    if (isnan(*(double*)p2))
        return -1;
 
    return *(double*)p1 == *(double*)p2
        ? 0
        : -(*(double*)p1 < *(double*)p2) + (*(double*)p1 > *(double*)p2); // Returns -1 for smaller and +1 for larger
}
 
 
size_t qSortDouble(double* dArray, size_t nlength)
{
    // Sort the passed array using the compareDouble helper function
    qsort((void*)dArray, nlength, sizeof(double), compareDouble);
 
    // Exclude the NaNs in the array
    for (int i = nlength - 1; i >= 0; i--)
    {
        if (!isnan(dArray[i]) && !isinf(dArray[i]))
            return i + 1;
    }
    return 0;
}
 
 
static void replaceSearchMethods(string& sLine, size_t nPos, size_t nFinalPos, const string& sReplacement, const string& sMethod, string& sArgument)
{
    // Prepare the argument (use empty one or construct one
    // from argument and variable value)
    if (sArgument == "()")
        sArgument = "(" + sReplacement + ", " + sReplacement + ")";
    else if (sArgument.find(',') == string::npos)
        sArgument.insert(sArgument.length()-1, ", " + sReplacement + "");
    else
    {
        string sTemp = "(";
        sArgument.erase(0,1);
        sTemp += getNextArgument(sArgument, true);
        sTemp += ", " + sReplacement;
 
        if (sArgument[sArgument.find_first_not_of(' ')] == ')')
            sArgument = sTemp + ")";
        else
            sArgument = sTemp + ", " + sArgument;
    }
 
    // Replace the method with its standard function signature
    if (sMethod == "fnd")
        sLine.replace(nPos, nFinalPos-nPos, "strfnd" + sArgument);
    else if (sMethod == "rfnd")
        sLine.replace(nPos, nFinalPos-nPos, "strrfnd" + sArgument);
    else if (sMethod == "mtch")
        sLine.replace(nPos, nFinalPos-nPos, "strmatch" + sArgument);
    else if (sMethod == "rmtch")
        sLine.replace(nPos, nFinalPos-nPos, "strrmatch" + sArgument);
    else if (sMethod == "nmtch")
        sLine.replace(nPos, nFinalPos-nPos, "str_not_match" + sArgument);
    else if (sMethod == "nrmtch")
        sLine.replace(nPos, nFinalPos-nPos, "str_not_rmatch" + sArgument);
}
 
 
static void replaceAccessMethods(string& sLine, size_t nPos, size_t nFinalPos, const string& sReplacement, const string& sMethod, string& sArgument)
{
    // Prepare the argument (use empty one or construct one
    // from argument and variable value)
    if (sArgument == "()")
        sArgument = "(" + sReplacement + ", 1)";
    else
        sArgument.insert(1, sReplacement + ", ");
 
    // Replace the method with its standard function signature
    if (sMethod == "at")
        sLine.replace(nPos, nFinalPos-nPos, "char" + sArgument);
    else if (sMethod == "sub")
        sLine.replace(nPos, nFinalPos-nPos, "substr" + sArgument);
    else if (sMethod == "splt")
        sLine.replace(nPos, nFinalPos-nPos, "split" + sArgument);
}
 
 
void replaceStringMethod(string& sLine, size_t nPos, size_t nLength, const string& sReplacement)
{
    // Does the string variable name end with a dot?
    if (sLine[nPos+nLength] != '.')
    {
        sLine.replace(nPos, nLength, sReplacement);
        return;
    }
 
    static const string sDELIMITER = "+-*/ ={}^&|!,\\%#?:\";";
    string sMethod = "";
    string sArgument = "";
    size_t nFinalPos = 0;
 
    // Find the end of the appended method. This is either
    // the closing parenthesis or a delimiter character. Split
    // the found method into its name and its argument
    for (size_t i = nPos+nLength+1; i < sLine.length(); i++)
    {
        if (sLine[i] == '(')
        {
            // Method ends with closing parenthesis
            sMethod = sLine.substr(nPos+nLength+1, i-(nPos+nLength+1));
            sArgument = sLine.substr(i, getMatchingParenthesis(sLine.substr(i))+1);
            nFinalPos = i += getMatchingParenthesis(sLine.substr(i))+1;
            break;
        }
        else if (sDELIMITER.find(sLine[i]) != string::npos)
        {
            // Method ends with a delimiter
            sMethod = sLine.substr(nPos+nLength+1, i-(nPos+nLength+1));
            nFinalPos = i;
            break;
        }
    }
 
    // If the argument list is empty, use an empty
    // parenthesis instead
    if (!sArgument.length())
        sArgument = "()";
 
    // This if-else constrct replaces the found
    // method occurences with their standard string function
    if (sMethod == "len")
    {
        // String length methods
        sLine.replace(nPos, nFinalPos-nPos, "strlen(" + sReplacement + ")");
    }
    else if (sMethod == "at"
             || sMethod == "sub"
             || sMethod == "splt")
    {
        // Access methods and splitter
        replaceAccessMethods(sLine, nPos, nFinalPos, sReplacement, sMethod, sArgument);
    }
    else if (sMethod == "fnd"
             || sMethod == "rfnd"
             || sMethod == "mtch"
             || sMethod == "rmtch"
             || sMethod == "nmtch"
             || sMethod == "nrmtch")
    {
        // All search-oriented methods
        replaceSearchMethods(sLine, nPos, nFinalPos, sReplacement, sMethod, sArgument);
    }
}
 
 
std::string shortenFileName(const std::string& sFullFileName)
{
    size_t nPos = std::string::npos;
 
    std::string sFileName = replacePathSeparator(sFullFileName);
 
    while (sFileName.rfind('/', nPos) != string::npos)
    {
        nPos = sFileName.rfind('/', nPos);
 
        if (nPos != 0 && nPos-1 != ':')
        {
            size_t nPos_2 = sFileName.rfind('/', nPos-1);
 
            if (nPos_2 != string::npos)
            {
                sFileName = sFileName.substr(0,nPos_2+1) + ".." + sFileName.substr(nPos);
                nPos = nPos_2;
            }
            else
                break;
        }
        else
            break;
    }
 
    return sFileName;
}
 
 
std::string incrementVersion(std::string _sVer)
{
    // Increment the version by one (corresponds to
    // the build count)
    return intToVersion(versionToInt(_sVer)+1);
}