plugin.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 "plugin.hpp"
#include "../../kernel.hpp"
#include "../utils/tools.hpp"
 
// CLASS PLUGIN
 
 
Package::Package() : sCommand(""), sMainProcedure(""), sArgumentList(""), sType("TYPE_UNSPECIFIED"), sLicense(""), sName("Plugin"), sVersion("<AUTO>"), sAuthor("User"), sDescription("Description"), sMenuEntry(""), sDocumentationIndexID(""), sKeyWords("NONE"), sChangesLog("NONE")
{ }
 
 
Package::Package(const std::string& sInstallInfoString) : Package()
{
    // Get the options values from the string
    sCommand = getOptionValue(sInstallInfoString, "plugincommand", "");
    sMainProcedure = getOptionValue(sInstallInfoString, "pluginmain", "");
    sArgumentList = getOptionValue(sInstallInfoString, "pluginmain", "");
    sMenuEntry = getOptionValue(sInstallInfoString, "pluginmenuentry", "");
    sType = getOptionValue(sInstallInfoString, "type", "TYPE_UNSPECIFIED");
    sLicense = getOptionValue(sInstallInfoString, "license", "???");
    sName = getOptionValue(sInstallInfoString, "name", "Plugin");
    sVersion = getOptionValue(sInstallInfoString, "version", "0.0.1");
    sAuthor = getOptionValue(sInstallInfoString, "author", "User");
    sKeyWords = getOptionValue(sInstallInfoString, "keywords", "NONE");
    sChangesLog = getOptionValue(sInstallInfoString, "changelog", "NONE");
    sDescription = getOptionValue(sInstallInfoString, "desc", "Description");
 
    if (!sDescription.length())
        sDescription = getOptionValue(sInstallInfoString, "plugindesc", "Description");
 
    // If the main procedure was defined, separate it
    // here into name and argument list
    if (sMainProcedure.length())
    {
        sMainProcedure.erase(sMainProcedure.find('('));
 
        if (sMainProcedure.front() == '$')
            sMainProcedure.erase(0, 1);
 
        sArgumentList = sArgumentList.substr(sArgumentList.find('('));
    }
}
 
 
std::string Package::getOptionValue(const std::string& sInstallInfoString, const std::string& sOption, const std::string& sDefault)
{
    // Option is available? If no,
    // return the default value
    if (findParameter(sInstallInfoString, sOption, '='))
    {
        // Get the value
        std::string sOptionValue = getArgAtPos(sInstallInfoString, findParameter(sInstallInfoString, sOption, '=')+sOption.length());
        StripSpaces(sOptionValue);
 
        // Does it have a length? If no,
        // return the default value
        if (sOptionValue.length())
        {
            // If the default value has a non-zero length,
            // surround the extracted value using parentheses,
            // if it contains whitespaces or commas.
            if (sDefault.length() && (sOptionValue.find(' ') != std::string::npos || sOptionValue.find(',') != std::string::npos))
                sOptionValue = "(" + sOptionValue + ")";
 
            return sOptionValue;
        }
    }
 
    return sDefault;
}
 
 
std::string Package::exportDefinition() const
{
    return sCommand + "," + sMainProcedure + "," + sArgumentList + "," + sType + "," + sName + "," + sVersion + "," + sAuthor + "," + sDescription + "," + sDocumentationIndexID + "," + sLicense + "," + sMenuEntry + "," + sKeyWords + "," + sChangesLog + ",";
}
 
 
void Package::importDefinition(std::string sDefinitionString)
{
    sCommand = getNextArgument(sDefinitionString, true);
    sMainProcedure = getNextArgument(sDefinitionString, true);
    sArgumentList = getNextArgument(sDefinitionString, true);
    sType = getNextArgument(sDefinitionString, true);
    sName = getNextArgument(sDefinitionString, true);
 
    if (!sDefinitionString.length())
        return;
 
    sVersion = getNextArgument(sDefinitionString, true);
 
    if (!sDefinitionString.length())
        return;
 
    sAuthor = getNextArgument(sDefinitionString, true);
 
    if (!sDefinitionString.length())
        return;
 
    sDescription = getNextArgument(sDefinitionString, true);
 
    if (!sDefinitionString.length())
        return;
 
    sDocumentationIndexID = getNextArgument(sDefinitionString, true);
 
    if (!sDefinitionString.length())
        return;
 
    sLicense = getNextArgument(sDefinitionString, true);
 
    if (!sDefinitionString.length())
        return;
 
    sMenuEntry = getNextArgument(sDefinitionString, true);
 
    if (!sDefinitionString.length())
        return;
 
    sKeyWords = getNextArgument(sDefinitionString, true);
 
    if (!sDefinitionString.length())
        return;
 
    sChangesLog = getNextArgument(sDefinitionString, true);
}
 
 
bool Package::isPlugin() const
{
    return sType.substr(0, 11) == "TYPE_PLUGIN";
}
 
 
bool Package::operator==(const Package& _package) const
{
    return _package.sCommand == sCommand && _package.sName == sName && _package.sAuthor == sAuthor;
}
 
 
bool Package::operator!=(const Package& _package) const
{
    return !operator==(_package);
}
 
 
void Package::update(const Package& _package)
{
    sMainProcedure = _package.sMainProcedure;
    sArgumentList = _package.sArgumentList;
    sType = _package.sType;
    sName = _package.sName;
    sAuthor = _package.sAuthor;
    sDescription = _package.sDescription;
    sLicense = _package.sLicense;
 
    // Do we need to increment the current
    // package version?
    if (_package.sVersion == "<AUTO>")
        incrementVersion();
    else
        sVersion = _package.sVersion;
}
 
 
void Package::incrementVersion()
{
    sVersion = ::incrementVersion(sVersion);
}
 
 
std::string Package::getName() const
{
    return stripParentheses(sName);
}
 
 
std::string Package::getAuthor() const
{
    return stripParentheses(sAuthor);
}
 
 
std::string Package::getDescription() const
{
    return stripParentheses(sDescription);
}
 
 
std::string Package::getKeyWords() const
{
    return stripParentheses(sKeyWords);
}
 
 
std::string Package::getLicense() const
{
    return stripParentheses(sLicense);
}
 
 
std::string Package::getMenuEntry() const
{
    return stripParentheses(sMenuEntry);
}
 
 
std::string Package::getCommandSignature() const
{
    if (!sCommand.length())
        return "";
 
    std::string sSignature = sCommand + " ";
 
    if (sArgumentList.find("<EXPRESSION>") != std::string::npos && sArgumentList.find("<PARAMSTRING>") != std::string::npos)
        sSignature += "EX -set PAR ";
    else if (sArgumentList.find("<EXPRESSION>") != std::string::npos)
        sSignature += "EX ";
    else if (sArgumentList.find("<PARAMSTRING>") != std::string::npos)
        sSignature += "-PAR ";
    else if (sArgumentList.find("<CMDSTRING>") != std::string::npos)
        sSignature += "(...) ";
 
    if (sType.find("TYPE_PLUGIN_WITH_RETURN_VALUE") != std::string::npos)
        sSignature += "-> ARG";
 
    return sSignature;
}
 
 
std::string Package::getChangesLog() const
{
    return stripParentheses(sChangesLog);
}
 
 
 
 
 
// CLASS PLUGINMANAGER
 
 
 
PackageManager::PackageManager() : FileSystem()
{
    sPluginDefinitionFile = "<>/numere.plugins";
    sPluginProcName = "";
    sPluginVarList = "";
}
 
 
PackageManager::PackageManager(const PackageManager& _manager) : PackageManager()
{
    assign(_manager);
}
 
 
void PackageManager::assign(const PackageManager& _manager)
{
    vPackageInfo = _manager.vPackageInfo;
}
 
 
PackageManager::~PackageManager()
{
    if (fPlugins.is_open())
        fPlugins.close();
}
 
 
PackageManager& PackageManager::operator=(const PackageManager& _manager)
{
    assign(_manager);
    return *this;
}
 
 
void PackageManager::updatePluginFile()
{
    sPluginDefinitionFile = FileSystem::ValidFileName(sPluginDefinitionFile, ".plugins");
 
    fPlugins.open(sPluginDefinitionFile.c_str(), std::ios_base::trunc | std::ios_base::out);
 
    // Ensure that the file is read and writeable
    if (fPlugins.fail())
        throw SyntaxError(SyntaxError::CANNOT_READ_FILE, "", SyntaxError::invalid_position, sPluginDefinitionFile);
 
    // Write the contents to file
    for (unsigned int i = 0; i < vPackageInfo.size(); i++)
    {
        fPlugins << vPackageInfo[i].exportDefinition() << std::endl;
    }
 
    fPlugins.close();
    return;
}
 
 
bool PackageManager::loadPlugins()
{
    std::string sLine = "";
 
    sPluginDefinitionFile = FileSystem::ValidFileName(sPluginDefinitionFile, ".plugins");
 
    fPlugins.open(sPluginDefinitionFile.c_str());
 
    // Ensure that the file is readable
    if (fPlugins.fail())
        throw SyntaxError(SyntaxError::CANNOT_READ_FILE, "", SyntaxError::invalid_position, sPluginDefinitionFile);
 
    // Read the file's contents to memory
    while (!fPlugins.eof())
    {
        std::getline(fPlugins, sLine);
        StripSpaces(sLine);
 
        if (sLine.length())
        {
            // Create a new Plugin instance and import
            // the definition
            vPackageInfo.push_back(Package());
            vPackageInfo.back().importDefinition(sLine);
        }
    }
 
    fPlugins.close();
 
    return true;
}
 
 
bool PackageManager::evalPluginCmd(std::string& sCmd)
{
    std::string sExpr = "";
    std::string sParams = "";
    std::string sCommand = "";
    std::string sCommandLine = "";
    Package _plugin;
 
    if (!vPackageInfo.size())
        return false;
 
    // Find the plugin definition
    for (unsigned int i = 0; i < vPackageInfo.size(); i++)
    {
        if (findCommand(sCmd, vPackageInfo[i].sCommand).sString == vPackageInfo[i].sCommand)
        {
            _plugin = vPackageInfo[i];
            break;
        }
    }
 
    if (!_plugin.sCommand.length())
        return false;
 
    // Find the plugin call
    Match _match = findCommand(sCmd, _plugin.sCommand);
    sCommandLine = extractCommandString(sCmd, _match);
 
    // Fill the internal variables with the values from the
    // definition
    sPluginProcName = _plugin.sMainProcedure;
    sPluginVarList = _plugin.sArgumentList;
 
    if (sPluginVarList[0] == '(' && sPluginVarList[sPluginVarList.length()-1] == ')')
        sPluginVarList = sPluginVarList.substr(1, sPluginVarList.length()-2);
 
    // Fill the different command line tags
    // If the argument list expects an expression, expression
    // and parameters are determined different than without
    // an expression
    if (sPluginVarList.find("<EXPRESSION>") != std::string::npos)
    {
        if (sCommandLine.find("-set") != std::string::npos || sCommandLine.find("--") != std::string::npos)
        {
            if (sCommandLine.find("-set") != std::string::npos)
                sParams = sCommandLine.substr(sCommandLine.find("-set"));
            else
                sParams = sCommandLine.substr(sCommandLine.find("--"));
        }
 
        if (sParams.length())
        {
            sExpr = sCommandLine.substr(sCommandLine.find(_plugin.sCommand)+_plugin.sCommand.length());
            sExpr.erase(sExpr.find(sParams));
            StripSpaces(sParams);
        }
        else
            sExpr = sCommandLine.substr(sCommandLine.find(_plugin.sCommand)+_plugin.sCommand.length());
 
        StripSpaces(sExpr);
        sParams = "\"" + sParams + "\"";
    }
    else if (sPluginVarList.find("<PARAMSTRING>") != std::string::npos)
    {
        if (sCommandLine.find('-') != std::string::npos)
            sParams = sCommandLine.substr(sCommandLine.find('-', sCommandLine.find(_plugin.sCommand)));
 
        StripSpaces(sParams);
        sParams = "\"" + sParams + "\"";
    }
 
    sCommand = "\"" + sCommandLine + "\"";
 
    for (unsigned int i = 1; i < sCommandLine.length()-1; i++)
    {
        if (sCommandLine[i] == '"' && sCommandLine[i-1] != '\\')
            sCommandLine.insert(i,1,'\\');
    }
 
    if (sParams.length())
    {
        for (unsigned int i = 1; i < sParams.length()-1; i++)
        {
            if (sParams[i] == '"' && sParams[i-1] != '\\')
                sParams.insert(i,1,'\\');
        }
    }
 
    // Replace the procedure argument list with the
    // corresponding command line tags
    while (sPluginVarList.find("<CMDSTRING>") != std::string::npos)
        sPluginVarList.replace(sPluginVarList.find("<CMDSTRING>"), 11, sCommand);
 
    while (sPluginVarList.find("<EXPRESSION>") != std::string::npos)
        sPluginVarList.replace(sPluginVarList.find("<EXPRESSION>"), 12, sExpr);
 
    while (sPluginVarList.find("<PARAMSTRING>") != std::string::npos)
        sPluginVarList.replace(sPluginVarList.find("<PARAMSTRING>"), 13, sParams);
 
    // If the plugin should have a return value,
    // add a corresponding tag to the command line
    // at the location of the call to the plugin.
    if (_plugin.sType.find("TYPE_PLUGIN_WITH_RETURN_VALUE") != std::string::npos)
        sCmd.replace(_match.nPos, sCommandLine.length(), "<<RETURNVAL>>");
    else
        sCmd.clear();
 
    return true;
}
 
 
bool PackageManager::declareNewPackage(const std::string& sInstallInfoString)
{
    static std::string sProtectedCommands = ";quit;help;find;uninstall;install;include;credits;about;continue;break;var;cst;tab;global;throw;namespace;return;abort;explicit;str;if;else;elseif;endif;while;endwhile;for;endfor;switch;case;default;endswitch;";
    bool bAllowOverride = false;
 
    // Create the new plugin
    Package _package(sInstallInfoString);
 
    // Determine, whether a forced override is
    // allowed
    if (findParameter(sInstallInfoString, "flags", '='))
    {
        if (getArgAtPos(sInstallInfoString, findParameter(sInstallInfoString, "flags", '=')+5).find("ENABLE_FORCE_OVERRIDE") != std::string::npos)
            bAllowOverride = true;
    }
 
    // Ensure that the necessary information has been provided
    // if the new package is a plugin
    if (_package.isPlugin())
    {
        if (!_package.sCommand.length())
            throw SyntaxError(SyntaxError::PLUGIN_HAS_NO_CMD, "", SyntaxError::invalid_position);
 
        if (sProtectedCommands.find(";" + _package.sCommand + ";") != std::string::npos)
            throw SyntaxError(SyntaxError::PLUGIN_MAY_NOT_OVERRIDE, "", SyntaxError::invalid_position, _package.sCommand);
 
        if (!_package.sMainProcedure.length())
            throw SyntaxError(SyntaxError::PLUGIN_HAS_NO_MAIN, "", SyntaxError::invalid_position);
    }
 
    // Append the plugin or override an existing one
    if (vPackageInfo.size())
    {
        for (unsigned int i = 0; i < vPackageInfo.size(); i++)
        {
            // Identical plugin command found?
            if (_package.isPlugin() && vPackageInfo[i].sCommand == _package.sCommand)
            {
                // Plugin is identical or forced override is enabled
                if (vPackageInfo[i] == _package || bAllowOverride)
                {
                    // Plugin names have to be unique: ensure that there's no
                    // duplicate
                    for (unsigned int j = i+1; j < vPackageInfo.size(); j++)
                    {
                        if (vPackageInfo[j].sName == _package.sName && vPackageInfo[j] != _package)
                            throw SyntaxError(SyntaxError::PLUGINNAME_ALREADY_EXISTS, "", SyntaxError::invalid_position, _package.getName());
                    }
 
                    // Update the existing plugin
                    vPackageInfo[i].update(_package);
                }
                else
                    throw SyntaxError(SyntaxError::PLUGINCMD_ALREADY_EXISTS, "", SyntaxError::invalid_position, _package.sCommand);
 
                break;
            }
            else if (vPackageInfo[i].sName == _package.sName)
            {
                // Plugin names have to be unique
                if (vPackageInfo[i] != _package)
                    throw SyntaxError(SyntaxError::PLUGINNAME_ALREADY_EXISTS, "", SyntaxError::invalid_position, _package.getName());
 
                vPackageInfo[i] = _package;
                break;
            }
 
            // Nothing found? Simply append the new plugin
            if (i == vPackageInfo.size()-1)
            {
                vPackageInfo.push_back(_package);
 
                if (vPackageInfo.back().sVersion == "<AUTO>")
                    vPackageInfo.back().sVersion = "0.0.1";
 
                break;
            }
        }
    }
    else
    {
        // No plugin installed? Simply append the
        // new plugin
        vPackageInfo.push_back(_package);
 
        if (vPackageInfo.back().sVersion == "<AUTO>")
            vPackageInfo.back().sVersion = "0.0.1";
    }
 
    updatePluginFile();
 
    NumeReKernel::getInstance()->refreshFunctionTree();
    return true;
}
 
 
void PackageManager::addHelpIndex(const std::string& _sPluginName, std::string _sHelpId)
{
    StripSpaces(_sHelpId);
    std::string sPluginName = _sPluginName;
    StripSpaces(sPluginName);
 
    if (!vPackageInfo.size() || !_sHelpId.length())
        return;
 
    if (sPluginName.length())
    {
        // Search for the plugin with the selected name
        for (unsigned int i = 0; i < vPackageInfo.size(); i++)
        {
            // Identical name found? Append the documentation
            // index ID
            if (vPackageInfo[i].getName() == sPluginName)
            {
                if (vPackageInfo[i].sDocumentationIndexID.length())
                {
                    if (vPackageInfo[i].sDocumentationIndexID != _sHelpId
                        && vPackageInfo[i].sDocumentationIndexID.find(";"+_sHelpId) == std::string::npos
                        && vPackageInfo[i].sDocumentationIndexID.find(_sHelpId+";") == std::string::npos
                        && vPackageInfo[i].sDocumentationIndexID.find(";"+_sHelpId+";") == std::string::npos)
                    vPackageInfo[i].sDocumentationIndexID += ";" + _sHelpId;
                }
                else
                    vPackageInfo[i].sDocumentationIndexID = _sHelpId;
 
                updatePluginFile();
                break;
            }
        }
    }
    else
    {
        // No plugin name selected? Simply append it to the last
        // available plugin definition
        if (vPackageInfo.back().sDocumentationIndexID.length())
            vPackageInfo.back().sDocumentationIndexID += ";" + _sHelpId;
        else
            vPackageInfo.back().sDocumentationIndexID = _sHelpId;
 
        updatePluginFile();
    }
 
    return;
}
 
 
bool PackageManager::isPluginCmd(const std::string& sCmd) const
{
    if (findCommand(sCmd, "explicit").sString == "explicit")
        return false;
 
    if (vPackageInfo.size())
    {
        for (unsigned int i = 0; i < vPackageInfo.size(); i++)
        {
            if (vPackageInfo[i].isPlugin() && findCommand(sCmd, vPackageInfo[i].sCommand).sString == vPackageInfo[i].sCommand)
                return true;
        }
    }
 
    return false;
}
 
 
std::string PackageManager::deletePackage(const std::string& sPackage)
{
    std::string sHLPIDs = "<<NO_HLP_ENTRY>>";
 
    for (size_t i = 0; i < vPackageInfo.size(); i++)
    {
        // Plugin found?
        if (vPackageInfo[i].getName() == sPackage)
        {
            // Store the documentation index ID
            if (vPackageInfo[i].sDocumentationIndexID.length())
                sHLPIDs = vPackageInfo[i].sDocumentationIndexID;
 
            // Remove the plugin
            vPackageInfo.erase(i + vPackageInfo.begin());
 
            updatePluginFile();
 
            NumeReKernel::getInstance()->refreshFunctionTree();
            return sHLPIDs;
        }
    }
 
    return "";
}
 
 
std::map<std::string, std::string> PackageManager::getMenuMap() const
{
    std::map<std::string, std::string> mMenuMap;
 
    for (size_t i = 0; i < vPackageInfo.size(); i++)
    {
        if (vPackageInfo[i].sType == "TYPE_GUI_PLUGIN" && vPackageInfo[i].getMenuEntry().length())
            mMenuMap[vPackageInfo[i].getMenuEntry()] = vPackageInfo[i].sMainProcedure;
    }
 
    return mMenuMap;
}
 
 
std::string PackageManager::getPluginInfoPath()
{
    return FileSystem::ValidFileName(sPluginDefinitionFile, ".plugins");
}