shellinstance.h

/*
    
  This file is a part of Shellp, a 'shell helper' library.
  
  Copyright (C) 2011-2012 Jori Liesenborgs
  
  Contact: jori.liesenborgs@gmail.com

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library 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
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  
  USA

*/

#ifndef SHELLP_SHELLINSTANCE_H

#define SHELLP_SHELLINSTANCE_H

#include "shellconfig.h"
#include <jthread/jmutex.h>
#include <errut/errorbase.h>
#include <string>
#include <vector>
#include <list>
#include <map>

namespace mu
{
        class Parser;
}

namespace shellp
{

class IOSystem;
class ShellCommand;

typedef double (*FunctionWith1Arg)(double x0);
typedef double (*FunctionWith2Arg)(double x0, double x1);
typedef double (*FunctionWith3Arg)(double x0, double x1, double x2);
typedef double (*FunctionWith4Arg)(double x0, double x1, double x2, double x3);
typedef double (*FunctionWith5Arg)(double x0, double x1, double x2, double x3, double x4);

class SHELLP_IMPORTEXPORT ShellInstance : public errut::ErrorBase
{
public:
        ShellInstance();
        ~ShellInstance();

        static ShellInstance *getInstance();

        static int run(const std::string &title, const std::string &shellPrefix, int argc, char **argv);

        void setIOSystem(IOSystem *pSys)                                        { m_pIOSys = pSys; }
        void setInteractive(bool interactive)                                   { m_interactive = interactive; }
        void setRequestExit()                                                   { m_requestExit = true; }
        void setErrorExit()                                                     { m_errExit = true; m_requestExit = true; }

        IOSystem *getIOSystem()                                                 { return m_pIOSys; }
        bool isInteractive() const                                              { return m_interactive; }
        bool isExitRequested() const                                            { return m_requestExit; }
        bool isErrorExit() const                                                { return m_errExit; }

        bool evaluateExpression(const std::string &expression, double &value);
        bool storeVariable(const std::string &name, double value);
        bool processCommandLine(const std::vector<std::string> &args);
        void getParserNamesAndValues(std::vector<std::string> &constNames, std::vector<double> &constValues,
                                     std::vector<std::string> &varNames, std::vector<double> &varValues);
        void clearVariables();

        bool defineConstant(const std::string &name, double value);
        void clearConstants();

        bool defineFunction(const std::string &name, FunctionWith1Arg callBack);
        bool defineFunction(const std::string &name, FunctionWith2Arg callBack);
        bool defineFunction(const std::string &name, FunctionWith3Arg callBack);
        bool defineFunction(const std::string &name, FunctionWith4Arg callBack);
        bool defineFunction(const std::string &name, FunctionWith5Arg callBack);
        
        std::vector<std::string> getCommandNames() const;
        ShellCommand *getCommand(const std::string &commandName);

        void appendCommandLine(const std::string &line);
        std::vector<std::string> getCommandLines() const;

        virtual bool isSaved() const                                            { return true; }

        bool setInterrupted(bool f = true);
        bool isInterrupted();

        bool registerUnitName(int unitID, const std::string &name);
        bool setUnitMultiplier(int initID, double value);
        bool getUnitName(int unitID, std::string &name) const;
        double getUnitMultiplier(int unitID) const;

        bool getPreprocessorVariableContent(const std::string &name, std::string &contents) const;
        bool registerPreprocessorVariable(const std::string &name, const std::string &contents);
        void getPreprocessorVariables(std::vector<std::string> &names) const;
        void clearPreprocessorVariables();
protected:
        void unrecoverableError(const std::string &str);
private:
        void registerCommand(ShellCommand *pCmd, const std::string &cmdName);
        void unregisterCommand(ShellCommand *pCmd);
//      static mu::value_type* addParserVariable(const mu::char_type *a_szName, void *a_pUserData);

        class CommandName
        {
        public:
                CommandName(ShellCommand *pCmd, const std::string &n)                   { m_pCmd = pCmd; m_name = n; }
                std::string getName() const                                             { return m_name; }
                ShellCommand *getCommand()                                              { return m_pCmd; }
        private:
                ShellCommand *m_pCmd;
                std::string m_name;
        };

        std::vector<CommandName> m_commandList;
        IOSystem *m_pIOSys;
        bool m_interactive, m_requestExit, m_errExit;

        mu::Parser *m_pMuParser;
        std::map<std::string, void *> m_variables;

        std::vector<std::string> m_commandLines;
        
        jthread::JMutex m_mutex;
        bool m_interrupted;

        static ShellInstance *m_pInstance;

        std::map<int, std::pair<std::string, double> > m_units;
        std::map<std::string, std::string> m_preprocessorVariables;
        
        friend class ShellCommand;      
};

} // end namespace

#endif // SHELLP_SHELLINSTANCE_H