From 3099d2011c505c0c73c4304344e9ee936caab7a3 Mon Sep 17 00:00:00 2001 From: astrojhgu Date: Fri, 21 Aug 2009 04:14:23 +0000 Subject: git-svn-id: file:///home/svn/opt_utilities@45 ed2142bd-67ad-457f-ba7c-d818d4011675 --- muparser/muParserDLL.cpp | 657 ----------------------------------------------- 1 file changed, 657 deletions(-) delete mode 100644 muparser/muParserDLL.cpp (limited to 'muparser/muParserDLL.cpp') diff --git a/muparser/muParserDLL.cpp b/muparser/muParserDLL.cpp deleted file mode 100644 index 0f85cb7..0000000 --- a/muparser/muParserDLL.cpp +++ /dev/null @@ -1,657 +0,0 @@ -/* - __________ - _____ __ __\______ \_____ _______ ______ ____ _______ - / \ | | \| ___/\__ \ \_ __ \/ ___/_/ __ \\_ __ \ - | Y Y \| | /| | / __ \_| | \/\___ \ \ ___/ | | \/ - |__|_| /|____/ |____| (____ /|__| /____ > \___ >|__| - \/ \/ \/ \/ - Copyright (C) 2004-2006 Ingo Berg - - Permission is hereby granted, free of charge, to any person obtaining a copy of this - software and associated documentation files (the "Software"), to deal in the Software - without restriction, including without limitation the rights to use, copy, modify, - merge, publish, distribute, sublicense, and/or sell copies of the Software, and to - permit persons to whom the Software is furnished to do so, subject to the following conditions: - - The above copyright notice and this permission notice shall be included in all copies or - substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT - NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND - NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, - DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -*/ - - -#if defined(MUPARSER_DLL) && defined(_WIN32) - -#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; - -#if !defined(_UNICODE) - typedef std::string string_type; -#else - typedef std::wstring string_type; -#endif - -typedef string_type::value_type char_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(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, void *pUserData) -{ - parser_type p(GetPtr(a_hParser)); - p->SetVarFactory(a_pFactory, pUserData); -} - -//--------------------------------------------------------------------------- -/** \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( string_type(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 mupDefineStrFun1(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 mupDefineStrFun2(parser_handle a_hParser, const char *a_szName, strfun_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 mupDefineStrFun3(parser_handle a_hParser, const char *a_szName, strfun_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 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, - bool a_bAllowOpt) -{ - MU_PARSER_TRY - parser_type p(GetPtr(a_hParser)); - p->DefinePostfixOprt(a_szName, a_pOprt, a_bAllowOpt); - MU_PARSER_CATCH -} - -//--------------------------------------------------------------------------- -MU_PARSER_API void mupDefineInfixOprt(parser_handle a_hParser, - const char *a_szName, - fun_type1 a_pOprt, - bool a_bAllowOpt) -{ - MU_PARSER_TRY - parser_type p(GetPtr(a_hParser)); - p->DefineInfixOprt(a_szName, a_pOprt, a_bAllowOpt); - MU_PARSER_CATCH -} - -// Define character sets for identifiers -//--------------------------------------------------------------------------- -MU_PARSER_API void mupDefineNameChars(parser_handle a_hParser, const char *a_szCharset) -{ - parser_type p(GetPtr(a_hParser)); - p->DefineNameChars(a_szCharset); -} - -//--------------------------------------------------------------------------- -MU_PARSER_API void mupDefineOprtChars(parser_handle a_hParser, const char *a_szCharset) -{ - parser_type p(GetPtr(a_hParser)); - p->DefineOprtChars(a_szCharset); -} - -//--------------------------------------------------------------------------- -MU_PARSER_API void mupDefineInfixOprtChars(parser_handle a_hParser, const char *a_szCharset) -{ - parser_type p(GetPtr(a_hParser)); - p->DefineInfixOprtChars(a_szCharset); -} - -//--------------------------------------------------------------------------- -/** \brief Get the number of variables defined in the parser. - \param a_hParser [in] Must be a valid parser handle. - \return The number of used variables. - \sa mupGetExprVar -*/ -MU_PARSER_API int mupGetVarNum(parser_handle a_hParser) -{ - MU_PARSER_TRY - parser_type p(GetPtr(a_hParser)); - const mu::varmap_type VarMap = p->GetVar(); - return (int)VarMap.size(); - MU_PARSER_CATCH - - return 0; // never reached -} - -//--------------------------------------------------------------------------- -/** \brief Return a variable that is used in an expression. - - Prior to calling this function call mupGetExprVarNum in order to get the - number of variables in the expression. If the parameter a_iVar is greater - than the number of variables both a_szName and a_pVar will be set to zero. - As a side effect this function will trigger an internal calculation of the - expression undefined variables will be set to zero during this calculation. - During the calculation user defined callback functions present in the expression - will be called, this is unavoidable. - - \param a_hParser [in] A valid parser handle. - \param a_iVar [in] The index of the variable to return. - \param a_szName [out] Pointer to the variable name. - \param a_pVar [out] Pointer to the variable. - \throw nothrow -*/ -MU_PARSER_API void mupGetVar(parser_handle a_hParser, unsigned a_iVar, const char **a_szName, double **a_pVar) -{ - // A static buffer is needed for the name since i cant return the - // pointer from the map. - static char szName[1024]; - - MU_PARSER_TRY - parser_type p(GetPtr(a_hParser)); - const mu::varmap_type VarMap = p->GetVar(); - - if (a_iVar>=VarMap.size()) - { - *a_szName = 0; - *a_pVar = 0; - return; - } - mu::varmap_type::const_iterator item; - - item = VarMap.begin(); - for (unsigned i=0; ifirst.c_str(), sizeof(szName)); - szName[sizeof(szName)-1] = 0; - - *a_szName = &szName[0]; - *a_pVar = item->second; - return; - - MU_PARSER_CATCH - - *a_szName = 0; - *a_pVar = 0; -} - -//--------------------------------------------------------------------------- -/** \brief Get the number of variables used in the expression currently set in the parser. - \param a_hParser [in] Must be a valid parser handle. - \return The number of used variables. - \sa mupGetExprVar -*/ -MU_PARSER_API int mupGetExprVarNum(parser_handle a_hParser) -{ - MU_PARSER_TRY - parser_type p(GetPtr(a_hParser)); - const mu::varmap_type VarMap = p->GetUsedVar(); - return (int)VarMap.size(); - MU_PARSER_CATCH - - return 0; // never reached -} - -//--------------------------------------------------------------------------- -/** \brief Return a variable that is used in an expression. - - Prior to calling this function call mupGetExprVarNum in order to get the - number of variables in the expression. If the parameter a_iVar is greater - than the number of variables both a_szName and a_pVar will be set to zero. - As a side effect this function will trigger an internal calculation of the - expression undefined variables will be set to zero during this calculation. - During the calculation user defined callback functions present in the expression - will be called, this is unavoidable. - - \param a_hParser [in] A valid parser handle. - \param a_iVar [in] The index of the variable to return. - \param a_szName [out] Pointer to the variable name. - \param a_pVar [out] Pointer to the variable. - \throw nothrow -*/ -MU_PARSER_API void mupGetExprVar(parser_handle a_hParser, unsigned a_iVar, const char **a_szName, double **a_pVar) -{ - // A static buffer is needed for the name since i cant return the - // pointer from the map. - static char szName[1024]; - - MU_PARSER_TRY - parser_type p(GetPtr(a_hParser)); - const mu::varmap_type VarMap = p->GetUsedVar(); - - if (a_iVar>=VarMap.size()) - { - *a_szName = 0; - *a_pVar = 0; - return; - } - mu::varmap_type::const_iterator item; - - item = VarMap.begin(); - for (unsigned i=0; ifirst.c_str(), sizeof(szName)); - szName[sizeof(szName)-1] = 0; - - *a_szName = &szName[0]; - *a_pVar = item->second; - return; - - MU_PARSER_CATCH - - *a_szName = 0; - *a_pVar = 0; -} - -//--------------------------------------------------------------------------- -/** \brief Return the number of constants defined in a parser. */ -MU_PARSER_API int mupGetConstNum(parser_handle a_hParser) -{ - MU_PARSER_TRY - parser_type p(GetPtr(a_hParser)); - const mu::valmap_type ValMap = p->GetConst(); - return (int)ValMap.size(); - MU_PARSER_CATCH - - return 0; // never reached -} - -//--------------------------------------------------------------------------- -/** \brief Retrieve name and value of a single parser constant. - \param a_hParser [in] a valid parser handle - \param a_iVar [in] Index of the constant to query - \param a_pszName [out] pointer to a null terminated string with the constant name - \param [out] The constant value -*/ -MU_PARSER_API void mupGetConst(parser_handle a_hParser, unsigned a_iVar, - const char **a_pszName, double &a_fVal) -{ - // A static buffer is needed for the name since i cant return the - // pointer from the map. - static char szName[1024]; - - MU_PARSER_TRY - parser_type p(GetPtr(a_hParser)); - const mu::valmap_type ValMap = p->GetConst(); - - if (a_iVar>=ValMap.size()) - { - *a_pszName = 0; - a_fVal = 0; - return; - } - - mu::valmap_type::const_iterator item; - item = ValMap.begin(); - for (unsigned i=0; ifirst.c_str(), sizeof(szName)); - szName[sizeof(szName)-1] = 0; - - *a_pszName = &szName[0]; - a_fVal = item->second; - return; - - MU_PARSER_CATCH - - *a_pszName = 0; - a_fVal = 0; -} - -//--------------------------------------------------------------------------- -/** \brief Add a custom value regognition function. -*/ -MU_PARSER_API void mupAddValIdent(parser_handle a_hParser, identfun_type a_pFun) -{ - MU_PARSER_TRY - parser_type p(GetPtr(a_hParser)); - p->AddValIdent(a_pFun); - MU_PARSER_CATCH -} - -//--------------------------------------------------------------------------- -/** \brief Query if an error occured. - - After querying the internal error bit will be reset. So a consecutive call - will return false. -*/ -MU_PARSER_API bool mupError() -{ - bool bError(g_bError); - g_bError = false; - return bError; -} - -//--------------------------------------------------------------------------- -/** \brief Reset the internal error flag. -*/ -MU_PARSER_API void mupErrorReset() -{ - g_bError = false; -} - -//--------------------------------------------------------------------------- -/** \brief Return the message associated with the last error. -*/ -MU_PARSER_API const char* mupGetErrorMsg() -{ - return g_ParserError.GetMsg().c_str(); -} - -//--------------------------------------------------------------------------- -/** \brief Return the message associated with the last error. -*/ -MU_PARSER_API const char* mupGetErrorToken() -{ - return g_ParserError.GetToken().c_str(); -} - -//--------------------------------------------------------------------------- -/** \brief Return the code associated with the last error. -*/ -MU_PARSER_API int mupGetErrorCode() -{ - return g_ParserError.GetCode(); -} - -//--------------------------------------------------------------------------- -/** \brief Return the postion associated with the last error. */ -MU_PARSER_API int mupGetErrorPos() -{ - return (int)g_ParserError.GetPos(); -} - - -#endif // MUPARSER_DLL -- cgit v1.2.2