commandlineparser.cpp

Go to the documentation of this file.

/*****************************************************************************
    NumeRe: Framework fuer Numerische Rechnungen
    Copyright (C) 2021  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 "commandlineparser.hpp"
#include "../kernel.hpp"
#include "utils/tools.hpp"            // For findCommand, extractCommandString and getMatchingParenthesis
#include "maths/parser_functions.hpp" // For evaluateTargetOptionInCommand
 
// Prototype needed for file name conversion
std::string removeQuotationMarks(const std::string& sString);
 
 
 
CommandLineParser::CommandLineParser(const std::string& sCommandLine, CommandLineParser::CommandSignature signature) : m_commandLine(sCommandLine)
{
    // Try to find any command
    Match _mMatch = findCommand(sCommandLine);
 
    // Parse the command line, if a command was found
    if (_mMatch.sString.length())
    {
        m_cmd = _mMatch.sString;
        m_returnValueStatement = sCommandLine.substr(0, _mMatch.nPos);
 
        parse(extractCommandString(sCommandLine, _mMatch), signature);
    }
}
 
 
CommandLineParser::CommandLineParser(const std::string& sCommandLine, const std::string& sCommand, CommandLineParser::CommandSignature signature) : m_commandLine(sCommandLine)
{
    // Try to find the specified command
    Match _mMatch = findCommand(sCommandLine, sCommand);
 
    // Parse the command line, if the command was found
    if (_mMatch.sString.length())
    {
        m_cmd = _mMatch.sString;
        m_returnValueStatement = sCommandLine.substr(0, _mMatch.nPos);
 
        parse(extractCommandString(sCommandLine, _mMatch), signature);
    }
}
 
 
void CommandLineParser::parse(const std::string& sCommandString, CommandLineParser::CommandSignature signature)
{
    switch (signature)
    {
        // Command-parameter sequence
        case CMD_PAR:
            m_parlist = sCommandString.substr(sCommandString.find('-'));
            break;
 
        // Command-dataobject-parameter sequence
        case CMD_DAT_PAR:
        {
            m_expr = sCommandString.substr(m_cmd.length()+1);
            StripSpaces(m_expr);
 
            size_t nQuotes = 0;
 
            for (size_t i = 0; i < m_expr.length(); i++)
            {
                if (m_expr[i] == '"' && (!i || m_expr[i-1] != '\\'))
                {
                    nQuotes++;
                    continue;
                }
 
                if (!(nQuotes % 2))
                {
                    // Handle parentheses
                    if (m_expr[i] == '(' || m_expr[i] == '{')
                        i += getMatchingParenthesis(m_expr.substr(i));
 
                    // Handle lists (will jump to the minus sign or
                    // a possible following expression part, if no list)
                    if ((m_expr[i] == ',' || m_expr[i] == ' ' || m_expr[i] == '+') && m_expr.find_first_not_of(",+ ", i) != std::string::npos)
                        i = m_expr.find_first_not_of(",+ ", i);
 
                    // If this is a quotation mark, increment the
                    // counter and continue
                    if (m_expr[i] == '"')
                    {
                        nQuotes++;
                        continue;
                    }
 
                    // Extract params
                    if (m_expr[i] == ' ' || m_expr[i] == '-')
                    {
                        m_parlist = m_expr.substr(m_expr.find('-', i));
                        m_expr.erase(i);
                        break;
                    }
                }
            }
 
            break;
        }
        // Command-expression-set-parameter sequence
        case CMD_EXPR_set_PAR:
        {
            m_expr = sCommandString.substr(m_cmd.length()+1);
            StripSpaces(m_expr);
 
            size_t nQuotes = 0;
 
            for (size_t i = 0; i < m_expr.length(); i++)
            {
                if (m_expr[i] == '"' && (!i || m_expr[i-1] != '\\'))
                    nQuotes++;
 
                // Are we not in a string literal?
                if (!(nQuotes % 2))
                {
                    if (m_expr[i] == '(' || m_expr[i] == '{')
                        i += getMatchingParenthesis(m_expr.substr(i));
 
                    // Is this the start of the parameter list?
                    if (m_expr.substr(i, 2) == "--" || m_expr.substr(i, 5) == "-set ")
                    {
                        m_parlist = m_expr.substr(i);
                        m_expr.erase(i);
 
                        break;
                    }
                }
            }
        }
    }
 
    // Strip obsolete spaces
    StripSpaces(m_expr);
    StripSpaces(m_parlist);
}
 
 
std::string CommandLineParser::parseFileName(std::string& sFileName, std::string& sFileExt, const std::string& sBasePath) const
{
    FileSystem _fSys;
    _fSys.initializeFromKernel();
 
    if (sBasePath.length()
        && sFileName.find("\\\\") == std::string::npos
        && sFileName.find("//") == std::string::npos
        && sFileName.find(':') == std::string::npos
        && sFileName.find('<') == std::string::npos)
        sFileName.insert(0, sBasePath + "/");
 
    // If the filename contains a extension, extract it here and declare it as a valid file type
    if (sFileName.find('.') != std::string::npos)
    {
        size_t nPos = sFileName.find_last_of("/\\");
 
        if (sFileName.find('.', nPos) != std::string::npos)
            sFileExt = sFileName.substr(sFileName.rfind('.'));
    }
 
    // There are some protected ones
    if (sFileExt == ".exe" || sFileExt == ".dll" || sFileExt == ".sys")
    {
        throw SyntaxError(SyntaxError::FILETYPE_MAY_NOT_BE_WRITTEN, m_commandLine, SyntaxError::invalid_position, sFileExt);
    }
 
    if (!sFileExt.length())
        return _fSys.ValidFolderName(sFileName);
 
    // Declare the extension
    _fSys.declareFileType(sFileExt);
 
    // Get a valid file name
    return _fSys.ValidFileName(sFileName, sFileExt);
}
 
 
void CommandLineParser::setReturnValue(const std::vector<mu::value_type>& vRetVal)
{
    m_returnValueStatement += NumeReKernel::getInstance()->getParser().CreateTempVectorVar(vRetVal);
}
 
 
void CommandLineParser::setReturnValue(const std::vector<std::string>& vRetVal)
{
    m_returnValueStatement += NumeReKernel::getInstance()->getStringParser().createTempStringVectorVar(vRetVal);
}
 
 
bool CommandLineParser::exprContainsDataObjects() const
{
    return NumeReKernel::getInstance()->getMemoryManager().containsTablesOrClusters(m_expr);
}
 
 
std::string CommandLineParser::getExprAsFileName(std::string sFileExt, const std::string& sBasePath) const
{
    // Make a copy
    std::string sFileName = m_expr;
 
    // Call functions first
    if (!NumeReKernel::getInstance()->getDefinitions().call(sFileName))
        throw SyntaxError(SyntaxError::FUNCTION_ERROR, sFileName, SyntaxError::invalid_position);
 
    if (NumeReKernel::getInstance()->getStringParser().containsStringVars(sFileName))
        NumeReKernel::getInstance()->getStringParser().getStringValues(sFileName);
 
    if (NumeReKernel::getInstance()->getMemoryManager().containsTablesOrClusters(sFileName))
        getDataElements(sFileName, NumeReKernel::getInstance()->getParser(), NumeReKernel::getInstance()->getMemoryManager(), NumeReKernel::getInstance()->getSettings());
 
    // Strip the spaces and ensure that there's something left
    StripSpaces(sFileName);
 
    if (!sFileName.length())
        return "";
 
    // If there's a string in the file name, parse it here
    if (NumeReKernel::getInstance()->getStringParser().isStringExpression(sFileName))
    {
        std::string sDummy;
        NumeReKernel::getInstance()->getStringParser().evalAndFormat(sFileName, sDummy, true);
    }
 
    sFileName = removeQuotationMarks(sFileName);
 
    // Parse the prepared file path
    return parseFileName(sFileName, sFileExt, sBasePath);
}
 
 
DataAccessParser CommandLineParser::getExprAsDataObject() const
{
    std::string sExpr = m_expr;
 
    // Call functions first
    if (!NumeReKernel::getInstance()->getDefinitions().call(sExpr))
        throw SyntaxError(SyntaxError::FUNCTION_ERROR, m_commandLine, sExpr);
 
    if (sExpr.find("??") != std::string::npos)
        sExpr = promptForUserInput(sExpr);
 
    return DataAccessParser(sExpr);
}
 
 
std::string CommandLineParser::getExprAsMathExpression(bool parseDataObjects) const
{
    NumeReKernel* instance = NumeReKernel::getInstance();
    // Make a copy
    std::string sExpr = m_expr;
 
    // Call functions first
    if (!instance->getDefinitions().call(sExpr))
        throw SyntaxError(SyntaxError::FUNCTION_ERROR, m_commandLine, sExpr);
 
    if (sExpr.find("??") != std::string::npos)
        sExpr = promptForUserInput(sExpr);
 
    if (parseDataObjects && instance->getMemoryManager().containsTablesOrClusters(sExpr))
        getDataElements(sExpr, instance->getParser(), instance->getMemoryManager(), instance->getSettings());
 
    if (!instance->getMemoryManager().containsTablesOrClusters(sExpr) && sExpr.find('{') != std::string::npos)
        convertVectorToExpression(sExpr, instance->getSettings());
 
    StripSpaces(sExpr);
 
    return sExpr;
}
 
 
std::string CommandLineParser::parseExprAsString() const
{
    NumeReKernel* instance = NumeReKernel::getInstance();
    // Make a copy
    std::string sExpr = m_expr;
 
    // Call functions first
    if (!instance->getDefinitions().call(sExpr))
        throw SyntaxError(SyntaxError::FUNCTION_ERROR, m_commandLine, sExpr);
 
    StripSpaces(sExpr);
 
    if (sExpr.find("??") != std::string::npos)
        sExpr = promptForUserInput(sExpr);
 
    if (NumeReKernel::getInstance()->getStringParser().isStringExpression(sExpr))
    {
        sExpr += " -nq";
        std::string sDummy;
        NumeReKernel::getInstance()->getStringParser().evalAndFormat(sExpr, sDummy, true);
        return toInternalString(sExpr);
    }
 
    return sExpr;
}
 
 
std::vector<mu::value_type> CommandLineParser::parseExprAsNumericalValues() const
{
    NumeReKernel* instance = NumeReKernel::getInstance();
    // Make a copy
    std::string sValue = m_expr;
 
    // Call functions first
    if (!instance->getDefinitions().call(sValue))
        throw SyntaxError(SyntaxError::FUNCTION_ERROR, sValue, SyntaxError::invalid_position);
 
    // Parse strings (if any)
    if (instance->getStringParser().isStringExpression(sValue))
    {
        std::string sDummy = "";
        instance->getStringParser().evalAndFormat(sValue, sDummy, true);
    }
 
    // Resolve table accesses
    if (instance->getMemoryManager().containsTablesOrClusters(sValue))
        getDataElements(sValue, instance->getParser(), instance->getMemoryManager(), instance->getSettings());
 
    instance->getParser().SetExpr(sValue);
    int nRes;
    mu::value_type* v;
 
    v = instance->getParser().Eval(nRes);
 
    std::vector<mu::value_type> vVals(v, v+nRes);
 
    return vVals;
}
 
 
IntervalSet CommandLineParser::parseIntervals(bool bErase)
{
    return IntervalSet(m_parlist);
}
 
 
std::string CommandLineParser::getTargetTable(Indices& _targetIndices, const std::string& sDefaultTableName)
{
    NumeReKernel* instance = NumeReKernel::getInstance();
    return evaluateTargetOptionInCommand(m_parlist, sDefaultTableName, _targetIndices, instance->getParser(), instance->getMemoryManager(), instance->getSettings());
}
 
 
std::vector<std::string> CommandLineParser::getAllParametersWithValues() const
{
    size_t pos = 0;
    std::vector<std::string> vParams;
 
    while ((pos = m_parlist.find('=', pos)) != std::string::npos)
    {
        if (!isInQuotes(m_parlist, pos))
        {
            size_t lastChar = m_parlist.find_last_not_of(" =", pos);
 
            if (lastChar)
            {
                size_t firstChar = m_parlist.find_last_of(" -", lastChar) + 1;
                vParams.push_back(m_parlist.substr(firstChar, lastChar + 1 - firstChar));
            }
        }
 
        pos++;
    }
 
    return vParams;
}
 
 
std::string CommandLineParser::getParameterValue(const std::string& sParameter) const
{
    int nParPos = findParameter(m_parlist, sParameter, '=');
 
    if (!nParPos)
        return "";
 
    return getArgAtPos(m_parlist, nParPos+sParameter.length(), ARGEXTRACT_NONE);
}
 
 
std::string CommandLineParser::getFileParameterValue(std::string sFileExt, const std::string& sBaseFolder, const std::string& sDefaultName) const
{
    FileSystem _fSys;
    _fSys.initializeFromKernel();
 
    std::string sParams = m_parlist;
 
    // Call functions first
    if (!NumeReKernel::getInstance()->getDefinitions().call(sParams))
        throw SyntaxError(SyntaxError::FUNCTION_ERROR, sParams, SyntaxError::invalid_position);
 
    if (NumeReKernel::getInstance()->getStringParser().containsStringVars(sParams))
        NumeReKernel::getInstance()->getStringParser().getStringValues(sParams);
 
    if (NumeReKernel::getInstance()->getMemoryManager().containsTablesOrClusters(sParams))
        getDataElements(sParams, NumeReKernel::getInstance()->getParser(), NumeReKernel::getInstance()->getMemoryManager(), NumeReKernel::getInstance()->getSettings());
 
    int nParPos = findParameter(sParams, "file", '=');
 
    if (!nParPos && sDefaultName.length())
        return _fSys.ValidFileName(removeQuotationMarks(sDefaultName), sFileExt);
    else if (!nParPos)
        return "";
 
    std::string sFileName = getArgAtPos(sParams, nParPos+4, ARGEXTRACT_NONE);
    NumeReKernel* instance = NumeReKernel::getInstance();
 
    // String evaluation
    if (instance->getStringParser().isStringExpression(sFileName))
    {
        std::string dummy;
        instance->getStringParser().evalAndFormat(sFileName, dummy, true);
    }
 
    sFileName = removeQuotationMarks(sFileName);
 
    // If a filename had been found, parse it here
    if (sFileName.length())
        return parseFileName(sFileName, sFileExt, sBaseFolder);
    else if (sDefaultName.length())
        return _fSys.ValidFileName(removeQuotationMarks(sDefaultName), sFileExt);
 
    return "";
}
 
 
std::string CommandLineParser::getFileParameterValueForSaving(std::string sFileExt, const std::string& sBaseFolder, const std::string& sDefaultName) const
{
    FileSystem _fSys;
    _fSys.initializeFromKernel();
 
    return _fSys.ValidizeAndPrepareName(getFileParameterValue(sFileExt, sBaseFolder, sDefaultName), sFileExt);
}
 
 
std::string CommandLineParser::getParameterValueAsString(const std::string& sParameter, const std::string& sDefaultValue, bool stripAlways, bool onlyStringEvaluation) const
{
    int nParPos = findParameter(m_parlist, sParameter, '=');
 
    if (!nParPos)
        return sDefaultValue;
 
    std::string arg = getArgAtPos(m_parlist,
                                  nParPos+sParameter.length(),
                                  ARGEXTRACT_PARSED | (onlyStringEvaluation ? ARGEXTRACT_ASSTRING : ARGEXTRACT_NONE));
    StripSpaces(arg);
 
    if (!stripAlways && arg.find(",") != std::string::npos && arg.find("\"") != std::string::npos)
        return arg;
    else if (arg.front() == '"' && arg.back() == '"')
        return removeQuotationMarks(arg);
 
    return arg;
}
 
 
std::vector<mu::value_type> CommandLineParser::getParameterValueAsNumericalValue(const std::string& sParameter) const
{
    int nParPos = findParameter(m_parlist, sParameter, '=');
 
    if (!nParPos)
        return std::vector<mu::value_type>();
 
    std::string arg = getArgAtPos(m_parlist, nParPos+sParameter.length(), ARGEXTRACT_PARSED | ARGEXTRACT_STRIPPED);
    std::vector<mu::value_type> vArgs;
 
    while (arg.length())
    {
        vArgs.push_back(StrToDb(getNextArgument(arg, true)));
    }
 
    return vArgs;
}
 
 
bool CommandLineParser::hasParam(const std::string& sParameter) const
{
    return findParameter(m_parlist, sParameter) != 0;
}