3 _____ __ _____________ _______ ______ ___________
4 / \| | \____ \__ \\_ __ \/ ___// __ \_ __ \
5 | Y Y \ | / |_> > __ \| | \/\___ \\ ___/| | \/
6 |__|_| /____/| __(____ /__| /____ >\___ >__|
8 Copyright (C) 2004 - 2020 Ingo Berg
10 Redistribution and use in source and binary forms, with or without modification, are permitted
11 provided that the following conditions are met:
13 * Redistributions of source code must retain the above copyright notice, this list of
14 conditions and the following disclaimer.
15 * Redistributions in binary form must reproduce the above copyright notice, this list of
16 conditions and the following disclaimer in the documentation and/or other materials provided
17 with the distribution.
19 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
20 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
21 FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
22 CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
25 IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
26 OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 #if defined(MUPARSER_DLL)
32 #define WIN32_LEAN_AND_MEAN
33 #define _CRT_SECURE_NO_WARNINGS
34 #define _CRT_SECURE_NO_DEPRECATE
41 #include "muParserDLL.h"
43 #include "muParserInt.h"
44 #include "muParserError.h"
48 #pragma warning(disable : 26812)
57 catch (muError_t &e) \
59 ParserTag *pTag = static_cast<ParserTag*>(a_hParser); \
61 pTag->bError = true; \
62 if (pTag->errHandler) \
63 (pTag->errHandler)(a_hParser); \
67 ParserTag *pTag = static_cast<ParserTag*>(a_hParser); \
68 pTag->exc = muError_t(mu::ecINTERNAL_ERROR); \
69 pTag->bError = true; \
70 if (pTag->errHandler) \
71 (pTag->errHandler)(a_hParser); \
75 \brief This file contains the implementation of the DLL interface of muparser.
78 typedef mu::ParserBase::exception_type muError_t;
79 typedef mu::ParserBase muParser_t;
87 : pParser((nType == muBASETYPE_FLOAT)
88 ? (mu::ParserBase*)new mu::Parser()
89 : (nType == muBASETYPE_INT) ? (mu::ParserBase*)new mu::ParserInt() : nullptr)
93 , m_nParserType(nType)
101 mu::ParserBase* pParser;
102 mu::ParserBase::exception_type exc;
103 muErrorHandler_t errHandler;
107 ParserTag(const ParserTag& ref);
108 ParserTag& operator=(const ParserTag& ref);
113 static muChar_t s_tmpOutBuf[2048];
115 //---------------------------------------------------------------------------
118 // unexported functions
121 //---------------------------------------------------------------------------
124 inline muParser_t* AsParser(muParserHandle_t a_hParser)
126 return static_cast<ParserTag*>(a_hParser)->pParser;
130 inline ParserTag* AsParserTag(muParserHandle_t a_hParser)
132 return static_cast<ParserTag*>(a_hParser);
138 BOOL APIENTRY DllMain(HANDLE /*hModule*/, DWORD ul_reason_for_call, LPVOID /*lpReserved*/)
140 switch (ul_reason_for_call)
142 case DLL_PROCESS_ATTACH:
145 case DLL_THREAD_ATTACH:
146 case DLL_THREAD_DETACH:
147 case DLL_PROCESS_DETACH:
156 //---------------------------------------------------------------------------
159 // exported functions
162 //---------------------------------------------------------------------------
164 API_EXPORT(void) mupSetVarFactory(muParserHandle_t a_hParser, muFacFun_t a_pFactory, void* pUserData)
167 muParser_t* p(AsParser(a_hParser));
168 p->SetVarFactory(a_pFactory, pUserData);
173 /** \brief Create a new Parser instance and return its handle. */
174 API_EXPORT(muParserHandle_t) mupCreate(int nBaseType)
178 case muBASETYPE_FLOAT: return (void*)(new ParserTag(muBASETYPE_FLOAT));
179 case muBASETYPE_INT: return (void*)(new ParserTag(muBASETYPE_INT));
180 default: return nullptr;
185 /** \brief Release the parser instance related with a parser handle. */
186 API_EXPORT(void) mupRelease(muParserHandle_t a_hParser)
189 ParserTag* p = static_cast<ParserTag*>(a_hParser);
195 API_EXPORT(const muChar_t*) mupGetVersion(muParserHandle_t a_hParser)
198 muParser_t* const p(AsParser(a_hParser));
201 sprintf(s_tmpOutBuf, "%s", p->GetVersion().c_str());
203 wsprintf(s_tmpOutBuf, _T("%s"), p->GetVersion().c_str());
212 /** \brief Evaluate the expression. */
213 API_EXPORT(muFloat_t) mupEval(muParserHandle_t a_hParser)
216 muParser_t* const p(AsParser(a_hParser));
223 API_EXPORT(muFloat_t*) mupEvalMulti(muParserHandle_t a_hParser, int* nNum)
227 throw std::runtime_error("Argument is null!");
229 muParser_t* const p(AsParser(a_hParser));
230 return p->Eval(*nNum);
236 API_EXPORT(void) mupEvalBulk(muParserHandle_t a_hParser, muFloat_t* a_res, int nSize)
239 muParser_t* p(AsParser(a_hParser));
240 p->Eval(a_res, nSize);
245 API_EXPORT(void) mupSetExpr(muParserHandle_t a_hParser, const muChar_t* a_szExpr)
248 muParser_t* const p(AsParser(a_hParser));
249 p->SetExpr(a_szExpr);
254 API_EXPORT(void) mupRemoveVar(muParserHandle_t a_hParser, const muChar_t* a_szName)
257 muParser_t* const p(AsParser(a_hParser));
258 p->RemoveVar(a_szName);
263 /** \brief Release all parser variables.
264 \param a_hParser Handle to the parser instance.
266 API_EXPORT(void) mupClearVar(muParserHandle_t a_hParser)
269 muParser_t* const p(AsParser(a_hParser));
275 /** \brief Release all parser variables.
276 \param a_hParser Handle to the parser instance.
278 API_EXPORT(void) mupClearConst(muParserHandle_t a_hParser)
281 muParser_t* const p(AsParser(a_hParser));
287 /** \brief Clear all user defined operators.
288 \param a_hParser Handle to the parser instance.
290 API_EXPORT(void) mupClearOprt(muParserHandle_t a_hParser)
293 muParser_t* const p(AsParser(a_hParser));
299 API_EXPORT(void) mupClearFun(muParserHandle_t a_hParser)
302 muParser_t* const p(AsParser(a_hParser));
308 API_EXPORT(void) mupDefineFun0(muParserHandle_t a_hParser,
309 const muChar_t* a_szName,
311 muBool_t a_bAllowOpt)
314 muParser_t* const p(AsParser(a_hParser));
315 p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
320 API_EXPORT(void) mupDefineFun1(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun1_t a_pFun, muBool_t a_bAllowOpt)
323 muParser_t* const p(AsParser(a_hParser));
324 p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
329 API_EXPORT(void) mupDefineFun2(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun2_t a_pFun, muBool_t a_bAllowOpt)
332 muParser_t* const p(AsParser(a_hParser));
333 p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
338 API_EXPORT(void) mupDefineFun3(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun3_t a_pFun, muBool_t a_bAllowOpt)
341 muParser_t* const p(AsParser(a_hParser));
342 p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
347 API_EXPORT(void) mupDefineFun4(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun4_t a_pFun, muBool_t a_bAllowOpt)
350 muParser_t* const p(AsParser(a_hParser));
351 p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
356 API_EXPORT(void) mupDefineFun5(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun5_t a_pFun, muBool_t a_bAllowOpt)
359 muParser_t* const p(AsParser(a_hParser));
360 p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
365 API_EXPORT(void) mupDefineFun6(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun6_t a_pFun, muBool_t a_bAllowOpt)
368 muParser_t* const p(AsParser(a_hParser));
369 p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
374 API_EXPORT(void) mupDefineFun7(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun7_t a_pFun, muBool_t a_bAllowOpt)
377 muParser_t* const p(AsParser(a_hParser));
378 p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
383 API_EXPORT(void) mupDefineFun8(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun8_t a_pFun, muBool_t a_bAllowOpt)
386 muParser_t* const p(AsParser(a_hParser));
387 p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
392 API_EXPORT(void) mupDefineFun9(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun9_t a_pFun, muBool_t a_bAllowOpt)
395 muParser_t* const p(AsParser(a_hParser));
396 p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
401 API_EXPORT(void) mupDefineFun10(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun10_t a_pFun, muBool_t a_bAllowOpt)
404 muParser_t* const p(AsParser(a_hParser));
405 p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
410 API_EXPORT(void) mupDefineBulkFun0(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun0_t a_pFun)
413 muParser_t* const p(AsParser(a_hParser));
414 p->DefineFun(a_szName, a_pFun, false);
419 API_EXPORT(void) mupDefineBulkFun1(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun1_t a_pFun)
422 muParser_t* const p(AsParser(a_hParser));
423 p->DefineFun(a_szName, a_pFun, false);
428 API_EXPORT(void) mupDefineBulkFun2(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun2_t a_pFun)
431 muParser_t* const p(AsParser(a_hParser));
432 p->DefineFun(a_szName, a_pFun, false);
437 API_EXPORT(void) mupDefineBulkFun3(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun3_t a_pFun)
440 muParser_t* const p(AsParser(a_hParser));
441 p->DefineFun(a_szName, a_pFun, false);
446 API_EXPORT(void) mupDefineBulkFun4(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun4_t a_pFun)
449 muParser_t* const p(AsParser(a_hParser));
450 p->DefineFun(a_szName, a_pFun, false);
455 API_EXPORT(void) mupDefineBulkFun5(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun5_t a_pFun)
458 muParser_t* const p(AsParser(a_hParser));
459 p->DefineFun(a_szName, a_pFun, false);
464 API_EXPORT(void) mupDefineBulkFun6(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun6_t a_pFun)
467 muParser_t* const p(AsParser(a_hParser));
468 p->DefineFun(a_szName, a_pFun, false);
473 API_EXPORT(void) mupDefineBulkFun7(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun7_t a_pFun)
476 muParser_t* const p(AsParser(a_hParser));
477 p->DefineFun(a_szName, a_pFun, false);
482 API_EXPORT(void) mupDefineBulkFun8(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun8_t a_pFun)
485 muParser_t* const p(AsParser(a_hParser));
486 p->DefineFun(a_szName, a_pFun, false);
491 API_EXPORT(void) mupDefineBulkFun9(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun9_t a_pFun)
494 muParser_t* const p(AsParser(a_hParser));
495 p->DefineFun(a_szName, a_pFun, false);
500 API_EXPORT(void) mupDefineBulkFun10(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun10_t a_pFun)
503 muParser_t* const p(AsParser(a_hParser));
504 p->DefineFun(a_szName, a_pFun, false);
509 API_EXPORT(void) mupDefineStrFun1(muParserHandle_t a_hParser, const muChar_t* a_szName, muStrFun1_t a_pFun)
512 muParser_t* const p(AsParser(a_hParser));
513 p->DefineFun(a_szName, a_pFun, false);
518 API_EXPORT(void) mupDefineStrFun2(muParserHandle_t a_hParser, const muChar_t* a_szName, muStrFun2_t a_pFun)
521 muParser_t* const p(AsParser(a_hParser));
522 p->DefineFun(a_szName, a_pFun, false);
527 API_EXPORT(void) mupDefineStrFun3(muParserHandle_t a_hParser, const muChar_t* a_szName, muStrFun3_t a_pFun)
530 muParser_t* const p(AsParser(a_hParser));
531 p->DefineFun(a_szName, a_pFun, false);
536 API_EXPORT(void) mupDefineMultFun(muParserHandle_t a_hParser, const muChar_t* a_szName, muMultFun_t a_pFun, muBool_t a_bAllowOpt)
539 muParser_t* const p(AsParser(a_hParser));
540 p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
545 API_EXPORT(void) mupDefineOprt(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun2_t a_pFun, muInt_t a_nPrec, muInt_t a_nOprtAsct, muBool_t a_bAllowOpt)
548 muParser_t* const p(AsParser(a_hParser));
549 p->DefineOprt(a_szName, a_pFun, a_nPrec, (mu::EOprtAssociativity)a_nOprtAsct, a_bAllowOpt != 0);
554 API_EXPORT(void) mupDefineVar(muParserHandle_t a_hParser, const muChar_t* a_szName, muFloat_t* a_pVar)
557 muParser_t* const p(AsParser(a_hParser));
558 p->DefineVar(a_szName, a_pVar);
563 API_EXPORT(void) mupDefineBulkVar(muParserHandle_t a_hParser, const muChar_t* a_szName, muFloat_t* a_pVar)
566 muParser_t* const p(AsParser(a_hParser));
567 p->DefineVar(a_szName, a_pVar);
572 API_EXPORT(void) mupDefineConst(muParserHandle_t a_hParser, const muChar_t* a_szName, muFloat_t a_fVal)
575 muParser_t* const p(AsParser(a_hParser));
576 p->DefineConst(a_szName, a_fVal);
581 API_EXPORT(void) mupDefineStrConst(muParserHandle_t a_hParser, const muChar_t* a_szName, const muChar_t* a_szVal)
584 muParser_t* const p(AsParser(a_hParser));
585 p->DefineStrConst(a_szName, a_szVal);
590 API_EXPORT(const muChar_t*) mupGetExpr(muParserHandle_t a_hParser)
593 muParser_t* const p(AsParser(a_hParser));
595 // C# explodes when pMsg is returned directly. For some reason it can't access
596 // the memory where the message lies directly.
598 sprintf(s_tmpOutBuf, "%s", p->GetExpr().c_str());
600 wsprintf(s_tmpOutBuf, _T("%s"), p->GetExpr().c_str());
610 API_EXPORT(void) mupDefinePostfixOprt(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun1_t a_pOprt, muBool_t a_bAllowOpt)
613 muParser_t* const p(AsParser(a_hParser));
614 p->DefinePostfixOprt(a_szName, a_pOprt, a_bAllowOpt != 0);
619 API_EXPORT(void) mupDefineInfixOprt(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun1_t a_pOprt, muBool_t a_bAllowOpt)
622 muParser_t* const p(AsParser(a_hParser));
623 p->DefineInfixOprt(a_szName, a_pOprt, a_bAllowOpt != 0);
627 // Define character sets for identifiers
628 API_EXPORT(void) mupDefineNameChars(muParserHandle_t a_hParser, const muChar_t* a_szCharset)
630 muParser_t* const p(AsParser(a_hParser));
631 p->DefineNameChars(a_szCharset);
635 API_EXPORT(void) mupDefineOprtChars(muParserHandle_t a_hParser, const muChar_t* a_szCharset)
637 muParser_t* const p(AsParser(a_hParser));
638 p->DefineOprtChars(a_szCharset);
642 API_EXPORT(void) mupDefineInfixOprtChars(muParserHandle_t a_hParser, const muChar_t* a_szCharset)
644 muParser_t* const p(AsParser(a_hParser));
645 p->DefineInfixOprtChars(a_szCharset);
649 /** \brief Get the number of variables defined in the parser.
650 \param a_hParser [in] Must be a valid parser handle.
651 \return The number of used variables.
654 API_EXPORT(int) mupGetVarNum(muParserHandle_t a_hParser)
657 muParser_t* const p(AsParser(a_hParser));
658 const mu::varmap_type VarMap = p->GetVar();
659 return (int)VarMap.size();
662 return 0; // never reached
666 /** \brief Return a variable that is used in an expression.
667 \param a_hParser [in] A valid parser handle.
668 \param a_iVar [in] The index of the variable to return.
669 \param a_szName [out] Pointer to the variable name.
670 \param a_pVar [out] Pointer to the variable.
673 Prior to calling this function call mupGetExprVarNum in order to get the
674 number of variables in the expression. If the parameter a_iVar is greater
675 than the number of variables both a_szName and a_pVar will be set to zero.
676 As a side effect this function will trigger an internal calculation of the
677 expression undefined variables will be set to zero during this calculation.
678 During the calculation user defined callback functions present in the expression
679 will be called, this is unavoidable.
681 API_EXPORT(void) mupGetVar(muParserHandle_t a_hParser, unsigned a_iVar, const muChar_t** a_szName, muFloat_t** a_pVar)
683 // A static buffer is needed for the name since i can't return the
684 // pointer from the map.
685 static muChar_t szName[1024];
688 muParser_t* const p(AsParser(a_hParser));
689 const mu::varmap_type VarMap = p->GetVar();
691 if (a_iVar >= VarMap.size())
697 mu::varmap_type::const_iterator item;
699 item = VarMap.begin();
700 for (unsigned i = 0; i < a_iVar; ++i)
704 strncpy(szName, item->first.c_str(), sizeof(szName));
706 wcsncpy(szName, item->first.c_str(), sizeof(szName));
709 szName[sizeof(szName) - 1] = 0;
711 *a_szName = &szName[0];
712 *a_pVar = item->second;
721 /** \brief Get the number of variables used in the expression currently set in the parser.
722 \param a_hParser [in] Must be a valid parser handle.
723 \return The number of used variables.
726 API_EXPORT(int) mupGetExprVarNum(muParserHandle_t a_hParser)
729 muParser_t* const p(AsParser(a_hParser));
730 const mu::varmap_type VarMap = p->GetUsedVar();
731 return (int)VarMap.size();
734 return 0; // never reached
738 /** \brief Return a variable that is used in an expression.
740 Prior to calling this function call mupGetExprVarNum in order to get the
741 number of variables in the expression. If the parameter a_iVar is greater
742 than the number of variables both a_szName and a_pVar will be set to zero.
743 As a side effect this function will trigger an internal calculation of the
744 expression undefined variables will be set to zero during this calculation.
745 During the calculation user defined callback functions present in the expression
746 will be called, this is unavoidable.
748 \param a_hParser [in] A valid parser handle.
749 \param a_iVar [in] The index of the variable to return.
750 \param a_szName [out] Pointer to the variable name.
751 \param a_pVar [out] Pointer to the variable.
754 API_EXPORT(void) mupGetExprVar(muParserHandle_t a_hParser, unsigned a_iVar, const muChar_t** a_szName, muFloat_t** a_pVar)
756 // A static buffer is needed for the name since i can't return the
757 // pointer from the map.
758 static muChar_t szName[1024];
761 muParser_t* const p(AsParser(a_hParser));
762 const mu::varmap_type VarMap = p->GetUsedVar();
764 if (a_iVar >= VarMap.size())
770 mu::varmap_type::const_iterator item;
772 item = VarMap.begin();
773 for (unsigned i = 0; i < a_iVar; ++i)
777 strncpy(szName, item->first.c_str(), sizeof(szName));
779 wcsncpy(szName, item->first.c_str(), sizeof(szName));
782 szName[sizeof(szName) - 1] = 0;
784 *a_szName = &szName[0];
785 *a_pVar = item->second;
794 /** \brief Return the number of constants defined in a parser. */
795 API_EXPORT(int) mupGetConstNum(muParserHandle_t a_hParser)
798 muParser_t* const p(AsParser(a_hParser));
799 const mu::valmap_type ValMap = p->GetConst();
800 return (int)ValMap.size();
803 return 0; // never reached
807 API_EXPORT(void) mupSetArgSep(muParserHandle_t a_hParser, const muChar_t cArgSep)
810 muParser_t* const p(AsParser(a_hParser));
811 p->SetArgSep(cArgSep);
816 API_EXPORT(void) mupResetLocale(muParserHandle_t a_hParser)
819 muParser_t* const p(AsParser(a_hParser));
825 API_EXPORT(void) mupSetDecSep(muParserHandle_t a_hParser, const muChar_t cDecSep)
828 muParser_t* const p(AsParser(a_hParser));
829 p->SetDecSep(cDecSep);
834 API_EXPORT(void) mupSetThousandsSep(muParserHandle_t a_hParser, const muChar_t cThousandsSep)
837 muParser_t* const p(AsParser(a_hParser));
838 p->SetThousandsSep(cThousandsSep);
842 //---------------------------------------------------------------------------
843 /** \brief Retrieve name and value of a single parser constant.
844 \param a_hParser [in] a valid parser handle
845 \param a_iVar [in] Index of the constant to query
846 \param a_pszName [out] pointer to a null terminated string with the constant name
847 \param [out] The constant value
849 API_EXPORT(void) mupGetConst(muParserHandle_t a_hParser, unsigned a_iVar, const muChar_t** a_pszName, muFloat_t* a_fVal)
851 // A static buffer is needed for the name since i can't return the
852 // pointer from the map.
853 static muChar_t szName[1024];
856 muParser_t* const p(AsParser(a_hParser));
857 const mu::valmap_type ValMap = p->GetConst();
859 if (a_iVar >= ValMap.size())
866 mu::valmap_type::const_iterator item;
867 item = ValMap.begin();
868 for (unsigned i = 0; i < a_iVar; ++i)
872 strncpy(szName, item->first.c_str(), sizeof(szName));
874 wcsncpy(szName, item->first.c_str(), sizeof(szName));
877 szName[sizeof(szName) - 1] = 0;
879 *a_pszName = &szName[0];
880 *a_fVal = item->second;
890 /** \brief Add a custom value recognition function. */
891 API_EXPORT(void) mupAddValIdent(muParserHandle_t a_hParser, muIdentFun_t a_pFun)
894 muParser_t* p(AsParser(a_hParser));
895 p->AddValIdent(a_pFun);
900 /** \brief Query if an error occurred.
902 After querying the internal error bit will be reset. So a consecutive call
905 API_EXPORT(muBool_t) mupError(muParserHandle_t a_hParser)
907 bool bError(AsParserTag(a_hParser)->bError);
908 AsParserTag(a_hParser)->bError = false;
913 /** \brief Reset the internal error flag. */
914 API_EXPORT(void) mupErrorReset(muParserHandle_t a_hParser)
916 AsParserTag(a_hParser)->bError = false;
920 API_EXPORT(void) mupSetErrorHandler(muParserHandle_t a_hParser, muErrorHandler_t a_pHandler)
922 AsParserTag(a_hParser)->errHandler = a_pHandler;
926 /** \brief Return the message associated with the last error. */
927 API_EXPORT(const muChar_t*) mupGetErrorMsg(muParserHandle_t a_hParser)
929 ParserTag* const p(AsParserTag(a_hParser));
930 const muChar_t* pMsg = p->exc.GetMsg().c_str();
932 // C# explodes when pMsg is returned directly. For some reason it can't access
933 // the memory where the message lies directly.
935 sprintf(s_tmpOutBuf, "%s", pMsg);
937 wsprintf(s_tmpOutBuf, _T("%s"), pMsg);
944 /** \brief Return the message associated with the last error. */
945 API_EXPORT(const muChar_t*) mupGetErrorToken(muParserHandle_t a_hParser)
947 ParserTag* const p(AsParserTag(a_hParser));
948 const muChar_t* pToken = p->exc.GetToken().c_str();
950 // C# explodes when pMsg is returned directly. For some reason it can't access
951 // the memory where the message lies directly.
953 sprintf(s_tmpOutBuf, "%s", pToken);
955 wsprintf(s_tmpOutBuf, _T("%s"), pToken);
962 /** \brief Return the code associated with the last error.
964 API_EXPORT(int) mupGetErrorCode(muParserHandle_t a_hParser)
966 return AsParserTag(a_hParser)->exc.GetCode();
970 /** \brief Return the position associated with the last error. */
971 API_EXPORT(int) mupGetErrorPos(muParserHandle_t a_hParser)
973 return (int)AsParserTag(a_hParser)->exc.GetPos();
977 API_EXPORT(muFloat_t*) mupCreateVar()
979 return new muFloat_t(0);
983 API_EXPORT(void) mupReleaseVar(muFloat_t* ptr)
988 #if defined(_MSC_VER)
992 #endif // MUPARSER_DLL