diff --git a/muparser-2.2.5/include/muParserBase.h b/muparser-2.2.5/include/muParserBase.h index 5440808ea..93637fca6 100644 --- a/muparser-2.2.5/include/muParserBase.h +++ b/muparser-2.2.5/include/muParserBase.h @@ -114,29 +114,24 @@ class ParserBase { bool HasBuiltInOprt() const; void AddValIdent(identfun_type a_pCallback); - /** \fn void mu::ParserBase::DefineFun(const string_type &a_strName, fun_type0 a_pFun, bool - a_bAllowOpt = true) + /** \fn void mu::ParserBase::DefineFun(const string_type &a_strName, fun_type0 a_pFun) \brief Define a parser function without arguments. \param a_strName Name of the function \param a_pFun Pointer to the callback function - \param a_bAllowOpt A flag indicating this function may be optimized */ template - OptionalError DefineFun(const string_type &a_strName, T a_pFun, bool a_bAllowOpt = true) { - return AddCallback(a_strName, ParserCallback(a_pFun, a_bAllowOpt), m_FunDef, - ValidNameChars()); + OptionalError DefineFun(const string_type &a_strName, T a_pFun) { + return AddCallback(a_strName, ParserCallback(a_pFun), m_FunDef, ValidNameChars()); } OptionalError DefineOprt(const string_type &a_strName, fun_type2 a_pFun, unsigned a_iPri = 0, - EOprtAssociativity a_eAssociativity = oaLEFT, - bool a_bAllowOpt = false); + EOprtAssociativity a_eAssociativity = oaLEFT); OptionalError DefineConst(const string_type &a_sName, value_type a_fVal); OptionalError DefineStrConst(const string_type &a_sName, const string_type &a_strVal); OptionalError DefineVar(const string_type &a_sName, value_type *a_fVar); - OptionalError DefinePostfixOprt(const string_type &a_strFun, fun_type1 a_pOprt, - bool a_bAllowOpt = true); + OptionalError DefinePostfixOprt(const string_type &a_strFun, fun_type1 a_pOprt); OptionalError DefineInfixOprt(const string_type &a_strName, fun_type1 a_pOprt, - int a_iPrec = prINFIX, bool a_bAllowOpt = true); + int a_iPrec = prINFIX); // Clear user defined variables, constants or functions void ClearVar(); diff --git a/muparser-2.2.5/include/muParserCallback.h b/muparser-2.2.5/include/muParserCallback.h index 83417f27b..08d7a7cba 100644 --- a/muparser-2.2.5/include/muParserCallback.h +++ b/muparser-2.2.5/include/muParserCallback.h @@ -48,25 +48,23 @@ namespace mu { */ class ParserCallback final { public: - ParserCallback(fun_type0 a_pFun, bool a_bAllowOpti); - ParserCallback(fun_type1 a_pFun, bool a_bAllowOpti, int a_iPrec = -1, - ECmdCode a_iCode = cmFUNC); - ParserCallback(fun_type2 a_pFun, bool a_bAllowOpti, int a_iPrec, - EOprtAssociativity a_eAssociativity); - ParserCallback(fun_type2 a_pFun, bool a_bAllowOpti); - ParserCallback(fun_type3 a_pFun, bool a_bAllowOpti); - ParserCallback(fun_type4 a_pFun, bool a_bAllowOpti); - ParserCallback(fun_type5 a_pFun, bool a_bAllowOpti); - ParserCallback(fun_type6 a_pFun, bool a_bAllowOpti); - ParserCallback(fun_type7 a_pFun, bool a_bAllowOpti); - ParserCallback(fun_type8 a_pFun, bool a_bAllowOpti); - ParserCallback(fun_type9 a_pFun, bool a_bAllowOpti); - ParserCallback(fun_type10 a_pFun, bool a_bAllowOpti); + explicit ParserCallback(fun_type0 a_pFun); + ParserCallback(fun_type1 a_pFun, int a_iPrec = -1, ECmdCode a_iCode = cmFUNC); + ParserCallback(fun_type2 a_pFun, int a_iPrec, EOprtAssociativity a_eAssociativity); + explicit ParserCallback(fun_type2 a_pFun); + explicit ParserCallback(fun_type3 a_pFun); + explicit ParserCallback(fun_type4 a_pFun); + explicit ParserCallback(fun_type5 a_pFun); + explicit ParserCallback(fun_type6 a_pFun); + explicit ParserCallback(fun_type7 a_pFun); + explicit ParserCallback(fun_type8 a_pFun); + explicit ParserCallback(fun_type9 a_pFun); + explicit ParserCallback(fun_type10 a_pFun); - ParserCallback(multfun_type a_pFun, bool a_bAllowOpti); - ParserCallback(strfun_type1 a_pFun, bool a_bAllowOpti); - ParserCallback(strfun_type2 a_pFun, bool a_bAllowOpti); - ParserCallback(strfun_type3 a_pFun, bool a_bAllowOpti); + explicit ParserCallback(multfun_type a_pFun); + explicit ParserCallback(strfun_type1 a_pFun); + explicit ParserCallback(strfun_type2 a_pFun); + explicit ParserCallback(strfun_type3 a_pFun); ParserCallback(); ParserCallback(const ParserCallback& a_Fun); diff --git a/muparser-2.2.5/src/muParserBase.cpp b/muparser-2.2.5/src/muParserBase.cpp index 80c1abc9c..1643c944c 100644 --- a/muparser-2.2.5/src/muParserBase.cpp +++ b/muparser-2.2.5/src/muParserBase.cpp @@ -365,10 +365,9 @@ const char_type *ParserBase::ValidInfixOprtChars() const { /** \brief Add a user defined operator. \post Will reset the Parser to string parsing mode. */ -OptionalError ParserBase::DefinePostfixOprt(const string_type &a_sName, fun_type1 a_pFun, - bool a_bAllowOpt) { - return AddCallback(a_sName, ParserCallback(a_pFun, a_bAllowOpt, prPOSTFIX, cmOPRT_POSTFIX), - m_PostOprtDef, ValidOprtChars()); +OptionalError ParserBase::DefinePostfixOprt(const string_type &a_sName, fun_type1 a_pFun) { + return AddCallback(a_sName, ParserCallback(a_pFun, prPOSTFIX, cmOPRT_POSTFIX), m_PostOprtDef, + ValidOprtChars()); } //--------------------------------------------------------------------------- @@ -389,13 +388,12 @@ void ParserBase::Init() { \param [in] a_sName operator Identifier \param [in] a_pFun Operator callback function \param [in] a_iPrec Operator Precedence (default=prSIGN) - \param [in] a_bAllowOpt True if operator is volatile (default=false) \sa EPrec */ -OptionalError ParserBase::DefineInfixOprt(const string_type &a_sName, fun_type1 a_pFun, int a_iPrec, - bool a_bAllowOpt) { - return AddCallback(a_sName, ParserCallback(a_pFun, a_bAllowOpt, a_iPrec, cmOPRT_INFIX), - m_InfixOprtDef, ValidInfixOprtChars()); +OptionalError ParserBase::DefineInfixOprt(const string_type &a_sName, fun_type1 a_pFun, + int a_iPrec) { + return AddCallback(a_sName, ParserCallback(a_pFun, a_iPrec, cmOPRT_INFIX), m_InfixOprtDef, + ValidInfixOprtChars()); } //--------------------------------------------------------------------------- @@ -404,18 +402,17 @@ OptionalError ParserBase::DefineInfixOprt(const string_type &a_sName, fun_type1 \param [in] a_pFun Pointer to the callback function. \param [in] a_iPrec Precedence of the operator. \param [in] a_eAssociativity The associativity of the operator. - \param [in] a_bAllowOpt If this is true the operator may be optimized away. Adds a new Binary operator the the parser instance. */ OptionalError ParserBase::DefineOprt(const string_type &a_sName, fun_type2 a_pFun, unsigned a_iPrec, - EOprtAssociativity a_eAssociativity, bool a_bAllowOpt) { + EOprtAssociativity a_eAssociativity) { // Check for conflicts with built in operator names for (int i = 0; m_bBuiltInOp && i < cmENDIF; ++i) if (a_sName == string_type(c_DefaultOprt[i])) return Error(ecBUILTIN_OVERLOAD, -1, a_sName); - return AddCallback(a_sName, ParserCallback(a_pFun, a_bAllowOpt, a_iPrec, a_eAssociativity), - m_OprtDef, ValidOprtChars()); + return AddCallback(a_sName, ParserCallback(a_pFun, a_iPrec, a_eAssociativity), m_OprtDef, + ValidOprtChars()); } //--------------------------------------------------------------------------- diff --git a/muparser-2.2.5/src/muParserCallback.cpp b/muparser-2.2.5/src/muParserCallback.cpp index abb2c594f..9feae7b9a 100644 --- a/muparser-2.2.5/src/muParserCallback.cpp +++ b/muparser-2.2.5/src/muParserCallback.cpp @@ -31,36 +31,33 @@ namespace mu { //--------------------------------------------------------------------------- -ParserCallback::ParserCallback(fun_type0 a_pFun, bool a_bAllowOpti) +ParserCallback::ParserCallback(fun_type0 a_pFun) : m_pFun((void*)a_pFun), m_iArgc(0), m_iPri(-1), m_eOprtAsct(oaNONE), m_iCode(cmFUNC), - m_iType(tpDBL), - m_bAllowOpti(a_bAllowOpti) {} + m_iType(tpDBL) {} //--------------------------------------------------------------------------- -ParserCallback::ParserCallback(fun_type1 a_pFun, bool a_bAllowOpti, int a_iPrec, ECmdCode a_iCode) +ParserCallback::ParserCallback(fun_type1 a_pFun, int a_iPrec, ECmdCode a_iCode) : m_pFun((void*)a_pFun), m_iArgc(1), m_iPri(a_iPrec), m_eOprtAsct(oaNONE), m_iCode(a_iCode), - m_iType(tpDBL), - m_bAllowOpti(a_bAllowOpti) {} + m_iType(tpDBL) {} //--------------------------------------------------------------------------- /** \brief Constructor for constructing function callbacks taking two arguments. */ -ParserCallback::ParserCallback(fun_type2 a_pFun, bool a_bAllowOpti) +ParserCallback::ParserCallback(fun_type2 a_pFun) : m_pFun((void*)a_pFun), m_iArgc(2), m_iPri(-1), m_eOprtAsct(oaNONE), m_iCode(cmFUNC), - m_iType(tpDBL), - m_bAllowOpti(a_bAllowOpti) {} + m_iType(tpDBL) {} //--------------------------------------------------------------------------- /** \brief Constructor for constructing binary operator callbacks. @@ -69,135 +66,121 @@ ParserCallback::ParserCallback(fun_type2 a_pFun, bool a_bAllowOpti) \param a_iPrec The operator precedence \param a_eOprtAsct The operators associativity */ -ParserCallback::ParserCallback(fun_type2 a_pFun, bool a_bAllowOpti, int a_iPrec, - EOprtAssociativity a_eOprtAsct) +ParserCallback::ParserCallback(fun_type2 a_pFun, int a_iPrec, EOprtAssociativity a_eOprtAsct) : m_pFun((void*)a_pFun), m_iArgc(2), m_iPri(a_iPrec), m_eOprtAsct(a_eOprtAsct), m_iCode(cmOPRT_BIN), - m_iType(tpDBL), - m_bAllowOpti(a_bAllowOpti) {} + m_iType(tpDBL) {} //--------------------------------------------------------------------------- -ParserCallback::ParserCallback(fun_type3 a_pFun, bool a_bAllowOpti) +ParserCallback::ParserCallback(fun_type3 a_pFun) : m_pFun((void*)a_pFun), m_iArgc(3), m_iPri(-1), m_eOprtAsct(oaNONE), m_iCode(cmFUNC), - m_iType(tpDBL), - m_bAllowOpti(a_bAllowOpti) {} + m_iType(tpDBL) {} //--------------------------------------------------------------------------- -ParserCallback::ParserCallback(fun_type4 a_pFun, bool a_bAllowOpti) +ParserCallback::ParserCallback(fun_type4 a_pFun) : m_pFun((void*)a_pFun), m_iArgc(4), m_iPri(-1), m_eOprtAsct(oaNONE), m_iCode(cmFUNC), - m_iType(tpDBL), - m_bAllowOpti(a_bAllowOpti) {} + m_iType(tpDBL) {} //--------------------------------------------------------------------------- -ParserCallback::ParserCallback(fun_type5 a_pFun, bool a_bAllowOpti) +ParserCallback::ParserCallback(fun_type5 a_pFun) : m_pFun((void*)a_pFun), m_iArgc(5), m_iPri(-1), m_eOprtAsct(oaNONE), m_iCode(cmFUNC), - m_iType(tpDBL), - m_bAllowOpti(a_bAllowOpti) {} + m_iType(tpDBL) {} //--------------------------------------------------------------------------- -ParserCallback::ParserCallback(fun_type6 a_pFun, bool a_bAllowOpti) +ParserCallback::ParserCallback(fun_type6 a_pFun) : m_pFun((void*)a_pFun), m_iArgc(6), m_iPri(-1), m_eOprtAsct(oaNONE), m_iCode(cmFUNC), - m_iType(tpDBL), - m_bAllowOpti(a_bAllowOpti) {} + m_iType(tpDBL) {} //--------------------------------------------------------------------------- -ParserCallback::ParserCallback(fun_type7 a_pFun, bool a_bAllowOpti) +ParserCallback::ParserCallback(fun_type7 a_pFun) : m_pFun((void*)a_pFun), m_iArgc(7), m_iPri(-1), m_eOprtAsct(oaNONE), m_iCode(cmFUNC), - m_iType(tpDBL), - m_bAllowOpti(a_bAllowOpti) {} + m_iType(tpDBL) {} //--------------------------------------------------------------------------- -ParserCallback::ParserCallback(fun_type8 a_pFun, bool a_bAllowOpti) +ParserCallback::ParserCallback(fun_type8 a_pFun) : m_pFun((void*)a_pFun), m_iArgc(8), m_iPri(-1), m_eOprtAsct(oaNONE), m_iCode(cmFUNC), - m_iType(tpDBL), - m_bAllowOpti(a_bAllowOpti) {} + m_iType(tpDBL) {} //--------------------------------------------------------------------------- -ParserCallback::ParserCallback(fun_type9 a_pFun, bool a_bAllowOpti) +ParserCallback::ParserCallback(fun_type9 a_pFun) : m_pFun((void*)a_pFun), m_iArgc(9), m_iPri(-1), m_eOprtAsct(oaNONE), m_iCode(cmFUNC), - m_iType(tpDBL), - m_bAllowOpti(a_bAllowOpti) {} + m_iType(tpDBL) {} //--------------------------------------------------------------------------- -ParserCallback::ParserCallback(fun_type10 a_pFun, bool a_bAllowOpti) +ParserCallback::ParserCallback(fun_type10 a_pFun) : m_pFun((void*)a_pFun), m_iArgc(10), m_iPri(-1), m_eOprtAsct(oaNONE), m_iCode(cmFUNC), - m_iType(tpDBL), - m_bAllowOpti(a_bAllowOpti) {} + m_iType(tpDBL) {} //--------------------------------------------------------------------------- -ParserCallback::ParserCallback(multfun_type a_pFun, bool a_bAllowOpti) +ParserCallback::ParserCallback(multfun_type a_pFun) : m_pFun((void*)a_pFun), m_iArgc(-1), m_iPri(-1), m_eOprtAsct(oaNONE), m_iCode(cmFUNC), - m_iType(tpDBL), - m_bAllowOpti(a_bAllowOpti) {} + m_iType(tpDBL) {} //--------------------------------------------------------------------------- -ParserCallback::ParserCallback(strfun_type1 a_pFun, bool a_bAllowOpti) +ParserCallback::ParserCallback(strfun_type1 a_pFun) : m_pFun((void*)a_pFun), m_iArgc(0), m_iPri(-1), m_eOprtAsct(oaNONE), m_iCode(cmFUNC_STR), - m_iType(tpSTR), - m_bAllowOpti(a_bAllowOpti) {} + m_iType(tpSTR) {} //--------------------------------------------------------------------------- -ParserCallback::ParserCallback(strfun_type2 a_pFun, bool a_bAllowOpti) +ParserCallback::ParserCallback(strfun_type2 a_pFun) : m_pFun((void*)a_pFun), m_iArgc(1), m_iPri(-1), m_eOprtAsct(oaNONE), m_iCode(cmFUNC_STR), - m_iType(tpSTR), - m_bAllowOpti(a_bAllowOpti) {} + m_iType(tpSTR) {} //--------------------------------------------------------------------------- -ParserCallback::ParserCallback(strfun_type3 a_pFun, bool a_bAllowOpti) +ParserCallback::ParserCallback(strfun_type3 a_pFun) : m_pFun((void*)a_pFun), m_iArgc(2), m_iPri(-1), m_eOprtAsct(oaNONE), m_iCode(cmFUNC_STR), - m_iType(tpSTR), - m_bAllowOpti(a_bAllowOpti) {} + m_iType(tpSTR) {} //--------------------------------------------------------------------------- /** \brief Default constructor. diff --git a/muparser-2.2.5/src/muParserDLL.cpp b/muparser-2.2.5/src/muParserDLL.cpp index 59d8e286a..9942b46a8 100644 --- a/muparser-2.2.5/src/muParserDLL.cpp +++ b/muparser-2.2.5/src/muParserDLL.cpp @@ -264,111 +264,100 @@ API_EXPORT(void) mupClearFun(muParserHandle_t a_hParser) { //--------------------------------------------------------------------------- API_EXPORT(void) -mupDefineFun0(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun0_t a_pFun, - muBool_t a_bAllowOpt) { +mupDefineFun0(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun0_t a_pFun) { MU_TRY muParser_t* const p(AsParser(a_hParser)); - p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0); + p->DefineFun(a_szName, a_pFun); MU_CATCH } //--------------------------------------------------------------------------- API_EXPORT(void) -mupDefineFun1(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun1_t a_pFun, - muBool_t a_bAllowOpt) { +mupDefineFun1(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun1_t a_pFun) { MU_TRY muParser_t* const p(AsParser(a_hParser)); - p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0); + p->DefineFun(a_szName, a_pFun); MU_CATCH } //--------------------------------------------------------------------------- API_EXPORT(void) -mupDefineFun2(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun2_t a_pFun, - muBool_t a_bAllowOpt) { +mupDefineFun2(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun2_t a_pFun) { MU_TRY muParser_t* const p(AsParser(a_hParser)); - p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0); + p->DefineFun(a_szName, a_pFun); MU_CATCH } //--------------------------------------------------------------------------- API_EXPORT(void) -mupDefineFun3(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun3_t a_pFun, - muBool_t a_bAllowOpt) { +mupDefineFun3(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun3_t a_pFun) { MU_TRY muParser_t* const p(AsParser(a_hParser)); - p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0); + p->DefineFun(a_szName, a_pFun); MU_CATCH } //--------------------------------------------------------------------------- API_EXPORT(void) -mupDefineFun4(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun4_t a_pFun, - muBool_t a_bAllowOpt) { +mupDefineFun4(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun4_t a_pFun) { MU_TRY muParser_t* const p(AsParser(a_hParser)); - p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0); + p->DefineFun(a_szName, a_pFun); MU_CATCH } //--------------------------------------------------------------------------- API_EXPORT(void) -mupDefineFun5(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun5_t a_pFun, - muBool_t a_bAllowOpt) { +mupDefineFun5(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun5_t a_pFun) { MU_TRY muParser_t* const p(AsParser(a_hParser)); - p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0); + p->DefineFun(a_szName, a_pFun); MU_CATCH } //--------------------------------------------------------------------------- API_EXPORT(void) -mupDefineFun6(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun6_t a_pFun, - muBool_t a_bAllowOpt) { +mupDefineFun6(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun6_t a_pFun) { MU_TRY muParser_t* const p(AsParser(a_hParser)); - p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0); + p->DefineFun(a_szName, a_pFun); MU_CATCH } //--------------------------------------------------------------------------- API_EXPORT(void) -mupDefineFun7(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun7_t a_pFun, - muBool_t a_bAllowOpt) { +mupDefineFun7(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun7_t a_pFun) { MU_TRY muParser_t* const p(AsParser(a_hParser)); - p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0); + p->DefineFun(a_szName, a_pFun); MU_CATCH } //--------------------------------------------------------------------------- API_EXPORT(void) -mupDefineFun8(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun8_t a_pFun, - muBool_t a_bAllowOpt) { +mupDefineFun8(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun8_t a_pFun) { MU_TRY muParser_t* const p(AsParser(a_hParser)); - p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0); + p->DefineFun(a_szName, a_pFun); MU_CATCH } //--------------------------------------------------------------------------- API_EXPORT(void) -mupDefineFun9(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun9_t a_pFun, - muBool_t a_bAllowOpt) { +mupDefineFun9(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun9_t a_pFun) { MU_TRY muParser_t* const p(AsParser(a_hParser)); - p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0); + p->DefineFun(a_szName, a_pFun); MU_CATCH } //--------------------------------------------------------------------------- API_EXPORT(void) -mupDefineFun10(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun10_t a_pFun, - muBool_t a_bAllowOpt) { +mupDefineFun10(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun10_t a_pFun) { MU_TRY muParser_t* const p(AsParser(a_hParser)); - p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0); + p->DefineFun(a_szName, a_pFun); MU_CATCH } @@ -377,7 +366,7 @@ API_EXPORT(void) mupDefineStrFun1(muParserHandle_t a_hParser, const muChar_t* a_szName, muStrFun1_t a_pFun) { MU_TRY muParser_t* const p(AsParser(a_hParser)); - p->DefineFun(a_szName, a_pFun, false); + p->DefineFun(a_szName, a_pFun); MU_CATCH } @@ -386,7 +375,7 @@ API_EXPORT(void) mupDefineStrFun2(muParserHandle_t a_hParser, const muChar_t* a_szName, muStrFun2_t a_pFun) { MU_TRY muParser_t* const p(AsParser(a_hParser)); - p->DefineFun(a_szName, a_pFun, false); + p->DefineFun(a_szName, a_pFun); MU_CATCH } @@ -395,28 +384,26 @@ API_EXPORT(void) mupDefineStrFun3(muParserHandle_t a_hParser, const muChar_t* a_szName, muStrFun3_t a_pFun) { MU_TRY muParser_t* const p(AsParser(a_hParser)); - p->DefineFun(a_szName, a_pFun, false); + p->DefineFun(a_szName, a_pFun); MU_CATCH } //--------------------------------------------------------------------------- API_EXPORT(void) -mupDefineMultFun(muParserHandle_t a_hParser, const muChar_t* a_szName, muMultFun_t a_pFun, - muBool_t a_bAllowOpt) { +mupDefineMultFun(muParserHandle_t a_hParser, const muChar_t* a_szName, muMultFun_t a_pFun) { MU_TRY muParser_t* const p(AsParser(a_hParser)); - p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0); + p->DefineFun(a_szName, a_pFun); MU_CATCH } //--------------------------------------------------------------------------- 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) { + muInt_t a_nPrec, muInt_t a_nOprtAsct) { MU_TRY muParser_t* const p(AsParser(a_hParser)); - throwIfError(p->DefineOprt(a_szName, a_pFun, a_nPrec, (mu::EOprtAssociativity)a_nOprtAsct, - a_bAllowOpt != 0)); + throwIfError(p->DefineOprt(a_szName, a_pFun, a_nPrec, (mu::EOprtAssociativity)a_nOprtAsct)); MU_CATCH } @@ -478,21 +465,19 @@ API_EXPORT(const muChar_t*) mupGetExpr(muParserHandle_t a_hParser) { //--------------------------------------------------------------------------- API_EXPORT(void) -mupDefinePostfixOprt(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun1_t a_pOprt, - muBool_t a_bAllowOpt) { +mupDefinePostfixOprt(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun1_t a_pOprt) { MU_TRY muParser_t* const p(AsParser(a_hParser)); - p->DefinePostfixOprt(a_szName, a_pOprt, a_bAllowOpt != 0); + p->DefinePostfixOprt(a_szName, a_pOprt); MU_CATCH } //--------------------------------------------------------------------------- API_EXPORT(void) -mupDefineInfixOprt(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun1_t a_pOprt, - muBool_t a_bAllowOpt) { +mupDefineInfixOprt(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun1_t a_pOprt) { MU_TRY muParser_t* const p(AsParser(a_hParser)); - p->DefineInfixOprt(a_szName, a_pOprt, a_bAllowOpt != 0); + p->DefineInfixOprt(a_szName, a_pOprt); MU_CATCH }