_ZN2mu10ParserBase9DefineFunIPFddEEEvRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEET_b: 140| 83.8k| { 141| 83.8k| AddCallback(a_strName, ParserCallback(a_pFun, a_bAllowOpt), m_FunDef, ValidNameChars()); 142| 83.8k| } _ZN2mu10ParserBase9DefineFunIPFdddEEEvRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEET_b: 140| 3.99k| { 141| 3.99k| AddCallback(a_strName, ParserCallback(a_pFun, a_bAllowOpt), m_FunDef, ValidNameChars()); 142| 3.99k| } _ZN2mu10ParserBase9DefineFunIPFdPKdiEEEvRKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEET_b: 140| 15.9k| { 141| 15.9k| AddCallback(a_strName, ParserCallback(a_pFun, a_bAllowOpt), m_FunDef, ValidNameChars()); 142| 15.9k| } _ZN2mu10ParserBase14change_dec_sepIcEC2Ecci: 221| 2| {} _ZNK2mu10ParserBase14change_dec_sepIcE16do_decimal_pointEv: 226| 785k| { 227| 785k| return m_cDecPoint; 228| 785k| } _ZNK2mu10ParserBase14change_dec_sepIcE16do_thousands_sepEv: 231| 781k| { 232| 781k| return m_cThousandsSep; 233| 781k| } _ZNK2mu10ParserBase14change_dec_sepIcE11do_groupingEv: 236| 781k| { 237| | // fix for issue 4: https://code.google.com/p/muparser/issues/detail?id=4 238| | // courtesy of Jens Bartsch 239| | // original code: 240| | // return std::string(1, (char)m_nGroup); 241| | // new code: 242| 781k| return std::string(1, (char)(m_cThousandsSep > 0 ? m_nGroup : CHAR_MAX)); ------------------ | Branch (242:34): [True: 0, False: 781k] ------------------ 243| 781k| } _ZNK2mu14ParserByteCode7GetSizeEv: 133| 1.51k| { 134| 1.51k| return m_vRPN.size(); 135| 1.51k| } _ZNK2mu14ParserByteCode7GetBaseEv: 138| 1.51k| { 139| 1.51k| if (m_vRPN.size() == 0) ------------------ | Branch (139:8): [True: 0, False: 1.51k] ------------------ 140| 0| throw ParserError(ecINTERNAL_ERROR); 141| 1.51k| else 142| 1.51k| return &m_vRPN[0]; 143| 1.51k| } _ZN2mu14ParserErrorMsgD2Ev: 64| 1| ~ParserErrorMsg() = default; _ZN2mu8TypeInfoIdE9IsIntegerEv: 50| 3.99k| static bool IsInteger() { return false; } _ZN2mu8MathImplIdE3SinEd: 116| 200| static T Sin(T v) { return sin(v); } _ZN2mu8MathImplIdE3CosEd: 117| 197| static T Cos(T v) { return cos(v); } _ZN2mu8MathImplIdE3TanEd: 118| 195| static T Tan(T v) { return tan(v); } _ZN2mu8MathImplIdE4ASinEd: 119| 195| static T ASin(T v) { return asin(v); } _ZN2mu8MathImplIdE4ACosEd: 120| 194| static T ACos(T v) { return acos(v); } _ZN2mu8MathImplIdE4ATanEd: 121| 195| static T ATan(T v) { return atan(v); } _ZN2mu8MathImplIdE5ATan2Edd: 122| 388| static T ATan2(T v1, T v2) { return atan2(v1, v2); } _ZN2mu8MathImplIdE4SinhEd: 123| 207| static T Sinh(T v) { return sinh(v); } _ZN2mu8MathImplIdE4CoshEd: 124| 195| static T Cosh(T v) { return cosh(v); } _ZN2mu8MathImplIdE4TanhEd: 125| 195| static T Tanh(T v) { return tanh(v); } _ZN2mu8MathImplIdE5ASinhEd: 126| 195| static T ASinh(T v) { return log(v + sqrt(v * v + 1)); } _ZN2mu8MathImplIdE5ACoshEd: 127| 195| static T ACosh(T v) { return log(v + sqrt(v * v - 1)); } _ZN2mu8MathImplIdE5ATanhEd: 128| 195| static T ATanh(T v) { return ((T)0.5 * log((1 + v) / (1 - v))); } _ZN2mu8MathImplIdE4Log2Ed: 130| 195| static T Log2(T v) { return log(v) / log((T)2); } // Logarithm base 2 _ZN2mu8MathImplIdE5Log10Ed: 131| 195| static T Log10(T v) { return log10(v); } // Logarithm base 10 _ZN2mu8MathImplIdE3LogEd: 129| 288| static T Log(T v) { return log(v); } _ZN2mu8MathImplIdE3ExpEd: 132| 195| static T Exp(T v) { return exp(v); } _ZN2mu8MathImplIdE4SqrtEd: 134| 196| static T Sqrt(T v) { return sqrt(v); } _ZN2mu8MathImplIdE4SignEd: 136| 420| static T Sign(T v) { return (T)((v < 0) ? -1 : (v > 0) ? 1 : 0); } ------------------ | Branch (136:35): [True: 225, False: 195] | Branch (136:50): [True: 49, False: 146] ------------------ _ZN2mu8MathImplIdE4RintEd: 135| 195| static T Rint(T v) { return floor(v + (T)0.5); } _ZN2mu8MathImplIdE3AbsEd: 133| 394| static T Abs(T v) { return (v >= 0) ? v : -v; } ------------------ | Branch (133:30): [True: 200, False: 194] ------------------ _ZN2mu8MathImplIdE3SumEPKdi: 143| 526| { 144| 526| if (!a_iArgc) ------------------ | Branch (144:8): [True: 0, False: 526] ------------------ 145| 0| throw ParserError(_T("too few arguments for function sum.")); ------------------ | | 69| 0| #define _T(x) x ------------------ 146| | 147| 526| T fRes = 0; 148| 42.2k| for (int i = 0; i < a_iArgc; ++i) fRes += a_afArg[i]; ------------------ | Branch (148:20): [True: 41.7k, False: 526] ------------------ 149| 526| return fRes; 150| 526| } _ZN2mu8MathImplIdE3AvgEPKdi: 153| 498| { 154| 498| if (!a_iArgc) ------------------ | Branch (154:8): [True: 0, False: 498] ------------------ 155| 0| throw ParserError(_T("too few arguments for function avg.")); ------------------ | | 69| 0| #define _T(x) x ------------------ 156| | 157| 498| T fRes = 0; 158| 43.8k| for (int i = 0; i < a_iArgc; ++i) fRes += a_afArg[i]; ------------------ | Branch (158:20): [True: 43.3k, False: 498] ------------------ 159| 498| return fRes / (T)a_iArgc; 160| 498| } _ZN2mu8MathImplIdE3MinEPKdi: 163| 1.13k| { 164| 1.13k| if (!a_iArgc) ------------------ | Branch (164:8): [True: 0, False: 1.13k] ------------------ 165| 0| throw ParserError(_T("too few arguments for function min.")); ------------------ | | 69| 0| #define _T(x) x ------------------ 166| | 167| 1.13k| T fRes = a_afArg[0]; 168| 85.5k| for (int i = 0; i < a_iArgc; ++i) ------------------ | Branch (168:20): [True: 84.4k, False: 1.13k] ------------------ 169| 84.4k| fRes = std::min(fRes, a_afArg[i]); 170| | 171| 1.13k| return fRes; 172| 1.13k| } _ZN2mu8MathImplIdE3MaxEPKdi: 175| 1.30k| { 176| 1.30k| if (!a_iArgc) ------------------ | Branch (176:8): [True: 0, False: 1.30k] ------------------ 177| 0| throw ParserError(_T("too few arguments for function max.")); ------------------ | | 69| 0| #define _T(x) x ------------------ 178| | 179| 1.30k| T fRes = a_afArg[0]; 180| 36.7k| for (int i = 0; i < a_iArgc; ++i) fRes = std::max(fRes, a_afArg[i]); ------------------ | Branch (180:20): [True: 35.4k, False: 1.30k] ------------------ 181| | 182| 1.30k| return fRes; 183| 1.30k| } _ZN2mu8MathImplIdE10UnaryMinusEd: 139| 2.26k| static T UnaryMinus(T v) { return -v; } _ZN2mu8MathImplIdE3PowEdd: 137| 118k| static T Pow(T v1, T v2) { return std::pow(v1, v2); } _ZNK2mu21generic_callable_type12call_multfunEPKdi: 104| 3.45k| { 105| 3.45k| if (_pUserData == nullptr) { ------------------ | Branch (105:8): [True: 3.45k, False: 0] ------------------ 106| 3.45k| auto multfun_typed_ptr = reinterpret_cast(_pRawFun); 107| 3.45k| return (*multfun_typed_ptr)(a_afArg, a_iArgc); 108| 3.45k| } else { 109| 0| auto multfun_userdata_typed_ptr = reinterpret_cast(_pRawFun); 110| 0| return (*multfun_userdata_typed_ptr)(_pUserData, a_afArg, a_iArgc); 111| 0| } 112| 3.45k| } _ZNK2mu21generic_callable_typeeqES0_: 131| 71.5k| { 132| 71.5k| return _pRawFun == other._pRawFun && _pUserData == other._pUserData; ------------------ | Branch (132:11): [True: 4.66k, False: 66.9k] | Branch (132:41): [True: 4.66k, False: 0] ------------------ 133| 71.5k| } _ZNK2mu21generic_callable_typeeqEDn: 141| 75.2k| { 142| 75.2k| return _pRawFun == nullptr; 143| 75.2k| } _ZNK2mu21generic_callable_typeneEDn: 146| 164k| { 147| 164k| return _pRawFun != nullptr; 148| 164k| } _ZNK2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE7GetCodeEv: 383| 13.2M| { 384| 13.2M| if (m_pCallback.get()) ------------------ | Branch (384:8): [True: 1.01M, False: 12.2M] ------------------ 385| 1.01M| { 386| 1.01M| return m_pCallback->GetCode(); 387| 1.01M| } 388| 12.2M| else 389| 12.2M| { 390| 12.2M| return m_iCode; 391| 12.2M| } 392| 13.2M| } _ZNK2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE6GetPriEv: 409| 65.8k| { 410| 65.8k| if (!m_pCallback.get()) ------------------ | Branch (410:8): [True: 0, False: 65.8k] ------------------ 411| 0| throw ParserError(ecINTERNAL_ERROR); 412| | 413| 65.8k| if (m_pCallback->GetCode() != cmOPRT_BIN && m_pCallback->GetCode() != cmOPRT_INFIX) ------------------ | Branch (413:8): [True: 65.8k, False: 0] | Branch (413:48): [True: 0, False: 65.8k] ------------------ 414| 0| throw ParserError(ecINTERNAL_ERROR); 415| | 416| 65.8k| return m_pCallback->GetPri(); 417| 65.8k| } _ZNK2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE11GetAsStringEv: 514| 24.3k| { 515| 24.3k| return m_strTok; 516| 24.3k| } _ZN2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEC2Ev: 200| 3.27M| {} _ZNK2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE11GetFuncAddrEv: 444| 314k| { 445| 314k| return (m_pCallback.get()) ------------------ | Branch (445:11): [True: 234k, False: 80.8k] ------------------ 446| 314k| ? generic_callable_type{(erased_fun_type)m_pCallback->GetAddr(), 447| 234k| m_pCallback->GetUserData()} 448| 314k| : generic_callable_type{}; 449| 314k| } _ZNK2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE11GetArgCountEv: 487| 300k| { 488| 300k| MUP_ASSERT(m_pCallback.get()); ------------------ | | 78| 300k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 300k] | | ------------------ | | 79| 300k| { \ | | 80| 0| stringstream_type ss; \ | | 81| 0| ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 82| 0| << __FILE__ << _T(" line ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 83| 0| << __LINE__ << _T("."); \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 84| 0| throw ParserError( ecINTERNAL_ERROR, -1, ss.str()); \ | | 85| 0| } ------------------ 489| | 490| 300k| if (!m_pCallback->IsValid()) ------------------ | Branch (490:8): [True: 0, False: 300k] ------------------ 491| 0| throw ParserError(ecINTERNAL_ERROR); 492| | 493| 300k| return m_pCallback->GetArgc(); 494| 300k| } _ZN2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE6SetValEdRKS7_: 297| 972k| { 298| 972k| m_iCode = cmVAL; 299| 972k| m_iType = tpDBL; 300| 972k| m_fVal = a_fVal; 301| 972k| m_strTok = a_strTok; 302| 972k| m_iIdx = -1; 303| | 304| 972k| m_pTok = 0; 305| 972k| m_pCallback.reset(0); 306| | 307| 972k| return *this; 308| 972k| } _ZNK2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE6GetValEv: 458| 835k| { 459| 835k| switch (m_iCode) 460| 835k| { 461| 835k| case cmVAL: return m_fVal; ------------------ | Branch (461:4): [True: 835k, False: 1] ------------------ 462| 0| case cmVAR: return *((TBase*)m_pTok); ------------------ | Branch (462:4): [True: 0, False: 835k] ------------------ 463| 1| default: throw ParserError(ecVAL_EXPECTED); ------------------ | Branch (463:4): [True: 1, False: 835k] ------------------ 464| 835k| } 465| 835k| } _ZN2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEC2ERKS8_: 211| 7.21M| { 212| 7.21M| Assign(a_Tok); 213| 7.21M| } _ZN2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE6AssignERKS8_: 234| 16.0M| { 235| 16.0M| m_iCode = a_Tok.m_iCode; 236| 16.0M| m_pTok = a_Tok.m_pTok; 237| 16.0M| m_strTok = a_Tok.m_strTok; 238| 16.0M| m_iIdx = a_Tok.m_iIdx; 239| 16.0M| m_strVal = a_Tok.m_strVal; 240| 16.0M| m_iType = a_Tok.m_iType; 241| 16.0M| m_fVal = a_Tok.m_fVal; 242| | // create new callback object if a_Tok has one 243| 16.0M| m_pCallback.reset(a_Tok.m_pCallback.get() ? a_Tok.m_pCallback->Clone() : 0); ------------------ | Branch (243:22): [True: 545k, False: 15.5M] ------------------ 244| 16.0M| } _ZNK2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE7GetTypeEv: 396| 1.04M| { 397| 1.04M| if (m_pCallback.get()) ------------------ | Branch (397:8): [True: 150k, False: 898k] ------------------ 398| 150k| { 399| 150k| return m_pCallback->GetType(); 400| 150k| } 401| 898k| else 402| 898k| { 403| 898k| return m_iType; 404| 898k| } 405| 1.04M| } _ZNK2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE13IsOptimizableEv: 500| 75.1k| { 501| 75.1k| return m_pCallback->IsValid() && m_pCallback->IsOptimizable(); ------------------ | Branch (501:11): [True: 75.1k, False: 0] | Branch (501:37): [True: 75.1k, False: 0] ------------------ 502| 75.1k| } _ZNK2mu21generic_callable_type8call_funILm1EJRdEEEdDpOT0_: 76| 6.70k| { 77| 6.70k| static_assert(NbParams == sizeof...(Args), "mismatch between NbParams and Args"); 78| 6.70k| if (_pUserData == nullptr) ------------------ | Branch (78:8): [True: 6.70k, False: 0] ------------------ 79| 6.70k| { 80| 6.70k| auto fun_typed_ptr = reinterpret_cast::fun_type>(_pRawFun); 81| 6.70k| return (*fun_typed_ptr)(std::forward(args)...); 82| 6.70k| } 83| 0| else 84| 0| { 85| 0| auto fun_userdata_typed_ptr = reinterpret_cast::fun_userdata_type>(_pRawFun); 86| 0| return (*fun_userdata_typed_ptr)(_pUserData, std::forward(args)...); 87| 0| } 88| 6.70k| } _ZNK2mu21generic_callable_type8call_funILm2EJRdS2_EEEdDpOT0_: 76| 388| { 77| 388| static_assert(NbParams == sizeof...(Args), "mismatch between NbParams and Args"); 78| 388| if (_pUserData == nullptr) ------------------ | Branch (78:8): [True: 388, False: 0] ------------------ 79| 388| { 80| 388| auto fun_typed_ptr = reinterpret_cast::fun_type>(_pRawFun); 81| 388| return (*fun_typed_ptr)(std::forward(args)...); 82| 388| } 83| 0| else 84| 0| { 85| 0| auto fun_userdata_typed_ptr = reinterpret_cast::fun_userdata_type>(_pRawFun); 86| 0| return (*fun_userdata_typed_ptr)(_pUserData, std::forward(args)...); 87| 0| } 88| 388| } _ZN2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEaSERKS8_: 223| 8.85M| { 224| 8.85M| Assign(a_Tok); 225| 8.85M| return *this; 226| 8.85M| } _ZN2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE6SetIdxEi: 353| 24.0k| { 354| 24.0k| if (m_iCode != cmSTRING || a_iIdx < 0) ------------------ | Branch (354:8): [True: 0, False: 24.0k] | Branch (354:31): [True: 0, False: 24.0k] ------------------ 355| 0| throw ParserError(ecINTERNAL_ERROR); 356| | 357| 24.0k| m_iIdx = a_iIdx; 358| 24.0k| } _ZN2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE3SetENS_8ECmdCodeERKS7_: 258| 2.03M| { 259| | // The following types can't be set this way, they have special Set functions 260| 2.03M| MUP_ASSERT(a_iType != cmVAR); ------------------ | | 78| 2.03M| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 2.03M] | | ------------------ | | 79| 2.03M| { \ | | 80| 0| stringstream_type ss; \ | | 81| 0| ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 82| 0| << __FILE__ << _T(" line ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 83| 0| << __LINE__ << _T("."); \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 84| 0| throw ParserError( ecINTERNAL_ERROR, -1, ss.str()); \ | | 85| 0| } ------------------ 261| 2.03M| MUP_ASSERT(a_iType != cmVAL); ------------------ | | 78| 2.03M| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 2.03M] | | ------------------ | | 79| 2.03M| { \ | | 80| 0| stringstream_type ss; \ | | 81| 0| ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 82| 0| << __FILE__ << _T(" line ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 83| 0| << __LINE__ << _T("."); \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 84| 0| throw ParserError( ecINTERNAL_ERROR, -1, ss.str()); \ | | 85| 0| } ------------------ 262| 2.03M| MUP_ASSERT(a_iType != cmFUNC); ------------------ | | 78| 2.03M| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 2.03M] | | ------------------ | | 79| 2.03M| { \ | | 80| 0| stringstream_type ss; \ | | 81| 0| ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 82| 0| << __FILE__ << _T(" line ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 83| 0| << __LINE__ << _T("."); \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 84| 0| throw ParserError( ecINTERNAL_ERROR, -1, ss.str()); \ | | 85| 0| } ------------------ 263| | 264| 2.03M| m_iCode = a_iType; 265| 2.03M| m_iType = tpVOID; 266| 2.03M| m_pTok = 0; 267| 2.03M| m_strTok = a_strTok; 268| 2.03M| m_iIdx = -1; 269| | 270| 2.03M| return *this; 271| 2.03M| } _ZN2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE3SetERKNS_14ParserCallbackERKS7_: 276| 93.7k| { 277| 93.7k| MUP_ASSERT(a_pCallback.IsValid()); ------------------ | | 78| 93.7k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 93.7k] | | ------------------ | | 79| 93.7k| { \ | | 80| 0| stringstream_type ss; \ | | 81| 0| ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 82| 0| << __FILE__ << _T(" line ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 83| 0| << __LINE__ << _T("."); \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 84| 0| throw ParserError( ecINTERNAL_ERROR, -1, ss.str()); \ | | 85| 0| } ------------------ 278| | 279| 93.7k| m_iCode = a_pCallback.GetCode(); 280| 93.7k| m_iType = tpVOID; 281| 93.7k| m_strTok = a_sTok; 282| 93.7k| m_pCallback.reset(new ParserCallback(a_pCallback)); 283| | 284| 93.7k| m_pTok = 0; 285| 93.7k| m_iIdx = -1; 286| | 287| 93.7k| return *this; 288| 93.7k| } _ZN2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE9SetStringERKS7_m: 334| 24.1k| { 335| 24.1k| m_iCode = cmSTRING; 336| 24.1k| m_iType = tpSTR; 337| 24.1k| m_strTok = a_strTok; 338| 24.1k| m_iIdx = static_cast(a_iSize); 339| | 340| 24.1k| m_pTok = 0; 341| 24.1k| m_pCallback.reset(0); 342| 24.1k| return *this; 343| 24.1k| } _ZN2mu6Parser5IsValEPKcPiPd: 56| 781k| { 57| 781k| value_type fVal(0); 58| | 59| 781k| stringstream_type stream(a_szExpr); 60| 781k| stream.seekg(0); // todo: check if this really is necessary 61| 781k| stream.imbue(Parser::s_locale); 62| 781k| stream >> fVal; 63| 781k| stringstream_type::pos_type iEnd = stream.tellg(); // Position after reading 64| | 65| 781k| if (iEnd == (stringstream_type::pos_type) - 1) ------------------ | Branch (65:7): [True: 24.8k, False: 756k] ------------------ 66| 24.8k| return 0; 67| | 68| 756k| *a_iPos += (int)iEnd; 69| 756k| *a_fVal = fVal; 70| 756k| return 1; 71| 781k| } _ZN2mu6ParserC2Ev: 81| 3.99k| { 82| 3.99k| AddValIdent(IsVal); 83| | 84| 3.99k| InitCharSets(); 85| 3.99k| InitFun(); 86| 3.99k| InitConst(); 87| 3.99k| InitOprt(); 88| 3.99k| } _ZN2mu6Parser12InitCharSetsEv: 98| 3.99k| { 99| 3.99k| DefineNameChars(_T("0123456789_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 100| 3.99k| DefineOprtChars(_T("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+-*^/?<>=#!$%&|~'_{}")); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 101| 3.99k| DefineInfixOprtChars(_T("/+-*^?<>=#!$%&|~'_")); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 102| 3.99k| } _ZN2mu6Parser7InitFunEv: 107| 3.99k| { 108| 3.99k| if (mu::TypeInfo::IsInteger()) ------------------ | Branch (108:7): [True: 0, False: 3.99k] ------------------ 109| 0| { 110| | // When setting MUP_BASETYPE to an integer type 111| | // Place functions for dealing with integer values here 112| | // ... 113| | // ... 114| | // ... 115| 0| } 116| 3.99k| else 117| 3.99k| { 118| | // trigonometric functions 119| 3.99k| DefineFun(_T("sin"), MathImpl::Sin); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 120| 3.99k| DefineFun(_T("cos"), MathImpl::Cos); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 121| 3.99k| DefineFun(_T("tan"), MathImpl::Tan); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 122| | // arcus functions 123| 3.99k| DefineFun(_T("asin"), MathImpl::ASin); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 124| 3.99k| DefineFun(_T("acos"), MathImpl::ACos); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 125| 3.99k| DefineFun(_T("atan"), MathImpl::ATan); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 126| 3.99k| DefineFun(_T("atan2"), MathImpl::ATan2); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 127| | // hyperbolic functions 128| 3.99k| DefineFun(_T("sinh"), MathImpl::Sinh); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 129| 3.99k| DefineFun(_T("cosh"), MathImpl::Cosh); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 130| 3.99k| DefineFun(_T("tanh"), MathImpl::Tanh); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 131| | // arcus hyperbolic functions 132| 3.99k| DefineFun(_T("asinh"), MathImpl::ASinh); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 133| 3.99k| DefineFun(_T("acosh"), MathImpl::ACosh); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 134| 3.99k| DefineFun(_T("atanh"), MathImpl::ATanh); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 135| | // Logarithm functions 136| 3.99k| DefineFun(_T("log2"), MathImpl::Log2); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 137| 3.99k| DefineFun(_T("log10"), MathImpl::Log10); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 138| 3.99k| DefineFun(_T("log"), MathImpl::Log); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 139| 3.99k| DefineFun(_T("ln"), MathImpl::Log); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 140| | // misc 141| 3.99k| DefineFun(_T("exp"), MathImpl::Exp); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 142| 3.99k| DefineFun(_T("sqrt"), MathImpl::Sqrt); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 143| 3.99k| DefineFun(_T("sign"), MathImpl::Sign); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 144| 3.99k| DefineFun(_T("rint"), MathImpl::Rint); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 145| 3.99k| DefineFun(_T("abs"), MathImpl::Abs); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 146| | // Functions with variable number of arguments 147| 3.99k| DefineFun(_T("sum"), MathImpl::Sum); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 148| 3.99k| DefineFun(_T("avg"), MathImpl::Avg); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 149| 3.99k| DefineFun(_T("min"), MathImpl::Min); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 150| 3.99k| DefineFun(_T("max"), MathImpl::Max); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 151| 3.99k| } 152| 3.99k| } _ZN2mu6Parser9InitConstEv: 161| 3.99k| { 162| 3.99k| DefineConst(_T("_pi"), MathImpl::CONST_PI); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 163| 3.99k| DefineConst(_T("_e"), MathImpl::CONST_E); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 164| 3.99k| } _ZN2mu6Parser8InitOprtEv: 172| 3.99k| { 173| 3.99k| DefineInfixOprt(_T("-"), MathImpl::UnaryMinus); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 174| 3.99k| DefineInfixOprt(_T("+"), MathImpl::UnaryPlus); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 175| 3.99k| } _ZN2mu10ParserBaseC2Ev: 108| 3.99k| { 109| 3.99k| InitTokenReader(); 110| 3.99k| } _ZN2mu10ParserBaseD2Ev: 141| 3.99k| {} _ZN2mu10ParserBase15InitTokenReaderEv: 246| 3.99k| { 247| 3.99k| m_pTokenReader.reset(new token_reader_type(this)); 248| 3.99k| } _ZNK2mu10ParserBase6ReInitEv: 257| 127k| { 258| 127k| m_pParseFormula = &ParserBase::ParseString; 259| 127k| m_vStringBuf.clear(); 260| 127k| m_vRPN.clear(); 261| 127k| m_pTokenReader->ReInit(); 262| 127k| } _ZN2mu10ParserBase11AddValIdentEPFiPKcPiPdE: 329| 3.99k| { 330| 3.99k| m_pTokenReader->AddValIdent(a_pCallback); 331| 3.99k| } _ZN2mu10ParserBase11AddCallbackERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS_14ParserCallbackERNS1_3mapIS7_SA_NS1_4lessIS7_EENS5_INS1_4pairIS8_SA_EEEEEEPKc: 350| 111k| { 351| 111k| if (!a_Callback.IsValid()) ------------------ | Branch (351:7): [True: 0, False: 111k] ------------------ 352| 0| Error(ecINVALID_FUN_PTR); 353| | 354| 111k| const funmap_type* pFunMap = &a_Storage; 355| | 356| | // Check for conflicting operator or function names 357| 111k| if (pFunMap != &m_FunDef && m_FunDef.find(a_strName) != m_FunDef.end()) ------------------ | Branch (357:7): [True: 7.98k, False: 103k] | Branch (357:7): [True: 0, False: 111k] | Branch (357:31): [True: 0, False: 7.98k] ------------------ 358| 0| Error(ecNAME_CONFLICT, -1, a_strName); 359| | 360| 111k| if (pFunMap != &m_PostOprtDef && m_PostOprtDef.find(a_strName) != m_PostOprtDef.end()) ------------------ | Branch (360:7): [True: 111k, False: 0] | Branch (360:7): [True: 0, False: 111k] | Branch (360:36): [True: 0, False: 111k] ------------------ 361| 0| Error(ecNAME_CONFLICT, -1, a_strName); 362| | 363| 111k| if (pFunMap != &m_InfixOprtDef && pFunMap != &m_OprtDef && m_InfixOprtDef.find(a_strName) != m_InfixOprtDef.end()) ------------------ | Branch (363:7): [True: 103k, False: 7.98k] | Branch (363:7): [True: 0, False: 111k] | Branch (363:37): [True: 103k, False: 0] | Branch (363:62): [True: 0, False: 103k] ------------------ 364| 0| Error(ecNAME_CONFLICT, -1, a_strName); 365| | 366| 111k| if (pFunMap != &m_InfixOprtDef && pFunMap != &m_OprtDef && m_OprtDef.find(a_strName) != m_OprtDef.end()) ------------------ | Branch (366:7): [True: 103k, False: 7.98k] | Branch (366:7): [True: 0, False: 111k] | Branch (366:37): [True: 103k, False: 0] | Branch (366:62): [True: 0, False: 103k] ------------------ 367| 0| Error(ecNAME_CONFLICT, -1, a_strName); 368| | 369| 111k| CheckOprt(a_strName, a_Callback, a_szCharSet); 370| 111k| a_Storage[a_strName] = a_Callback; 371| 111k| ReInit(); 372| 111k| } _ZNK2mu10ParserBase9CheckOprtERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS_14ParserCallbackES9_: 382| 111k| { 383| 111k| if (!a_sName.length() || ------------------ | Branch (383:7): [True: 0, False: 111k] ------------------ 384| 111k| (a_sName.find_first_not_of(a_szCharSet) != string_type::npos) || ------------------ | Branch (384:4): [True: 0, False: 111k] ------------------ 385| 111k| (a_sName[0] >= '0' && a_sName[0] <= '9')) ------------------ | Branch (385:5): [True: 103k, False: 7.98k] | Branch (385:26): [True: 0, False: 103k] ------------------ 386| 0| { 387| 0| switch (a_Callback.GetCode()) 388| 0| { 389| 0| case cmOPRT_POSTFIX: Error(ecINVALID_POSTFIX_IDENT, -1, a_sName); break; ------------------ | Branch (389:4): [True: 0, False: 0] ------------------ 390| 0| case cmOPRT_INFIX: Error(ecINVALID_INFIX_IDENT, -1, a_sName); break; ------------------ | Branch (390:4): [True: 0, False: 0] ------------------ 391| 0| default: Error(ecINVALID_NAME, -1, a_sName); ------------------ | Branch (391:4): [True: 0, False: 0] ------------------ 392| 0| } 393| 0| } 394| 111k| } _ZNK2mu10ParserBase9CheckNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_: 401| 7.98k| { 402| 7.98k| if (!a_sName.length() || ------------------ | Branch (402:7): [True: 0, False: 7.98k] ------------------ 403| 7.98k| (a_sName.find_first_not_of(a_szCharSet) != string_type::npos) || ------------------ | Branch (403:4): [True: 0, False: 7.98k] ------------------ 404| 7.98k| (a_sName[0] >= '0' && a_sName[0] <= '9')) ------------------ | Branch (404:5): [True: 7.98k, False: 0] | Branch (404:26): [True: 0, False: 7.98k] ------------------ 405| 0| { 406| 0| Error(ecINVALID_NAME); 407| 0| } 408| 7.98k| } _ZN2mu10ParserBase7SetExprERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 418| 3.99k| { 419| | // Check locale compatibility 420| 3.99k| if (m_pTokenReader->GetArgSep() == std::use_facet >(s_locale).decimal_point()) ------------------ | Branch (420:7): [True: 0, False: 3.99k] ------------------ 421| 0| Error(ecLOCALE); 422| | 423| | // Check maximum allowed expression length. An arbitrary value small enough so i can debug expressions sent to me 424| 3.99k| if (a_sExpr.length() >= MaxLenExpression) ------------------ | Branch (424:7): [True: 29, False: 3.96k] ------------------ 425| 29| Error(ecEXPRESSION_TOO_LONG, 0, a_sExpr); 426| | 427| 3.99k| m_pTokenReader->SetFormula(a_sExpr + _T(" ")); ------------------ | | 69| 3.99k| #define _T(x) x ------------------ 428| 3.99k| ReInit(); 429| 3.99k| } _ZNK2mu10ParserBase10GetOprtDefEv: 436| 3.42M| { 437| 3.42M| return (const char_type**)(&c_DefaultOprt[0]); 438| 3.42M| } _ZN2mu10ParserBase15DefineNameCharsEPKc: 445| 3.99k| { 446| 3.99k| m_sNameChars = a_szCharset; 447| 3.99k| } _ZN2mu10ParserBase15DefineOprtCharsEPKc: 454| 3.99k| { 455| 3.99k| m_sOprtChars = a_szCharset; 456| 3.99k| } _ZN2mu10ParserBase20DefineInfixOprtCharsEPKc: 463| 3.99k| { 464| 3.99k| m_sInfixOprtChars = a_szCharset; 465| 3.99k| } _ZNK2mu10ParserBase14ValidNameCharsEv: 472| 3.80M| { 473| 3.80M| MUP_ASSERT(m_sNameChars.size()); ------------------ | | 78| 3.80M| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 3.80M] | | ------------------ | | 79| 3.80M| { \ | | 80| 0| stringstream_type ss; \ | | 81| 0| ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 82| 0| << __FILE__ << _T(" line ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 83| 0| << __LINE__ << _T("."); \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 84| 0| throw ParserError( ecINTERNAL_ERROR, -1, ss.str()); \ | | 85| 0| } ------------------ 474| 3.80M| return m_sNameChars.c_str(); 475| 3.80M| } _ZNK2mu10ParserBase14ValidOprtCharsEv: 482| 2.90M| { 483| 2.90M| MUP_ASSERT(m_sOprtChars.size()); ------------------ | | 78| 2.90M| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 2.90M] | | ------------------ | | 79| 2.90M| { \ | | 80| 0| stringstream_type ss; \ | | 81| 0| ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 82| 0| << __FILE__ << _T(" line ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 83| 0| << __LINE__ << _T("."); \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 84| 0| throw ParserError( ecINTERNAL_ERROR, -1, ss.str()); \ | | 85| 0| } ------------------ 484| 2.90M| return m_sOprtChars.c_str(); 485| 2.90M| } _ZNK2mu10ParserBase19ValidInfixOprtCharsEv: 492| 92.7k| { 493| 92.7k| MUP_ASSERT(m_sInfixOprtChars.size()); ------------------ | | 78| 92.7k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 92.7k] | | ------------------ | | 79| 92.7k| { \ | | 80| 0| stringstream_type ss; \ | | 81| 0| ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 82| 0| << __FILE__ << _T(" line ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 83| 0| << __LINE__ << _T("."); \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 84| 0| throw ParserError( ecINTERNAL_ERROR, -1, ss.str()); \ | | 85| 0| } ------------------ 494| 92.7k| return m_sInfixOprtChars.c_str(); 495| 92.7k| } _ZN2mu10ParserBase15DefineInfixOprtERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPFddEib: 532| 7.98k| { 533| 7.98k| if (a_sName.length() > MaxLenIdentifier) ------------------ | Branch (533:7): [True: 0, False: 7.98k] ------------------ 534| 0| Error(ecIDENTIFIER_TOO_LONG); 535| | 536| 7.98k| AddCallback(a_sName, ParserCallback(a_pFun, a_bAllowOpt, a_iPrec, cmOPRT_INFIX), m_InfixOprtDef, ValidInfixOprtChars()); 537| 7.98k| } _ZN2mu10ParserBase11DefineConstERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEd: 618| 7.98k| { 619| 7.98k| if (a_sName.length() > MaxLenIdentifier) ------------------ | Branch (619:7): [True: 0, False: 7.98k] ------------------ 620| 0| Error(ecIDENTIFIER_TOO_LONG); 621| | 622| 7.98k| CheckName(a_sName, ValidNameChars()); 623| 7.98k| m_ConstDef[a_sName] = a_fVal; 624| 7.98k| ReInit(); 625| 7.98k| } _ZNK2mu10ParserBase17GetOprtPrecedenceERKNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE: 632| 560k| { 633| 560k| switch (a_Tok.GetCode()) 634| 560k| { 635| | // built in operators 636| 0| case cmEND: return -5; ------------------ | Branch (636:3): [True: 0, False: 560k] ------------------ 637| 0| case cmARG_SEP: return -4; ------------------ | Branch (637:3): [True: 0, False: 560k] ------------------ 638| 0| case cmASSIGN: return -1; ------------------ | Branch (638:3): [True: 0, False: 560k] ------------------ 639| 0| case cmELSE: ------------------ | Branch (639:3): [True: 0, False: 560k] ------------------ 640| 64.6k| case cmIF: return 0; ------------------ | Branch (640:3): [True: 64.6k, False: 496k] ------------------ 641| 3.21k| case cmLAND: return prLAND; ------------------ | Branch (641:3): [True: 3.21k, False: 557k] ------------------ 642| 3.41k| case cmLOR: return prLOR; ------------------ | Branch (642:3): [True: 3.41k, False: 557k] ------------------ 643| 3.38k| case cmLT: ------------------ | Branch (643:3): [True: 3.38k, False: 557k] ------------------ 644| 7.07k| case cmGT: ------------------ | Branch (644:3): [True: 3.68k, False: 557k] ------------------ 645| 9.11k| case cmLE: ------------------ | Branch (645:3): [True: 2.03k, False: 558k] ------------------ 646| 10.9k| case cmGE: ------------------ | Branch (646:3): [True: 1.79k, False: 559k] ------------------ 647| 12.8k| case cmNEQ: ------------------ | Branch (647:3): [True: 1.92k, False: 559k] ------------------ 648| 14.5k| case cmEQ: return prCMP; ------------------ | Branch (648:3): [True: 1.70k, False: 559k] ------------------ 649| 3.88k| case cmADD: ------------------ | Branch (649:3): [True: 3.88k, False: 557k] ------------------ 650| 61.7k| case cmSUB: return prADD_SUB; ------------------ | Branch (650:3): [True: 57.8k, False: 503k] ------------------ 651| 5.50k| case cmMUL: ------------------ | Branch (651:3): [True: 5.50k, False: 555k] ------------------ 652| 9.16k| case cmDIV: return prMUL_DIV; ------------------ | Branch (652:3): [True: 3.65k, False: 557k] ------------------ 653| 338k| case cmPOW: return prPOW; ------------------ | Branch (653:3): [True: 338k, False: 222k] ------------------ 654| | 655| | // user defined binary operators 656| 65.8k| case cmOPRT_INFIX: ------------------ | Branch (656:3): [True: 65.8k, False: 495k] ------------------ 657| 65.8k| case cmOPRT_BIN: return a_Tok.GetPri(); ------------------ | Branch (657:3): [True: 0, False: 560k] ------------------ 658| 0| default: ------------------ | Branch (658:3): [True: 0, False: 560k] ------------------ 659| 0| throw exception_type(ecINTERNAL_ERROR, 5, _T("")); ------------------ | | 69| 0| #define _T(x) x ------------------ 660| 560k| } 661| 560k| } _ZNK2mu10ParserBase20GetOprtAssociativityERKNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE: 668| 157k| { 669| 157k| switch (a_Tok.GetCode()) 670| 157k| { 671| 0| case cmASSIGN: ------------------ | Branch (671:3): [True: 0, False: 157k] ------------------ 672| 1.43k| case cmLAND: ------------------ | Branch (672:3): [True: 1.43k, False: 156k] ------------------ 673| 2.76k| case cmLOR: ------------------ | Branch (673:3): [True: 1.33k, False: 156k] ------------------ 674| 4.12k| case cmLT: ------------------ | Branch (674:3): [True: 1.35k, False: 156k] ------------------ 675| 5.70k| case cmGT: ------------------ | Branch (675:3): [True: 1.57k, False: 155k] ------------------ 676| 6.67k| case cmLE: ------------------ | Branch (676:3): [True: 970, False: 156k] ------------------ 677| 7.52k| case cmGE: ------------------ | Branch (677:3): [True: 859, False: 156k] ------------------ 678| 8.43k| case cmNEQ: ------------------ | Branch (678:3): [True: 907, False: 156k] ------------------ 679| 9.17k| case cmEQ: ------------------ | Branch (679:3): [True: 736, False: 156k] ------------------ 680| 10.2k| case cmADD: ------------------ | Branch (680:3): [True: 1.11k, False: 156k] ------------------ 681| 12.4k| case cmSUB: ------------------ | Branch (681:3): [True: 2.12k, False: 155k] ------------------ 682| 14.3k| case cmMUL: ------------------ | Branch (682:3): [True: 1.98k, False: 155k] ------------------ 683| 15.8k| case cmDIV: return oaLEFT; ------------------ | Branch (683:3): [True: 1.41k, False: 156k] ------------------ 684| 141k| case cmPOW: return oaRIGHT; ------------------ | Branch (684:3): [True: 141k, False: 15.8k] ------------------ 685| 0| case cmOPRT_BIN: return a_Tok.GetAssociativity(); ------------------ | Branch (685:3): [True: 0, False: 157k] ------------------ 686| 0| default: return oaNONE; ------------------ | Branch (686:3): [True: 0, False: 157k] ------------------ 687| 157k| } 688| 157k| } _ZNK2mu10ParserBase9ApplyFuncERNSt3__15stackINS_11ParserTokenIdNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_5dequeISA_NS7_ISA_EEEEEESF_i: 801| 75.2k| { 802| 75.2k| MUP_ASSERT(m_pTokenReader.get()); ------------------ | | 78| 75.2k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 75.2k] | | ------------------ | | 79| 75.2k| { \ | | 80| 0| stringstream_type ss; \ | | 81| 0| ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 82| 0| << __FILE__ << _T(" line ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 83| 0| << __LINE__ << _T("."); \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 84| 0| throw ParserError( ecINTERNAL_ERROR, -1, ss.str()); \ | | 85| 0| } ------------------ 803| | 804| | // Operator stack empty or does not contain tokens with callback functions 805| 75.2k| if (a_stOpt.empty() || a_stOpt.top().GetFuncAddr() == 0) ------------------ | Branch (805:7): [True: 0, False: 75.2k] | Branch (805:7): [True: 0, False: 75.2k] | Branch (805:26): [True: 0, False: 75.2k] ------------------ 806| 0| return; 807| | 808| 75.2k| token_type funTok = a_stOpt.top(); 809| 75.2k| a_stOpt.pop(); 810| 75.2k| MUP_ASSERT(funTok.GetFuncAddr() != nullptr); ------------------ | | 78| 75.2k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 75.2k] | | ------------------ | | 79| 75.2k| { \ | | 80| 0| stringstream_type ss; \ | | 81| 0| ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 82| 0| << __FILE__ << _T(" line ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 83| 0| << __LINE__ << _T("."); \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 84| 0| throw ParserError( ecINTERNAL_ERROR, -1, ss.str()); \ | | 85| 0| } ------------------ 811| | 812| | // Binary operators must rely on their internal operator number 813| | // since counting of operators relies on commas for function arguments 814| | // binary operators do not have commas in their expression 815| 75.2k| int iArgCount = (funTok.GetCode() == cmOPRT_BIN) ? funTok.GetArgCount() : a_iArgCount; ------------------ | Branch (815:19): [True: 0, False: 75.2k] ------------------ 816| | 817| | // determine how many parameters the function needs. To remember iArgCount includes the 818| | // string parameter whilst GetArgCount() counts only numeric parameters. 819| 75.2k| int iArgRequired = funTok.GetArgCount() + ((funTok.GetType() == tpSTR) ? 1 : 0); ------------------ | Branch (819:46): [True: 0, False: 75.2k] ------------------ 820| | 821| | // That's the number of numerical parameters 822| 75.2k| int iArgNumerical = iArgCount - ((funTok.GetType() == tpSTR) ? 1 : 0); ------------------ | Branch (822:36): [True: 0, False: 75.2k] ------------------ 823| | 824| 75.2k| if (funTok.GetCode() == cmFUNC_STR && iArgCount - iArgNumerical > 1) ------------------ | Branch (824:7): [True: 0, False: 75.2k] | Branch (824:41): [True: 0, False: 0] ------------------ 825| 0| Error(ecINTERNAL_ERROR); 826| | 827| 75.2k| if (funTok.GetArgCount() >= 0 && iArgCount > iArgRequired) ------------------ | Branch (827:7): [True: 71.6k, False: 3.57k] | Branch (827:36): [True: 7, False: 71.6k] ------------------ 828| 7| Error(ecTOO_MANY_PARAMS, m_pTokenReader->GetPos() - 1, funTok.GetAsString()); 829| | 830| 75.2k| if (funTok.GetCode() != cmOPRT_BIN && iArgCount < iArgRequired) ------------------ | Branch (830:7): [True: 75.2k, False: 7] | Branch (830:41): [True: 2, False: 75.2k] ------------------ 831| 2| Error(ecTOO_FEW_PARAMS, m_pTokenReader->GetPos() - 1, funTok.GetAsString()); 832| | 833| 75.2k| if (funTok.GetCode() == cmFUNC_STR && iArgCount > iArgRequired) ------------------ | Branch (833:7): [True: 0, False: 75.2k] | Branch (833:41): [True: 0, False: 0] ------------------ 834| 0| Error(ecTOO_MANY_PARAMS, m_pTokenReader->GetPos() - 1, funTok.GetAsString()); 835| | 836| | // Collect the numeric function arguments from the value stack and store them 837| | // in a vector 838| 75.2k| std::vector stArg; 839| 352k| for (int i = 0; i < iArgNumerical; ++i) ------------------ | Branch (839:19): [True: 277k, False: 75.2k] ------------------ 840| 277k| { 841| 277k| if (a_stVal.empty()) ------------------ | Branch (841:8): [True: 50, False: 277k] ------------------ 842| 50| Error(ecINTERNAL_ERROR, m_pTokenReader->GetPos(), funTok.GetAsString()); 843| | 844| 277k| stArg.push_back(a_stVal.top()); 845| 277k| a_stVal.pop(); 846| | 847| 277k| if (stArg.back().GetType() == tpSTR && funTok.GetType() != tpSTR) ------------------ | Branch (847:8): [True: 5, False: 277k] | Branch (847:43): [True: 5, False: 0] ------------------ 848| 5| Error(ecVAL_EXPECTED, m_pTokenReader->GetPos(), funTok.GetAsString()); 849| 277k| } 850| | 851| 75.2k| switch (funTok.GetCode()) 852| 75.2k| { 853| 0| case cmFUNC_STR: ------------------ | Branch (853:3): [True: 0, False: 75.2k] ------------------ 854| 0| if (a_stVal.empty()) ------------------ | Branch (854:8): [True: 0, False: 0] ------------------ 855| 0| Error(ecINTERNAL_ERROR, m_pTokenReader->GetPos(), funTok.GetAsString()); 856| | 857| 0| stArg.push_back(a_stVal.top()); 858| 0| a_stVal.pop(); 859| | 860| 0| if (stArg.back().GetType() == tpSTR && funTok.GetType() != tpSTR) ------------------ | Branch (860:8): [True: 0, False: 0] | Branch (860:43): [True: 0, False: 0] ------------------ 861| 0| Error(ecVAL_EXPECTED, m_pTokenReader->GetPos(), funTok.GetAsString()); 862| | 863| 0| ApplyStrFunc(funTok, stArg); 864| 0| break; 865| | 866| 0| case cmFUNC_BULK: ------------------ | Branch (866:3): [True: 0, False: 75.2k] ------------------ 867| 0| m_vRPN.AddBulkFun(funTok.GetFuncAddr(), (int)stArg.size()); 868| 0| break; 869| | 870| 0| case cmOPRT_BIN: ------------------ | Branch (870:3): [True: 0, False: 75.2k] ------------------ 871| 0| case cmOPRT_POSTFIX: ------------------ | Branch (871:3): [True: 0, False: 75.2k] ------------------ 872| 66.7k| case cmOPRT_INFIX: ------------------ | Branch (872:3): [True: 66.7k, False: 8.47k] ------------------ 873| 75.1k| case cmFUNC: ------------------ | Branch (873:3): [True: 8.41k, False: 66.8k] ------------------ 874| 75.1k| if (funTok.GetArgCount() == -1 && iArgCount == 0) ------------------ | Branch (874:8): [True: 3.57k, False: 71.5k] | Branch (874:38): [True: 1, False: 3.57k] ------------------ 875| 1| Error(ecTOO_FEW_PARAMS, m_pTokenReader->GetPos(), funTok.GetAsString()); 876| | 877| 75.1k| m_vRPN.AddFun(funTok.GetFuncAddr(), (funTok.GetArgCount() == -1) ? -iArgNumerical : iArgNumerical, funTok.IsOptimizable()); ------------------ | Branch (877:40): [True: 3.57k, False: 71.5k] ------------------ 878| 75.1k| break; 879| 0| default: ------------------ | Branch (879:3): [True: 0, False: 75.2k] ------------------ 880| 0| break; 881| 75.2k| } 882| | 883| | // Push dummy value representing the function result to the stack 884| 75.1k| token_type token; 885| 75.1k| token.SetVal(1); 886| 75.1k| a_stVal.push(token); 887| 75.1k| } _ZNK2mu10ParserBase11ApplyIfElseERNSt3__15stackINS_11ParserTokenIdNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_5dequeISA_NS7_ISA_EEEEEESF_: 891| 28.8k| { 892| | // Check if there is an if Else clause to be calculated 893| 107k| while (a_stOpt.size() && a_stOpt.top().GetCode() == cmELSE) ------------------ | Branch (893:10): [True: 106k, False: 384] | Branch (893:28): [True: 78.5k, False: 28.4k] ------------------ 894| 78.5k| { 895| 78.5k| MUP_ASSERT(!a_stOpt.empty()) ------------------ | | 78| 78.5k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 78.5k] | | ------------------ | | 79| 78.5k| { \ | | 80| 0| stringstream_type ss; \ | | 81| 0| ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 82| 0| << __FILE__ << _T(" line ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 83| 0| << __LINE__ << _T("."); \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 84| 0| throw ParserError( ecINTERNAL_ERROR, -1, ss.str()); \ | | 85| 0| } ------------------ 896| 78.5k| token_type opElse = a_stOpt.top(); 897| 78.5k| a_stOpt.pop(); 898| | 899| | // Take the value associated with the else branch from the value stack 900| 78.5k| MUP_ASSERT(!a_stVal.empty()); ------------------ | | 78| 78.5k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 78.5k] | | ------------------ | | 79| 78.5k| { \ | | 80| 0| stringstream_type ss; \ | | 81| 0| ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 82| 0| << __FILE__ << _T(" line ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 83| 0| << __LINE__ << _T("."); \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 84| 0| throw ParserError( ecINTERNAL_ERROR, -1, ss.str()); \ | | 85| 0| } ------------------ 901| 78.5k| token_type vVal2 = a_stVal.top(); 902| 78.5k| if (vVal2.GetType() != tpDBL) ------------------ | Branch (902:8): [True: 3, False: 78.5k] ------------------ 903| 3| Error(ecUNEXPECTED_STR, m_pTokenReader->GetPos()); 904| | 905| 78.5k| a_stVal.pop(); 906| | 907| | // it then else is a ternary operator Pop all three values from the value s 908| | // tack and just return the right value 909| 78.5k| MUP_ASSERT(!a_stVal.empty()); ------------------ | | 78| 78.5k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 13, False: 78.5k] | | ------------------ | | 79| 78.5k| { \ | | 80| 13| stringstream_type ss; \ | | 81| 13| ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 13| #define _T(x) x | | ------------------ | | ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 13| #define _T(x) x | | ------------------ | | 82| 13| << __FILE__ << _T(" line ") \ | | ------------------ | | | | 69| 13| #define _T(x) x | | ------------------ | | 83| 13| << __LINE__ << _T("."); \ | | ------------------ | | | | 69| 13| #define _T(x) x | | ------------------ | | 84| 13| throw ParserError( ecINTERNAL_ERROR, -1, ss.str()); \ | | 85| 13| } ------------------ 910| 78.5k| token_type vVal1 = a_stVal.top(); 911| 78.5k| if (vVal1.GetType() != tpDBL) ------------------ | Branch (911:8): [True: 1, False: 78.5k] ------------------ 912| 1| Error(ecUNEXPECTED_STR, m_pTokenReader->GetPos()); 913| | 914| 78.5k| a_stVal.pop(); 915| | 916| 78.5k| MUP_ASSERT(!a_stVal.empty()); ------------------ | | 78| 78.5k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 26, False: 78.5k] | | ------------------ | | 79| 78.5k| { \ | | 80| 26| stringstream_type ss; \ | | 81| 26| ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 26| #define _T(x) x | | ------------------ | | ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 26| #define _T(x) x | | ------------------ | | 82| 26| << __FILE__ << _T(" line ") \ | | ------------------ | | | | 69| 26| #define _T(x) x | | ------------------ | | 83| 26| << __LINE__ << _T("."); \ | | ------------------ | | | | 69| 26| #define _T(x) x | | ------------------ | | 84| 26| throw ParserError( ecINTERNAL_ERROR, -1, ss.str()); \ | | 85| 26| } ------------------ 917| 78.5k| token_type vExpr = a_stVal.top(); 918| 78.5k| a_stVal.pop(); 919| | 920| 78.5k| a_stVal.push((vExpr.GetVal() != 0) ? vVal1 : vVal2); ------------------ | Branch (920:17): [True: 32.1k, False: 46.3k] ------------------ 921| | 922| 78.5k| token_type opIf = a_stOpt.top(); 923| 78.5k| a_stOpt.pop(); 924| | 925| 78.5k| MUP_ASSERT(opElse.GetCode() == cmELSE); ------------------ | | 78| 78.5k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 78.5k] | | ------------------ | | 79| 78.5k| { \ | | 80| 0| stringstream_type ss; \ | | 81| 0| ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 82| 0| << __FILE__ << _T(" line ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 83| 0| << __LINE__ << _T("."); \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 84| 0| throw ParserError( ecINTERNAL_ERROR, -1, ss.str()); \ | | 85| 0| } ------------------ 926| | 927| 78.5k| if (opIf.GetCode() != cmIF) ------------------ | Branch (927:8): [True: 1, False: 78.5k] ------------------ 928| 1| Error(ecMISPLACED_COLON, m_pTokenReader->GetPos()); 929| | 930| 78.5k| m_vRPN.AddIfElse(cmENDIF); 931| 78.5k| } // while pending if-else-clause found 932| 28.8k| } _ZNK2mu10ParserBase12ApplyBinOprtERNSt3__15stackINS_11ParserTokenIdNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_5dequeISA_NS7_ISA_EEEEEESF_: 939| 140k| { 940| | // is it a user defined binary operator? 941| 140k| if (a_stOpt.top().GetCode() == cmOPRT_BIN) ------------------ | Branch (941:7): [True: 0, False: 140k] ------------------ 942| 0| { 943| 0| ApplyFunc(a_stOpt, a_stVal, 2); 944| 0| } 945| 140k| else 946| 140k| { 947| 140k| if (a_stVal.size() < 2) ------------------ | Branch (947:8): [True: 32, False: 140k] ------------------ 948| 32| Error(ecINTERNAL_ERROR, m_pTokenReader->GetPos(), _T("ApplyBinOprt: not enough values in value stack!")); ------------------ | | 69| 32| #define _T(x) x ------------------ 949| | 950| 140k| token_type valTok1 = a_stVal.top(); 951| 140k| a_stVal.pop(); 952| | 953| 140k| token_type valTok2 = a_stVal.top(); 954| 140k| a_stVal.pop(); 955| | 956| 140k| token_type optTok = a_stOpt.top(); 957| 140k| a_stOpt.pop(); 958| | 959| 140k| token_type resTok; 960| | 961| 140k| if (valTok1.GetType() != valTok2.GetType() || ------------------ | Branch (961:8): [True: 45, False: 140k] ------------------ 962| 140k| (valTok1.GetType() == tpSTR && valTok2.GetType() == tpSTR)) ------------------ | Branch (962:6): [True: 9, False: 140k] | Branch (962:36): [True: 9, False: 0] ------------------ 963| 22| Error(ecOPRT_TYPE_CONFLICT, m_pTokenReader->GetPos(), optTok.GetAsString()); 964| | 965| 140k| if (optTok.GetCode() == cmASSIGN) ------------------ | Branch (965:8): [True: 0, False: 140k] ------------------ 966| 0| { 967| 0| if (valTok2.GetCode() != cmVAR) ------------------ | Branch (967:9): [True: 0, False: 0] ------------------ 968| 0| Error(ecUNEXPECTED_OPERATOR, -1, _T("=")); ------------------ | | 69| 0| #define _T(x) x ------------------ 969| | 970| 0| m_vRPN.AddAssignOp(valTok2.GetVar()); 971| 0| } 972| 140k| else 973| 140k| m_vRPN.AddOp(optTok.GetCode()); 974| | 975| 140k| resTok.SetVal(1); 976| 140k| a_stVal.push(resTok); 977| 140k| } 978| 140k| } _ZNK2mu10ParserBase18ApplyRemainingOprtERNSt3__15stackINS_11ParserTokenIdNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_5dequeISA_NS7_ISA_EEEEEESF_: 986| 501k| { 987| 601k| while (stOpt.size() && ------------------ | Branch (987:10): [True: 552k, False: 49.0k] ------------------ 988| 601k| stOpt.top().GetCode() != cmBO && ------------------ | Branch (988:4): [True: 220k, False: 331k] ------------------ 989| 601k| stOpt.top().GetCode() != cmIF) ------------------ | Branch (989:4): [True: 100k, False: 120k] ------------------ 990| 100k| { 991| 100k| token_type tok = stOpt.top(); 992| 100k| switch (tok.GetCode()) 993| 100k| { 994| 1.91k| case cmOPRT_INFIX: ------------------ | Branch (994:4): [True: 1.91k, False: 98.3k] ------------------ 995| 1.91k| case cmOPRT_BIN: ------------------ | Branch (995:4): [True: 0, False: 100k] ------------------ 996| 2.14k| case cmLE: ------------------ | Branch (996:4): [True: 223, False: 100k] ------------------ 997| 2.35k| case cmGE: ------------------ | Branch (997:4): [True: 216, False: 100k] ------------------ 998| 2.57k| case cmNEQ: ------------------ | Branch (998:4): [True: 216, False: 100k] ------------------ 999| 2.78k| case cmEQ: ------------------ | Branch (999:4): [True: 210, False: 100k] ------------------ 1000| 3.08k| case cmLT: ------------------ | Branch (1000:4): [True: 297, False: 100k] ------------------ 1001| 3.63k| case cmGT: ------------------ | Branch (1001:4): [True: 558, False: 99.7k] ------------------ 1002| 4.08k| case cmADD: ------------------ | Branch (1002:4): [True: 445, False: 99.8k] ------------------ 1003| 4.64k| case cmSUB: ------------------ | Branch (1003:4): [True: 561, False: 99.7k] ------------------ 1004| 5.28k| case cmMUL: ------------------ | Branch (1004:4): [True: 636, False: 99.6k] ------------------ 1005| 5.85k| case cmDIV: ------------------ | Branch (1005:4): [True: 572, False: 99.7k] ------------------ 1006| 70.7k| case cmPOW: ------------------ | Branch (1006:4): [True: 64.9k, False: 35.4k] ------------------ 1007| 71.0k| case cmLAND: ------------------ | Branch (1007:4): [True: 332, False: 99.9k] ------------------ 1008| 71.4k| case cmLOR: ------------------ | Branch (1008:4): [True: 371, False: 99.9k] ------------------ 1009| 71.4k| case cmASSIGN: ------------------ | Branch (1009:4): [True: 0, False: 100k] ------------------ 1010| 71.4k| if (stOpt.top().GetCode() == cmOPRT_INFIX) ------------------ | Branch (1010:9): [True: 1.91k, False: 69.5k] ------------------ 1011| 1.91k| ApplyFunc(stOpt, stVal, 1); 1012| 69.5k| else 1013| 69.5k| ApplyBinOprt(stOpt, stVal); 1014| 71.4k| break; 1015| | 1016| 28.8k| case cmELSE: ------------------ | Branch (1016:4): [True: 28.8k, False: 71.4k] ------------------ 1017| 28.8k| ApplyIfElse(stOpt, stVal); 1018| 28.8k| break; 1019| | 1020| 0| default: ------------------ | Branch (1020:4): [True: 0, False: 100k] ------------------ 1021| 0| Error(ecINTERNAL_ERROR); 1022| 100k| } 1023| 100k| } 1024| 501k| } _ZNK2mu10ParserBase12ParseCmdCodeEv: 1035| 882| { 1036| 882| return ParseCmdCodeBulk(0, 0); 1037| 882| } _ZNK2mu10ParserBase17ParseCmdCodeShortEv: 1040| 632| { 1041| 632| const SToken *const tok = m_vRPN.GetBase(); 1042| 632| value_type buf; 1043| | 1044| 632| switch (tok->Cmd) 1045| 632| { 1046| 632| case cmVAL: ------------------ | Branch (1046:3): [True: 632, False: 0] ------------------ 1047| 632| return tok->Val.data2; 1048| | 1049| 0| case cmVAR: ------------------ | Branch (1049:3): [True: 0, False: 632] ------------------ 1050| 0| return *tok->Val.ptr; 1051| | 1052| 0| case cmVARMUL: ------------------ | Branch (1052:3): [True: 0, False: 632] ------------------ 1053| 0| return *tok->Val.ptr * tok->Val.data + tok->Val.data2; 1054| | 1055| 0| case cmVARPOW2: ------------------ | Branch (1055:3): [True: 0, False: 632] ------------------ 1056| 0| buf = *(tok->Val.ptr); 1057| 0| return buf * buf; 1058| | 1059| 0| case cmVARPOW3: ------------------ | Branch (1059:3): [True: 0, False: 632] ------------------ 1060| 0| buf = *(tok->Val.ptr); 1061| 0| return buf * buf * buf; 1062| | 1063| 0| case cmVARPOW4: ------------------ | Branch (1063:3): [True: 0, False: 632] ------------------ 1064| 0| buf = *(tok->Val.ptr); 1065| 0| return buf * buf * buf * buf; 1066| | 1067| | // numerical function without any argument 1068| 0| case cmFUNC: ------------------ | Branch (1068:3): [True: 0, False: 632] ------------------ 1069| 0| return tok->Fun.cb.call_fun<0>(); 1070| | 1071| | // String function without a numerical argument 1072| 0| case cmFUNC_STR: ------------------ | Branch (1072:3): [True: 0, False: 632] ------------------ 1073| 0| return tok->Fun.cb.call_strfun<1>(m_vStringBuf[0].c_str()); 1074| | 1075| 0| default: ------------------ | Branch (1075:3): [True: 0, False: 632] ------------------ 1076| 0| throw ParserError(ecINTERNAL_ERROR); 1077| 632| } 1078| 632| } _ZNK2mu10ParserBase16ParseCmdCodeBulkEii: 1086| 882| { 1087| 882| assert(nThreadID <= s_MaxNumOpenMPThreads); 1088| | 1089| | // Note: The check for nOffset==0 and nThreadID here is not necessary but 1090| | // brings a minor performance gain when not in bulk mode. 1091| 882| value_type *stack = ((nOffset == 0) && (nThreadID == 0)) ? &m_vStackBuffer[0] : &m_vStackBuffer[nThreadID * (m_vStackBuffer.size() / s_MaxNumOpenMPThreads)]; ------------------ | Branch (1091:24): [True: 882, False: 0] | Branch (1091:42): [True: 882, False: 0] ------------------ 1092| 882| value_type buf; 1093| 882| int sidx(0); 1094| 377k| for (const SToken* pTok = m_vRPN.GetBase(); pTok->Cmd != cmEND; ++pTok) ------------------ | Branch (1094:47): [True: 376k, False: 882] ------------------ 1095| 376k| { 1096| 376k| switch (pTok->Cmd) 1097| 376k| { 1098| | // built in binary operators 1099| 195| case cmLE: --sidx; stack[sidx] = stack[sidx] <= stack[sidx + 1]; continue; ------------------ | Branch (1099:4): [True: 195, False: 376k] ------------------ 1100| 199| case cmGE: --sidx; stack[sidx] = stack[sidx] >= stack[sidx + 1]; continue; ------------------ | Branch (1100:4): [True: 199, False: 376k] ------------------ 1101| 203| case cmNEQ: --sidx; stack[sidx] = stack[sidx] != stack[sidx + 1]; continue; ------------------ | Branch (1101:4): [True: 203, False: 376k] ------------------ 1102| 194| case cmEQ: --sidx; stack[sidx] = stack[sidx] == stack[sidx + 1]; continue; ------------------ | Branch (1102:4): [True: 194, False: 376k] ------------------ 1103| 250| case cmLT: --sidx; stack[sidx] = stack[sidx] < stack[sidx + 1]; continue; ------------------ | Branch (1103:4): [True: 250, False: 376k] ------------------ 1104| 251| case cmGT: --sidx; stack[sidx] = stack[sidx] > stack[sidx + 1]; continue; ------------------ | Branch (1104:4): [True: 251, False: 376k] ------------------ 1105| 392| case cmADD: --sidx; stack[sidx] += stack[1 + sidx]; continue; ------------------ | Branch (1105:4): [True: 392, False: 376k] ------------------ 1106| 445| case cmSUB: --sidx; stack[sidx] -= stack[1 + sidx]; continue; ------------------ | Branch (1106:4): [True: 445, False: 376k] ------------------ 1107| 884| case cmMUL: --sidx; stack[sidx] *= stack[1 + sidx]; continue; ------------------ | Branch (1107:4): [True: 884, False: 375k] ------------------ 1108| 587| case cmDIV: --sidx; ------------------ | Branch (1108:4): [True: 587, False: 375k] ------------------ 1109| 587| stack[sidx] /= stack[1 + sidx]; 1110| 587| continue; 1111| | 1112| 53.5k| case cmPOW: ------------------ | Branch (1112:4): [True: 53.5k, False: 322k] ------------------ 1113| 53.5k| --sidx; stack[sidx] = MathImpl::Pow(stack[sidx], stack[1 + sidx]); 1114| 53.5k| continue; 1115| | 1116| 400| case cmLAND: --sidx; stack[sidx] = stack[sidx] && stack[sidx + 1]; continue; ------------------ | Branch (1116:4): [True: 400, False: 376k] | Branch (1116:40): [True: 205, False: 195] | Branch (1116:55): [True: 201, False: 4] ------------------ 1117| 399| case cmLOR: --sidx; stack[sidx] = stack[sidx] || stack[sidx + 1]; continue; ------------------ | Branch (1117:4): [True: 399, False: 376k] | Branch (1117:40): [True: 197, False: 202] | Branch (1117:55): [True: 6, False: 196] ------------------ 1118| | 1119| 0| case cmASSIGN: ------------------ | Branch (1119:4): [True: 0, False: 376k] ------------------ 1120| | // Bugfix for Bulkmode: 1121| | // for details see: 1122| | // https://groups.google.com/forum/embed/?place=forum/muparser-dev&showsearch=true&showpopout=true&showtabs=false&parenturl=http://muparser.beltoforion.de/mup_forum.html&afterlogin&pli=1#!topic/muparser-dev/szgatgoHTws 1123| 0| --sidx; 1124| 0| stack[sidx] = *(pTok->Oprt.ptr + nOffset) = stack[sidx + 1]; 1125| 0| continue; 1126| | // original code: 1127| | //--sidx; Stack[sidx] = *pTok->Oprt.ptr = Stack[sidx+1]; continue; 1128| | 1129| 3.98k| case cmIF: ------------------ | Branch (1129:4): [True: 3.98k, False: 372k] ------------------ 1130| 3.98k| if (stack[sidx--] == 0) ------------------ | Branch (1130:9): [True: 3.23k, False: 752] ------------------ 1131| 3.23k| { 1132| 3.23k| MUP_ASSERT(sidx >= 0); ------------------ | | 78| 3.23k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 3.23k] | | ------------------ | | 79| 3.23k| { \ | | 80| 0| stringstream_type ss; \ | | 81| 0| ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 82| 0| << __FILE__ << _T(" line ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 83| 0| << __LINE__ << _T("."); \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 84| 0| throw ParserError( ecINTERNAL_ERROR, -1, ss.str()); \ | | 85| 0| } ------------------ 1133| 3.23k| pTok += pTok->Oprt.offset; 1134| 3.23k| } 1135| 3.98k| continue; 1136| | 1137| 3.98k| case cmELSE: ------------------ | Branch (1137:4): [True: 752, False: 375k] ------------------ 1138| 752| pTok += pTok->Oprt.offset; 1139| 752| continue; 1140| | 1141| 3.23k| case cmENDIF: ------------------ | Branch (1141:4): [True: 3.23k, False: 373k] ------------------ 1142| 3.23k| continue; 1143| | 1144| | // value and variable tokens 1145| 0| case cmVAR: stack[++sidx] = *(pTok->Val.ptr + nOffset); continue; ------------------ | Branch (1145:4): [True: 0, False: 376k] ------------------ 1146| 306k| case cmVAL: stack[++sidx] = pTok->Val.data2; continue; ------------------ | Branch (1146:4): [True: 306k, False: 69.8k] ------------------ 1147| | 1148| 0| case cmVARPOW2: buf = *(pTok->Val.ptr + nOffset); ------------------ | Branch (1148:4): [True: 0, False: 376k] ------------------ 1149| 0| stack[++sidx] = buf * buf; 1150| 0| continue; 1151| | 1152| 0| case cmVARPOW3: buf = *(pTok->Val.ptr + nOffset); ------------------ | Branch (1152:4): [True: 0, False: 376k] ------------------ 1153| 0| stack[++sidx] = buf * buf * buf; 1154| 0| continue; 1155| | 1156| 0| case cmVARPOW4: buf = *(pTok->Val.ptr + nOffset); ------------------ | Branch (1156:4): [True: 0, False: 376k] ------------------ 1157| 0| stack[++sidx] = buf * buf * buf * buf; 1158| 0| continue; 1159| | 1160| 0| case cmVARMUL: ------------------ | Branch (1160:4): [True: 0, False: 376k] ------------------ 1161| 0| stack[++sidx] = *(pTok->Val.ptr + nOffset) * pTok->Val.data + pTok->Val.data2; 1162| 0| continue; 1163| | 1164| | // Next is treatment of numeric functions 1165| 3.92k| case cmFUNC: ------------------ | Branch (1165:4): [True: 3.92k, False: 372k] ------------------ 1166| 3.92k| { 1167| 3.92k| int iArgCount = pTok->Fun.argc; 1168| | 1169| | // switch according to argument count 1170| 3.92k| switch (iArgCount) 1171| 3.92k| { 1172| 0| case 0: sidx += 1; stack[sidx] = pTok->Fun.cb.call_fun<0 >(); continue; ------------------ | Branch (1172:5): [True: 0, False: 3.92k] ------------------ 1173| 270| case 1: stack[sidx] = pTok->Fun.cb.call_fun<1 >(stack[sidx]); continue; ------------------ | Branch (1173:5): [True: 270, False: 3.65k] ------------------ 1174| 194| case 2: sidx -= 1; stack[sidx] = pTok->Fun.cb.call_fun<2 >(stack[sidx], stack[sidx + 1]); continue; ------------------ | Branch (1174:5): [True: 194, False: 3.72k] ------------------ 1175| 0| case 3: sidx -= 2; stack[sidx] = pTok->Fun.cb.call_fun<3 >(stack[sidx], stack[sidx + 1], stack[sidx + 2]); continue; ------------------ | Branch (1175:5): [True: 0, False: 3.92k] ------------------ 1176| 0| case 4: sidx -= 3; stack[sidx] = pTok->Fun.cb.call_fun<4 >(stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3]); continue; ------------------ | Branch (1176:5): [True: 0, False: 3.92k] ------------------ 1177| 0| case 5: sidx -= 4; stack[sidx] = pTok->Fun.cb.call_fun<5 >(stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3], stack[sidx + 4]); continue; ------------------ | Branch (1177:5): [True: 0, False: 3.92k] ------------------ 1178| 0| case 6: sidx -= 5; stack[sidx] = pTok->Fun.cb.call_fun<6 >(stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3], stack[sidx + 4], stack[sidx + 5]); continue; ------------------ | Branch (1178:5): [True: 0, False: 3.92k] ------------------ 1179| 0| case 7: sidx -= 6; stack[sidx] = pTok->Fun.cb.call_fun<7 >(stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3], stack[sidx + 4], stack[sidx + 5], stack[sidx + 6]); continue; ------------------ | Branch (1179:5): [True: 0, False: 3.92k] ------------------ 1180| 0| case 8: sidx -= 7; stack[sidx] = pTok->Fun.cb.call_fun<8 >(stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3], stack[sidx + 4], stack[sidx + 5], stack[sidx + 6], stack[sidx + 7]); continue; ------------------ | Branch (1180:5): [True: 0, False: 3.92k] ------------------ 1181| 0| case 9: sidx -= 8; stack[sidx] = pTok->Fun.cb.call_fun<9 >(stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3], stack[sidx + 4], stack[sidx + 5], stack[sidx + 6], stack[sidx + 7], stack[sidx + 8]); continue; ------------------ | Branch (1181:5): [True: 0, False: 3.92k] ------------------ 1182| 0| case 10:sidx -= 9; stack[sidx] = pTok->Fun.cb.call_fun<10>(stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3], stack[sidx + 4], stack[sidx + 5], stack[sidx + 6], stack[sidx + 7], stack[sidx + 8], stack[sidx + 9]); continue; ------------------ | Branch (1182:5): [True: 0, False: 3.92k] ------------------ 1183| 3.45k| default: ------------------ | Branch (1183:5): [True: 3.45k, False: 464] ------------------ 1184| | // function with variable arguments store the number as a negative value 1185| 3.45k| if (iArgCount > 0) ------------------ | Branch (1185:10): [True: 0, False: 3.45k] ------------------ 1186| 0| Error(ecINTERNAL_ERROR, -1); 1187| | 1188| 3.45k| sidx -= -iArgCount - 1; 1189| | 1190| | // From oss-fuzz. Happend when Multiarg functions and if-then-else are used incorrectly. 1191| | // Expressions where this was observed: 1192| | // sum(0?1,2,3,4,5:6) -> fixed 1193| | // avg(0>3?4:(""),0^3?4:("")) 1194| | // 1195| | // The final result normally lieas at position 1. If sixd is smaller there is something wrong. 1196| 3.45k| if (sidx <= 0) ------------------ | Branch (1196:10): [True: 0, False: 3.45k] ------------------ 1197| 0| Error(ecINTERNAL_ERROR, -1); 1198| | // 1199| | 1200| 3.45k| stack[sidx] = pTok->Fun.cb.call_multfun(&stack[sidx], -iArgCount); 1201| 3.45k| continue; 1202| 3.92k| } 1203| 3.92k| } 1204| | 1205| | // Next is treatment of string functions 1206| 0| case cmFUNC_STR: ------------------ | Branch (1206:4): [True: 0, False: 376k] ------------------ 1207| 0| { 1208| 0| sidx -= pTok->Fun.argc - 1; 1209| | 1210| | // The index of the string argument in the string table 1211| 0| int iIdxStack = pTok->Fun.idx; 1212| 0| if (iIdxStack < 0 || iIdxStack >= (int)m_vStringBuf.size()) ------------------ | Branch (1212:9): [True: 0, False: 0] | Branch (1212:26): [True: 0, False: 0] ------------------ 1213| 0| Error(ecINTERNAL_ERROR, m_pTokenReader->GetPos()); 1214| | 1215| 0| switch (pTok->Fun.argc) // switch according to argument count ------------------ | Branch (1215:13): [True: 0, False: 0] ------------------ 1216| 0| { 1217| 0| case 0: stack[sidx] = pTok->Fun.cb.call_strfun<1>(m_vStringBuf[iIdxStack].c_str()); continue; ------------------ | Branch (1217:5): [True: 0, False: 0] ------------------ 1218| 0| case 1: stack[sidx] = pTok->Fun.cb.call_strfun<2>(m_vStringBuf[iIdxStack].c_str(), stack[sidx]); continue; ------------------ | Branch (1218:5): [True: 0, False: 0] ------------------ 1219| 0| case 2: stack[sidx] = pTok->Fun.cb.call_strfun<3>(m_vStringBuf[iIdxStack].c_str(), stack[sidx], stack[sidx + 1]); continue; ------------------ | Branch (1219:5): [True: 0, False: 0] ------------------ 1220| 0| case 3: stack[sidx] = pTok->Fun.cb.call_strfun<4>(m_vStringBuf[iIdxStack].c_str(), stack[sidx], stack[sidx + 1], stack[sidx + 2]); continue; ------------------ | Branch (1220:5): [True: 0, False: 0] ------------------ 1221| 0| case 4: stack[sidx] = pTok->Fun.cb.call_strfun<5>(m_vStringBuf[iIdxStack].c_str(), stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3]); continue; ------------------ | Branch (1221:5): [True: 0, False: 0] ------------------ 1222| 0| case 5: stack[sidx] = pTok->Fun.cb.call_strfun<6>(m_vStringBuf[iIdxStack].c_str(), stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3], stack[sidx + 4]); continue; ------------------ | Branch (1222:5): [True: 0, False: 0] ------------------ 1223| 0| } 1224| | 1225| 0| continue; 1226| 0| } 1227| | 1228| 0| case cmFUNC_BULK: ------------------ | Branch (1228:4): [True: 0, False: 376k] ------------------ 1229| 0| { 1230| 0| int iArgCount = pTok->Fun.argc; 1231| | 1232| | // switch according to argument count 1233| 0| switch (iArgCount) 1234| 0| { 1235| 0| case 0: sidx += 1; stack[sidx] = pTok->Fun.cb.call_bulkfun<0 >(nOffset, nThreadID); continue; ------------------ | Branch (1235:5): [True: 0, False: 0] ------------------ 1236| 0| case 1: stack[sidx] = pTok->Fun.cb.call_bulkfun<1 >(nOffset, nThreadID, stack[sidx]); continue; ------------------ | Branch (1236:5): [True: 0, False: 0] ------------------ 1237| 0| case 2: sidx -= 1; stack[sidx] = pTok->Fun.cb.call_bulkfun<2 >(nOffset, nThreadID, stack[sidx], stack[sidx + 1]); continue; ------------------ | Branch (1237:5): [True: 0, False: 0] ------------------ 1238| 0| case 3: sidx -= 2; stack[sidx] = pTok->Fun.cb.call_bulkfun<3 >(nOffset, nThreadID, stack[sidx], stack[sidx + 1], stack[sidx + 2]); continue; ------------------ | Branch (1238:5): [True: 0, False: 0] ------------------ 1239| 0| case 4: sidx -= 3; stack[sidx] = pTok->Fun.cb.call_bulkfun<4 >(nOffset, nThreadID, stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3]); continue; ------------------ | Branch (1239:5): [True: 0, False: 0] ------------------ 1240| 0| case 5: sidx -= 4; stack[sidx] = pTok->Fun.cb.call_bulkfun<5 >(nOffset, nThreadID, stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3], stack[sidx + 4]); continue; ------------------ | Branch (1240:5): [True: 0, False: 0] ------------------ 1241| 0| case 6: sidx -= 5; stack[sidx] = pTok->Fun.cb.call_bulkfun<6 >(nOffset, nThreadID, stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3], stack[sidx + 4], stack[sidx + 5]); continue; ------------------ | Branch (1241:5): [True: 0, False: 0] ------------------ 1242| 0| case 7: sidx -= 6; stack[sidx] = pTok->Fun.cb.call_bulkfun<7 >(nOffset, nThreadID, stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3], stack[sidx + 4], stack[sidx + 5], stack[sidx + 6]); continue; ------------------ | Branch (1242:5): [True: 0, False: 0] ------------------ 1243| 0| case 8: sidx -= 7; stack[sidx] = pTok->Fun.cb.call_bulkfun<8 >(nOffset, nThreadID, stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3], stack[sidx + 4], stack[sidx + 5], stack[sidx + 6], stack[sidx + 7]); continue; ------------------ | Branch (1243:5): [True: 0, False: 0] ------------------ 1244| 0| case 9: sidx -= 8; stack[sidx] = pTok->Fun.cb.call_bulkfun<9 >(nOffset, nThreadID, stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3], stack[sidx + 4], stack[sidx + 5], stack[sidx + 6], stack[sidx + 7], stack[sidx + 8]); continue; ------------------ | Branch (1244:5): [True: 0, False: 0] ------------------ 1245| 0| case 10:sidx -= 9; stack[sidx] = pTok->Fun.cb.call_bulkfun<10>(nOffset, nThreadID, stack[sidx], stack[sidx + 1], stack[sidx + 2], stack[sidx + 3], stack[sidx + 4], stack[sidx + 5], stack[sidx + 6], stack[sidx + 7], stack[sidx + 8], stack[sidx + 9]); continue; ------------------ | Branch (1245:5): [True: 0, False: 0] ------------------ 1246| 0| default: ------------------ | Branch (1246:5): [True: 0, False: 0] ------------------ 1247| 0| throw exception_type(ecINTERNAL_ERROR, 2, _T("")); ------------------ | | 69| 0| #define _T(x) x ------------------ 1248| 0| } 1249| 0| } 1250| | 1251| 0| default: ------------------ | Branch (1251:4): [True: 0, False: 376k] ------------------ 1252| 0| throw exception_type(ecINTERNAL_ERROR, 3, _T("")); ------------------ | | 69| 0| #define _T(x) x ------------------ 1253| 376k| } // switch CmdCode 1254| 376k| } // for all bytecode tokens 1255| | 1256| 882| return stack[m_nFinalResultIdx]; 1257| 882| } _ZNK2mu10ParserBase9CreateRPNEv: 1261| 3.96k| { 1262| 3.96k| if (!m_pTokenReader->GetExpr().length()) ------------------ | Branch (1262:7): [True: 0, False: 3.96k] ------------------ 1263| 0| Error(ecUNEXPECTED_EOF, 0); 1264| | 1265| 3.96k| std::stack stOpt, stVal; 1266| 3.96k| std::stack stArgCount; 1267| 3.96k| token_type opta, opt; // for storing operators 1268| 3.96k| token_type val, tval; // for storing value 1269| 3.96k| int ifElseCounter = 0; 1270| | 1271| 3.96k| ReInit(); 1272| | 1273| | // The outermost counter counts the number of separated items 1274| | // such as in "a=10,b=20,c=c+a" 1275| 3.96k| stArgCount.push(1); 1276| | 1277| 3.96k| for (;;) 1278| 2.90M| { 1279| 2.90M| opt = m_pTokenReader->ReadNextToken(); 1280| | 1281| 2.90M| switch (opt.GetCode()) 1282| 2.90M| { 1283| | // 1284| | // Next three are different kind of value entries 1285| | // 1286| 24.1k| case cmSTRING: ------------------ | Branch (1286:4): [True: 24.1k, False: 2.88M] ------------------ 1287| 24.1k| if (stOpt.empty()) ------------------ | Branch (1287:9): [True: 111, False: 24.0k] ------------------ 1288| 111| Error(ecSTR_RESULT, m_pTokenReader->GetPos(), opt.GetAsString()); 1289| | 1290| 24.1k| opt.SetIdx((int)m_vStringBuf.size()); // Assign buffer index to token 1291| 24.1k| stVal.push(opt); 1292| 24.1k| m_vStringBuf.push_back(opt.GetAsString()); // Store string in internal buffer 1293| 24.1k| break; 1294| | 1295| 0| case cmVAR: ------------------ | Branch (1295:4): [True: 0, False: 2.90M] ------------------ 1296| 0| stVal.push(opt); 1297| 0| m_vRPN.AddVar(static_cast(opt.GetVar())); 1298| 0| break; 1299| | 1300| 757k| case cmVAL: ------------------ | Branch (1300:4): [True: 757k, False: 2.15M] ------------------ 1301| 757k| stVal.push(opt); 1302| 757k| m_vRPN.AddVal(opt.GetVal()); 1303| 757k| break; 1304| | 1305| 116k| case cmELSE: ------------------ | Branch (1305:4): [True: 116k, False: 2.79M] ------------------ 1306| 116k| if (stArgCount.empty()) ------------------ | Branch (1306:9): [True: 0, False: 116k] ------------------ 1307| 0| Error(ecMISPLACED_COLON, m_pTokenReader->GetPos()); 1308| | 1309| 116k| if (stArgCount.top() > 1) ------------------ | Branch (1309:9): [True: 15, False: 116k] ------------------ 1310| 15| Error(ecUNEXPECTED_ARG_SEP, m_pTokenReader->GetPos()); 1311| | 1312| 116k| stArgCount.pop(); 1313| | 1314| 116k| ifElseCounter--; 1315| 116k| if (ifElseCounter < 0) ------------------ | Branch (1315:9): [True: 34, False: 116k] ------------------ 1316| 34| Error(ecMISPLACED_COLON, m_pTokenReader->GetPos()); 1317| | 1318| 116k| ApplyRemainingOprt(stOpt, stVal); 1319| 116k| m_vRPN.AddIfElse(cmELSE); 1320| 116k| stOpt.push(opt); 1321| 116k| break; 1322| | 1323| 289k| case cmARG_SEP: ------------------ | Branch (1323:4): [True: 289k, False: 2.61M] ------------------ 1324| 289k| if (!stOpt.empty() && stOpt.top().GetCode() == cmIF) ------------------ | Branch (1324:9): [True: 245k, False: 44.1k] | Branch (1324:27): [True: 2, False: 245k] ------------------ 1325| 2| Error(ecUNEXPECTED_ARG_SEP, m_pTokenReader->GetPos()); 1326| | 1327| 289k| if (stArgCount.empty()) ------------------ | Branch (1327:9): [True: 0, False: 289k] ------------------ 1328| 0| Error(ecUNEXPECTED_ARG_SEP, m_pTokenReader->GetPos()); 1329| | 1330| 289k| ++stArgCount.top(); 1331| | // Falls through. 1332| | // intentional (no break!) 1333| | 1334| 291k| case cmEND: ------------------ | Branch (1334:4): [True: 1.84k, False: 2.90M] ------------------ 1335| 291k| ApplyRemainingOprt(stOpt, stVal); 1336| 291k| break; 1337| | 1338| 93.9k| case cmBC: ------------------ | Branch (1338:4): [True: 93.9k, False: 2.81M] ------------------ 1339| 93.9k| { 1340| | // The argument count for parameterless functions is zero 1341| | // by default an opening bracket sets parameter count to 1 1342| | // in preparation of arguments to come. If the last token 1343| | // was an opening bracket we know better... 1344| 93.9k| if (opta.GetCode() == cmBO) ------------------ | Branch (1344:9): [True: 2, False: 93.9k] ------------------ 1345| 2| --stArgCount.top(); 1346| | 1347| 93.9k| ApplyRemainingOprt(stOpt, stVal); 1348| | 1349| | // Check if the bracket content has been evaluated completely 1350| 93.9k| if (stOpt.size() && stOpt.top().GetCode() == cmBO) ------------------ | Branch (1350:9): [True: 93.9k, False: 1] | Branch (1350:25): [True: 90.0k, False: 3.84k] ------------------ 1351| 90.0k| { 1352| | // if opt is ")" and opta is "(" the bracket has been evaluated, now its time to check 1353| | // if there is either a function or a sign pending 1354| | // neither the opening nor the closing bracket will be pushed back to 1355| | // the operator stack 1356| | // Check if a function is standing in front of the opening bracket, 1357| | // if yes evaluate it afterwards check for infix operators 1358| 90.0k| MUP_ASSERT(stArgCount.size()); ------------------ | | 78| 90.0k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 90.0k] | | ------------------ | | 79| 90.0k| { \ | | 80| 0| stringstream_type ss; \ | | 81| 0| ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 82| 0| << __FILE__ << _T(" line ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 83| 0| << __LINE__ << _T("."); \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 84| 0| throw ParserError( ecINTERNAL_ERROR, -1, ss.str()); \ | | 85| 0| } ------------------ 1359| 90.0k| int iArgCount = stArgCount.top(); 1360| 90.0k| stArgCount.pop(); 1361| | 1362| 90.0k| stOpt.pop(); // Take opening bracket from stack 1363| | 1364| 90.0k| if (iArgCount > 1 && (stOpt.size() == 0 || ------------------ | Branch (1364:10): [True: 2.87k, False: 87.2k] | Branch (1364:28): [True: 8, False: 2.86k] ------------------ 1365| 2.87k| (stOpt.top().GetCode() != cmFUNC && ------------------ | Branch (1365:8): [True: 24, False: 2.84k] ------------------ 1366| 2.86k| stOpt.top().GetCode() != cmFUNC_BULK && ------------------ | Branch (1366:8): [True: 24, False: 0] ------------------ 1367| 2.86k| stOpt.top().GetCode() != cmFUNC_STR))) ------------------ | Branch (1367:8): [True: 24, False: 0] ------------------ 1368| 32| Error(ecUNEXPECTED_ARG, m_pTokenReader->GetPos()); 1369| | 1370| | // The opening bracket was popped from the stack now check if there 1371| | // was a function before this bracket 1372| 90.0k| if (stOpt.size() && ------------------ | Branch (1372:10): [True: 89.7k, False: 314] | Branch (1372:10): [True: 8.42k, False: 81.6k] ------------------ 1373| 90.0k| stOpt.top().GetCode() != cmOPRT_INFIX && ------------------ | Branch (1373:7): [True: 89.3k, False: 445] ------------------ 1374| 90.0k| stOpt.top().GetCode() != cmOPRT_BIN && ------------------ | Branch (1374:7): [True: 89.3k, False: 0] ------------------ 1375| 90.0k| stOpt.top().GetFuncAddr() != 0) ------------------ | Branch (1375:7): [True: 8.42k, False: 80.8k] ------------------ 1376| 8.42k| { 1377| 8.42k| ApplyFunc(stOpt, stVal, iArgCount); 1378| 8.42k| } 1379| 90.0k| } 1380| 93.9k| } // if bracket content is evaluated 1381| 93.9k| break; 1382| | 1383| | // 1384| | // Next are the binary operator entries 1385| | // 1386| 272k| case cmIF: ------------------ | Branch (1386:4): [True: 272k, False: 2.63M] ------------------ 1387| 272k| ifElseCounter++; 1388| 272k| stArgCount.push(1); 1389| | // Falls through. 1390| | // intentional (no break!) 1391| | 1392| 273k| case cmLAND: ------------------ | Branch (1392:4): [True: 1.80k, False: 2.90M] ------------------ 1393| 275k| case cmLOR: ------------------ | Branch (1393:4): [True: 1.76k, False: 2.90M] ------------------ 1394| 277k| case cmLT: ------------------ | Branch (1394:4): [True: 1.74k, False: 2.90M] ------------------ 1395| 279k| case cmGT: ------------------ | Branch (1395:4): [True: 2.35k, False: 2.90M] ------------------ 1396| 280k| case cmLE: ------------------ | Branch (1396:4): [True: 1.22k, False: 2.90M] ------------------ 1397| 282k| case cmGE: ------------------ | Branch (1397:4): [True: 1.10k, False: 2.90M] ------------------ 1398| 283k| case cmNEQ: ------------------ | Branch (1398:4): [True: 1.15k, False: 2.90M] ------------------ 1399| 284k| case cmEQ: ------------------ | Branch (1399:4): [True: 977, False: 2.90M] ------------------ 1400| 285k| case cmADD: ------------------ | Branch (1400:4): [True: 1.77k, False: 2.90M] ------------------ 1401| 288k| case cmSUB: ------------------ | Branch (1401:4): [True: 2.96k, False: 2.90M] ------------------ 1402| 292k| case cmMUL: ------------------ | Branch (1402:4): [True: 3.16k, False: 2.90M] ------------------ 1403| 294k| case cmDIV: ------------------ | Branch (1403:4): [True: 2.38k, False: 2.90M] ------------------ 1404| 437k| case cmPOW: ------------------ | Branch (1404:4): [True: 143k, False: 2.76M] ------------------ 1405| 437k| case cmASSIGN: ------------------ | Branch (1405:4): [True: 0, False: 2.90M] ------------------ 1406| 437k| case cmOPRT_BIN: ------------------ | Branch (1406:4): [True: 0, False: 2.90M] ------------------ 1407| | 1408| | // A binary operator (user defined or built in) has been found. 1409| 437k| while ( 1410| 573k| stOpt.size() && ------------------ | Branch (1410:6): [True: 555k, False: 17.8k] ------------------ 1411| 573k| stOpt.top().GetCode() != cmBO && ------------------ | Branch (1411:6): [True: 552k, False: 2.91k] ------------------ 1412| 573k| stOpt.top().GetCode() != cmELSE && ------------------ | Branch (1412:6): [True: 464k, False: 87.9k] ------------------ 1413| 573k| stOpt.top().GetCode() != cmIF) ------------------ | Branch (1413:6): [True: 280k, False: 183k] ------------------ 1414| 280k| { 1415| 280k| int nPrec1 = GetOprtPrecedence(stOpt.top()), 1416| 280k| nPrec2 = GetOprtPrecedence(opt); 1417| | 1418| 280k| if (stOpt.top().GetCode() == opt.GetCode()) ------------------ | Branch (1418:10): [True: 157k, False: 122k] ------------------ 1419| 157k| { 1420| | 1421| | // Deal with operator associativity 1422| 157k| EOprtAssociativity eOprtAsct = GetOprtAssociativity(opt); 1423| 157k| if ((eOprtAsct == oaRIGHT && (nPrec1 <= nPrec2)) || ------------------ | Branch (1423:12): [True: 141k, False: 15.8k] | Branch (1423:36): [True: 141k, False: 0] ------------------ 1424| 157k| (eOprtAsct == oaLEFT && (nPrec1 < nPrec2))) ------------------ | Branch (1424:9): [True: 15.8k, False: 0] | Branch (1424:32): [True: 0, False: 15.8k] ------------------ 1425| 141k| { 1426| 141k| break; 1427| 141k| } 1428| 157k| } 1429| 122k| else if (nPrec1 < nPrec2) ------------------ | Branch (1429:15): [True: 3.17k, False: 119k] ------------------ 1430| 3.17k| { 1431| | // In case the operators are not equal the precedence decides alone... 1432| 3.17k| break; 1433| 3.17k| } 1434| | 1435| 135k| if (stOpt.top().GetCode() == cmOPRT_INFIX) ------------------ | Branch (1435:10): [True: 64.8k, False: 70.7k] ------------------ 1436| 64.8k| ApplyFunc(stOpt, stVal, 1); 1437| 70.7k| else 1438| 70.7k| ApplyBinOprt(stOpt, stVal); 1439| 135k| } // while ( ... ) 1440| | 1441| 437k| if (opt.GetCode() == cmIF) ------------------ | Branch (1441:9): [True: 271k, False: 165k] ------------------ 1442| 271k| m_vRPN.AddIfElse(opt.GetCode()); 1443| | 1444| | // The operator can't be evaluated right now, push back to the operator stack 1445| 437k| stOpt.push(opt); 1446| 437k| break; 1447| | 1448| | // 1449| | // Last section contains functions and operators implicitly mapped to functions 1450| | // 1451| 1.09M| case cmBO: ------------------ | Branch (1451:4): [True: 1.09M, False: 1.81M] ------------------ 1452| 1.09M| stArgCount.push(1); 1453| 1.09M| stOpt.push(opt); 1454| 1.09M| break; 1455| | 1456| 84.0k| case cmOPRT_INFIX: ------------------ | Branch (1456:4): [True: 84.0k, False: 2.82M] ------------------ 1457| 93.6k| case cmFUNC: ------------------ | Branch (1457:4): [True: 9.61k, False: 2.89M] ------------------ 1458| 93.6k| case cmFUNC_BULK: ------------------ | Branch (1458:4): [True: 0, False: 2.90M] ------------------ 1459| 93.6k| case cmFUNC_STR: ------------------ | Branch (1459:4): [True: 0, False: 2.90M] ------------------ 1460| 93.6k| stOpt.push(opt); 1461| 93.6k| break; 1462| | 1463| 0| case cmOPRT_POSTFIX: ------------------ | Branch (1463:4): [True: 0, False: 2.90M] ------------------ 1464| 0| stOpt.push(opt); 1465| 0| ApplyFunc(stOpt, stVal, 1); // this is the postfix operator 1466| 0| break; 1467| | 1468| 0| default: Error(ecINTERNAL_ERROR, 3); ------------------ | Branch (1468:4): [True: 0, False: 2.90M] ------------------ 1469| 2.90M| } // end of switch operator-token 1470| | 1471| 2.90M| opta = opt; 1472| | 1473| 2.90M| if (opt.GetCode() == cmEND) ------------------ | Branch (1473:8): [True: 1.78k, False: 2.90M] ------------------ 1474| 1.78k| { 1475| 1.78k| m_vRPN.Finalize(); 1476| 1.78k| break; 1477| 1.78k| } 1478| | 1479| 2.90M| if (ParserBase::g_DbgDumpStack) ------------------ | Branch (1479:8): [True: 0, False: 2.90M] ------------------ 1480| 0| { 1481| 0| StackDump(stVal, stOpt); 1482| 0| m_vRPN.AsciiDump(); 1483| 0| } 1484| | 1485| |// if (ParserBase::g_DbgDumpCmdCode) 1486| | //m_vRPN.AsciiDump(); 1487| 2.90M| } // while (true) 1488| | 1489| 1.78k| if (ParserBase::g_DbgDumpCmdCode) ------------------ | Branch (1489:7): [True: 0, False: 1.78k] ------------------ 1490| 0| m_vRPN.AsciiDump(); 1491| | 1492| 1.78k| if (ifElseCounter > 0) ------------------ | Branch (1492:7): [True: 240, False: 1.54k] ------------------ 1493| 240| Error(ecMISSING_ELSE_CLAUSE); 1494| | 1495| | // get the last value (= final result) from the stack 1496| 1.78k| MUP_ASSERT(stArgCount.size() == 1); ------------------ | | 78| 1.78k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 8, False: 1.77k] | | ------------------ | | 79| 1.78k| { \ | | 80| 8| stringstream_type ss; \ | | 81| 8| ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 8| #define _T(x) x | | ------------------ | | ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 8| #define _T(x) x | | ------------------ | | 82| 8| << __FILE__ << _T(" line ") \ | | ------------------ | | | | 69| 8| #define _T(x) x | | ------------------ | | 83| 8| << __LINE__ << _T("."); \ | | ------------------ | | | | 69| 8| #define _T(x) x | | ------------------ | | 84| 8| throw ParserError( ecINTERNAL_ERROR, -1, ss.str()); \ | | 85| 8| } ------------------ 1497| 1.77k| m_nFinalResultIdx = stArgCount.top(); 1498| 1.77k| if (m_nFinalResultIdx == 0) ------------------ | Branch (1498:7): [True: 0, False: 1.77k] ------------------ 1499| 0| Error(ecINTERNAL_ERROR, 9); 1500| | 1501| 1.77k| if (stVal.size() == 0) ------------------ | Branch (1501:7): [True: 22, False: 1.75k] ------------------ 1502| 22| Error(ecEMPTY_EXPRESSION); 1503| | 1504| | // 2020-09-17; fix for https://oss-fuzz.com/testcase-detail/5758791700971520 1505| | // I don't need the value stack any more. Destructively check if all values in the value 1506| | // stack represent floating point values 1507| 45.2k| while (stVal.size()) ------------------ | Branch (1507:10): [True: 43.4k, False: 1.77k] ------------------ 1508| 43.4k| { 1509| 43.4k| if (stVal.top().GetType() != tpDBL) ------------------ | Branch (1509:8): [True: 2, False: 43.4k] ------------------ 1510| 2| Error(ecSTR_RESULT); 1511| | 1512| 43.4k| stVal.pop(); 1513| 43.4k| } 1514| | 1515| 1.77k| m_vStackBuffer.resize(m_vRPN.GetMaxStackSize() * s_MaxNumOpenMPThreads); 1516| 1.77k| } _ZNK2mu10ParserBase11ParseStringEv: 1528| 3.96k| { 1529| 3.96k| try 1530| 3.96k| { 1531| 3.96k| CreateRPN(); 1532| | 1533| 3.96k| if (m_vRPN.GetSize() == 2) ------------------ | Branch (1533:8): [True: 632, False: 3.33k] ------------------ 1534| 632| { 1535| 632| m_pParseFormula = &ParserBase::ParseCmdCodeShort; 1536| 632| m_vStackBuffer[1] = (this->*m_pParseFormula)(); 1537| 632| return m_vStackBuffer[1]; 1538| 632| } 1539| 3.33k| else 1540| 3.33k| { 1541| 3.33k| m_pParseFormula = &ParserBase::ParseCmdCode; 1542| 3.33k| return (this->*m_pParseFormula)(); 1543| 3.33k| } 1544| 3.96k| } 1545| 3.96k| catch (ParserError& exc) 1546| 3.96k| { 1547| 2.44k| exc.SetFormula(m_pTokenReader->GetExpr()); 1548| 2.44k| throw; 1549| 2.44k| } 1550| 3.96k| } _ZNK2mu10ParserBase5ErrorENS_11EErrorCodesEiRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 1564| 2.42k| { 1565| 2.42k| throw exception_type(a_iErrc, a_sTok, m_pTokenReader->GetExpr(), a_iPos); 1566| 2.42k| } _ZNK2mu10ParserBase14HasBuiltInOprtEv: 1700| 8.36M| { 1701| 8.36M| return m_bBuiltInOp; 1702| 8.36M| } _ZNK2mu10ParserBase4EvalEv: 1817| 3.96k| { 1818| 3.96k| return (this->*m_pParseFormula)(); 1819| 3.96k| } _ZN2mu14ParserByteCodeC2Ev: 56| 3.99k| { 57| 3.99k| m_vRPN.reserve(50); 58| 3.99k| } _ZN2mu14ParserByteCode6AddValEd: 136| 757k| { 137| 757k| ++m_iStackPos; 138| 757k| m_iMaxStackSize = std::max(m_iMaxStackSize, (size_t)m_iStackPos); 139| | 140| | // If optimization does not apply 141| 757k| SToken tok; 142| 757k| tok.Cmd = cmVAL; 143| 757k| tok.Val.ptr = nullptr; 144| 757k| tok.Val.data = 0; 145| 757k| tok.Val.data2 = a_fVal; 146| 757k| m_vRPN.push_back(tok); 147| 757k| } _ZN2mu14ParserByteCode15ConstantFoldingENS_8ECmdCodeE: 151| 80.9k| { 152| 80.9k| std::size_t sz = m_vRPN.size(); 153| 80.9k| value_type& x = m_vRPN[sz - 2].Val.data2; 154| 80.9k| value_type& y = m_vRPN[sz - 1].Val.data2; 155| | 156| 80.9k| switch (a_Oprt) 157| 80.9k| { 158| 1.26k| case cmLAND: x = (int)x && (int)y; m_vRPN.pop_back(); break; ------------------ | Branch (158:3): [True: 1.26k, False: 79.6k] | Branch (158:20): [True: 472, False: 788] | Branch (158:30): [True: 419, False: 53] ------------------ 159| 1.29k| case cmLOR: x = (int)x || (int)y; m_vRPN.pop_back(); break; ------------------ | Branch (159:3): [True: 1.29k, False: 79.6k] | Branch (159:20): [True: 794, False: 504] | Branch (159:30): [True: 124, False: 380] ------------------ 160| 1.38k| case cmLT: x = x < y; m_vRPN.pop_back(); break; ------------------ | Branch (160:3): [True: 1.38k, False: 79.5k] ------------------ 161| 2.01k| case cmGT: x = x > y; m_vRPN.pop_back(); break; ------------------ | Branch (161:3): [True: 2.01k, False: 78.9k] ------------------ 162| 885| case cmLE: x = x <= y; m_vRPN.pop_back(); break; ------------------ | Branch (162:3): [True: 885, False: 80.0k] ------------------ 163| 879| case cmGE: x = x >= y; m_vRPN.pop_back(); break; ------------------ | Branch (163:3): [True: 879, False: 80.0k] ------------------ 164| 924| case cmNEQ: x = x != y; m_vRPN.pop_back(); break; ------------------ | Branch (164:3): [True: 924, False: 80.0k] ------------------ 165| 753| case cmEQ: x = x == y; m_vRPN.pop_back(); break; ------------------ | Branch (165:3): [True: 753, False: 80.1k] ------------------ 166| 1.09k| case cmADD: x = x + y; m_vRPN.pop_back(); break; ------------------ | Branch (166:3): [True: 1.09k, False: 79.8k] ------------------ 167| 2.27k| case cmSUB: x = x - y; m_vRPN.pop_back(); break; ------------------ | Branch (167:3): [True: 2.27k, False: 78.6k] ------------------ 168| 1.66k| case cmMUL: x = x * y; m_vRPN.pop_back(); break; ------------------ | Branch (168:3): [True: 1.66k, False: 79.2k] ------------------ 169| 1.41k| case cmDIV: ------------------ | Branch (169:3): [True: 1.41k, False: 79.5k] ------------------ 170| 1.41k| x = x / y; 171| 1.41k| m_vRPN.pop_back(); 172| 1.41k| break; 173| | 174| 65.0k| case cmPOW: x = MathImpl::Pow(x, y); ------------------ | Branch (174:3): [True: 65.0k, False: 15.8k] ------------------ 175| 65.0k| m_vRPN.pop_back(); 176| 65.0k| break; 177| | 178| 0| default: ------------------ | Branch (178:3): [True: 0, False: 80.9k] ------------------ 179| 0| break; 180| 80.9k| } // switch opcode 181| 80.9k| } _ZN2mu14ParserByteCode5AddOpENS_8ECmdCodeE: 195| 140k| { 196| 140k| bool bOptimized = false; 197| | 198| 140k| if (m_bEnableOptimizer) ------------------ | Branch (198:7): [True: 140k, False: 0] ------------------ 199| 140k| { 200| 140k| std::size_t sz = m_vRPN.size(); 201| | 202| | // Check for foldable constants like: 203| | // cmVAL cmVAL cmADD 204| | // where cmADD can stand fopr any binary operator applied to 205| | // two constant values. 206| 140k| if (sz >= 2 && m_vRPN[sz - 2].Cmd == cmVAL && m_vRPN[sz - 1].Cmd == cmVAL) ------------------ | Branch (206:8): [True: 140k, False: 0] | Branch (206:19): [True: 81.6k, False: 58.5k] | Branch (206:50): [True: 80.9k, False: 703] ------------------ 207| 80.9k| { 208| 80.9k| ConstantFolding(a_Oprt); 209| 80.9k| bOptimized = true; 210| 80.9k| } 211| 59.2k| else 212| 59.2k| { 213| 59.2k| switch (a_Oprt) 214| 59.2k| { 215| 53.6k| case cmPOW: ------------------ | Branch (215:5): [True: 53.6k, False: 5.62k] ------------------ 216| | // Optimization for polynomials of low order 217| 53.6k| if (m_vRPN[sz - 2].Cmd == cmVAR && m_vRPN[sz - 1].Cmd == cmVAL) ------------------ | Branch (217:10): [True: 0, False: 53.6k] | Branch (217:41): [True: 0, False: 0] ------------------ 218| 0| { 219| 0| if (m_vRPN[sz - 1].Val.data2 == 0) ------------------ | Branch (219:11): [True: 0, False: 0] ------------------ 220| 0| { 221| 0| m_vRPN[sz - 2].Cmd = cmVAL; 222| 0| m_vRPN[sz - 2].Val.ptr = nullptr; 223| 0| m_vRPN[sz - 2].Val.data = 0; 224| 0| m_vRPN[sz - 2].Val.data2 = 1; 225| 0| } 226| 0| else if (m_vRPN[sz - 1].Val.data2 == 1) ------------------ | Branch (226:16): [True: 0, False: 0] ------------------ 227| 0| m_vRPN[sz - 2].Cmd = cmVAR; 228| 0| else if (m_vRPN[sz - 1].Val.data2 == 2) ------------------ | Branch (228:16): [True: 0, False: 0] ------------------ 229| 0| m_vRPN[sz - 2].Cmd = cmVARPOW2; 230| 0| else if (m_vRPN[sz - 1].Val.data2 == 3) ------------------ | Branch (230:16): [True: 0, False: 0] ------------------ 231| 0| m_vRPN[sz - 2].Cmd = cmVARPOW3; 232| 0| else if (m_vRPN[sz - 1].Val.data2 == 4) ------------------ | Branch (232:16): [True: 0, False: 0] ------------------ 233| 0| m_vRPN[sz - 2].Cmd = cmVARPOW4; 234| 0| else 235| 0| break; 236| | 237| 0| m_vRPN.pop_back(); 238| 0| bOptimized = true; 239| 0| } 240| 53.6k| break; 241| | 242| 53.6k| case cmSUB: ------------------ | Branch (242:5): [True: 530, False: 58.7k] ------------------ 243| 1.08k| case cmADD: ------------------ | Branch (243:5): [True: 555, False: 58.7k] ------------------ 244| | // Simple optimization based on pattern recognition for a shitload of different 245| | // bytecode combinations of addition/subtraction 246| 1.08k| if ((m_vRPN[sz - 1].Cmd == cmVAR && m_vRPN[sz - 2].Cmd == cmVAL) || ------------------ | Branch (246:11): [True: 0, False: 1.08k] | Branch (246:42): [True: 0, False: 0] ------------------ 247| 1.08k| (m_vRPN[sz - 1].Cmd == cmVAL && m_vRPN[sz - 2].Cmd == cmVAR) || ------------------ | Branch (247:8): [True: 618, False: 467] | Branch (247:39): [True: 0, False: 618] ------------------ 248| 1.08k| (m_vRPN[sz - 1].Cmd == cmVAL && m_vRPN[sz - 2].Cmd == cmVARMUL) || ------------------ | Branch (248:8): [True: 618, False: 467] | Branch (248:39): [True: 0, False: 618] ------------------ 249| 1.08k| (m_vRPN[sz - 1].Cmd == cmVARMUL && m_vRPN[sz - 2].Cmd == cmVAL) || ------------------ | Branch (249:8): [True: 0, False: 1.08k] | Branch (249:42): [True: 0, False: 0] ------------------ 250| 1.08k| (m_vRPN[sz - 1].Cmd == cmVAR && m_vRPN[sz - 2].Cmd == cmVAR && m_vRPN[sz - 2].Val.ptr == m_vRPN[sz - 1].Val.ptr) || ------------------ | Branch (250:8): [True: 0, False: 1.08k] | Branch (250:39): [True: 0, False: 0] | Branch (250:70): [True: 0, False: 0] ------------------ 251| 1.08k| (m_vRPN[sz - 1].Cmd == cmVAR && m_vRPN[sz - 2].Cmd == cmVARMUL && m_vRPN[sz - 2].Val.ptr == m_vRPN[sz - 1].Val.ptr) || ------------------ | Branch (251:8): [True: 0, False: 1.08k] | Branch (251:39): [True: 0, False: 0] | Branch (251:73): [True: 0, False: 0] ------------------ 252| 1.08k| (m_vRPN[sz - 1].Cmd == cmVARMUL && m_vRPN[sz - 2].Cmd == cmVAR && m_vRPN[sz - 2].Val.ptr == m_vRPN[sz - 1].Val.ptr) || ------------------ | Branch (252:8): [True: 0, False: 1.08k] | Branch (252:42): [True: 0, False: 0] | Branch (252:73): [True: 0, False: 0] ------------------ 253| 1.08k| (m_vRPN[sz - 1].Cmd == cmVARMUL && m_vRPN[sz - 2].Cmd == cmVARMUL && m_vRPN[sz - 2].Val.ptr == m_vRPN[sz - 1].Val.ptr)) ------------------ | Branch (253:8): [True: 0, False: 1.08k] | Branch (253:42): [True: 0, False: 0] | Branch (253:76): [True: 0, False: 0] ------------------ 254| 0| { 255| 0| MUP_ASSERT( ------------------ | | 78| 0| if (!(COND)) \ | | ------------------ | | | Branch (78:19): [True: 0, False: 0] | | | Branch (78:19): [True: 0, False: 0] | | | Branch (78:19): [True: 0, False: 0] | | | Branch (78:19): [True: 0, False: 0] | | | Branch (78:19): [True: 0, False: 0] | | ------------------ | | 79| 0| { \ | | 80| 0| stringstream_type ss; \ | | 81| 0| ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 82| 0| << __FILE__ << _T(" line ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 83| 0| << __LINE__ << _T("."); \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 84| 0| throw ParserError( ecINTERNAL_ERROR, -1, ss.str()); \ | | 85| 0| } ------------------ 256| 0| (m_vRPN[sz - 2].Val.ptr == nullptr && m_vRPN[sz - 1].Val.ptr != nullptr) || 257| 0| (m_vRPN[sz - 2].Val.ptr != nullptr && m_vRPN[sz - 1].Val.ptr == nullptr) || 258| 0| (m_vRPN[sz - 2].Val.ptr == m_vRPN[sz - 1].Val.ptr)); 259| | 260| 0| m_vRPN[sz - 2].Cmd = cmVARMUL; 261| 0| m_vRPN[sz - 2].Val.ptr = (value_type*)((long long)(m_vRPN[sz - 2].Val.ptr) | (long long)(m_vRPN[sz - 1].Val.ptr)); // variable 262| 0| m_vRPN[sz - 2].Val.data2 += ((a_Oprt == cmSUB) ? -1 : 1) * m_vRPN[sz - 1].Val.data2; // offset ------------------ | Branch (262:36): [True: 0, False: 0] ------------------ 263| 0| m_vRPN[sz - 2].Val.data += ((a_Oprt == cmSUB) ? -1 : 1) * m_vRPN[sz - 1].Val.data; // multiplicand ------------------ | Branch (263:35): [True: 0, False: 0] ------------------ 264| 0| m_vRPN.pop_back(); 265| 0| bOptimized = true; 266| 0| } 267| 1.08k| break; 268| | 269| 1.42k| case cmMUL: ------------------ | Branch (269:5): [True: 1.42k, False: 57.8k] ------------------ 270| 1.42k| if ((m_vRPN[sz - 1].Cmd == cmVAR && m_vRPN[sz - 2].Cmd == cmVAL) || ------------------ | Branch (270:11): [True: 0, False: 1.42k] | Branch (270:42): [True: 0, False: 0] ------------------ 271| 1.42k| (m_vRPN[sz - 1].Cmd == cmVAL && m_vRPN[sz - 2].Cmd == cmVAR)) ------------------ | Branch (271:8): [True: 788, False: 641] | Branch (271:39): [True: 0, False: 788] ------------------ 272| 0| { 273| 0| m_vRPN[sz - 2].Cmd = cmVARMUL; 274| 0| m_vRPN[sz - 2].Val.ptr = (value_type*)((long long)(m_vRPN[sz - 2].Val.ptr) | (long long)(m_vRPN[sz - 1].Val.ptr)); 275| 0| m_vRPN[sz - 2].Val.data = m_vRPN[sz - 2].Val.data2 + m_vRPN[sz - 1].Val.data2; 276| 0| m_vRPN[sz - 2].Val.data2 = 0; 277| 0| m_vRPN.pop_back(); 278| 0| bOptimized = true; 279| 0| } 280| 1.42k| else if ( 281| 1.42k| (m_vRPN[sz - 1].Cmd == cmVAL && m_vRPN[sz - 2].Cmd == cmVARMUL) || ------------------ | Branch (281:8): [True: 788, False: 641] | Branch (281:39): [True: 0, False: 788] ------------------ 282| 1.42k| (m_vRPN[sz - 1].Cmd == cmVARMUL && m_vRPN[sz - 2].Cmd == cmVAL)) ------------------ | Branch (282:8): [True: 0, False: 1.42k] | Branch (282:42): [True: 0, False: 0] ------------------ 283| 0| { 284| | // Optimization: 2*(3*b+1) or (3*b+1)*2 -> 6*b+2 285| 0| m_vRPN[sz - 2].Cmd = cmVARMUL; 286| 0| m_vRPN[sz - 2].Val.ptr = (value_type*)((long long)(m_vRPN[sz - 2].Val.ptr) | (long long)(m_vRPN[sz - 1].Val.ptr)); 287| 0| if (m_vRPN[sz - 1].Cmd == cmVAL) ------------------ | Branch (287:11): [True: 0, False: 0] ------------------ 288| 0| { 289| 0| m_vRPN[sz - 2].Val.data *= m_vRPN[sz - 1].Val.data2; 290| 0| m_vRPN[sz - 2].Val.data2 *= m_vRPN[sz - 1].Val.data2; 291| 0| } 292| 0| else 293| 0| { 294| 0| m_vRPN[sz - 2].Val.data = m_vRPN[sz - 1].Val.data * m_vRPN[sz - 2].Val.data2; 295| 0| m_vRPN[sz - 2].Val.data2 = m_vRPN[sz - 1].Val.data2 * m_vRPN[sz - 2].Val.data2; 296| 0| } 297| 0| m_vRPN.pop_back(); 298| 0| bOptimized = true; 299| 0| } 300| 1.42k| else if ( 301| 1.42k| m_vRPN[sz - 1].Cmd == cmVAR && m_vRPN[sz - 2].Cmd == cmVAR && ------------------ | Branch (301:7): [True: 0, False: 1.42k] | Branch (301:38): [True: 0, False: 0] ------------------ 302| 1.42k| m_vRPN[sz - 1].Val.ptr == m_vRPN[sz - 2].Val.ptr) ------------------ | Branch (302:7): [True: 0, False: 0] ------------------ 303| 0| { 304| | // Optimization: a*a -> a^2 305| 0| m_vRPN[sz - 2].Cmd = cmVARPOW2; 306| 0| m_vRPN.pop_back(); 307| 0| bOptimized = true; 308| 0| } 309| 1.42k| break; 310| | 311| 727| case cmDIV: ------------------ | Branch (311:5): [True: 727, False: 58.5k] ------------------ 312| 727| if (m_vRPN[sz - 1].Cmd == cmVAL && m_vRPN[sz - 2].Cmd == cmVARMUL && m_vRPN[sz - 1].Val.data2 != 0) ------------------ | Branch (312:10): [True: 407, False: 320] | Branch (312:41): [True: 0, False: 407] | Branch (312:75): [True: 0, False: 0] ------------------ 313| 0| { 314| | // Optimization: 4*a/2 -> 2*a 315| 0| m_vRPN[sz - 2].Val.data /= m_vRPN[sz - 1].Val.data2; 316| 0| m_vRPN[sz - 2].Val.data2 /= m_vRPN[sz - 1].Val.data2; 317| 0| m_vRPN.pop_back(); 318| 0| bOptimized = true; 319| 0| } 320| 727| break; 321| | 322| | // no optimization for other opcodes 323| 2.38k| default: ------------------ | Branch (323:5): [True: 2.38k, False: 56.8k] ------------------ 324| 2.38k| break; 325| 59.2k| } // switch a_Oprt 326| 59.2k| } 327| 140k| } 328| | 329| | // If optimization can't be applied just write the value 330| 140k| if (!bOptimized) ------------------ | Branch (330:7): [True: 59.2k, False: 80.9k] ------------------ 331| 59.2k| { 332| 59.2k| --m_iStackPos; 333| 59.2k| SToken tok; 334| 59.2k| tok.Cmd = a_Oprt; 335| 59.2k| m_vRPN.push_back(tok); 336| 59.2k| } 337| 140k| } _ZN2mu14ParserByteCode9AddIfElseENS_8ECmdCodeE: 341| 466k| { 342| 466k| SToken tok; 343| 466k| tok.Cmd = a_Oprt; 344| 466k| m_vRPN.push_back(tok); 345| 466k| } _ZN2mu14ParserByteCode6AddFunENS_21generic_callable_typeEib: 375| 75.1k| { 376| 75.1k| std::size_t sz = m_vRPN.size(); 377| 75.1k| bool optimize = false; 378| | 379| | // only optimize functions with fixed number of more than a single arguments 380| 75.1k| if (isFunctionOptimizable && m_bEnableOptimizer && a_iArgc > 0) ------------------ | Branch (380:7): [True: 75.1k, False: 0] | Branch (380:32): [True: 75.1k, False: 0] | Branch (380:54): [True: 71.5k, False: 3.57k] ------------------ 381| 71.5k| { 382| | // Unary Plus is a no-op 383| 71.5k| if (a_pFun == generic_callable_type{(erased_fun_type)&MathImpl::UnaryPlus, nullptr}) ------------------ | Branch (383:8): [True: 4.66k, False: 66.9k] ------------------ 384| 4.66k| return; 385| | 386| 66.9k| optimize = true; 387| | 388| 73.7k| for (int i = 0; i < std::abs(a_iArgc); ++i) ------------------ | Branch (388:20): [True: 67.1k, False: 6.62k] ------------------ 389| 67.1k| { 390| 67.1k| if (m_vRPN[sz - i - 1].Cmd != cmVAL) ------------------ | Branch (390:9): [True: 60.2k, False: 6.82k] ------------------ 391| 60.2k| { 392| 60.2k| optimize = false; 393| 60.2k| break; 394| 60.2k| } 395| 67.1k| } 396| 66.9k| } 397| | 398| 70.4k| if (optimize) ------------------ | Branch (398:7): [True: 6.62k, False: 63.8k] ------------------ 399| 6.62k| { 400| 6.62k| value_type val = 0; 401| 6.62k| switch (a_iArgc) 402| 6.62k| { 403| 6.43k| case 1: val = a_pFun.call_fun<1>(m_vRPN[sz - 1].Val.data2); break; ------------------ | Branch (403:4): [True: 6.43k, False: 194] ------------------ 404| 194| case 2: val = a_pFun.call_fun<2>(m_vRPN[sz - 2].Val.data2, m_vRPN[sz - 1].Val.data2); break; ------------------ | Branch (404:4): [True: 194, False: 6.43k] ------------------ 405| 0| case 3: val = a_pFun.call_fun<3>(m_vRPN[sz - 3].Val.data2, m_vRPN[sz - 2].Val.data2, m_vRPN[sz - 1].Val.data2); break; ------------------ | Branch (405:4): [True: 0, False: 6.62k] ------------------ 406| 0| case 4: val = a_pFun.call_fun<4>(m_vRPN[sz - 4].Val.data2, m_vRPN[sz - 3].Val.data2, m_vRPN[sz - 2].Val.data2, m_vRPN[sz - 1].Val.data2); break; ------------------ | Branch (406:4): [True: 0, False: 6.62k] ------------------ 407| 0| case 5: val = a_pFun.call_fun<5>(m_vRPN[sz - 5].Val.data2, m_vRPN[sz - 4].Val.data2, m_vRPN[sz - 3].Val.data2, m_vRPN[sz - 2].Val.data2, m_vRPN[sz - 1].Val.data2); break; ------------------ | Branch (407:4): [True: 0, False: 6.62k] ------------------ 408| 0| case 6: val = a_pFun.call_fun<6>(m_vRPN[sz - 6].Val.data2, m_vRPN[sz - 5].Val.data2, m_vRPN[sz - 4].Val.data2, m_vRPN[sz - 3].Val.data2, m_vRPN[sz - 2].Val.data2, m_vRPN[sz - 1].Val.data2); break; ------------------ | Branch (408:4): [True: 0, False: 6.62k] ------------------ 409| 0| case 7: val = a_pFun.call_fun<7>(m_vRPN[sz - 7].Val.data2, m_vRPN[sz - 6].Val.data2, m_vRPN[sz - 5].Val.data2, m_vRPN[sz - 4].Val.data2, m_vRPN[sz - 3].Val.data2, m_vRPN[sz - 2].Val.data2, m_vRPN[sz - 1].Val.data2); break; ------------------ | Branch (409:4): [True: 0, False: 6.62k] ------------------ 410| 0| case 8: val = a_pFun.call_fun<8>(m_vRPN[sz - 8].Val.data2, m_vRPN[sz - 7].Val.data2, m_vRPN[sz - 6].Val.data2, m_vRPN[sz - 5].Val.data2, m_vRPN[sz - 4].Val.data2, m_vRPN[sz - 3].Val.data2, m_vRPN[sz - 2].Val.data2, m_vRPN[sz - 1].Val.data2); break; ------------------ | Branch (410:4): [True: 0, False: 6.62k] ------------------ 411| 0| case 9: val = a_pFun.call_fun<9>(m_vRPN[sz - 9].Val.data2, m_vRPN[sz - 8].Val.data2, m_vRPN[sz - 7].Val.data2, m_vRPN[sz - 6].Val.data2, m_vRPN[sz - 5].Val.data2, m_vRPN[sz - 4].Val.data2, m_vRPN[sz - 3].Val.data2, m_vRPN[sz - 2].Val.data2, m_vRPN[sz - 1].Val.data2); break; ------------------ | Branch (411:4): [True: 0, False: 6.62k] ------------------ 412| 0| case 10: val = a_pFun.call_fun<10>(m_vRPN[sz - 10].Val.data2, m_vRPN[sz - 9].Val.data2, m_vRPN[sz - 8].Val.data2, m_vRPN[sz - 7].Val.data2, m_vRPN[sz - 6].Val.data2, m_vRPN[sz - 5].Val.data2, m_vRPN[sz - 4].Val.data2, m_vRPN[sz - 3].Val.data2, m_vRPN[sz - 2].Val.data2, m_vRPN[sz - 1].Val.data2); break; ------------------ | Branch (412:4): [True: 0, False: 6.62k] ------------------ 413| 0| default: ------------------ | Branch (413:4): [True: 0, False: 6.62k] ------------------ 414| | // For now functions with unlimited number of arguments are not optimized 415| 0| throw ParserError(ecINTERNAL_ERROR); 416| 6.62k| } 417| | 418| | // remove the folded values 419| 6.62k| m_vRPN.erase(m_vRPN.end() - a_iArgc, m_vRPN.end()); 420| | 421| 6.62k| SToken tok; 422| 6.62k| tok.Cmd = cmVAL; 423| 6.62k| tok.Val.data = 0; 424| 6.62k| tok.Val.data2 = val; 425| 6.62k| tok.Val.ptr = nullptr; 426| 6.62k| m_vRPN.push_back(tok); 427| 6.62k| } 428| 63.8k| else 429| 63.8k| { 430| 63.8k| SToken tok; 431| 63.8k| tok.Cmd = cmFUNC; 432| 63.8k| tok.Fun.argc = a_iArgc; 433| 63.8k| tok.Fun.cb = a_pFun; 434| 63.8k| m_vRPN.push_back(tok); 435| 63.8k| } 436| | 437| 70.4k| m_iStackPos = m_iStackPos - std::abs(a_iArgc) + 1; 438| 70.4k| m_iMaxStackSize = std::max(m_iMaxStackSize, (size_t)m_iStackPos); 439| | 440| 70.4k| } _ZN2mu14ParserByteCode8FinalizeEv: 488| 1.78k| { 489| 1.78k| SToken tok; 490| 1.78k| tok.Cmd = cmEND; 491| 1.78k| m_vRPN.push_back(tok); 492| 1.78k| rpn_type(m_vRPN).swap(m_vRPN); // shrink bytecode vector to fit 493| | 494| | // Determine the if-then-else jump offsets 495| 1.78k| std::stack stIf, stElse; 496| 1.78k| int idx; 497| 1.08M| for (int i = 0; i < (int)m_vRPN.size(); ++i) ------------------ | Branch (497:19): [True: 1.08M, False: 1.78k] ------------------ 498| 1.08M| { 499| 1.08M| switch (m_vRPN[i].Cmd) 500| 1.08M| { 501| 222k| case cmIF: ------------------ | Branch (501:4): [True: 222k, False: 863k] ------------------ 502| 222k| stIf.push(i); 503| 222k| break; 504| | 505| 101k| case cmELSE: ------------------ | Branch (505:4): [True: 101k, False: 984k] ------------------ 506| 101k| stElse.push(i); 507| 101k| idx = stIf.top(); 508| 101k| stIf.pop(); 509| 101k| m_vRPN[idx].Oprt.offset = i - idx; 510| 101k| break; 511| | 512| 71.6k| case cmENDIF: ------------------ | Branch (512:4): [True: 71.6k, False: 1.01M] ------------------ 513| 71.6k| idx = stElse.top(); 514| 71.6k| stElse.pop(); 515| 71.6k| m_vRPN[idx].Oprt.offset = i - idx; 516| 71.6k| break; 517| | 518| 690k| default: ------------------ | Branch (518:4): [True: 690k, False: 395k] ------------------ 519| 690k| break; 520| 1.08M| } 521| 1.08M| } 522| 1.78k| } _ZNK2mu14ParserByteCode15GetMaxStackSizeEv: 526| 1.51k| { 527| 1.51k| return m_iMaxStackSize + 1; 528| 1.51k| } _ZN2mu14ParserByteCode5clearEv: 540| 127k| { 541| 127k| m_vRPN.clear(); 542| 127k| m_iStackPos = 0; 543| 127k| m_iMaxStackSize = 0; 544| 127k| } _ZN2mu14ParserCallbackC2EPFddEbiNS_8ECmdCodeE: 73| 91.7k| {} _ZN2mu14ParserCallbackC2EPFddEb: 78| 83.8k| {} _ZN2mu14ParserCallbackC2EPFdddEb: 92| 3.99k| {} _ZN2mu14ParserCallbackC2EPFdPKdiEb: 578| 15.9k| {} _ZN2mu14ParserCallbackC2Ev: 733| 750k| {} _ZN2mu14ParserCallbackC2ERKS0_: 741| 639k| { 742| 639k| Assign(ref); 743| 639k| } _ZN2mu14ParserCallbackaSERKS0_: 746| 111k| { 747| 111k| Assign(ref); 748| 111k| return *this; 749| 111k| } _ZN2mu14ParserCallbackD2Ev: 753| 862k| { 754| 862k| if (m_iArgc & CALLBACK_INTERNAL_WITH_USER_DATA) ------------------ | Branch (754:7): [True: 0, False: 862k] ------------------ 755| 0| delete reinterpret_cast(m_pFun); 756| 862k| } _ZN2mu14ParserCallback6AssignERKS0_: 764| 750k| { 765| 750k| if (this == &ref) ------------------ | Branch (765:7): [True: 0, False: 750k] ------------------ 766| 0| return; 767| | 768| 750k| if (m_iArgc & CALLBACK_INTERNAL_WITH_USER_DATA) { ------------------ | Branch (768:7): [True: 0, False: 750k] ------------------ 769| 0| delete reinterpret_cast(m_pFun); 770| 0| m_pFun = nullptr; 771| 0| } 772| | 773| 750k| if (ref.m_iArgc & CALLBACK_INTERNAL_WITH_USER_DATA) ------------------ | Branch (773:7): [True: 0, False: 750k] ------------------ 774| 0| m_pFun = new CbWithUserData(*reinterpret_cast(ref.m_pFun)); 775| 750k| else 776| 750k| m_pFun = ref.m_pFun; 777| 750k| m_iArgc = ref.m_iArgc; 778| 750k| m_bAllowOpti = ref.m_bAllowOpti; 779| 750k| m_iCode = ref.m_iCode; 780| 750k| m_iType = ref.m_iType; 781| 750k| m_iPri = ref.m_iPri; 782| 750k| m_eOprtAsct = ref.m_eOprtAsct; 783| 750k| } _ZNK2mu14ParserCallback5CloneEv: 788| 545k| { 789| 545k| return new ParserCallback(*this); 790| 545k| } _ZNK2mu14ParserCallback13IsOptimizableEv: 799| 75.1k| { 800| 75.1k| return m_bAllowOpti; 801| 75.1k| } _ZNK2mu14ParserCallback7GetAddrEv: 812| 815k| { 813| 815k| if (m_iArgc & CALLBACK_INTERNAL_WITH_USER_DATA) ------------------ | Branch (813:7): [True: 0, False: 815k] ------------------ 814| 0| return reinterpret_cast(m_pFun)->pFun; 815| 815k| else 816| 815k| return m_pFun; 817| 815k| } _ZNK2mu14ParserCallback11GetUserDataEv: 825| 234k| { 826| 234k| if (m_iArgc & CALLBACK_INTERNAL_WITH_USER_DATA) ------------------ | Branch (826:7): [True: 0, False: 234k] ------------------ 827| 0| return reinterpret_cast(m_pFun)->pUserData; 828| 234k| else 829| 234k| return nullptr; 830| 234k| } _ZNK2mu14ParserCallback7IsValidEv: 840| 581k| { 841| 581k| return GetAddr() != nullptr ------------------ | Branch (841:10): [True: 581k, False: 0] ------------------ 842| 581k| && !((m_iArgc & CALLBACK_INTERNAL_WITH_USER_DATA) ------------------ | Branch (842:9): [True: 0, False: 581k] ------------------ 843| 581k| && GetUserData() == nullptr); ------------------ | Branch (843:12): [True: 0, False: 0] ------------------ 844| 581k| } _ZNK2mu14ParserCallback7GetCodeEv: 849| 1.23M| { 850| 1.23M| return m_iCode; 851| 1.23M| } _ZNK2mu14ParserCallback7GetTypeEv: 855| 150k| { 856| 150k| return m_iType; 857| 150k| } _ZNK2mu14ParserCallback6GetPriEv: 866| 65.8k| { 867| 65.8k| return m_iPri; 868| 65.8k| } _ZNK2mu14ParserCallback7GetArgcEv: 887| 300k| { 888| 300k| return (m_iArgc & CALLBACK_INTERNAL_VAR_ARGS) ? -1 : (m_iArgc & CALLBACK_INTERNAL_FIXED_ARGS_MASK); ------------------ | Branch (888:10): [True: 14.2k, False: 286k] ------------------ 889| 300k| } _ZN2mu14ParserErrorMsg8InstanceEv: 41| 2.47k| { 42| 2.47k| static const ParserErrorMsg instance; 43| 2.47k| return instance; 44| 2.47k| } _ZNK2mu14ParserErrorMsgixEj: 48| 2.47k| { 49| 2.47k| return (a_iIdx < m_vErrMsg.size()) ? m_vErrMsg[a_iIdx] : string_type(); ------------------ | Branch (49:10): [True: 2.47k, False: 0] ------------------ 50| 2.47k| } _ZN2mu14ParserErrorMsgC2Ev: 55| 1| { 56| 1| m_vErrMsg.resize(ecCOUNT); 57| | 58| 1| m_vErrMsg[ecUNASSIGNABLE_TOKEN] = _T("Unexpected token \"$TOK$\" found at position $POS$."); ------------------ | | 69| 1| #define _T(x) x ------------------ 59| 1| m_vErrMsg[ecINTERNAL_ERROR] = _T("Internal error"); ------------------ | | 69| 1| #define _T(x) x ------------------ 60| 1| m_vErrMsg[ecINVALID_NAME] = _T("Invalid function-, variable- or constant name: \"$TOK$\"."); ------------------ | | 69| 1| #define _T(x) x ------------------ 61| 1| m_vErrMsg[ecINVALID_BINOP_IDENT] = _T("Invalid binary operator identifier: \"$TOK$\"."); ------------------ | | 69| 1| #define _T(x) x ------------------ 62| 1| m_vErrMsg[ecINVALID_INFIX_IDENT] = _T("Invalid infix operator identifier: \"$TOK$\"."); ------------------ | | 69| 1| #define _T(x) x ------------------ 63| 1| m_vErrMsg[ecINVALID_POSTFIX_IDENT] = _T("Invalid postfix operator identifier: \"$TOK$\"."); ------------------ | | 69| 1| #define _T(x) x ------------------ 64| 1| m_vErrMsg[ecINVALID_FUN_PTR] = _T("Invalid pointer to callback function."); ------------------ | | 69| 1| #define _T(x) x ------------------ 65| 1| m_vErrMsg[ecEMPTY_EXPRESSION] = _T("Expression is empty."); ------------------ | | 69| 1| #define _T(x) x ------------------ 66| 1| m_vErrMsg[ecINVALID_VAR_PTR] = _T("Invalid pointer to variable."); ------------------ | | 69| 1| #define _T(x) x ------------------ 67| 1| m_vErrMsg[ecUNEXPECTED_OPERATOR] = _T("Unexpected operator \"$TOK$\" found at position $POS$"); ------------------ | | 69| 1| #define _T(x) x ------------------ 68| 1| m_vErrMsg[ecUNEXPECTED_EOF] = _T("Unexpected end of expression at position $POS$"); ------------------ | | 69| 1| #define _T(x) x ------------------ 69| 1| m_vErrMsg[ecUNEXPECTED_ARG_SEP] = _T("Unexpected argument separator at position $POS$"); ------------------ | | 69| 1| #define _T(x) x ------------------ 70| 1| m_vErrMsg[ecUNEXPECTED_PARENS] = _T("Unexpected parenthesis \"$TOK$\" at position $POS$"); ------------------ | | 69| 1| #define _T(x) x ------------------ 71| 1| m_vErrMsg[ecUNEXPECTED_FUN] = _T("Unexpected function \"$TOK$\" at position $POS$"); ------------------ | | 69| 1| #define _T(x) x ------------------ 72| 1| m_vErrMsg[ecUNEXPECTED_VAL] = _T("Unexpected value \"$TOK$\" found at position $POS$"); ------------------ | | 69| 1| #define _T(x) x ------------------ 73| 1| m_vErrMsg[ecUNEXPECTED_VAR] = _T("Unexpected variable \"$TOK$\" found at position $POS$"); ------------------ | | 69| 1| #define _T(x) x ------------------ 74| 1| m_vErrMsg[ecUNEXPECTED_ARG] = _T("Function arguments used without a function (position: $POS$)"); ------------------ | | 69| 1| #define _T(x) x ------------------ 75| 1| m_vErrMsg[ecMISSING_PARENS] = _T("Missing parenthesis"); ------------------ | | 69| 1| #define _T(x) x ------------------ 76| 1| m_vErrMsg[ecTOO_MANY_PARAMS] = _T("Too many parameters for function \"$TOK$\" at expression position $POS$"); ------------------ | | 69| 1| #define _T(x) x ------------------ 77| 1| m_vErrMsg[ecTOO_FEW_PARAMS] = _T("Too few parameters for function \"$TOK$\" at expression position $POS$"); ------------------ | | 69| 1| #define _T(x) x ------------------ 78| 1| m_vErrMsg[ecDIV_BY_ZERO] = _T("Divide by zero"); ------------------ | | 69| 1| #define _T(x) x ------------------ 79| 1| m_vErrMsg[ecDOMAIN_ERROR] = _T("Domain error"); ------------------ | | 69| 1| #define _T(x) x ------------------ 80| 1| m_vErrMsg[ecNAME_CONFLICT] = _T("Name conflict"); ------------------ | | 69| 1| #define _T(x) x ------------------ 81| 1| m_vErrMsg[ecOPT_PRI] = _T("Invalid value for operator priority (must be greater or equal to zero)."); ------------------ | | 69| 1| #define _T(x) x ------------------ 82| 1| m_vErrMsg[ecBUILTIN_OVERLOAD] = _T("user defined binary operator \"$TOK$\" conflicts with a built in operator."); ------------------ | | 69| 1| #define _T(x) x ------------------ 83| 1| m_vErrMsg[ecUNEXPECTED_STR] = _T("Unexpected string token found at position $POS$."); ------------------ | | 69| 1| #define _T(x) x ------------------ 84| 1| m_vErrMsg[ecUNTERMINATED_STRING] = _T("Unterminated string starting at position $POS$."); ------------------ | | 69| 1| #define _T(x) x ------------------ 85| 1| m_vErrMsg[ecSTRING_EXPECTED] = _T("String function called with a non string type of argument."); ------------------ | | 69| 1| #define _T(x) x ------------------ 86| 1| m_vErrMsg[ecVAL_EXPECTED] = _T("String value used where a numerical argument is expected."); ------------------ | | 69| 1| #define _T(x) x ------------------ 87| 1| m_vErrMsg[ecOPRT_TYPE_CONFLICT] = _T("No suitable overload for operator \"$TOK$\" at position $POS$."); ------------------ | | 69| 1| #define _T(x) x ------------------ 88| 1| m_vErrMsg[ecSTR_RESULT] = _T("Strings must only be used as function arguments!"); ------------------ | | 69| 1| #define _T(x) x ------------------ 89| 1| m_vErrMsg[ecGENERIC] = _T("Parser error."); ------------------ | | 69| 1| #define _T(x) x ------------------ 90| 1| m_vErrMsg[ecLOCALE] = _T("Decimal separator is identic to function argument separator."); ------------------ | | 69| 1| #define _T(x) x ------------------ 91| 1| m_vErrMsg[ecUNEXPECTED_CONDITIONAL] = _T("The \"$TOK$\" operator must be preceded by a closing bracket."); ------------------ | | 69| 1| #define _T(x) x ------------------ 92| 1| m_vErrMsg[ecMISSING_ELSE_CLAUSE] = _T("If-then-else operator is missing an else clause"); ------------------ | | 69| 1| #define _T(x) x ------------------ 93| 1| m_vErrMsg[ecMISPLACED_COLON] = _T("Misplaced colon at position $POS$"); ------------------ | | 69| 1| #define _T(x) x ------------------ 94| 1| m_vErrMsg[ecUNREASONABLE_NUMBER_OF_COMPUTATIONS] = _T("Number of computations to small for bulk mode. (Vectorisation overhead too costly)"); ------------------ | | 69| 1| #define _T(x) x ------------------ 95| 1| m_vErrMsg[ecIDENTIFIER_TOO_LONG] = _T("Identifier too long."); ------------------ | | 69| 1| #define _T(x) x ------------------ 96| 1| m_vErrMsg[ecEXPRESSION_TOO_LONG] = _T("Expression too long."); ------------------ | | 69| 1| #define _T(x) x ------------------ 97| 1| m_vErrMsg[ecINVALID_CHARACTERS_FOUND] = _T("Invalid non printable characters found in expression/identifer!"); ------------------ | | 69| 1| #define _T(x) x ------------------ 98| | 99| 41| for (int i = 0; i < ecCOUNT; ++i) ------------------ | Branch (99:19): [True: 40, False: 1] ------------------ 100| 40| { 101| 40| if (!m_vErrMsg[i].length()) ------------------ | Branch (101:8): [True: 0, False: 40] ------------------ 102| 0| throw std::runtime_error("Error definitions are incomplete!"); 103| 40| } 104| 1| } _ZN2mu11ParserErrorC2ENS_11EErrorCodesE: 135| 1| { 136| 1| m_strMsg = m_ErrMsg[m_iErrc]; 137| 1| stringstream_type stream; 138| 1| stream << (int)m_iPos; 139| 1| ReplaceSubString(m_strMsg, _T("$POS$"), stream.str()); ------------------ | | 69| 1| #define _T(x) x ------------------ 140| 1| ReplaceSubString(m_strMsg, _T("$TOK$"), m_strTok); ------------------ | | 69| 1| #define _T(x) x ------------------ 141| 1| } _ZN2mu11ParserErrorC2ENS_11EErrorCodesERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEESA_i: 169| 2.42k| { 170| 2.42k| m_strMsg = m_ErrMsg[m_iErrc]; 171| 2.42k| stringstream_type stream; 172| 2.42k| stream << (int)m_iPos; 173| 2.42k| ReplaceSubString(m_strMsg, _T("$POS$"), stream.str()); ------------------ | | 69| 2.42k| #define _T(x) x ------------------ 174| 2.42k| ReplaceSubString(m_strMsg, _T("$TOK$"), m_strTok); ------------------ | | 69| 2.42k| #define _T(x) x ------------------ 175| 2.42k| } _ZN2mu11ParserErrorC2ENS_11EErrorCodesEiRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 190| 47| { 191| 47| m_strMsg = m_ErrMsg[m_iErrc]; 192| 47| stringstream_type stream; 193| 47| stream << (int)m_iPos; 194| 47| ReplaceSubString(m_strMsg, _T("$POS$"), stream.str()); ------------------ | | 69| 47| #define _T(x) x ------------------ 195| 47| ReplaceSubString(m_strMsg, _T("$TOK$"), m_strTok); ------------------ | | 69| 47| #define _T(x) x ------------------ 196| 47| } _ZN2mu11ParserErrorD2Ev: 247| 2.47k| {} _ZN2mu11ParserError16ReplaceSubStringERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKS7_SA_: 257| 4.95k| { 258| 4.95k| string_type strResult; 259| 4.95k| string_type::size_type iPos(0), iNext(0); 260| | 261| 4.95k| for (;;) 262| 7.53k| { 263| 7.53k| iNext = strSource.find(strFind, iPos); 264| 7.53k| strResult.append(strSource, iPos, iNext - iPos); 265| | 266| 7.53k| if (iNext == string_type::npos) ------------------ | Branch (266:8): [True: 4.95k, False: 2.57k] ------------------ 267| 4.95k| break; 268| | 269| 2.57k| strResult.append(strReplaceWith); 270| 2.57k| iPos = iNext + strFind.length(); 271| 2.57k| } 272| | 273| 4.95k| strSource.swap(strResult); 274| 4.95k| } _ZN2mu11ParserError10SetFormulaERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 290| 2.44k| { 291| 2.44k| m_strFormula = a_strFormula; 292| 2.44k| } _ZN2mu17ParserTokenReaderC2EPNS_10ParserBaseE: 141| 3.99k| { 142| 3.99k| MUP_ASSERT(m_pParser != nullptr); ------------------ | | 78| 3.99k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 3.99k] | | ------------------ | | 79| 3.99k| { \ | | 80| 0| stringstream_type ss; \ | | 81| 0| ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 82| 0| << __FILE__ << _T(" line ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 83| 0| << __LINE__ << _T("."); \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 84| 0| throw ParserError( ecINTERNAL_ERROR, -1, ss.str()); \ | | 85| 0| } ------------------ 143| 3.99k| SetParent(m_pParser); 144| 3.99k| } _ZN2mu17ParserTokenReader16SaveBeforeReturnERKNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE: 164| 2.90M| { 165| 2.90M| m_lastTok = tok; 166| 2.90M| return m_lastTok; 167| 2.90M| } _ZN2mu17ParserTokenReader11AddValIdentEPFiPKcPiPdE: 171| 3.99k| { 172| | // Use push_front is used to give user defined callbacks a higher priority than 173| | // the built in ones. Otherwise reading hex numbers would not work 174| | // since the "0" in "0xff" would always be read first making parsing of 175| | // the rest impossible. 176| | // reference: 177| | // http://sourceforge.net/projects/muparser/forums/forum/462843/topic/4824956 178| 3.99k| m_vIdentFun.push_front(a_pCallback); 179| 3.99k| } _ZNK2mu17ParserTokenReader6GetPosEv: 195| 318| { 196| 318| return m_iPos; 197| 318| } _ZNK2mu17ParserTokenReader7GetExprEv: 206| 8.83k| { 207| 8.83k| return m_strFormula; 208| 8.83k| } _ZN2mu17ParserTokenReader10SetFormulaERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 224| 3.96k| { 225| 3.96k| m_strFormula = a_strFormula; 226| 3.96k| ReInit(); 227| 3.96k| } _ZN2mu17ParserTokenReader6ReInitEv: 253| 131k| { 254| 131k| m_iPos = 0; 255| 131k| m_iSynFlags = sfSTART_OF_LINE; 256| 131k| m_bracketStack = std::stack(); 257| 131k| m_UsedVar.clear(); 258| 131k| m_lastTok = token_type(); 259| 131k| } _ZN2mu17ParserTokenReader13ReadNextTokenEv: 264| 2.90M| { 265| 2.90M| MUP_ASSERT(m_pParser != nullptr); ------------------ | | 78| 2.90M| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 2.90M] | | ------------------ | | 79| 2.90M| { \ | | 80| 0| stringstream_type ss; \ | | 81| 0| ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 82| 0| << __FILE__ << _T(" line ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 83| 0| << __LINE__ << _T("."); \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 84| 0| throw ParserError( ecINTERNAL_ERROR, -1, ss.str()); \ | | 85| 0| } ------------------ 266| | 267| 2.90M| const char_type* szExpr = m_strFormula.c_str(); 268| 2.90M| token_type tok; 269| | 270| | // Ignore all non printable characters when reading the expression 271| 2.91M| while (szExpr[m_iPos] > 0 && szExpr[m_iPos] <= 0x20) ------------------ | Branch (271:10): [True: 2.90M, False: 2.77k] | Branch (271:32): [True: 3.74k, False: 2.90M] ------------------ 272| 3.74k| { 273| | // 14-31 are control characters. I donÄt want to have to deal with such strings at all! 274| | // (see https://en.cppreference.com/w/cpp/string/byte/isprint) 275| 3.74k| if (szExpr[m_iPos] >= 14 && szExpr[m_iPos] <= 31) ------------------ | Branch (275:8): [True: 3.17k, False: 571] | Branch (275:32): [True: 7, False: 3.16k] ------------------ 276| 7| Error(ecINVALID_CHARACTERS_FOUND, m_iPos); 277| | 278| 3.74k| ++m_iPos; 279| 3.74k| } 280| | 281| | // Check for end of formula 282| 2.90M| if (IsEOF(tok)) ------------------ | Branch (282:7): [True: 1.84k, False: 2.90M] ------------------ 283| 1.84k| return SaveBeforeReturn(tok); 284| | 285| | // Check for user defined binary operator 286| 2.90M| if (IsOprt(tok)) ------------------ | Branch (286:7): [True: 0, False: 2.90M] ------------------ 287| 0| return SaveBeforeReturn(tok); 288| | 289| | // Check for function token 290| 2.90M| if (IsFunTok(tok)) ------------------ | Branch (290:7): [True: 9.61k, False: 2.89M] ------------------ 291| 9.61k| return SaveBeforeReturn(tok); 292| | 293| | // Check built in operators / tokens 294| 2.89M| if (IsBuiltIn(tok)) ------------------ | Branch (294:7): [True: 1.82M, False: 1.07M] ------------------ 295| 1.82M| return SaveBeforeReturn(tok); 296| | 297| | // Check for function argument separators 298| 1.07M| if (IsArgSep(tok)) ------------------ | Branch (298:7): [True: 289k, False: 783k] ------------------ 299| 289k| return SaveBeforeReturn(tok); 300| | 301| | // Check for values / constant tokens 302| 783k| if (IsValTok(tok)) ------------------ | Branch (302:7): [True: 757k, False: 25.9k] ------------------ 303| 757k| return SaveBeforeReturn(tok); 304| | 305| | // Check for variable tokens 306| 25.9k| if (IsVarTok(tok)) ------------------ | Branch (306:7): [True: 0, False: 25.9k] ------------------ 307| 0| return SaveBeforeReturn(tok); 308| | 309| | // Check for string variables 310| 25.9k| if (IsStrVarTok(tok)) ------------------ | Branch (310:7): [True: 0, False: 25.9k] ------------------ 311| 0| return SaveBeforeReturn(tok); 312| | 313| | // Check for String tokens 314| 25.9k| if (IsString(tok)) ------------------ | Branch (314:7): [True: 24.1k, False: 1.81k] ------------------ 315| 24.1k| return SaveBeforeReturn(tok); 316| | 317| | // Check for unary operators 318| 1.81k| if (IsInfixOpTok(tok)) ------------------ | Branch (318:7): [True: 0, False: 1.81k] ------------------ 319| 0| return SaveBeforeReturn(tok); 320| | 321| | // Check for unary operators 322| 1.81k| if (IsPostOpTok(tok)) ------------------ | Branch (322:7): [True: 0, False: 1.81k] ------------------ 323| 0| return SaveBeforeReturn(tok); 324| | 325| | // Check String for undefined variable token. Done only if a 326| | // flag is set indicating to ignore undefined variables. 327| | // This is a way to conditionally avoid an error if 328| | // undefined variables occur. 329| | // (The GetUsedVar function must suppress the error for 330| | // undefined variables in order to collect all variable 331| | // names including the undefined ones.) 332| 1.81k| if ((m_bIgnoreUndefVar || m_pFactory) && IsUndefVarTok(tok)) ------------------ | Branch (332:8): [True: 1.22k, False: 595] | Branch (332:29): [True: 0, False: 595] | Branch (332:44): [True: 0, False: 0] ------------------ 333| 0| return SaveBeforeReturn(tok); 334| | 335| | // Check for unknown token 336| | // 337| | // !!! From this point on there is no exit without an exception possible... 338| | // 339| 1.81k| string_type strTok; 340| 1.81k| auto iEnd = ExtractToken(m_pParser->ValidNameChars(), strTok, (std::size_t)m_iPos); 341| 1.81k| if (iEnd != m_iPos) ------------------ | Branch (341:7): [True: 492, False: 1.32k] ------------------ 342| 492| Error(ecUNASSIGNABLE_TOKEN, m_iPos, strTok); 343| | 344| 1.81k| Error(ecUNASSIGNABLE_TOKEN, m_iPos, m_strFormula.substr(m_iPos)); 345| 1.81k| return token_type(); // never reached 346| 1.81k| } _ZN2mu17ParserTokenReader9SetParentEPNS_10ParserBaseE: 350| 3.99k| { 351| 3.99k| m_pParser = a_pParent; 352| 3.99k| m_pFunDef = &a_pParent->m_FunDef; 353| 3.99k| m_pOprtDef = &a_pParent->m_OprtDef; 354| 3.99k| m_pInfixOprtDef = &a_pParent->m_InfixOprtDef; 355| 3.99k| m_pPostOprtDef = &a_pParent->m_PostOprtDef; 356| 3.99k| m_pVarDef = &a_pParent->m_VarDef; 357| 3.99k| m_pStrVarDef = &a_pParent->m_StrVarDef; 358| 3.99k| m_pConstDef = &a_pParent->m_ConstDef; 359| 3.99k| } _ZNK2mu17ParserTokenReader12ExtractTokenEPKcRNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEm: 371| 6.14M| { 372| 6.14M| auto iEnd = m_strFormula.find_first_not_of(a_szCharSet, a_iPos); 373| | 374| 6.14M| if (iEnd == string_type::npos) ------------------ | Branch (374:7): [True: 0, False: 6.14M] ------------------ 375| 0| iEnd = m_strFormula.length(); 376| | 377| | // Assign token string if there was something found 378| 6.14M| if (a_iPos != iEnd) ------------------ | Branch (378:7): [True: 1.61M, False: 4.53M] ------------------ 379| 1.61M| a_sTok = string_type(m_strFormula.begin() + a_iPos, m_strFormula.begin() + iEnd); 380| | 381| 6.14M| return static_cast(iEnd); 382| 6.14M| } _ZNK2mu17ParserTokenReader20ExtractOperatorTokenERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEm: 393| 2.90M| { 394| | // Changed as per Issue 6: https://code.google.com/p/muparser/issues/detail?id=6 395| 2.90M| auto iEnd = m_strFormula.find_first_not_of(m_pParser->ValidOprtChars(), a_iPos); 396| 2.90M| if (iEnd == string_type::npos) ------------------ | Branch (396:7): [True: 0, False: 2.90M] ------------------ 397| 0| iEnd = m_strFormula.length(); 398| | 399| | // Assign token string if there was something found 400| 2.90M| if (a_iPos != iEnd) ------------------ | Branch (400:7): [True: 533k, False: 2.37M] ------------------ 401| 533k| { 402| 533k| a_sTok = string_type(m_strFormula.begin() + a_iPos, m_strFormula.begin() + iEnd); 403| 533k| return static_cast(iEnd); 404| 533k| } 405| 2.37M| else 406| 2.37M| { 407| | // There is still the chance of having to deal with an operator consisting exclusively 408| | // of alphabetic characters. 409| 2.37M| return ExtractToken(_T("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"), a_sTok, (std::size_t)a_iPos); ------------------ | | 69| 2.37M| #define _T(x) x ------------------ 410| 2.37M| } 411| 2.90M| } _ZN2mu17ParserTokenReader9IsBuiltInERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE: 419| 2.89M| { 420| 2.89M| const char_type** const pOprtDef = m_pParser->GetOprtDef(), 421| 2.89M| * const szFormula = m_strFormula.c_str(); 422| | 423| | // Compare token with function and operator strings 424| | // check string for operator/function 425| 47.3M| for (int i = 0; pOprtDef[i]; i++) ------------------ | Branch (425:19): [True: 46.2M, False: 1.07M] ------------------ 426| 46.2M| { 427| 46.2M| std::size_t len(std::char_traits::length(pOprtDef[i])); 428| 46.2M| if (string_type(pOprtDef[i]) == string_type(szFormula + m_iPos, szFormula + m_iPos + len)) ------------------ | Branch (428:8): [True: 1.82M, False: 44.4M] ------------------ 429| 1.82M| { 430| 1.82M| switch (i) 431| 1.82M| { 432| 1.81k| case cmLAND: ------------------ | Branch (432:5): [True: 1.81k, False: 1.82M] ------------------ 433| 3.58k| case cmLOR: ------------------ | Branch (433:5): [True: 1.77k, False: 1.82M] ------------------ 434| 5.33k| case cmLT: ------------------ | Branch (434:5): [True: 1.75k, False: 1.82M] ------------------ 435| 7.71k| case cmGT: ------------------ | Branch (435:5): [True: 2.37k, False: 1.82M] ------------------ 436| 8.94k| case cmLE: ------------------ | Branch (436:5): [True: 1.23k, False: 1.82M] ------------------ 437| 10.0k| case cmGE: ------------------ | Branch (437:5): [True: 1.11k, False: 1.82M] ------------------ 438| 11.2k| case cmNEQ: ------------------ | Branch (438:5): [True: 1.16k, False: 1.82M] ------------------ 439| 12.2k| case cmEQ: ------------------ | Branch (439:5): [True: 984, False: 1.82M] ------------------ 440| 35.1k| case cmADD: ------------------ | Branch (440:5): [True: 22.9k, False: 1.80M] ------------------ 441| 101k| case cmSUB: ------------------ | Branch (441:5): [True: 65.9k, False: 1.75M] ------------------ 442| 104k| case cmMUL: ------------------ | Branch (442:5): [True: 3.18k, False: 1.82M] ------------------ 443| 106k| case cmDIV: ------------------ | Branch (443:5): [True: 2.39k, False: 1.82M] ------------------ 444| 249k| case cmPOW: ------------------ | Branch (444:5): [True: 143k, False: 1.68M] ------------------ 445| 249k| case cmASSIGN: ------------------ | Branch (445:5): [True: 8, False: 1.82M] ------------------ 446| | // The assignment operator need special treatment 447| 249k| if (i == cmASSIGN && m_iSynFlags & noASSIGN) ------------------ | Branch (447:10): [True: 8, False: 249k] | Branch (447:27): [True: 7, False: 1] ------------------ 448| 7| Error(ecUNEXPECTED_OPERATOR, m_iPos, pOprtDef[i]); 449| | 450| 249k| if (!m_pParser->HasBuiltInOprt()) continue; ------------------ | Branch (450:10): [True: 0, False: 249k] ------------------ 451| 249k| if (m_iSynFlags & noOPT) ------------------ | Branch (451:10): [True: 84.2k, False: 165k] ------------------ 452| 84.2k| { 453| | // Maybe its an infix operator not an operator 454| | // Both operator types can share characters in 455| | // their identifiers 456| 84.2k| if (IsInfixOpTok(a_Tok)) ------------------ | Branch (456:11): [True: 84.0k, False: 187] ------------------ 457| 84.0k| return true; 458| | 459| 187| Error(ecUNEXPECTED_OPERATOR, m_iPos, pOprtDef[i]); 460| 187| } 461| | 462| 165k| m_iSynFlags = noBC | noOPT | noARG_SEP | noPOSTOP | noASSIGN | noIF | noELSE | noEND; 463| 165k| break; 464| | 465| 1.09M| case cmBO: ------------------ | Branch (465:5): [True: 1.09M, False: 732k] ------------------ 466| 1.09M| if (m_iSynFlags & noBO) ------------------ | Branch (466:10): [True: 6, False: 1.09M] ------------------ 467| 6| Error(ecUNEXPECTED_PARENS, m_iPos, pOprtDef[i]); 468| | 469| 1.09M| if (m_lastTok.GetCode() == cmFUNC) ------------------ | Branch (469:10): [True: 9.61k, False: 1.08M] ------------------ 470| 9.61k| m_iSynFlags = noOPT | noEND | noARG_SEP | noPOSTOP | noASSIGN | noIF | noELSE; 471| 1.08M| else 472| 1.08M| m_iSynFlags = noBC | noOPT | noEND | noARG_SEP | noPOSTOP | noASSIGN | noIF | noELSE; 473| | 474| 1.09M| m_bracketStack.push(cmBO); 475| 1.09M| break; 476| | 477| 93.9k| case cmBC: ------------------ | Branch (477:5): [True: 93.9k, False: 1.73M] ------------------ 478| 93.9k| if (m_iSynFlags & noBC) ------------------ | Branch (478:10): [True: 3, False: 93.9k] ------------------ 479| 3| Error(ecUNEXPECTED_PARENS, m_iPos, pOprtDef[i]); 480| | 481| 93.9k| m_iSynFlags = noBO | noVAR | noVAL | noFUN | noINFIXOP | noSTR | noASSIGN; 482| | 483| 93.9k| if (!m_bracketStack.empty()) ------------------ | Branch (483:10): [True: 93.9k, False: 10] ------------------ 484| 93.9k| m_bracketStack.pop(); 485| 10| else 486| 10| Error(ecUNEXPECTED_PARENS, m_iPos, pOprtDef[i]); 487| 93.9k| break; 488| | 489| 116k| case cmELSE: ------------------ | Branch (489:5): [True: 116k, False: 1.70M] ------------------ 490| 116k| if (m_iSynFlags & noELSE) ------------------ | Branch (490:10): [True: 6, False: 116k] ------------------ 491| 6| Error(ecUNEXPECTED_CONDITIONAL, m_iPos, pOprtDef[i]); 492| | 493| 116k| m_iSynFlags = noBC | noPOSTOP | noEND | noOPT | noIF | noELSE | noSTR; 494| 116k| break; 495| | 496| 272k| case cmIF: ------------------ | Branch (496:5): [True: 272k, False: 1.55M] ------------------ 497| 272k| if (m_iSynFlags & noIF) ------------------ | Branch (497:10): [True: 17, False: 272k] ------------------ 498| 17| Error(ecUNEXPECTED_CONDITIONAL, m_iPos, pOprtDef[i]); 499| | 500| 272k| m_iSynFlags = noBC | noPOSTOP | noEND | noOPT | noIF | noELSE | noSTR; 501| 272k| break; 502| | 503| 0| default: // The operator is listed in c_DefaultOprt, but not here. This is a bad thing... ------------------ | Branch (503:5): [True: 0, False: 1.82M] ------------------ 504| 0| Error(ecINTERNAL_ERROR); 505| 1.82M| } // switch operator id 506| | 507| 1.74M| m_iPos += (int)len; 508| 1.74M| a_Tok.Set((ECmdCode)i, pOprtDef[i]); 509| 1.74M| return true; 510| 1.82M| } // if operator string found 511| 46.2M| } // end of for all operator strings 512| | 513| 1.07M| return false; 514| 2.89M| } _ZN2mu17ParserTokenReader8IsArgSepERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE: 518| 1.07M| { 519| 1.07M| const char_type* szFormula = m_strFormula.c_str(); 520| | 521| 1.07M| if (szFormula[m_iPos] == m_cArgSep) ------------------ | Branch (521:7): [True: 289k, False: 782k] ------------------ 522| 289k| { 523| | // copy the separator into null terminated string 524| 289k| char_type szSep[2]; 525| 289k| szSep[0] = m_cArgSep; 526| 289k| szSep[1] = 0; 527| | 528| 289k| if (m_iSynFlags & noARG_SEP) ------------------ | Branch (528:8): [True: 6, False: 289k] ------------------ 529| 6| Error(ecUNEXPECTED_ARG_SEP, m_iPos, szSep); 530| | 531| 289k| m_iSynFlags = noBC | noOPT | noEND | noARG_SEP | noPOSTOP | noASSIGN; 532| 289k| m_iPos++; 533| 289k| a_Tok.Set(cmARG_SEP, szSep); 534| 289k| return true; 535| 289k| } 536| | 537| 782k| return false; 538| 1.07M| } _ZN2mu17ParserTokenReader5IsEOFERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE: 549| 2.90M| { 550| 2.90M| const char_type* szFormula = m_strFormula.c_str(); 551| | 552| | // check for EOF 553| 2.90M| if (!szFormula[m_iPos] /*|| szFormula[m_iPos] == '\n'*/) ------------------ | Branch (553:7): [True: 2.71k, False: 2.90M] ------------------ 554| 2.71k| { 555| 2.71k| if (m_iSynFlags & noEND) ------------------ | Branch (555:8): [True: 668, False: 2.04k] ------------------ 556| 668| Error(ecUNEXPECTED_EOF, m_iPos); 557| | 558| 2.71k| if (!m_bracketStack.empty()) ------------------ | Branch (558:8): [True: 200, False: 2.51k] ------------------ 559| 200| Error(ecMISSING_PARENS, m_iPos, _T(")")); ------------------ | | 69| 200| #define _T(x) x ------------------ 560| | 561| 2.71k| m_iSynFlags = 0; 562| 2.71k| a_Tok.Set(cmEND); 563| 2.71k| return true; 564| 2.71k| } 565| | 566| 2.90M| return false; 567| 2.90M| } _ZN2mu17ParserTokenReader12IsInfixOpTokERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE: 574| 84.8k| { 575| 84.8k| string_type sTok; 576| 84.8k| auto iEnd = ExtractToken(m_pParser->ValidInfixOprtChars(), sTok, (std::size_t)m_iPos); 577| 84.8k| if (iEnd == m_iPos) ------------------ | Branch (577:7): [True: 365, False: 84.4k] ------------------ 578| 365| return false; 579| | 580| | // iterate over all postfix operator strings 581| 84.4k| funmap_type::const_reverse_iterator it = m_pInfixOprtDef->rbegin(); 582| 106k| for (; it != m_pInfixOprtDef->rend(); ++it) ------------------ | Branch (582:10): [True: 105k, False: 360] ------------------ 583| 105k| { 584| 105k| if (sTok.find(it->first) != 0) ------------------ | Branch (584:8): [True: 21.8k, False: 84.0k] ------------------ 585| 21.8k| continue; 586| | 587| 84.0k| a_Tok.Set(it->second, it->first); 588| 84.0k| m_iPos += (int)it->first.length(); 589| | 590| 84.0k| if (m_iSynFlags & noINFIXOP) ------------------ | Branch (590:8): [True: 57, False: 84.0k] ------------------ 591| 57| Error(ecUNEXPECTED_OPERATOR, m_iPos, a_Tok.GetAsString()); 592| | 593| 84.0k| m_iSynFlags = noPOSTOP | noINFIXOP | noOPT | noBC | noSTR | noASSIGN | noARG_SEP; 594| 84.0k| return true; 595| 105k| } 596| | 597| 360| return false; 598| | 599| | /* 600| | a_Tok.Set(item->second, sTok); 601| | m_iPos = (int)iEnd; 602| | 603| | if (m_iSynFlags & noINFIXOP) 604| | Error(ecUNEXPECTED_OPERATOR, m_iPos, a_Tok.GetAsString()); 605| | 606| | m_iSynFlags = noPOSTOP | noINFIXOP | noOPT | noBC | noSTR | noASSIGN; 607| | return true; 608| | */ 609| 84.4k| } _ZN2mu17ParserTokenReader8IsFunTokERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE: 619| 2.90M| { 620| 2.90M| string_type strTok; 621| 2.90M| auto iEnd = ExtractToken(m_pParser->ValidNameChars(), strTok, (std::size_t)m_iPos); 622| 2.90M| if (iEnd == m_iPos) ------------------ | Branch (622:7): [True: 2.13M, False: 767k] ------------------ 623| 2.13M| return false; 624| | 625| 767k| funmap_type::const_iterator item = m_pFunDef->find(strTok); 626| 767k| if (item == m_pFunDef->end()) ------------------ | Branch (626:7): [True: 757k, False: 9.63k] ------------------ 627| 757k| return false; 628| | 629| | // Check if the next sign is an opening bracket 630| 9.63k| const char_type* szFormula = m_strFormula.c_str(); 631| 9.63k| if (szFormula[iEnd] != '(') ------------------ | Branch (631:7): [True: 20, False: 9.61k] ------------------ 632| 20| return false; 633| | 634| 9.61k| a_Tok.Set(item->second, strTok); 635| | 636| 9.61k| m_iPos = (int)iEnd; 637| 9.61k| if (m_iSynFlags & noFUN) ------------------ | Branch (637:7): [True: 1, False: 9.61k] ------------------ 638| 1| Error(ecUNEXPECTED_FUN, m_iPos - (int)a_Tok.GetAsString().length(), a_Tok.GetAsString()); 639| | 640| 9.61k| m_iSynFlags = noANY ^ noBO; 641| 9.61k| return true; 642| 9.63k| } _ZN2mu17ParserTokenReader6IsOprtERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE: 650| 2.90M| { 651| 2.90M| const char_type* const szExpr = m_strFormula.c_str(); 652| 2.90M| string_type strTok; 653| | 654| 2.90M| auto iEnd = ExtractOperatorToken(strTok, (std::size_t)m_iPos); 655| 2.90M| if (iEnd == m_iPos) ------------------ | Branch (655:7): [True: 2.37M, False: 533k] ------------------ 656| 2.37M| return false; 657| | 658| | // Check if the operator is a built in operator, if so ignore it here 659| 533k| const char_type** const pOprtDef = m_pParser->GetOprtDef(); 660| 8.11M| for (int i = 0; m_pParser->HasBuiltInOprt() && pOprtDef[i]; ++i) ------------------ | Branch (660:19): [True: 8.11M, False: 0] | Branch (660:50): [True: 7.96M, False: 142k] ------------------ 661| 7.96M| { 662| 7.96M| if (string_type(pOprtDef[i]) == strTok) ------------------ | Branch (662:8): [True: 390k, False: 7.57M] ------------------ 663| 390k| return false; 664| 7.96M| } 665| | 666| | // Note: 667| | // All tokens in oprt_bin_maptype are have been sorted by their length 668| | // Long operators must come first! Otherwise short names (like: "add") that 669| | // are part of long token names (like: "add123") will be found instead 670| | // of the long ones. 671| | // Length sorting is done with ascending length so we use a reverse iterator here. 672| 142k| funmap_type::const_reverse_iterator it = m_pOprtDef->rbegin(); 673| 142k| for (; it != m_pOprtDef->rend(); ++it) ------------------ | Branch (673:10): [True: 0, False: 142k] ------------------ 674| 0| { 675| 0| const string_type& sID = it->first; 676| 0| if (sID == string_type(szExpr + m_iPos, szExpr + m_iPos + sID.length())) ------------------ | Branch (676:8): [True: 0, False: 0] ------------------ 677| 0| { 678| 0| a_Tok.Set(it->second, strTok); 679| | 680| | // operator was found 681| 0| if (m_iSynFlags & noOPT) ------------------ | Branch (681:9): [True: 0, False: 0] ------------------ 682| 0| { 683| | // An operator was found but is not expected to occur at 684| | // this position of the formula, maybe it is an infix 685| | // operator, not a binary operator. Both operator types 686| | // can share characters in their identifiers. 687| 0| if (IsInfixOpTok(a_Tok)) ------------------ | Branch (687:10): [True: 0, False: 0] ------------------ 688| 0| return true; 689| 0| else 690| 0| { 691| | // nope, no infix operator 692| 0| return false; 693| | //Error(ecUNEXPECTED_OPERATOR, m_iPos, a_Tok.GetAsString()); 694| 0| } 695| | 696| 0| } 697| | 698| 0| m_iPos += (int)sID.length(); 699| 0| m_iSynFlags = noBC | noOPT | noARG_SEP | noPOSTOP | noEND | noASSIGN; 700| 0| return true; 701| 0| } 702| 0| } 703| | 704| 142k| return false; 705| 142k| } _ZN2mu17ParserTokenReader11IsPostOpTokERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE: 710| 595| { 711| | // Do not check for postfix operators if they are not allowed at 712| | // the current expression index. 713| | // 714| | // This will fix the bug reported here: 715| | // 716| | // http://sourceforge.net/tracker/index.php?func=detail&aid=3343891&group_id=137191&atid=737979 717| | // 718| 595| if (m_iSynFlags & noPOSTOP) ------------------ | Branch (718:7): [True: 418, False: 177] ------------------ 719| 418| return false; 720| | // 721| | 722| | // Tricky problem with equations like "3m+5": 723| | // m is a postfix operator, + is a valid sign for postfix operators and 724| | // for binary operators parser detects "m+" as operator string and 725| | // finds no matching postfix operator. 726| | // 727| | // This is a special case so this routine slightly differs from the other 728| | // token readers. 729| | 730| | // Test if there could be a postfix operator 731| 177| string_type sTok; 732| 177| auto iEnd = ExtractToken(m_pParser->ValidOprtChars(), sTok, (std::size_t)m_iPos); 733| 177| if (iEnd == m_iPos) ------------------ | Branch (733:7): [True: 28, False: 149] ------------------ 734| 28| return false; 735| | 736| | // iterate over all postfix operator strings 737| 149| funmap_type::const_reverse_iterator it = m_pPostOprtDef->rbegin(); 738| 149| for (; it != m_pPostOprtDef->rend(); ++it) ------------------ | Branch (738:10): [True: 0, False: 149] ------------------ 739| 0| { 740| 0| if (sTok.find(it->first) != 0) ------------------ | Branch (740:8): [True: 0, False: 0] ------------------ 741| 0| continue; 742| | 743| 0| a_Tok.Set(it->second, sTok); 744| 0| m_iPos += (int)it->first.length(); 745| | 746| 0| m_iSynFlags = noVAL | noVAR | noFUN | noBO | noPOSTOP | noSTR | noASSIGN; 747| 0| return true; 748| 0| } 749| | 750| 149| return false; 751| 149| } _ZN2mu17ParserTokenReader8IsValTokERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE: 762| 782k| { 763| 782k| MUP_ASSERT(m_pConstDef != nullptr); ------------------ | | 78| 782k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 782k] | | ------------------ | | 79| 782k| { \ | | 80| 0| stringstream_type ss; \ | | 81| 0| ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 82| 0| << __FILE__ << _T(" line ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 83| 0| << __LINE__ << _T("."); \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 84| 0| throw ParserError( ecINTERNAL_ERROR, -1, ss.str()); \ | | 85| 0| } ------------------ 764| 782k| MUP_ASSERT(m_pParser != nullptr); ------------------ | | 78| 782k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 782k] | | ------------------ | | 79| 782k| { \ | | 80| 0| stringstream_type ss; \ | | 81| 0| ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 82| 0| << __FILE__ << _T(" line ") \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 83| 0| << __LINE__ << _T("."); \ | | ------------------ | | | | 69| 0| #define _T(x) x | | ------------------ | | 84| 0| throw ParserError( ecINTERNAL_ERROR, -1, ss.str()); \ | | 85| 0| } ------------------ 765| | 766| 782k| string_type strTok; 767| 782k| value_type fVal(0); 768| | 769| | // 2.) Check for user defined constant 770| | // Read everything that could be a constant name 771| 782k| auto iEnd = ExtractToken(m_pParser->ValidNameChars(), strTok, (std::size_t)m_iPos); 772| 782k| if (iEnd != m_iPos) ------------------ | Branch (772:7): [True: 757k, False: 24.3k] ------------------ 773| 757k| { 774| 757k| valmap_type::const_iterator item = m_pConstDef->find(strTok); 775| 757k| if (item != m_pConstDef->end()) ------------------ | Branch (775:8): [True: 713, False: 757k] ------------------ 776| 713| { 777| 713| m_iPos = iEnd; 778| 713| a_Tok.SetVal(item->second, strTok); 779| | 780| 713| if (m_iSynFlags & noVAL) ------------------ | Branch (780:9): [True: 3, False: 710] ------------------ 781| 3| Error(ecUNEXPECTED_VAL, m_iPos - (int)strTok.length(), strTok); 782| | 783| 713| m_iSynFlags = noVAL | noVAR | noFUN | noBO | noINFIXOP | noSTR | noASSIGN; 784| 713| return true; 785| 713| } 786| 757k| } 787| | 788| | // 3.call the value recognition functions provided by the user 789| | // Call user defined value recognition functions 790| 781k| std::list::const_iterator item = m_vIdentFun.begin(); 791| 806k| for (item = m_vIdentFun.begin(); item != m_vIdentFun.end(); ++item) ------------------ | Branch (791:36): [True: 781k, False: 24.8k] ------------------ 792| 781k| { 793| 781k| int iStart = m_iPos; 794| 781k| if ((*item)(m_strFormula.c_str() + m_iPos, &m_iPos, &fVal) == 1) ------------------ | Branch (794:8): [True: 756k, False: 24.8k] ------------------ 795| 756k| { 796| | // 2013-11-27 Issue 2: https://code.google.com/p/muparser/issues/detail?id=2 797| 756k| strTok.assign(m_strFormula.c_str(), iStart, (std::size_t)m_iPos - iStart); 798| | 799| 756k| if (m_iSynFlags & noVAL) ------------------ | Branch (799:9): [True: 5, False: 756k] ------------------ 800| 5| Error(ecUNEXPECTED_VAL, m_iPos - (int)strTok.length(), strTok); 801| | 802| 756k| a_Tok.SetVal(fVal, strTok); 803| 756k| m_iSynFlags = noVAL | noVAR | noFUN | noBO | noINFIXOP | noSTR | noASSIGN; 804| 756k| return true; 805| 756k| } 806| 781k| } 807| | 808| 24.8k| return false; 809| 781k| } _ZN2mu17ParserTokenReader8IsVarTokERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE: 817| 24.8k| { 818| 24.8k| if (m_pVarDef->empty()) ------------------ | Branch (818:7): [True: 24.8k, False: 0] ------------------ 819| 24.8k| return false; 820| | 821| 0| string_type strTok; 822| 0| auto iEnd = ExtractToken(m_pParser->ValidNameChars(), strTok, (std::size_t)m_iPos); 823| 0| if (iEnd == m_iPos) ------------------ | Branch (823:7): [True: 0, False: 0] ------------------ 824| 0| return false; 825| | 826| 0| varmap_type::const_iterator item = m_pVarDef->find(strTok); 827| 0| if (item == m_pVarDef->end()) ------------------ | Branch (827:7): [True: 0, False: 0] ------------------ 828| 0| return false; 829| | 830| 0| if (m_iSynFlags & noVAR) ------------------ | Branch (830:7): [True: 0, False: 0] ------------------ 831| 0| Error(ecUNEXPECTED_VAR, m_iPos, strTok); 832| | 833| 0| m_pParser->OnDetectVar(&m_strFormula, m_iPos, iEnd); 834| | 835| 0| m_iPos = iEnd; 836| 0| a_Tok.SetVar(item->second, strTok); 837| 0| m_UsedVar[item->first] = item->second; // Add variable to used-var-list 838| | 839| 0| m_iSynFlags = noVAL | noVAR | noFUN | noBO | noINFIXOP | noSTR; 840| | 841| | // Zur Info hier die SynFlags von IsVal(): 842| | // m_iSynFlags = noVAL | noVAR | noFUN | noBO | noINFIXOP | noSTR | noASSIGN; 843| 0| return true; 844| 0| } _ZN2mu17ParserTokenReader11IsStrVarTokERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE: 848| 24.8k| { 849| 24.8k| if (!m_pStrVarDef || m_pStrVarDef->empty()) ------------------ | Branch (849:7): [True: 0, False: 24.8k] | Branch (849:24): [True: 24.8k, False: 0] ------------------ 850| 24.8k| return false; 851| | 852| 0| string_type strTok; 853| 0| auto iEnd = ExtractToken(m_pParser->ValidNameChars(), strTok, (std::size_t)m_iPos); 854| 0| if (iEnd == m_iPos) ------------------ | Branch (854:7): [True: 0, False: 0] ------------------ 855| 0| return false; 856| | 857| 0| strmap_type::const_iterator item = m_pStrVarDef->find(strTok); 858| 0| if (item == m_pStrVarDef->end()) ------------------ | Branch (858:7): [True: 0, False: 0] ------------------ 859| 0| return false; 860| | 861| 0| if (m_iSynFlags & noSTR) ------------------ | Branch (861:7): [True: 0, False: 0] ------------------ 862| 0| Error(ecUNEXPECTED_VAR, m_iPos, strTok); 863| | 864| 0| m_iPos = iEnd; 865| 0| if (!m_pParser->m_vStringVarBuf.size()) ------------------ | Branch (865:7): [True: 0, False: 0] ------------------ 866| 0| Error(ecINTERNAL_ERROR); 867| | 868| 0| a_Tok.SetString(m_pParser->m_vStringVarBuf[item->second], m_pParser->m_vStringVarBuf.size()); 869| | 870| 0| m_iSynFlags = noANY ^ (noBC | noOPT | noEND | noARG_SEP); 871| 0| return true; 872| 0| } _ZN2mu17ParserTokenReader8IsStringERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE: 935| 24.8k| { 936| 24.8k| if (m_strFormula[m_iPos] != '"') ------------------ | Branch (936:7): [True: 595, False: 24.2k] ------------------ 937| 595| return false; 938| | 939| 24.2k| string_type strBuf(&m_strFormula[(std::size_t)m_iPos + 1]); 940| 24.2k| std::size_t iEnd(0), iSkip(0); 941| | 942| | // parser over escaped '\"' end replace them with '"' 943| 24.5k| for (iEnd = (int)strBuf.find(_T('\"')); iEnd != 0 && iEnd != string_type::npos; iEnd = (int)strBuf.find(_T('\"'), iEnd)) ------------------ | | 69| 24.2k| #define _T(x) x ------------------ for (iEnd = (int)strBuf.find(_T('\"')); iEnd != 0 && iEnd != string_type::npos; iEnd = (int)strBuf.find(_T('\"'), iEnd)) ------------------ | | 69| 299| #define _T(x) x ------------------ | Branch (943:43): [True: 2.32k, False: 22.2k] | Branch (943:56): [True: 2.29k, False: 36] ------------------ 944| 2.29k| { 945| 2.29k| if (strBuf[iEnd - 1] != '\\') break; ------------------ | Branch (945:8): [True: 1.99k, False: 299] ------------------ 946| 299| strBuf.replace(iEnd - 1, 2, _T("\"")); ------------------ | | 69| 299| #define _T(x) x ------------------ 947| 299| iSkip++; 948| 299| } 949| | 950| 24.2k| if (iEnd == string_type::npos) ------------------ | Branch (950:7): [True: 36, False: 24.2k] ------------------ 951| 36| Error(ecUNTERMINATED_STRING, m_iPos, _T("\"")); ------------------ | | 69| 36| #define _T(x) x ------------------ 952| | 953| 24.2k| string_type strTok(strBuf.begin(), strBuf.begin() + iEnd); 954| | 955| 24.2k| if (m_iSynFlags & noSTR) ------------------ | Branch (955:7): [True: 64, False: 24.2k] ------------------ 956| 64| Error(ecUNEXPECTED_STR, m_iPos, strTok); 957| | 958| 24.2k| m_pParser->m_vStringBuf.push_back(strTok); // Store string in internal buffer 959| 24.2k| a_Tok.SetString(strTok, m_pParser->m_vStringBuf.size()); 960| | 961| 24.2k| m_iPos += (int)strTok.length() + 2 + (int)iSkip; // +2 for quotes; +iSkip for escape characters 962| 24.2k| m_iSynFlags = noANY ^ (noARG_SEP | noBC | noOPT | noEND); 963| | 964| 24.2k| return true; 965| 24.8k| } _ZNK2mu17ParserTokenReader5ErrorENS_11EErrorCodesEiRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 978| 1.81k| { 979| 1.81k| m_pParser->Error(a_iErrc, a_iPos, a_sTok); 980| 1.81k| } _ZNK2mu17ParserTokenReader9GetArgSepEv: 990| 3.99k| { 991| 3.99k| return m_cArgSep; 992| 3.99k| } LLVMFuzzerTestOneInput: 22| 3.99k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 23| 3.99k| std::string line_string((char *)data, size); 24| 3.99k| try { 25| 3.99k| mu::Parser parser; 26| 3.99k| parser.SetExpr(line_string); 27| 3.99k| parser.Eval(); 28| 3.99k| } catch (mu::Parser::exception_type &e) { 29| 2.47k| } catch (mu::ParserError &e) { 30| 0| } 31| 3.99k| return 0; 32| 3.99k|}