h/fish-shell
1
Fork 0
mirror of https://github.com/fish-shell/fish-shell.git synced 2026-05-31 12:21:19 -03:00
Code Issues Packages Projects Releases Wiki Activity

[muparser] Remove 'AllowOpt' parameters

Browse Source 
This parameter was used as a hint to optimize functions invoked
with constants, but is no longer used.
This commit is contained in:
ridiculousfish
2017-12-17 18:04:52 -08:00
parent 452211ebf5
commit 554382a286
5 changed files with 97 additions and 139 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
muparser-2.2.5/include/muParserBase.h
View File

@@ -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 <typename T>
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();

34
muparser-2.2.5/include/muParserCallback.h
View File

@@ -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);

23
muparser-2.2.5/src/muParserBase.cpp
View File

@@ -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());
}
//---------------------------------------------------------------------------

81
muparser-2.2.5/src/muParserCallback.cpp
View File

@@ -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.

81
muparser-2.2.5/src/muParserDLL.cpp
View File

@@ -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
}