muparserdll.cpp

Mathematical expressions parser library

#include "muParserDLL.h"
#include "muParser.h"
#include "muParserError.h"


#define MU_PARSER_TRY  \
        try            \
        {

#define MU_PARSER_CATCH          \
        }                        \
        catch(exception_type &e) \
        {                        \
          g_bError = true;       \
          g_ParserError = e;     \
          if (g_pErrHandler)     \
            g_pErrHandler();     \
        }                        \
        catch(...)               \
        {                        \
          g_bError = true;       \
          g_ParserError = exception_type(mu::ecINTERNAL_ERROR); \
          if (g_pErrHandler)     \
            g_pErrHandler();     \
        } 

//---------------------------------------------------------------------------
typedef mu::ParserBase::exception_type exception_type; 
typedef mu::ParserBase* parser_type;
        
//---------------------------------------------------------------------------
//
//
//  unexported variables
//
//
//---------------------------------------------------------------------------

/** \brief The last exception that was caught.
*/
exception_type g_ParserError;
errhandler_type g_pErrHandler;

//---------------------------------------------------------------------------
/** \brief Flags indicating an error occured.
*/
bool g_bError;

//---------------------------------------------------------------------------
//
//
//  unexported functions
//
//
//---------------------------------------------------------------------------

parser_type GetPtr(parser_handle a_hParser)
{
  return static_cast<parser_type>(a_hParser);
}

//---------------------------------------------------------------------------
/** \brief DLL entry point.
*/
BOOL APIENTRY DllMain( HANDLE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved )
{
	switch (ul_reason_for_call)
	{
	case DLL_PROCESS_ATTACH:
	case DLL_THREAD_ATTACH:
        g_pErrHandler = 0;
        g_bError = false;
        break;

  case DLL_THREAD_DETACH:
	case DLL_PROCESS_DETACH:
    		break;
	}

  return TRUE;
}

//---------------------------------------------------------------------------
//
//
//  exported functions
//
//
//---------------------------------------------------------------------------

MU_PARSER_API void mupSetErrorHandler(errhandler_type a_pHandler)
{
  g_pErrHandler = a_pHandler;
}

//---------------------------------------------------------------------------
MU_PARSER_API void mupSetVarFactory(parser_handle a_hParser, facfun_type a_pFactory)
{
  parser_type p(GetPtr(a_hParser));    
  p->SetVarFactory(a_pFactory);
}

//---------------------------------------------------------------------------
/** \brief Create a new Parser instance and return its handle.
*/
MU_PARSER_API parser_handle mupInit()
{
  return (void*)(new mu::Parser());
}

//---------------------------------------------------------------------------
/** \brief Release the parser instance related with a parser handle.
*/
MU_PARSER_API void mupRelease(parser_handle a_hParser)
{
  MU_PARSER_TRY
    parser_type p(GetPtr(a_hParser));    
    delete p;
  MU_PARSER_CATCH
}

//---------------------------------------------------------------------------
/** \brief Evaluate the expression.
*/
MU_PARSER_API double mupEval(parser_handle a_hParser)
{
  MU_PARSER_TRY
    parser_type p(GetPtr(a_hParser));    
    return p->Eval();  
  MU_PARSER_CATCH

  return 0;
}

//---------------------------------------------------------------------------
MU_PARSER_API void mupSetExpr(parser_handle a_hParser, const char *a_szExpr)
{
  MU_PARSER_TRY
    parser_type p(GetPtr(a_hParser));
    p->SetExpr(a_szExpr);
  MU_PARSER_CATCH
}

//---------------------------------------------------------------------------
MU_PARSER_API void mupRemoveVar(parser_handle a_hParser, const char *a_szName)
{
  MU_PARSER_TRY
    parser_type p(GetPtr(a_hParser));
    p->RemoveVar( std::string(a_szName) );
  MU_PARSER_CATCH
}

//---------------------------------------------------------------------------
/** \brief Release all parser variables.
    \param a_hParser Handle to the parser instance.
*/
MU_PARSER_API void mupClearVar(parser_handle a_hParser)
{
  MU_PARSER_TRY
    parser_type p(GetPtr(a_hParser));
    p->ClearVar();
  MU_PARSER_CATCH
}

//---------------------------------------------------------------------------
/** \brief Release all parser variables.
    \param a_hParser Handle to the parser instance.
*/
MU_PARSER_API void mupClearConst(parser_handle a_hParser)
{
  MU_PARSER_TRY
    parser_type p(GetPtr(a_hParser));
    p->ClearConst();
  MU_PARSER_CATCH
}

//---------------------------------------------------------------------------
/** \brief Clear all user defined operators. 
    \param a_hParser Handle to the parser instance.
*/
MU_PARSER_API void mupClearOprt(parser_handle a_hParser)
{
  MU_PARSER_TRY
    parser_type p(GetPtr(a_hParser));
    p->ClearOprt();
  MU_PARSER_CATCH
}

//---------------------------------------------------------------------------
MU_PARSER_API void mupDefineFun1(parser_handle a_hParser, const char *a_szName, fun_type1 a_pFun, bool a_bAllowOpt)
{
  MU_PARSER_TRY
    parser_type p(GetPtr(a_hParser));
    p->DefineFun(a_szName, a_pFun, a_bAllowOpt);
  MU_PARSER_CATCH
}

//---------------------------------------------------------------------------
MU_PARSER_API void mupDefineFun2(parser_handle a_hParser, const char *a_szName, fun_type2 a_pFun, bool a_bAllowOpt)
{
  MU_PARSER_TRY
    parser_type p(GetPtr(a_hParser));
    p->DefineFun(a_szName, a_pFun, a_bAllowOpt);
  MU_PARSER_CATCH
}

//---------------------------------------------------------------------------
MU_PARSER_API void mupDefineFun3(parser_handle a_hParser, const char *a_szName, fun_type3 a_pFun, bool a_bAllowOpt)
{
  MU_PARSER_TRY
    parser_type p(GetPtr(a_hParser));
    p->DefineFun(a_szName, a_pFun, a_bAllowOpt);
  MU_PARSER_CATCH
}

//---------------------------------------------------------------------------
MU_PARSER_API void mupDefineFun4(parser_handle a_hParser, const char *a_szName, fun_type4 a_pFun, bool a_bAllowOpt)
{
  MU_PARSER_TRY
    parser_type p(GetPtr(a_hParser));
    p->DefineFun(a_szName, a_pFun, a_bAllowOpt);
  MU_PARSER_CATCH
}

//---------------------------------------------------------------------------
MU_PARSER_API void mupDefineFun5(parser_handle a_hParser, const char *a_szName, fun_type5 a_pFun, bool a_bAllowOpt)
{
  MU_PARSER_TRY
    parser_type p(GetPtr(a_hParser));
    p->DefineFun(a_szName, a_pFun, a_bAllowOpt);
  MU_PARSER_CATCH
}

//---------------------------------------------------------------------------
MU_PARSER_API void mupDefineStrFun(parser_handle a_hParser, const char *a_szName, strfun_type1 a_pFun, bool a_bAllowOpt)
{
  MU_PARSER_TRY
    parser_type p(GetPtr(a_hParser));
    p->DefineFun(a_szName, a_pFun, a_bAllowOpt);
  MU_PARSER_CATCH
}

//---------------------------------------------------------------------------
MU_PARSER_API void mupDefineMultFun(parser_handle a_hParser, const char *a_szName, multfun_type a_pFun, bool a_bAllowOpt)
{
  MU_PARSER_TRY
    parser_type p(GetPtr(a_hParser));
    p->DefineFun(a_szName, a_pFun, a_bAllowOpt);
  MU_PARSER_CATCH
}

//---------------------------------------------------------------------------
MU_PARSER_API void mupDefineOprt(parser_handle a_hParser, const char *a_szName, fun_type2 a_pFun, int a_iPri, bool a_bAllowOpt)
{
  MU_PARSER_TRY
    parser_type p(GetPtr(a_hParser));
    p->DefineOprt(a_szName, a_pFun, a_iPri, a_bAllowOpt);
  MU_PARSER_CATCH
}

//---------------------------------------------------------------------------
MU_PARSER_API void mupDefineVar(parser_handle a_hParser, const char *a_szName, double *a_pVar)
{
  MU_PARSER_TRY
    parser_type p(GetPtr(a_hParser));
    p->DefineVar(a_szName, a_pVar);
  MU_PARSER_CATCH
}

//---------------------------------------------------------------------------
MU_PARSER_API void mupDefineConst(parser_handle a_hParser, const char *a_szName, double a_fVal)
{
  MU_PARSER_TRY
    parser_type p(GetPtr(a_hParser));
    p->DefineConst(a_szName, a_fVal);
  MU_PARSER_CATCH
}

//---------------------------------------------------------------------------
MU_PARSER_API void mupDefineStrConst(parser_handle a_hParser, const char *a_szName, const char *a_szVal)
{
  MU_PARSER_TRY
    parser_type p(GetPtr(a_hParser));
    p->DefineStrConst(a_szName, a_szVal);
  MU_PARSER_CATCH
}

//---------------------------------------------------------------------------
MU_PARSER_API const char* mupGetExpr(parser_handle a_hParser)
{
  MU_PARSER_TRY
    parser_type p(GetPtr(a_hParser));
    return p->GetExpr().c_str();
  MU_PARSER_CATCH

  return "";
}

//---------------------------------------------------------------------------
MU_PARSER_API void mupDefinePostfixOprt(parser_handle a_hParser, 
                                        const char *a_szName, 
                                        fun_type1 a_pOprt,