_ZN2mu10ParserBase9DefineFunIPFddEEEvRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEET_b: 140| 84.0k| { 141| 84.0k| AddCallback(a_strName, ParserCallback(a_pFun, a_bAllowOpt), m_FunDef, ValidNameChars()); 142| 84.0k| } _ZN2mu10ParserBase9DefineFunIPFdddEEEvRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEET_b: 140| 4.00k| { 141| 4.00k| AddCallback(a_strName, ParserCallback(a_pFun, a_bAllowOpt), m_FunDef, ValidNameChars()); 142| 4.00k| } _ZN2mu10ParserBase9DefineFunIPFdPKdiEEEvRKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEET_b: 140| 16.0k| { 141| 16.0k| AddCallback(a_strName, ParserCallback(a_pFun, a_bAllowOpt), m_FunDef, ValidNameChars()); 142| 16.0k| } _ZN2mu10ParserBase14change_dec_sepIcEC2Ecci: 221| 2| {} _ZNK2mu10ParserBase14change_dec_sepIcE16do_decimal_pointEv: 226| 805k| { 227| 805k| return m_cDecPoint; 228| 805k| } _ZNK2mu10ParserBase14change_dec_sepIcE16do_thousands_sepEv: 231| 801k| { 232| 801k| return m_cThousandsSep; 233| 801k| } _ZNK2mu10ParserBase14change_dec_sepIcE11do_groupingEv: 236| 801k| { 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| 801k| return std::string(1, (char)(m_cThousandsSep > 0 ? m_nGroup : CHAR_MAX)); ------------------ | Branch (242:34): [True: 0, False: 801k] ------------------ 243| 801k| } _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| 4.00k| static bool IsInteger() { return false; } _ZN2mu8MathImplIdE3SinEd: 116| 198| static T Sin(T v) { return sin(v); } _ZN2mu8MathImplIdE3CosEd: 117| 195| 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| 200| static T Sinh(T v) { return sinh(v); } _ZN2mu8MathImplIdE4CoshEd: 124| 195| static T Cosh(T v) { return cosh(v); } _ZN2mu8MathImplIdE4TanhEd: 125| 220| 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| 323| 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| 360| static T Log(T v) { return log(v); } _ZN2mu8MathImplIdE3ExpEd: 132| 195| static T Exp(T v) { return exp(v); } _ZN2mu8MathImplIdE4SqrtEd: 134| 200| static T Sqrt(T v) { return sqrt(v); } _ZN2mu8MathImplIdE4SignEd: 136| 408| static T Sign(T v) { return (T)((v < 0) ? -1 : (v > 0) ? 1 : 0); } ------------------ | Branch (136:35): [True: 212, False: 196] | Branch (136:50): [True: 196, False: 0] ------------------ _ZN2mu8MathImplIdE4RintEd: 135| 195| static T Rint(T v) { return floor(v + (T)0.5); } _ZN2mu8MathImplIdE3AbsEd: 133| 395| static T Abs(T v) { return (v >= 0) ? v : -v; } ------------------ | Branch (133:30): [True: 201, False: 194] ------------------ _ZN2mu8MathImplIdE3SumEPKdi: 143| 517| { 144| 517| if (!a_iArgc) ------------------ | Branch (144:8): [True: 0, False: 517] ------------------ 145| 0| throw ParserError(_T("too few arguments for function sum.")); ------------------ | | 69| 0| #define _T(x) x ------------------ 146| | 147| 517| T fRes = 0; 148| 39.6k| for (int i = 0; i < a_iArgc; ++i) fRes += a_afArg[i]; ------------------ | Branch (148:20): [True: 39.1k, False: 517] ------------------ 149| 517| return fRes; 150| 517| } _ZN2mu8MathImplIdE3AvgEPKdi: 153| 495| { 154| 495| if (!a_iArgc) ------------------ | Branch (154:8): [True: 0, False: 495] ------------------ 155| 0| throw ParserError(_T("too few arguments for function avg.")); ------------------ | | 69| 0| #define _T(x) x ------------------ 156| | 157| 495| T fRes = 0; 158| 38.5k| for (int i = 0; i < a_iArgc; ++i) fRes += a_afArg[i]; ------------------ | Branch (158:20): [True: 38.0k, False: 495] ------------------ 159| 495| return fRes / (T)a_iArgc; 160| 495| } _ZN2mu8MathImplIdE3MinEPKdi: 163| 1.10k| { 164| 1.10k| if (!a_iArgc) ------------------ | Branch (164:8): [True: 0, False: 1.10k] ------------------ 165| 0| throw ParserError(_T("too few arguments for function min.")); ------------------ | | 69| 0| #define _T(x) x ------------------ 166| | 167| 1.10k| T fRes = a_afArg[0]; 168| 52.6k| for (int i = 0; i < a_iArgc; ++i) ------------------ | Branch (168:20): [True: 51.5k, False: 1.10k] ------------------ 169| 51.5k| fRes = std::min(fRes, a_afArg[i]); 170| | 171| 1.10k| return fRes; 172| 1.10k| } _ZN2mu8MathImplIdE3MaxEPKdi: 175| 1.06k| { 176| 1.06k| if (!a_iArgc) ------------------ | Branch (176:8): [True: 0, False: 1.06k] ------------------ 177| 0| throw ParserError(_T("too few arguments for function max.")); ------------------ | | 69| 0| #define _T(x) x ------------------ 178| | 179| 1.06k| T fRes = a_afArg[0]; 180| 54.4k| for (int i = 0; i < a_iArgc; ++i) fRes = std::max(fRes, a_afArg[i]); ------------------ | Branch (180:20): [True: 53.3k, False: 1.06k] ------------------ 181| | 182| 1.06k| return fRes; 183| 1.06k| } _ZN2mu8MathImplIdE10UnaryMinusEd: 139| 3.88k| static T UnaryMinus(T v) { return -v; } _ZN2mu8MathImplIdE3PowEdd: 137| 116k| static T Pow(T v1, T v2) { return std::pow(v1, v2); } _ZNK2mu21generic_callable_type12call_multfunEPKdi: 104| 3.18k| { 105| 3.18k| if (_pUserData == nullptr) { ------------------ | Branch (105:8): [True: 3.18k, False: 0] ------------------ 106| 3.18k| auto multfun_typed_ptr = reinterpret_cast(_pRawFun); 107| 3.18k| return (*multfun_typed_ptr)(a_afArg, a_iArgc); 108| 3.18k| } 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.18k| } _ZNK2mu21generic_callable_typeeqES0_: 131| 85.6k| { 132| 85.6k| return _pRawFun == other._pRawFun && _pUserData == other._pUserData; ------------------ | Branch (132:11): [True: 5.78k, False: 79.8k] | Branch (132:41): [True: 5.78k, False: 0] ------------------ 133| 85.6k| } _ZNK2mu21generic_callable_typeeqEDn: 141| 89.2k| { 142| 89.2k| return _pRawFun == nullptr; 143| 89.2k| } _ZNK2mu21generic_callable_typeneEDn: 146| 186k| { 147| 186k| return _pRawFun != nullptr; 148| 186k| } _ZNK2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE7GetCodeEv: 383| 13.9M| { 384| 13.9M| if (m_pCallback.get()) ------------------ | Branch (384:8): [True: 1.19M, False: 12.7M] ------------------ 385| 1.19M| { 386| 1.19M| return m_pCallback->GetCode(); 387| 1.19M| } 388| 12.7M| else 389| 12.7M| { 390| 12.7M| return m_iCode; 391| 12.7M| } 392| 13.9M| } _ZNK2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE6GetPriEv: 409| 78.8k| { 410| 78.8k| if (!m_pCallback.get()) ------------------ | Branch (410:8): [True: 0, False: 78.8k] ------------------ 411| 0| throw ParserError(ecINTERNAL_ERROR); 412| | 413| 78.8k| if (m_pCallback->GetCode() != cmOPRT_BIN && m_pCallback->GetCode() != cmOPRT_INFIX) ------------------ | Branch (413:8): [True: 78.8k, False: 0] | Branch (413:48): [True: 0, False: 78.8k] ------------------ 414| 0| throw ParserError(ecINTERNAL_ERROR); 415| | 416| 78.8k| return m_pCallback->GetPri(); 417| 78.8k| } _ZNK2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE11GetAsStringEv: 514| 27.5k| { 515| 27.5k| return m_strTok; 516| 27.5k| } _ZN2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEC2Ev: 200| 3.35M| {} _ZNK2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE11GetFuncAddrEv: 444| 364k| { 445| 364k| return (m_pCallback.get()) ------------------ | Branch (445:11): [True: 276k, False: 88.2k] ------------------ 446| 364k| ? generic_callable_type{(erased_fun_type)m_pCallback->GetAddr(), 447| 276k| m_pCallback->GetUserData()} 448| 364k| : generic_callable_type{}; 449| 364k| } _ZNK2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE11GetArgCountEv: 487| 356k| { 488| 356k| MUP_ASSERT(m_pCallback.get()); ------------------ | | 78| 356k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 356k] | | ------------------ | | 79| 356k| { \ | | 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| 356k| if (!m_pCallback->IsValid()) ------------------ | Branch (490:8): [True: 0, False: 356k] ------------------ 491| 0| throw ParserError(ecINTERNAL_ERROR); 492| | 493| 356k| return m_pCallback->GetArgc(); 494| 356k| } _ZN2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE6SetValEdRKS7_: 297| 1.01M| { 298| 1.01M| m_iCode = cmVAL; 299| 1.01M| m_iType = tpDBL; 300| 1.01M| m_fVal = a_fVal; 301| 1.01M| m_strTok = a_strTok; 302| 1.01M| m_iIdx = -1; 303| | 304| 1.01M| m_pTok = 0; 305| 1.01M| m_pCallback.reset(0); 306| | 307| 1.01M| return *this; 308| 1.01M| } _ZNK2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE6GetValEv: 458| 858k| { 459| 858k| switch (m_iCode) 460| 858k| { 461| 858k| case cmVAL: return m_fVal; ------------------ | Branch (461:4): [True: 858k, False: 2] ------------------ 462| 0| case cmVAR: return *((TBase*)m_pTok); ------------------ | Branch (462:4): [True: 0, False: 858k] ------------------ 463| 2| default: throw ParserError(ecVAL_EXPECTED); ------------------ | Branch (463:4): [True: 2, False: 858k] ------------------ 464| 858k| } 465| 858k| } _ZN2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEC2ERKS8_: 211| 7.42M| { 212| 7.42M| Assign(a_Tok); 213| 7.42M| } _ZN2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE6AssignERKS8_: 234| 16.4M| { 235| 16.4M| m_iCode = a_Tok.m_iCode; 236| 16.4M| m_pTok = a_Tok.m_pTok; 237| 16.4M| m_strTok = a_Tok.m_strTok; 238| 16.4M| m_iIdx = a_Tok.m_iIdx; 239| 16.4M| m_strVal = a_Tok.m_strVal; 240| 16.4M| m_iType = a_Tok.m_iType; 241| 16.4M| m_fVal = a_Tok.m_fVal; 242| | // create new callback object if a_Tok has one 243| 16.4M| m_pCallback.reset(a_Tok.m_pCallback.get() ? a_Tok.m_pCallback->Clone() : 0); ------------------ | Branch (243:22): [True: 628k, False: 15.8M] ------------------ 244| 16.4M| } _ZNK2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE7GetTypeEv: 396| 1.10M| { 397| 1.10M| if (m_pCallback.get()) ------------------ | Branch (397:8): [True: 178k, False: 928k] ------------------ 398| 178k| { 399| 178k| return m_pCallback->GetType(); 400| 178k| } 401| 928k| else 402| 928k| { 403| 928k| return m_iType; 404| 928k| } 405| 1.10M| } _ZNK2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE13IsOptimizableEv: 500| 89.2k| { 501| 89.2k| return m_pCallback->IsValid() && m_pCallback->IsOptimizable(); ------------------ | Branch (501:11): [True: 89.2k, False: 0] | Branch (501:37): [True: 89.2k, False: 0] ------------------ 502| 89.2k| } _ZNK2mu21generic_callable_type8call_funILm1EJRdEEEdDpOT0_: 76| 8.53k| { 77| 8.53k| static_assert(NbParams == sizeof...(Args), "mismatch between NbParams and Args"); 78| 8.53k| if (_pUserData == nullptr) ------------------ | Branch (78:8): [True: 8.53k, False: 0] ------------------ 79| 8.53k| { 80| 8.53k| auto fun_typed_ptr = reinterpret_cast::fun_type>(_pRawFun); 81| 8.53k| return (*fun_typed_ptr)(std::forward(args)...); 82| 8.53k| } 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| 8.53k| } _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| 9.01M| { 224| 9.01M| Assign(a_Tok); 225| 9.01M| return *this; 226| 9.01M| } _ZN2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE6SetIdxEi: 353| 27.2k| { 354| 27.2k| if (m_iCode != cmSTRING || a_iIdx < 0) ------------------ | Branch (354:8): [True: 0, False: 27.2k] | Branch (354:31): [True: 0, False: 27.2k] ------------------ 355| 0| throw ParserError(ecINTERNAL_ERROR); 356| | 357| 27.2k| m_iIdx = a_iIdx; 358| 27.2k| } _ZN2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE3SetENS_8ECmdCodeERKS7_: 258| 2.05M| { 259| | // The following types can't be set this way, they have special Set functions 260| 2.05M| MUP_ASSERT(a_iType != cmVAR); ------------------ | | 78| 2.05M| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 2.05M] | | ------------------ | | 79| 2.05M| { \ | | 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.05M| MUP_ASSERT(a_iType != cmVAL); ------------------ | | 78| 2.05M| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 2.05M] | | ------------------ | | 79| 2.05M| { \ | | 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.05M| MUP_ASSERT(a_iType != cmFUNC); ------------------ | | 78| 2.05M| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 2.05M] | | ------------------ | | 79| 2.05M| { \ | | 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.05M| m_iCode = a_iType; 265| 2.05M| m_iType = tpVOID; 266| 2.05M| m_pTok = 0; 267| 2.05M| m_strTok = a_strTok; 268| 2.05M| m_iIdx = -1; 269| | 270| 2.05M| return *this; 271| 2.05M| } _ZN2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE3SetERKNS_14ParserCallbackERKS7_: 276| 107k| { 277| 107k| MUP_ASSERT(a_pCallback.IsValid()); ------------------ | | 78| 107k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 107k] | | ------------------ | | 79| 107k| { \ | | 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| 107k| m_iCode = a_pCallback.GetCode(); 280| 107k| m_iType = tpVOID; 281| 107k| m_strTok = a_sTok; 282| 107k| m_pCallback.reset(new ParserCallback(a_pCallback)); 283| | 284| 107k| m_pTok = 0; 285| 107k| m_iIdx = -1; 286| | 287| 107k| return *this; 288| 107k| } _ZN2mu11ParserTokenIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE9SetStringERKS7_m: 334| 27.3k| { 335| 27.3k| m_iCode = cmSTRING; 336| 27.3k| m_iType = tpSTR; 337| 27.3k| m_strTok = a_strTok; 338| 27.3k| m_iIdx = static_cast(a_iSize); 339| | 340| 27.3k| m_pTok = 0; 341| 27.3k| m_pCallback.reset(0); 342| 27.3k| return *this; 343| 27.3k| } _ZN2mu6Parser5IsValEPKcPiPd: 56| 801k| { 57| 801k| value_type fVal(0); 58| | 59| 801k| stringstream_type stream(a_szExpr); 60| 801k| stream.seekg(0); // todo: check if this really is necessary 61| 801k| stream.imbue(Parser::s_locale); 62| 801k| stream >> fVal; 63| 801k| stringstream_type::pos_type iEnd = stream.tellg(); // Position after reading 64| | 65| 801k| if (iEnd == (stringstream_type::pos_type) - 1) ------------------ | Branch (65:7): [True: 28.0k, False: 773k] ------------------ 66| 28.0k| return 0; 67| | 68| 773k| *a_iPos += (int)iEnd; 69| 773k| *a_fVal = fVal; 70| 773k| return 1; 71| 801k| } _ZN2mu6ParserC2Ev: 81| 4.00k| { 82| 4.00k| AddValIdent(IsVal); 83| | 84| 4.00k| InitCharSets(); 85| 4.00k| InitFun(); 86| 4.00k| InitConst(); 87| 4.00k| InitOprt(); 88| 4.00k| } _ZN2mu6Parser12InitCharSetsEv: 98| 4.00k| { 99| 4.00k| DefineNameChars(_T("0123456789_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 100| 4.00k| DefineOprtChars(_T("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+-*^/?<>=#!$%&|~'_{}")); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 101| 4.00k| DefineInfixOprtChars(_T("/+-*^?<>=#!$%&|~'_")); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 102| 4.00k| } _ZN2mu6Parser7InitFunEv: 107| 4.00k| { 108| 4.00k| if (mu::TypeInfo::IsInteger()) ------------------ | Branch (108:7): [True: 0, False: 4.00k] ------------------ 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| 4.00k| else 117| 4.00k| { 118| | // trigonometric functions 119| 4.00k| DefineFun(_T("sin"), MathImpl::Sin); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 120| 4.00k| DefineFun(_T("cos"), MathImpl::Cos); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 121| 4.00k| DefineFun(_T("tan"), MathImpl::Tan); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 122| | // arcus functions 123| 4.00k| DefineFun(_T("asin"), MathImpl::ASin); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 124| 4.00k| DefineFun(_T("acos"), MathImpl::ACos); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 125| 4.00k| DefineFun(_T("atan"), MathImpl::ATan); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 126| 4.00k| DefineFun(_T("atan2"), MathImpl::ATan2); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 127| | // hyperbolic functions 128| 4.00k| DefineFun(_T("sinh"), MathImpl::Sinh); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 129| 4.00k| DefineFun(_T("cosh"), MathImpl::Cosh); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 130| 4.00k| DefineFun(_T("tanh"), MathImpl::Tanh); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 131| | // arcus hyperbolic functions 132| 4.00k| DefineFun(_T("asinh"), MathImpl::ASinh); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 133| 4.00k| DefineFun(_T("acosh"), MathImpl::ACosh); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 134| 4.00k| DefineFun(_T("atanh"), MathImpl::ATanh); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 135| | // Logarithm functions 136| 4.00k| DefineFun(_T("log2"), MathImpl::Log2); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 137| 4.00k| DefineFun(_T("log10"), MathImpl::Log10); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 138| 4.00k| DefineFun(_T("log"), MathImpl::Log); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 139| 4.00k| DefineFun(_T("ln"), MathImpl::Log); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 140| | // misc 141| 4.00k| DefineFun(_T("exp"), MathImpl::Exp); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 142| 4.00k| DefineFun(_T("sqrt"), MathImpl::Sqrt); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 143| 4.00k| DefineFun(_T("sign"), MathImpl::Sign); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 144| 4.00k| DefineFun(_T("rint"), MathImpl::Rint); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 145| 4.00k| DefineFun(_T("abs"), MathImpl::Abs); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 146| | // Functions with variable number of arguments 147| 4.00k| DefineFun(_T("sum"), MathImpl::Sum); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 148| 4.00k| DefineFun(_T("avg"), MathImpl::Avg); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 149| 4.00k| DefineFun(_T("min"), MathImpl::Min); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 150| 4.00k| DefineFun(_T("max"), MathImpl::Max); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 151| 4.00k| } 152| 4.00k| } _ZN2mu6Parser9InitConstEv: 161| 4.00k| { 162| 4.00k| DefineConst(_T("_pi"), MathImpl::CONST_PI); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 163| 4.00k| DefineConst(_T("_e"), MathImpl::CONST_E); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 164| 4.00k| } _ZN2mu6Parser8InitOprtEv: 172| 4.00k| { 173| 4.00k| DefineInfixOprt(_T("-"), MathImpl::UnaryMinus); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 174| 4.00k| DefineInfixOprt(_T("+"), MathImpl::UnaryPlus); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 175| 4.00k| } _ZN2mu10ParserBaseC2Ev: 108| 4.00k| { 109| 4.00k| InitTokenReader(); 110| 4.00k| } _ZN2mu10ParserBaseD2Ev: 141| 4.00k| {} _ZN2mu10ParserBase15InitTokenReaderEv: 246| 4.00k| { 247| 4.00k| m_pTokenReader.reset(new token_reader_type(this)); 248| 4.00k| } _ZNK2mu10ParserBase6ReInitEv: 257| 128k| { 258| 128k| m_pParseFormula = &ParserBase::ParseString; 259| 128k| m_vStringBuf.clear(); 260| 128k| m_vRPN.clear(); 261| 128k| m_pTokenReader->ReInit(); 262| 128k| } _ZN2mu10ParserBase11AddValIdentEPFiPKcPiPdE: 329| 4.00k| { 330| 4.00k| m_pTokenReader->AddValIdent(a_pCallback); 331| 4.00k| } _ZN2mu10ParserBase11AddCallbackERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS_14ParserCallbackERNS1_3mapIS7_SA_NS1_4lessIS7_EENS5_INS1_4pairIS8_SA_EEEEEEPKc: 350| 112k| { 351| 112k| if (!a_Callback.IsValid()) ------------------ | Branch (351:7): [True: 0, False: 112k] ------------------ 352| 0| Error(ecINVALID_FUN_PTR); 353| | 354| 112k| const funmap_type* pFunMap = &a_Storage; 355| | 356| | // Check for conflicting operator or function names 357| 112k| if (pFunMap != &m_FunDef && m_FunDef.find(a_strName) != m_FunDef.end()) ------------------ | Branch (357:7): [True: 8.00k, False: 104k] | Branch (357:7): [True: 0, False: 112k] | Branch (357:31): [True: 0, False: 8.00k] ------------------ 358| 0| Error(ecNAME_CONFLICT, -1, a_strName); 359| | 360| 112k| if (pFunMap != &m_PostOprtDef && m_PostOprtDef.find(a_strName) != m_PostOprtDef.end()) ------------------ | Branch (360:7): [True: 112k, False: 0] | Branch (360:7): [True: 0, False: 112k] | Branch (360:36): [True: 0, False: 112k] ------------------ 361| 0| Error(ecNAME_CONFLICT, -1, a_strName); 362| | 363| 112k| if (pFunMap != &m_InfixOprtDef && pFunMap != &m_OprtDef && m_InfixOprtDef.find(a_strName) != m_InfixOprtDef.end()) ------------------ | Branch (363:7): [True: 104k, False: 8.00k] | Branch (363:7): [True: 0, False: 112k] | Branch (363:37): [True: 104k, False: 0] | Branch (363:62): [True: 0, False: 104k] ------------------ 364| 0| Error(ecNAME_CONFLICT, -1, a_strName); 365| | 366| 112k| if (pFunMap != &m_InfixOprtDef && pFunMap != &m_OprtDef && m_OprtDef.find(a_strName) != m_OprtDef.end()) ------------------ | Branch (366:7): [True: 104k, False: 8.00k] | Branch (366:7): [True: 0, False: 112k] | Branch (366:37): [True: 104k, False: 0] | Branch (366:62): [True: 0, False: 104k] ------------------ 367| 0| Error(ecNAME_CONFLICT, -1, a_strName); 368| | 369| 112k| CheckOprt(a_strName, a_Callback, a_szCharSet); 370| 112k| a_Storage[a_strName] = a_Callback; 371| 112k| ReInit(); 372| 112k| } _ZNK2mu10ParserBase9CheckOprtERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS_14ParserCallbackES9_: 382| 112k| { 383| 112k| if (!a_sName.length() || ------------------ | Branch (383:7): [True: 0, False: 112k] ------------------ 384| 112k| (a_sName.find_first_not_of(a_szCharSet) != string_type::npos) || ------------------ | Branch (384:4): [True: 0, False: 112k] ------------------ 385| 112k| (a_sName[0] >= '0' && a_sName[0] <= '9')) ------------------ | Branch (385:5): [True: 104k, False: 8.00k] | Branch (385:26): [True: 0, False: 104k] ------------------ 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| 112k| } _ZNK2mu10ParserBase9CheckNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_: 401| 8.00k| { 402| 8.00k| if (!a_sName.length() || ------------------ | Branch (402:7): [True: 0, False: 8.00k] ------------------ 403| 8.00k| (a_sName.find_first_not_of(a_szCharSet) != string_type::npos) || ------------------ | Branch (403:4): [True: 0, False: 8.00k] ------------------ 404| 8.00k| (a_sName[0] >= '0' && a_sName[0] <= '9')) ------------------ | Branch (404:5): [True: 8.00k, False: 0] | Branch (404:26): [True: 0, False: 8.00k] ------------------ 405| 0| { 406| 0| Error(ecINVALID_NAME); 407| 0| } 408| 8.00k| } _ZN2mu10ParserBase7SetExprERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 418| 4.00k| { 419| | // Check locale compatibility 420| 4.00k| if (m_pTokenReader->GetArgSep() == std::use_facet >(s_locale).decimal_point()) ------------------ | Branch (420:7): [True: 0, False: 4.00k] ------------------ 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| 4.00k| if (a_sExpr.length() >= MaxLenExpression) ------------------ | Branch (424:7): [True: 29, False: 3.97k] ------------------ 425| 29| Error(ecEXPRESSION_TOO_LONG, 0, a_sExpr); 426| | 427| 4.00k| m_pTokenReader->SetFormula(a_sExpr + _T(" ")); ------------------ | | 69| 4.00k| #define _T(x) x ------------------ 428| 4.00k| ReInit(); 429| 4.00k| } _ZNK2mu10ParserBase10GetOprtDefEv: 436| 3.54M| { 437| 3.54M| return (const char_type**)(&c_DefaultOprt[0]); 438| 3.54M| } _ZN2mu10ParserBase15DefineNameCharsEPKc: 445| 4.00k| { 446| 4.00k| m_sNameChars = a_szCharset; 447| 4.00k| } _ZN2mu10ParserBase15DefineOprtCharsEPKc: 454| 4.00k| { 455| 4.00k| m_sOprtChars = a_szCharset; 456| 4.00k| } _ZN2mu10ParserBase20DefineInfixOprtCharsEPKc: 463| 4.00k| { 464| 4.00k| m_sInfixOprtChars = a_szCharset; 465| 4.00k| } _ZNK2mu10ParserBase14ValidNameCharsEv: 472| 3.87M| { 473| 3.87M| MUP_ASSERT(m_sNameChars.size()); ------------------ | | 78| 3.87M| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 3.87M] | | ------------------ | | 79| 3.87M| { \ | | 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.87M| return m_sNameChars.c_str(); 475| 3.87M| } _ZNK2mu10ParserBase14ValidOprtCharsEv: 482| 2.95M| { 483| 2.95M| MUP_ASSERT(m_sOprtChars.size()); ------------------ | | 78| 2.95M| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 2.95M] | | ------------------ | | 79| 2.95M| { \ | | 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.95M| return m_sOprtChars.c_str(); 485| 2.95M| } _ZNK2mu10ParserBase19ValidInfixOprtCharsEv: 492| 106k| { 493| 106k| MUP_ASSERT(m_sInfixOprtChars.size()); ------------------ | | 78| 106k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 106k] | | ------------------ | | 79| 106k| { \ | | 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| 106k| return m_sInfixOprtChars.c_str(); 495| 106k| } _ZN2mu10ParserBase15DefineInfixOprtERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPFddEib: 532| 8.00k| { 533| 8.00k| if (a_sName.length() > MaxLenIdentifier) ------------------ | Branch (533:7): [True: 0, False: 8.00k] ------------------ 534| 0| Error(ecIDENTIFIER_TOO_LONG); 535| | 536| 8.00k| AddCallback(a_sName, ParserCallback(a_pFun, a_bAllowOpt, a_iPrec, cmOPRT_INFIX), m_InfixOprtDef, ValidInfixOprtChars()); 537| 8.00k| } _ZN2mu10ParserBase11DefineConstERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEd: 618| 8.00k| { 619| 8.00k| if (a_sName.length() > MaxLenIdentifier) ------------------ | Branch (619:7): [True: 0, False: 8.00k] ------------------ 620| 0| Error(ecIDENTIFIER_TOO_LONG); 621| | 622| 8.00k| CheckName(a_sName, ValidNameChars()); 623| 8.00k| m_ConstDef[a_sName] = a_fVal; 624| 8.00k| ReInit(); 625| 8.00k| } _ZNK2mu10ParserBase17GetOprtPrecedenceERKNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE: 632| 639k| { 633| 639k| switch (a_Tok.GetCode()) 634| 639k| { 635| | // built in operators 636| 0| case cmEND: return -5; ------------------ | Branch (636:3): [True: 0, False: 639k] ------------------ 637| 0| case cmARG_SEP: return -4; ------------------ | Branch (637:3): [True: 0, False: 639k] ------------------ 638| 0| case cmASSIGN: return -1; ------------------ | Branch (638:3): [True: 0, False: 639k] ------------------ 639| 0| case cmELSE: ------------------ | Branch (639:3): [True: 0, False: 639k] ------------------ 640| 77.5k| case cmIF: return 0; ------------------ | Branch (640:3): [True: 77.5k, False: 562k] ------------------ 641| 4.86k| case cmLAND: return prLAND; ------------------ | Branch (641:3): [True: 4.86k, False: 634k] ------------------ 642| 5.97k| case cmLOR: return prLOR; ------------------ | Branch (642:3): [True: 5.97k, False: 633k] ------------------ 643| 4.13k| case cmLT: ------------------ | Branch (643:3): [True: 4.13k, False: 635k] ------------------ 644| 8.68k| case cmGT: ------------------ | Branch (644:3): [True: 4.54k, False: 635k] ------------------ 645| 11.2k| case cmLE: ------------------ | Branch (645:3): [True: 2.57k, False: 637k] ------------------ 646| 13.4k| case cmGE: ------------------ | Branch (646:3): [True: 2.16k, False: 637k] ------------------ 647| 15.6k| case cmNEQ: ------------------ | Branch (647:3): [True: 2.19k, False: 637k] ------------------ 648| 18.4k| case cmEQ: return prCMP; ------------------ | Branch (648:3): [True: 2.85k, False: 636k] ------------------ 649| 8.79k| case cmADD: ------------------ | Branch (649:3): [True: 8.79k, False: 630k] ------------------ 650| 71.3k| case cmSUB: return prADD_SUB; ------------------ | Branch (650:3): [True: 62.5k, False: 577k] ------------------ 651| 6.34k| case cmMUL: ------------------ | Branch (651:3): [True: 6.34k, False: 633k] ------------------ 652| 13.4k| case cmDIV: return prMUL_DIV; ------------------ | Branch (652:3): [True: 7.05k, False: 632k] ------------------ 653| 369k| case cmPOW: return prPOW; ------------------ | Branch (653:3): [True: 369k, False: 270k] ------------------ 654| | 655| | // user defined binary operators 656| 78.8k| case cmOPRT_INFIX: ------------------ | Branch (656:3): [True: 78.8k, False: 560k] ------------------ 657| 78.8k| case cmOPRT_BIN: return a_Tok.GetPri(); ------------------ | Branch (657:3): [True: 0, False: 639k] ------------------ 658| 0| default: ------------------ | Branch (658:3): [True: 0, False: 639k] ------------------ 659| 0| throw exception_type(ecINTERNAL_ERROR, 5, _T("")); ------------------ | | 69| 0| #define _T(x) x ------------------ 660| 639k| } 661| 639k| } _ZNK2mu10ParserBase20GetOprtAssociativityERKNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE: 668| 173k| { 669| 173k| switch (a_Tok.GetCode()) 670| 173k| { 671| 0| case cmASSIGN: ------------------ | Branch (671:3): [True: 0, False: 173k] ------------------ 672| 1.30k| case cmLAND: ------------------ | Branch (672:3): [True: 1.30k, False: 171k] ------------------ 673| 3.11k| case cmLOR: ------------------ | Branch (673:3): [True: 1.81k, False: 171k] ------------------ 674| 4.82k| case cmLT: ------------------ | Branch (674:3): [True: 1.70k, False: 171k] ------------------ 675| 6.54k| case cmGT: ------------------ | Branch (675:3): [True: 1.72k, False: 171k] ------------------ 676| 7.55k| case cmLE: ------------------ | Branch (676:3): [True: 1.00k, False: 172k] ------------------ 677| 8.50k| case cmGE: ------------------ | Branch (677:3): [True: 953, False: 172k] ------------------ 678| 9.53k| case cmNEQ: ------------------ | Branch (678:3): [True: 1.02k, False: 172k] ------------------ 679| 10.4k| case cmEQ: ------------------ | Branch (679:3): [True: 894, False: 172k] ------------------ 680| 12.8k| case cmADD: ------------------ | Branch (680:3): [True: 2.44k, False: 170k] ------------------ 681| 14.4k| case cmSUB: ------------------ | Branch (681:3): [True: 1.60k, False: 171k] ------------------ 682| 16.5k| case cmMUL: ------------------ | Branch (682:3): [True: 2.11k, False: 170k] ------------------ 683| 18.7k| case cmDIV: return oaLEFT; ------------------ | Branch (683:3): [True: 2.12k, False: 170k] ------------------ 684| 154k| case cmPOW: return oaRIGHT; ------------------ | Branch (684:3): [True: 154k, False: 18.7k] ------------------ 685| 0| case cmOPRT_BIN: return a_Tok.GetAssociativity(); ------------------ | Branch (685:3): [True: 0, False: 173k] ------------------ 686| 0| default: return oaNONE; ------------------ | Branch (686:3): [True: 0, False: 173k] ------------------ 687| 173k| } 688| 173k| } _ZNK2mu10ParserBase9ApplyFuncERNSt3__15stackINS_11ParserTokenIdNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_5dequeISA_NS7_ISA_EEEEEESF_i: 801| 89.2k| { 802| 89.2k| MUP_ASSERT(m_pTokenReader.get()); ------------------ | | 78| 89.2k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 89.2k] | | ------------------ | | 79| 89.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| 89.2k| if (a_stOpt.empty() || a_stOpt.top().GetFuncAddr() == 0) ------------------ | Branch (805:7): [True: 0, False: 89.2k] | Branch (805:7): [True: 0, False: 89.2k] | Branch (805:26): [True: 0, False: 89.2k] ------------------ 806| 0| return; 807| | 808| 89.2k| token_type funTok = a_stOpt.top(); 809| 89.2k| a_stOpt.pop(); 810| 89.2k| MUP_ASSERT(funTok.GetFuncAddr() != nullptr); ------------------ | | 78| 89.2k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 89.2k] | | ------------------ | | 79| 89.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| 89.2k| int iArgCount = (funTok.GetCode() == cmOPRT_BIN) ? funTok.GetArgCount() : a_iArgCount; ------------------ | Branch (815:19): [True: 0, False: 89.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| 89.2k| int iArgRequired = funTok.GetArgCount() + ((funTok.GetType() == tpSTR) ? 1 : 0); ------------------ | Branch (819:46): [True: 0, False: 89.2k] ------------------ 820| | 821| | // That's the number of numerical parameters 822| 89.2k| int iArgNumerical = iArgCount - ((funTok.GetType() == tpSTR) ? 1 : 0); ------------------ | Branch (822:36): [True: 0, False: 89.2k] ------------------ 823| | 824| 89.2k| if (funTok.GetCode() == cmFUNC_STR && iArgCount - iArgNumerical > 1) ------------------ | Branch (824:7): [True: 0, False: 89.2k] | Branch (824:41): [True: 0, False: 0] ------------------ 825| 0| Error(ecINTERNAL_ERROR); 826| | 827| 89.2k| if (funTok.GetArgCount() >= 0 && iArgCount > iArgRequired) ------------------ | Branch (827:7): [True: 85.6k, False: 3.58k] | Branch (827:36): [True: 9, False: 85.6k] ------------------ 828| 9| Error(ecTOO_MANY_PARAMS, m_pTokenReader->GetPos() - 1, funTok.GetAsString()); 829| | 830| 89.2k| if (funTok.GetCode() != cmOPRT_BIN && iArgCount < iArgRequired) ------------------ | Branch (830:7): [True: 89.2k, False: 9] | Branch (830:41): [True: 3, False: 89.2k] ------------------ 831| 3| Error(ecTOO_FEW_PARAMS, m_pTokenReader->GetPos() - 1, funTok.GetAsString()); 832| | 833| 89.2k| if (funTok.GetCode() == cmFUNC_STR && iArgCount > iArgRequired) ------------------ | Branch (833:7): [True: 0, False: 89.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| 89.2k| std::vector stArg; 839| 359k| for (int i = 0; i < iArgNumerical; ++i) ------------------ | Branch (839:19): [True: 269k, False: 89.2k] ------------------ 840| 269k| { 841| 269k| if (a_stVal.empty()) ------------------ | Branch (841:8): [True: 43, False: 269k] ------------------ 842| 43| Error(ecINTERNAL_ERROR, m_pTokenReader->GetPos(), funTok.GetAsString()); 843| | 844| 269k| stArg.push_back(a_stVal.top()); 845| 269k| a_stVal.pop(); 846| | 847| 269k| if (stArg.back().GetType() == tpSTR && funTok.GetType() != tpSTR) ------------------ | Branch (847:8): [True: 6, False: 269k] | Branch (847:43): [True: 6, False: 0] ------------------ 848| 6| Error(ecVAL_EXPECTED, m_pTokenReader->GetPos(), funTok.GetAsString()); 849| 269k| } 850| | 851| 89.2k| switch (funTok.GetCode()) 852| 89.2k| { 853| 0| case cmFUNC_STR: ------------------ | Branch (853:3): [True: 0, False: 89.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: 89.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: 89.2k] ------------------ 871| 0| case cmOPRT_POSTFIX: ------------------ | Branch (871:3): [True: 0, False: 89.2k] ------------------ 872| 80.5k| case cmOPRT_INFIX: ------------------ | Branch (872:3): [True: 80.5k, False: 8.68k] ------------------ 873| 89.2k| case cmFUNC: ------------------ | Branch (873:3): [True: 8.62k, False: 80.6k] ------------------ 874| 89.2k| if (funTok.GetArgCount() == -1 && iArgCount == 0) ------------------ | Branch (874:8): [True: 3.58k, False: 85.6k] | Branch (874:38): [True: 1, False: 3.58k] ------------------ 875| 1| Error(ecTOO_FEW_PARAMS, m_pTokenReader->GetPos(), funTok.GetAsString()); 876| | 877| 89.2k| m_vRPN.AddFun(funTok.GetFuncAddr(), (funTok.GetArgCount() == -1) ? -iArgNumerical : iArgNumerical, funTok.IsOptimizable()); ------------------ | Branch (877:40): [True: 3.58k, False: 85.6k] ------------------ 878| 89.2k| break; 879| 0| default: ------------------ | Branch (879:3): [True: 0, False: 89.2k] ------------------ 880| 0| break; 881| 89.2k| } 882| | 883| | // Push dummy value representing the function result to the stack 884| 89.2k| token_type token; 885| 89.2k| token.SetVal(1); 886| 89.2k| a_stVal.push(token); 887| 89.2k| } _ZNK2mu10ParserBase11ApplyIfElseERNSt3__15stackINS_11ParserTokenIdNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_5dequeISA_NS7_ISA_EEEEEESF_: 891| 29.5k| { 892| | // Check if there is an if Else clause to be calculated 893| 113k| while (a_stOpt.size() && a_stOpt.top().GetCode() == cmELSE) ------------------ | Branch (893:10): [True: 112k, False: 346] | Branch (893:28): [True: 83.8k, False: 29.1k] ------------------ 894| 83.8k| { 895| 83.8k| MUP_ASSERT(!a_stOpt.empty()) ------------------ | | 78| 83.8k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 83.8k] | | ------------------ | | 79| 83.8k| { \ | | 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| 83.8k| token_type opElse = a_stOpt.top(); 897| 83.8k| a_stOpt.pop(); 898| | 899| | // Take the value associated with the else branch from the value stack 900| 83.8k| MUP_ASSERT(!a_stVal.empty()); ------------------ | | 78| 83.8k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 83.8k] | | ------------------ | | 79| 83.8k| { \ | | 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| 83.8k| token_type vVal2 = a_stVal.top(); 902| 83.8k| if (vVal2.GetType() != tpDBL) ------------------ | Branch (902:8): [True: 3, False: 83.8k] ------------------ 903| 3| Error(ecUNEXPECTED_STR, m_pTokenReader->GetPos()); 904| | 905| 83.8k| 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| 83.8k| MUP_ASSERT(!a_stVal.empty()); ------------------ | | 78| 83.8k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 17, False: 83.8k] | | ------------------ | | 79| 83.8k| { \ | | 80| 17| stringstream_type ss; \ | | 81| 17| ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 17| #define _T(x) x | | ------------------ | | ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 17| #define _T(x) x | | ------------------ | | 82| 17| << __FILE__ << _T(" line ") \ | | ------------------ | | | | 69| 17| #define _T(x) x | | ------------------ | | 83| 17| << __LINE__ << _T("."); \ | | ------------------ | | | | 69| 17| #define _T(x) x | | ------------------ | | 84| 17| throw ParserError( ecINTERNAL_ERROR, -1, ss.str()); \ | | 85| 17| } ------------------ 910| 83.8k| token_type vVal1 = a_stVal.top(); 911| 83.8k| if (vVal1.GetType() != tpDBL) ------------------ | Branch (911:8): [True: 1, False: 83.8k] ------------------ 912| 1| Error(ecUNEXPECTED_STR, m_pTokenReader->GetPos()); 913| | 914| 83.8k| a_stVal.pop(); 915| | 916| 83.8k| MUP_ASSERT(!a_stVal.empty()); ------------------ | | 78| 83.8k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 23, False: 83.7k] | | ------------------ | | 79| 83.8k| { \ | | 80| 23| stringstream_type ss; \ | | 81| 23| ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 23| #define _T(x) x | | ------------------ | | ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 23| #define _T(x) x | | ------------------ | | 82| 23| << __FILE__ << _T(" line ") \ | | ------------------ | | | | 69| 23| #define _T(x) x | | ------------------ | | 83| 23| << __LINE__ << _T("."); \ | | ------------------ | | | | 69| 23| #define _T(x) x | | ------------------ | | 84| 23| throw ParserError( ecINTERNAL_ERROR, -1, ss.str()); \ | | 85| 23| } ------------------ 917| 83.7k| token_type vExpr = a_stVal.top(); 918| 83.7k| a_stVal.pop(); 919| | 920| 83.7k| a_stVal.push((vExpr.GetVal() != 0) ? vVal1 : vVal2); ------------------ | Branch (920:17): [True: 35.5k, False: 48.2k] ------------------ 921| | 922| 83.7k| token_type opIf = a_stOpt.top(); 923| 83.7k| a_stOpt.pop(); 924| | 925| 83.7k| MUP_ASSERT(opElse.GetCode() == cmELSE); ------------------ | | 78| 83.7k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 83.7k] | | ------------------ | | 79| 83.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| } ------------------ 926| | 927| 83.7k| if (opIf.GetCode() != cmIF) ------------------ | Branch (927:8): [True: 1, False: 83.7k] ------------------ 928| 1| Error(ecMISPLACED_COLON, m_pTokenReader->GetPos()); 929| | 930| 83.7k| m_vRPN.AddIfElse(cmENDIF); 931| 83.7k| } // while pending if-else-clause found 932| 29.5k| } _ZNK2mu10ParserBase12ApplyBinOprtERNSt3__15stackINS_11ParserTokenIdNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_5dequeISA_NS7_ISA_EEEEEESF_: 939| 152k| { 940| | // is it a user defined binary operator? 941| 152k| if (a_stOpt.top().GetCode() == cmOPRT_BIN) ------------------ | Branch (941:7): [True: 0, False: 152k] ------------------ 942| 0| { 943| 0| ApplyFunc(a_stOpt, a_stVal, 2); 944| 0| } 945| 152k| else 946| 152k| { 947| 152k| if (a_stVal.size() < 2) ------------------ | Branch (947:8): [True: 39, False: 152k] ------------------ 948| 39| Error(ecINTERNAL_ERROR, m_pTokenReader->GetPos(), _T("ApplyBinOprt: not enough values in value stack!")); ------------------ | | 69| 39| #define _T(x) x ------------------ 949| | 950| 152k| token_type valTok1 = a_stVal.top(); 951| 152k| a_stVal.pop(); 952| | 953| 152k| token_type valTok2 = a_stVal.top(); 954| 152k| a_stVal.pop(); 955| | 956| 152k| token_type optTok = a_stOpt.top(); 957| 152k| a_stOpt.pop(); 958| | 959| 152k| token_type resTok; 960| | 961| 152k| if (valTok1.GetType() != valTok2.GetType() || ------------------ | Branch (961:8): [True: 51, False: 152k] ------------------ 962| 152k| (valTok1.GetType() == tpSTR && valTok2.GetType() == tpSTR)) ------------------ | Branch (962:6): [True: 9, False: 152k] | Branch (962:36): [True: 9, False: 0] ------------------ 963| 21| Error(ecOPRT_TYPE_CONFLICT, m_pTokenReader->GetPos(), optTok.GetAsString()); 964| | 965| 152k| if (optTok.GetCode() == cmASSIGN) ------------------ | Branch (965:8): [True: 0, False: 152k] ------------------ 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| 152k| else 973| 152k| m_vRPN.AddOp(optTok.GetCode()); 974| | 975| 152k| resTok.SetVal(1); 976| 152k| a_stVal.push(resTok); 977| 152k| } 978| 152k| } _ZNK2mu10ParserBase18ApplyRemainingOprtERNSt3__15stackINS_11ParserTokenIdNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_5dequeISA_NS7_ISA_EEEEEESF_: 986| 496k| { 987| 599k| while (stOpt.size() && ------------------ | Branch (987:10): [True: 559k, False: 40.3k] ------------------ 988| 599k| stOpt.top().GetCode() != cmBO && ------------------ | Branch (988:4): [True: 242k, False: 317k] ------------------ 989| 599k| stOpt.top().GetCode() != cmIF) ------------------ | Branch (989:4): [True: 103k, False: 138k] ------------------ 990| 103k| { 991| 103k| token_type tok = stOpt.top(); 992| 103k| switch (tok.GetCode()) 993| 103k| { 994| 2.93k| case cmOPRT_INFIX: ------------------ | Branch (994:4): [True: 2.93k, False: 100k] ------------------ 995| 2.93k| case cmOPRT_BIN: ------------------ | Branch (995:4): [True: 0, False: 103k] ------------------ 996| 3.30k| case cmLE: ------------------ | Branch (996:4): [True: 371, False: 102k] ------------------ 997| 3.54k| case cmGE: ------------------ | Branch (997:4): [True: 234, False: 103k] ------------------ 998| 3.88k| case cmNEQ: ------------------ | Branch (998:4): [True: 345, False: 102k] ------------------ 999| 4.10k| case cmEQ: ------------------ | Branch (999:4): [True: 215, False: 103k] ------------------ 1000| 4.45k| case cmLT: ------------------ | Branch (1000:4): [True: 351, False: 102k] ------------------ 1001| 4.91k| case cmGT: ------------------ | Branch (1001:4): [True: 463, False: 102k] ------------------ 1002| 5.48k| case cmADD: ------------------ | Branch (1002:4): [True: 564, False: 102k] ------------------ 1003| 6.15k| case cmSUB: ------------------ | Branch (1003:4): [True: 670, False: 102k] ------------------ 1004| 6.61k| case cmMUL: ------------------ | Branch (1004:4): [True: 467, False: 102k] ------------------ 1005| 7.18k| case cmDIV: ------------------ | Branch (1005:4): [True: 568, False: 102k] ------------------ 1006| 72.8k| case cmPOW: ------------------ | Branch (1006:4): [True: 65.6k, False: 37.6k] ------------------ 1007| 73.2k| case cmLAND: ------------------ | Branch (1007:4): [True: 363, False: 102k] ------------------ 1008| 73.7k| case cmLOR: ------------------ | Branch (1008:4): [True: 547, False: 102k] ------------------ 1009| 73.7k| case cmASSIGN: ------------------ | Branch (1009:4): [True: 0, False: 103k] ------------------ 1010| 73.7k| if (stOpt.top().GetCode() == cmOPRT_INFIX) ------------------ | Branch (1010:9): [True: 2.93k, False: 70.8k] ------------------ 1011| 2.93k| ApplyFunc(stOpt, stVal, 1); 1012| 70.8k| else 1013| 70.8k| ApplyBinOprt(stOpt, stVal); 1014| 73.7k| break; 1015| | 1016| 29.5k| case cmELSE: ------------------ | Branch (1016:4): [True: 29.5k, False: 73.7k] ------------------ 1017| 29.5k| ApplyIfElse(stOpt, stVal); 1018| 29.5k| break; 1019| | 1020| 0| default: ------------------ | Branch (1020:4): [True: 0, False: 103k] ------------------ 1021| 0| Error(ecINTERNAL_ERROR); 1022| 103k| } 1023| 103k| } 1024| 496k| } _ZNK2mu10ParserBase12ParseCmdCodeEv: 1035| 857| { 1036| 857| return ParseCmdCodeBulk(0, 0); 1037| 857| } _ZNK2mu10ParserBase17ParseCmdCodeShortEv: 1040| 654| { 1041| 654| const SToken *const tok = m_vRPN.GetBase(); 1042| 654| value_type buf; 1043| | 1044| 654| switch (tok->Cmd) 1045| 654| { 1046| 654| case cmVAL: ------------------ | Branch (1046:3): [True: 654, False: 0] ------------------ 1047| 654| return tok->Val.data2; 1048| | 1049| 0| case cmVAR: ------------------ | Branch (1049:3): [True: 0, False: 654] ------------------ 1050| 0| return *tok->Val.ptr; 1051| | 1052| 0| case cmVARMUL: ------------------ | Branch (1052:3): [True: 0, False: 654] ------------------ 1053| 0| return *tok->Val.ptr * tok->Val.data + tok->Val.data2; 1054| | 1055| 0| case cmVARPOW2: ------------------ | Branch (1055:3): [True: 0, False: 654] ------------------ 1056| 0| buf = *(tok->Val.ptr); 1057| 0| return buf * buf; 1058| | 1059| 0| case cmVARPOW3: ------------------ | Branch (1059:3): [True: 0, False: 654] ------------------ 1060| 0| buf = *(tok->Val.ptr); 1061| 0| return buf * buf * buf; 1062| | 1063| 0| case cmVARPOW4: ------------------ | Branch (1063:3): [True: 0, False: 654] ------------------ 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: 654] ------------------ 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: 654] ------------------ 1073| 0| return tok->Fun.cb.call_strfun<1>(m_vStringBuf[0].c_str()); 1074| | 1075| 0| default: ------------------ | Branch (1075:3): [True: 0, False: 654] ------------------ 1076| 0| throw ParserError(ecINTERNAL_ERROR); 1077| 654| } 1078| 654| } _ZNK2mu10ParserBase16ParseCmdCodeBulkEii: 1086| 857| { 1087| 857| 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| 857| value_type *stack = ((nOffset == 0) && (nThreadID == 0)) ? &m_vStackBuffer[0] : &m_vStackBuffer[nThreadID * (m_vStackBuffer.size() / s_MaxNumOpenMPThreads)]; ------------------ | Branch (1091:24): [True: 857, False: 0] | Branch (1091:42): [True: 857, False: 0] ------------------ 1092| 857| value_type buf; 1093| 857| int sidx(0); 1094| 341k| for (const SToken* pTok = m_vRPN.GetBase(); pTok->Cmd != cmEND; ++pTok) ------------------ | Branch (1094:47): [True: 340k, False: 857] ------------------ 1095| 340k| { 1096| 340k| switch (pTok->Cmd) 1097| 340k| { 1098| | // built in binary operators 1099| 197| case cmLE: --sidx; stack[sidx] = stack[sidx] <= stack[sidx + 1]; continue; ------------------ | Branch (1099:4): [True: 197, False: 340k] ------------------ 1100| 194| case cmGE: --sidx; stack[sidx] = stack[sidx] >= stack[sidx + 1]; continue; ------------------ | Branch (1100:4): [True: 194, False: 340k] ------------------ 1101| 199| case cmNEQ: --sidx; stack[sidx] = stack[sidx] != stack[sidx + 1]; continue; ------------------ | Branch (1101:4): [True: 199, False: 340k] ------------------ 1102| 195| case cmEQ: --sidx; stack[sidx] = stack[sidx] == stack[sidx + 1]; continue; ------------------ | Branch (1102:4): [True: 195, False: 340k] ------------------ 1103| 309| case cmLT: --sidx; stack[sidx] = stack[sidx] < stack[sidx + 1]; continue; ------------------ | Branch (1103:4): [True: 309, False: 339k] ------------------ 1104| 214| case cmGT: --sidx; stack[sidx] = stack[sidx] > stack[sidx + 1]; continue; ------------------ | Branch (1104:4): [True: 214, False: 340k] ------------------ 1105| 392| case cmADD: --sidx; stack[sidx] += stack[1 + sidx]; continue; ------------------ | Branch (1105:4): [True: 392, False: 339k] ------------------ 1106| 525| case cmSUB: --sidx; stack[sidx] -= stack[1 + sidx]; continue; ------------------ | Branch (1106:4): [True: 525, False: 339k] ------------------ 1107| 791| case cmMUL: --sidx; stack[sidx] *= stack[1 + sidx]; continue; ------------------ | Branch (1107:4): [True: 791, False: 339k] ------------------ 1108| 598| case cmDIV: --sidx; ------------------ | Branch (1108:4): [True: 598, False: 339k] ------------------ 1109| 598| stack[sidx] /= stack[1 + sidx]; 1110| 598| continue; 1111| | 1112| 52.2k| case cmPOW: ------------------ | Branch (1112:4): [True: 52.2k, False: 288k] ------------------ 1113| 52.2k| --sidx; stack[sidx] = MathImpl::Pow(stack[sidx], stack[1 + sidx]); 1114| 52.2k| continue; 1115| | 1116| 394| case cmLAND: --sidx; stack[sidx] = stack[sidx] && stack[sidx + 1]; continue; ------------------ | Branch (1116:4): [True: 394, False: 339k] | Branch (1116:40): [True: 198, False: 196] | Branch (1116:55): [True: 194, False: 4] ------------------ 1117| 397| case cmLOR: --sidx; stack[sidx] = stack[sidx] || stack[sidx + 1]; continue; ------------------ | Branch (1117:4): [True: 397, False: 339k] | Branch (1117:40): [True: 199, False: 198] | Branch (1117:55): [True: 6, False: 192] ------------------ 1118| | 1119| 0| case cmASSIGN: ------------------ | Branch (1119:4): [True: 0, False: 340k] ------------------ 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.54k| case cmIF: ------------------ | Branch (1129:4): [True: 3.54k, False: 336k] ------------------ 1130| 3.54k| if (stack[sidx--] == 0) ------------------ | Branch (1130:9): [True: 2.74k, False: 804] ------------------ 1131| 2.74k| { 1132| 2.74k| MUP_ASSERT(sidx >= 0); ------------------ | | 78| 2.74k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 2.74k] | | ------------------ | | 79| 2.74k| { \ | | 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| 2.74k| pTok += pTok->Oprt.offset; 1134| 2.74k| } 1135| 3.54k| continue; 1136| | 1137| 3.54k| case cmELSE: ------------------ | Branch (1137:4): [True: 804, False: 339k] ------------------ 1138| 804| pTok += pTok->Oprt.offset; 1139| 804| continue; 1140| | 1141| 2.74k| case cmENDIF: ------------------ | Branch (1141:4): [True: 2.74k, False: 337k] ------------------ 1142| 2.74k| continue; 1143| | 1144| | // value and variable tokens 1145| 0| case cmVAR: stack[++sidx] = *(pTok->Val.ptr + nOffset); continue; ------------------ | Branch (1145:4): [True: 0, False: 340k] ------------------ 1146| 272k| case cmVAL: stack[++sidx] = pTok->Val.data2; continue; ------------------ | Branch (1146:4): [True: 272k, False: 67.3k] ------------------ 1147| | 1148| 0| case cmVARPOW2: buf = *(pTok->Val.ptr + nOffset); ------------------ | Branch (1148:4): [True: 0, False: 340k] ------------------ 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: 340k] ------------------ 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: 340k] ------------------ 1157| 0| stack[++sidx] = buf * buf * buf * buf; 1158| 0| continue; 1159| | 1160| 0| case cmVARMUL: ------------------ | Branch (1160:4): [True: 0, False: 340k] ------------------ 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.61k| case cmFUNC: ------------------ | Branch (1165:4): [True: 3.61k, False: 336k] ------------------ 1166| 3.61k| { 1167| 3.61k| int iArgCount = pTok->Fun.argc; 1168| | 1169| | // switch according to argument count 1170| 3.61k| switch (iArgCount) 1171| 3.61k| { 1172| 0| case 0: sidx += 1; stack[sidx] = pTok->Fun.cb.call_fun<0 >(); continue; ------------------ | Branch (1172:5): [True: 0, False: 3.61k] ------------------ 1173| 237| case 1: stack[sidx] = pTok->Fun.cb.call_fun<1 >(stack[sidx]); continue; ------------------ | Branch (1173:5): [True: 237, False: 3.37k] ------------------ 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.41k] ------------------ 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.61k] ------------------ 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.61k] ------------------ 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.61k] ------------------ 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.61k] ------------------ 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.61k] ------------------ 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.61k] ------------------ 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.61k] ------------------ 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.61k] ------------------ 1183| 3.18k| default: ------------------ | Branch (1183:5): [True: 3.18k, False: 431] ------------------ 1184| | // function with variable arguments store the number as a negative value 1185| 3.18k| if (iArgCount > 0) ------------------ | Branch (1185:10): [True: 0, False: 3.18k] ------------------ 1186| 0| Error(ecINTERNAL_ERROR, -1); 1187| | 1188| 3.18k| 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.18k| if (sidx <= 0) ------------------ | Branch (1196:10): [True: 0, False: 3.18k] ------------------ 1197| 0| Error(ecINTERNAL_ERROR, -1); 1198| | // 1199| | 1200| 3.18k| stack[sidx] = pTok->Fun.cb.call_multfun(&stack[sidx], -iArgCount); 1201| 3.18k| continue; 1202| 3.61k| } 1203| 3.61k| } 1204| | 1205| | // Next is treatment of string functions 1206| 0| case cmFUNC_STR: ------------------ | Branch (1206:4): [True: 0, False: 340k] ------------------ 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: 340k] ------------------ 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: 340k] ------------------ 1252| 0| throw exception_type(ecINTERNAL_ERROR, 3, _T("")); ------------------ | | 69| 0| #define _T(x) x ------------------ 1253| 340k| } // switch CmdCode 1254| 340k| } // for all bytecode tokens 1255| | 1256| 857| return stack[m_nFinalResultIdx]; 1257| 857| } _ZNK2mu10ParserBase9CreateRPNEv: 1261| 3.97k| { 1262| 3.97k| if (!m_pTokenReader->GetExpr().length()) ------------------ | Branch (1262:7): [True: 0, False: 3.97k] ------------------ 1263| 0| Error(ecUNEXPECTED_EOF, 0); 1264| | 1265| 3.97k| std::stack stOpt, stVal; 1266| 3.97k| std::stack stArgCount; 1267| 3.97k| token_type opta, opt; // for storing operators 1268| 3.97k| token_type val, tval; // for storing value 1269| 3.97k| int ifElseCounter = 0; 1270| | 1271| 3.97k| 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.97k| stArgCount.push(1); 1276| | 1277| 3.97k| for (;;) 1278| 2.96M| { 1279| 2.96M| opt = m_pTokenReader->ReadNextToken(); 1280| | 1281| 2.96M| switch (opt.GetCode()) 1282| 2.96M| { 1283| | // 1284| | // Next three are different kind of value entries 1285| | // 1286| 27.3k| case cmSTRING: ------------------ | Branch (1286:4): [True: 27.3k, False: 2.93M] ------------------ 1287| 27.3k| if (stOpt.empty()) ------------------ | Branch (1287:9): [True: 113, False: 27.2k] ------------------ 1288| 113| Error(ecSTR_RESULT, m_pTokenReader->GetPos(), opt.GetAsString()); 1289| | 1290| 27.3k| opt.SetIdx((int)m_vStringBuf.size()); // Assign buffer index to token 1291| 27.3k| stVal.push(opt); 1292| 27.3k| m_vStringBuf.push_back(opt.GetAsString()); // Store string in internal buffer 1293| 27.3k| break; 1294| | 1295| 0| case cmVAR: ------------------ | Branch (1295:4): [True: 0, False: 2.96M] ------------------ 1296| 0| stVal.push(opt); 1297| 0| m_vRPN.AddVar(static_cast(opt.GetVar())); 1298| 0| break; 1299| | 1300| 774k| case cmVAL: ------------------ | Branch (1300:4): [True: 774k, False: 2.18M] ------------------ 1301| 774k| stVal.push(opt); 1302| 774k| m_vRPN.AddVal(opt.GetVal()); 1303| 774k| break; 1304| | 1305| 127k| case cmELSE: ------------------ | Branch (1305:4): [True: 127k, False: 2.83M] ------------------ 1306| 127k| if (stArgCount.empty()) ------------------ | Branch (1306:9): [True: 0, False: 127k] ------------------ 1307| 0| Error(ecMISPLACED_COLON, m_pTokenReader->GetPos()); 1308| | 1309| 127k| if (stArgCount.top() > 1) ------------------ | Branch (1309:9): [True: 15, False: 127k] ------------------ 1310| 15| Error(ecUNEXPECTED_ARG_SEP, m_pTokenReader->GetPos()); 1311| | 1312| 127k| stArgCount.pop(); 1313| | 1314| 127k| ifElseCounter--; 1315| 127k| if (ifElseCounter < 0) ------------------ | Branch (1315:9): [True: 38, False: 127k] ------------------ 1316| 38| Error(ecMISPLACED_COLON, m_pTokenReader->GetPos()); 1317| | 1318| 127k| ApplyRemainingOprt(stOpt, stVal); 1319| 127k| m_vRPN.AddIfElse(cmELSE); 1320| 127k| stOpt.push(opt); 1321| 127k| break; 1322| | 1323| 258k| case cmARG_SEP: ------------------ | Branch (1323:4): [True: 258k, False: 2.70M] ------------------ 1324| 258k| if (!stOpt.empty() && stOpt.top().GetCode() == cmIF) ------------------ | Branch (1324:9): [True: 222k, False: 35.4k] | Branch (1324:27): [True: 2, False: 222k] ------------------ 1325| 2| Error(ecUNEXPECTED_ARG_SEP, m_pTokenReader->GetPos()); 1326| | 1327| 258k| if (stArgCount.empty()) ------------------ | Branch (1327:9): [True: 0, False: 258k] ------------------ 1328| 0| Error(ecUNEXPECTED_ARG_SEP, m_pTokenReader->GetPos()); 1329| | 1330| 258k| ++stArgCount.top(); 1331| | // Falls through. 1332| | // intentional (no break!) 1333| | 1334| 260k| case cmEND: ------------------ | Branch (1334:4): [True: 1.85k, False: 2.95M] ------------------ 1335| 260k| ApplyRemainingOprt(stOpt, stVal); 1336| 260k| break; 1337| | 1338| 108k| case cmBC: ------------------ | Branch (1338:4): [True: 108k, False: 2.85M] ------------------ 1339| 108k| { 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| 108k| if (opta.GetCode() == cmBO) ------------------ | Branch (1344:9): [True: 3, False: 108k] ------------------ 1345| 3| --stArgCount.top(); 1346| | 1347| 108k| ApplyRemainingOprt(stOpt, stVal); 1348| | 1349| | // Check if the bracket content has been evaluated completely 1350| 108k| if (stOpt.size() && stOpt.top().GetCode() == cmBO) ------------------ | Branch (1350:9): [True: 108k, False: 0] | Branch (1350:25): [True: 97.8k, False: 10.7k] ------------------ 1351| 97.8k| { 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| 97.8k| MUP_ASSERT(stArgCount.size()); ------------------ | | 78| 97.8k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 97.8k] | | ------------------ | | 79| 97.8k| { \ | | 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| 97.8k| int iArgCount = stArgCount.top(); 1360| 97.8k| stArgCount.pop(); 1361| | 1362| 97.8k| stOpt.pop(); // Take opening bracket from stack 1363| | 1364| 97.8k| if (iArgCount > 1 && (stOpt.size() == 0 || ------------------ | Branch (1364:10): [True: 2.93k, False: 94.9k] | Branch (1364:28): [True: 6, False: 2.92k] ------------------ 1365| 2.93k| (stOpt.top().GetCode() != cmFUNC && ------------------ | Branch (1365:8): [True: 27, False: 2.90k] ------------------ 1366| 2.92k| stOpt.top().GetCode() != cmFUNC_BULK && ------------------ | Branch (1366:8): [True: 27, False: 0] ------------------ 1367| 2.92k| stOpt.top().GetCode() != cmFUNC_STR))) ------------------ | Branch (1367:8): [True: 27, False: 0] ------------------ 1368| 33| 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| 97.8k| if (stOpt.size() && ------------------ | Branch (1372:10): [True: 97.5k, False: 347] | Branch (1372:10): [True: 8.64k, False: 89.2k] ------------------ 1373| 97.8k| stOpt.top().GetCode() != cmOPRT_INFIX && ------------------ | Branch (1373:7): [True: 96.8k, False: 646] ------------------ 1374| 97.8k| stOpt.top().GetCode() != cmOPRT_BIN && ------------------ | Branch (1374:7): [True: 96.8k, False: 0] ------------------ 1375| 97.8k| stOpt.top().GetFuncAddr() != 0) ------------------ | Branch (1375:7): [True: 8.64k, False: 88.2k] ------------------ 1376| 8.64k| { 1377| 8.64k| ApplyFunc(stOpt, stVal, iArgCount); 1378| 8.64k| } 1379| 97.8k| } 1380| 108k| } // if bracket content is evaluated 1381| 108k| break; 1382| | 1383| | // 1384| | // Next are the binary operator entries 1385| | // 1386| 305k| case cmIF: ------------------ | Branch (1386:4): [True: 305k, False: 2.65M] ------------------ 1387| 305k| ifElseCounter++; 1388| 305k| stArgCount.push(1); 1389| | // Falls through. 1390| | // intentional (no break!) 1391| | 1392| 307k| case cmLAND: ------------------ | Branch (1392:4): [True: 1.90k, False: 2.95M] ------------------ 1393| 309k| case cmLOR: ------------------ | Branch (1393:4): [True: 2.43k, False: 2.95M] ------------------ 1394| 312k| case cmLT: ------------------ | Branch (1394:4): [True: 2.24k, False: 2.95M] ------------------ 1395| 314k| case cmGT: ------------------ | Branch (1395:4): [True: 2.48k, False: 2.95M] ------------------ 1396| 316k| case cmLE: ------------------ | Branch (1396:4): [True: 1.49k, False: 2.96M] ------------------ 1397| 317k| case cmGE: ------------------ | Branch (1397:4): [True: 1.26k, False: 2.96M] ------------------ 1398| 318k| case cmNEQ: ------------------ | Branch (1398:4): [True: 1.40k, False: 2.96M] ------------------ 1399| 319k| case cmEQ: ------------------ | Branch (1399:4): [True: 1.24k, False: 2.96M] ------------------ 1400| 323k| case cmADD: ------------------ | Branch (1400:4): [True: 3.62k, False: 2.95M] ------------------ 1401| 326k| case cmSUB: ------------------ | Branch (1401:4): [True: 2.81k, False: 2.95M] ------------------ 1402| 329k| case cmMUL: ------------------ | Branch (1402:4): [True: 3.21k, False: 2.95M] ------------------ 1403| 333k| case cmDIV: ------------------ | Branch (1403:4): [True: 3.72k, False: 2.95M] ------------------ 1404| 489k| case cmPOW: ------------------ | Branch (1404:4): [True: 155k, False: 2.80M] ------------------ 1405| 489k| case cmASSIGN: ------------------ | Branch (1405:4): [True: 0, False: 2.96M] ------------------ 1406| 489k| case cmOPRT_BIN: ------------------ | Branch (1406:4): [True: 0, False: 2.96M] ------------------ 1407| | 1408| | // A binary operator (user defined or built in) has been found. 1409| 489k| while ( 1410| 648k| stOpt.size() && ------------------ | Branch (1410:6): [True: 629k, False: 18.4k] ------------------ 1411| 648k| stOpt.top().GetCode() != cmBO && ------------------ | Branch (1411:6): [True: 625k, False: 4.70k] ------------------ 1412| 648k| stOpt.top().GetCode() != cmELSE && ------------------ | Branch (1412:6): [True: 526k, False: 98.4k] ------------------ 1413| 648k| stOpt.top().GetCode() != cmIF) ------------------ | Branch (1413:6): [True: 319k, False: 206k] ------------------ 1414| 319k| { 1415| 319k| int nPrec1 = GetOprtPrecedence(stOpt.top()), 1416| 319k| nPrec2 = GetOprtPrecedence(opt); 1417| | 1418| 319k| if (stOpt.top().GetCode() == opt.GetCode()) ------------------ | Branch (1418:10): [True: 173k, False: 146k] ------------------ 1419| 173k| { 1420| | 1421| | // Deal with operator associativity 1422| 173k| EOprtAssociativity eOprtAsct = GetOprtAssociativity(opt); 1423| 173k| if ((eOprtAsct == oaRIGHT && (nPrec1 <= nPrec2)) || ------------------ | Branch (1423:12): [True: 154k, False: 18.7k] | Branch (1423:36): [True: 154k, False: 0] ------------------ 1424| 173k| (eOprtAsct == oaLEFT && (nPrec1 < nPrec2))) ------------------ | Branch (1424:9): [True: 18.7k, False: 0] | Branch (1424:32): [True: 0, False: 18.7k] ------------------ 1425| 154k| { 1426| 154k| break; 1427| 154k| } 1428| 173k| } 1429| 146k| else if (nPrec1 < nPrec2) ------------------ | Branch (1429:15): [True: 6.56k, False: 140k] ------------------ 1430| 6.56k| { 1431| | // In case the operators are not equal the precedence decides alone... 1432| 6.56k| break; 1433| 6.56k| } 1434| | 1435| 158k| if (stOpt.top().GetCode() == cmOPRT_INFIX) ------------------ | Branch (1435:10): [True: 77.6k, False: 81.2k] ------------------ 1436| 77.6k| ApplyFunc(stOpt, stVal, 1); 1437| 81.2k| else 1438| 81.2k| ApplyBinOprt(stOpt, stVal); 1439| 158k| } // while ( ... ) 1440| | 1441| 489k| if (opt.GetCode() == cmIF) ------------------ | Branch (1441:9): [True: 305k, False: 183k] ------------------ 1442| 305k| m_vRPN.AddIfElse(opt.GetCode()); 1443| | 1444| | // The operator can't be evaluated right now, push back to the operator stack 1445| 489k| stOpt.push(opt); 1446| 489k| break; 1447| | 1448| | // 1449| | // Last section contains functions and operators implicitly mapped to functions 1450| | // 1451| 1.06M| case cmBO: ------------------ | Branch (1451:4): [True: 1.06M, False: 1.89M] ------------------ 1452| 1.06M| stArgCount.push(1); 1453| 1.06M| stOpt.push(opt); 1454| 1.06M| break; 1455| | 1456| 97.2k| case cmOPRT_INFIX: ------------------ | Branch (1456:4): [True: 97.2k, False: 2.86M] ------------------ 1457| 107k| case cmFUNC: ------------------ | Branch (1457:4): [True: 9.99k, False: 2.95M] ------------------ 1458| 107k| case cmFUNC_BULK: ------------------ | Branch (1458:4): [True: 0, False: 2.96M] ------------------ 1459| 107k| case cmFUNC_STR: ------------------ | Branch (1459:4): [True: 0, False: 2.96M] ------------------ 1460| 107k| stOpt.push(opt); 1461| 107k| break; 1462| | 1463| 0| case cmOPRT_POSTFIX: ------------------ | Branch (1463:4): [True: 0, False: 2.96M] ------------------ 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.96M] ------------------ 1469| 2.96M| } // end of switch operator-token 1470| | 1471| 2.95M| opta = opt; 1472| | 1473| 2.95M| if (opt.GetCode() == cmEND) ------------------ | Branch (1473:8): [True: 1.78k, False: 2.95M] ------------------ 1474| 1.78k| { 1475| 1.78k| m_vRPN.Finalize(); 1476| 1.78k| break; 1477| 1.78k| } 1478| | 1479| 2.95M| if (ParserBase::g_DbgDumpStack) ------------------ | Branch (1479:8): [True: 0, False: 2.95M] ------------------ 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.95M| } // 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: 242, False: 1.54k] ------------------ 1493| 242| 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: 10, False: 1.77k] | | ------------------ | | 79| 1.78k| { \ | | 80| 10| stringstream_type ss; \ | | 81| 10| ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 10| #define _T(x) x | | ------------------ | | ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \ | | ------------------ | | | | 69| 10| #define _T(x) x | | ------------------ | | 82| 10| << __FILE__ << _T(" line ") \ | | ------------------ | | | | 69| 10| #define _T(x) x | | ------------------ | | 83| 10| << __LINE__ << _T("."); \ | | ------------------ | | | | 69| 10| #define _T(x) x | | ------------------ | | 84| 10| throw ParserError( ecINTERNAL_ERROR, -1, ss.str()); \ | | 85| 10| } ------------------ 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: 21, False: 1.75k] ------------------ 1502| 21| 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| 36.1k| while (stVal.size()) ------------------ | Branch (1507:10): [True: 34.3k, False: 1.77k] ------------------ 1508| 34.3k| { 1509| 34.3k| if (stVal.top().GetType() != tpDBL) ------------------ | Branch (1509:8): [True: 2, False: 34.3k] ------------------ 1510| 2| Error(ecSTR_RESULT); 1511| | 1512| 34.3k| stVal.pop(); 1513| 34.3k| } 1514| | 1515| 1.77k| m_vStackBuffer.resize(m_vRPN.GetMaxStackSize() * s_MaxNumOpenMPThreads); 1516| 1.77k| } _ZNK2mu10ParserBase11ParseStringEv: 1528| 3.97k| { 1529| 3.97k| try 1530| 3.97k| { 1531| 3.97k| CreateRPN(); 1532| | 1533| 3.97k| if (m_vRPN.GetSize() == 2) ------------------ | Branch (1533:8): [True: 654, False: 3.32k] ------------------ 1534| 654| { 1535| 654| m_pParseFormula = &ParserBase::ParseCmdCodeShort; 1536| 654| m_vStackBuffer[1] = (this->*m_pParseFormula)(); 1537| 654| return m_vStackBuffer[1]; 1538| 654| } 1539| 3.32k| else 1540| 3.32k| { 1541| 3.32k| m_pParseFormula = &ParserBase::ParseCmdCode; 1542| 3.32k| return (this->*m_pParseFormula)(); 1543| 3.32k| } 1544| 3.97k| } 1545| 3.97k| catch (ParserError& exc) 1546| 3.97k| { 1547| 2.46k| exc.SetFormula(m_pTokenReader->GetExpr()); 1548| 2.46k| throw; 1549| 2.46k| } 1550| 3.97k| } _ZNK2mu10ParserBase5ErrorENS_11EErrorCodesEiRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 1564| 2.44k| { 1565| 2.44k| throw exception_type(a_iErrc, a_sTok, m_pTokenReader->GetExpr(), a_iPos); 1566| 2.44k| } _ZNK2mu10ParserBase14HasBuiltInOprtEv: 1700| 9.42M| { 1701| 9.42M| return m_bBuiltInOp; 1702| 9.42M| } _ZNK2mu10ParserBase4EvalEv: 1817| 3.97k| { 1818| 3.97k| return (this->*m_pParseFormula)(); 1819| 3.97k| } _ZN2mu14ParserByteCodeC2Ev: 56| 4.00k| { 57| 4.00k| m_vRPN.reserve(50); 58| 4.00k| } _ZN2mu14ParserByteCode6AddValEd: 136| 774k| { 137| 774k| ++m_iStackPos; 138| 774k| m_iMaxStackSize = std::max(m_iMaxStackSize, (size_t)m_iStackPos); 139| | 140| | // If optimization does not apply 141| 774k| SToken tok; 142| 774k| tok.Cmd = cmVAL; 143| 774k| tok.Val.ptr = nullptr; 144| 774k| tok.Val.data = 0; 145| 774k| tok.Val.data2 = a_fVal; 146| 774k| m_vRPN.push_back(tok); 147| 774k| } _ZN2mu14ParserByteCode15ConstantFoldingENS_8ECmdCodeE: 151| 85.5k| { 152| 85.5k| std::size_t sz = m_vRPN.size(); 153| 85.5k| value_type& x = m_vRPN[sz - 2].Val.data2; 154| 85.5k| value_type& y = m_vRPN[sz - 1].Val.data2; 155| | 156| 85.5k| switch (a_Oprt) 157| 85.5k| { 158| 1.45k| case cmLAND: x = (int)x && (int)y; m_vRPN.pop_back(); break; ------------------ | Branch (158:3): [True: 1.45k, False: 84.1k] | Branch (158:20): [True: 817, False: 634] | Branch (158:30): [True: 733, False: 84] ------------------ 159| 1.96k| case cmLOR: x = (int)x || (int)y; m_vRPN.pop_back(); break; ------------------ | Branch (159:3): [True: 1.96k, False: 83.6k] | Branch (159:20): [True: 1.38k, False: 575] | Branch (159:30): [True: 191, False: 384] ------------------ 160| 1.82k| case cmLT: x = x < y; m_vRPN.pop_back(); break; ------------------ | Branch (160:3): [True: 1.82k, False: 83.7k] ------------------ 161| 2.07k| case cmGT: x = x > y; m_vRPN.pop_back(); break; ------------------ | Branch (161:3): [True: 2.07k, False: 83.4k] ------------------ 162| 1.04k| case cmLE: x = x <= y; m_vRPN.pop_back(); break; ------------------ | Branch (162:3): [True: 1.04k, False: 84.5k] ------------------ 163| 1.04k| case cmGE: x = x >= y; m_vRPN.pop_back(); break; ------------------ | Branch (163:3): [True: 1.04k, False: 84.5k] ------------------ 164| 1.17k| case cmNEQ: x = x != y; m_vRPN.pop_back(); break; ------------------ | Branch (164:3): [True: 1.17k, False: 84.4k] ------------------ 165| 1.01k| case cmEQ: x = x == y; m_vRPN.pop_back(); break; ------------------ | Branch (165:3): [True: 1.01k, False: 84.5k] ------------------ 166| 3.09k| case cmADD: x = x + y; m_vRPN.pop_back(); break; ------------------ | Branch (166:3): [True: 3.09k, False: 82.4k] ------------------ 167| 1.97k| case cmSUB: x = x - y; m_vRPN.pop_back(); break; ------------------ | Branch (167:3): [True: 1.97k, False: 83.5k] ------------------ 168| 1.96k| case cmMUL: x = x * y; m_vRPN.pop_back(); break; ------------------ | Branch (168:3): [True: 1.96k, False: 83.6k] ------------------ 169| 2.47k| case cmDIV: ------------------ | Branch (169:3): [True: 2.47k, False: 83.0k] ------------------ 170| 2.47k| x = x / y; 171| 2.47k| m_vRPN.pop_back(); 172| 2.47k| break; 173| | 174| 64.4k| case cmPOW: x = MathImpl::Pow(x, y); ------------------ | Branch (174:3): [True: 64.4k, False: 21.1k] ------------------ 175| 64.4k| m_vRPN.pop_back(); 176| 64.4k| break; 177| | 178| 0| default: ------------------ | Branch (178:3): [True: 0, False: 85.5k] ------------------ 179| 0| break; 180| 85.5k| } // switch opcode 181| 85.5k| } _ZN2mu14ParserByteCode5AddOpENS_8ECmdCodeE: 195| 152k| { 196| 152k| bool bOptimized = false; 197| | 198| 152k| if (m_bEnableOptimizer) ------------------ | Branch (198:7): [True: 152k, False: 0] ------------------ 199| 152k| { 200| 152k| 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| 152k| if (sz >= 2 && m_vRPN[sz - 2].Cmd == cmVAL && m_vRPN[sz - 1].Cmd == cmVAL) ------------------ | Branch (206:8): [True: 152k, False: 0] | Branch (206:19): [True: 86.4k, False: 65.6k] | Branch (206:50): [True: 85.5k, False: 850] ------------------ 207| 85.5k| { 208| 85.5k| ConstantFolding(a_Oprt); 209| 85.5k| bOptimized = true; 210| 85.5k| } 211| 66.4k| else 212| 66.4k| { 213| 66.4k| switch (a_Oprt) 214| 66.4k| { 215| 60.5k| case cmPOW: ------------------ | Branch (215:5): [True: 60.5k, False: 5.95k] ------------------ 216| | // Optimization for polynomials of low order 217| 60.5k| if (m_vRPN[sz - 2].Cmd == cmVAR && m_vRPN[sz - 1].Cmd == cmVAL) ------------------ | Branch (217:10): [True: 0, False: 60.5k] | 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| 60.5k| break; 241| | 242| 60.5k| case cmSUB: ------------------ | Branch (242:5): [True: 642, False: 65.8k] ------------------ 243| 1.06k| case cmADD: ------------------ | Branch (243:5): [True: 421, False: 66.0k] ------------------ 244| | // Simple optimization based on pattern recognition for a shitload of different 245| | // bytecode combinations of addition/subtraction 246| 1.06k| if ((m_vRPN[sz - 1].Cmd == cmVAR && m_vRPN[sz - 2].Cmd == cmVAL) || ------------------ | Branch (246:11): [True: 0, False: 1.06k] | Branch (246:42): [True: 0, False: 0] ------------------ 247| 1.06k| (m_vRPN[sz - 1].Cmd == cmVAL && m_vRPN[sz - 2].Cmd == cmVAR) || ------------------ | Branch (247:8): [True: 633, False: 430] | Branch (247:39): [True: 0, False: 633] ------------------ 248| 1.06k| (m_vRPN[sz - 1].Cmd == cmVAL && m_vRPN[sz - 2].Cmd == cmVARMUL) || ------------------ | Branch (248:8): [True: 633, False: 430] | Branch (248:39): [True: 0, False: 633] ------------------ 249| 1.06k| (m_vRPN[sz - 1].Cmd == cmVARMUL && m_vRPN[sz - 2].Cmd == cmVAL) || ------------------ | Branch (249:8): [True: 0, False: 1.06k] | Branch (249:42): [True: 0, False: 0] ------------------ 250| 1.06k| (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.06k] | Branch (250:39): [True: 0, False: 0] | Branch (250:70): [True: 0, False: 0] ------------------ 251| 1.06k| (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.06k] | Branch (251:39): [True: 0, False: 0] | Branch (251:73): [True: 0, False: 0] ------------------ 252| 1.06k| (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.06k] | Branch (252:42): [True: 0, False: 0] | Branch (252:73): [True: 0, False: 0] ------------------ 253| 1.06k| (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.06k] | 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.06k| break; 268| | 269| 1.18k| case cmMUL: ------------------ | Branch (269:5): [True: 1.18k, False: 65.2k] ------------------ 270| 1.18k| if ((m_vRPN[sz - 1].Cmd == cmVAR && m_vRPN[sz - 2].Cmd == cmVAL) || ------------------ | Branch (270:11): [True: 0, False: 1.18k] | Branch (270:42): [True: 0, False: 0] ------------------ 271| 1.18k| (m_vRPN[sz - 1].Cmd == cmVAL && m_vRPN[sz - 2].Cmd == cmVAR)) ------------------ | Branch (271:8): [True: 694, False: 491] | Branch (271:39): [True: 0, False: 694] ------------------ 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.18k| else if ( 281| 1.18k| (m_vRPN[sz - 1].Cmd == cmVAL && m_vRPN[sz - 2].Cmd == cmVARMUL) || ------------------ | Branch (281:8): [True: 694, False: 491] | Branch (281:39): [True: 0, False: 694] ------------------ 282| 1.18k| (m_vRPN[sz - 1].Cmd == cmVARMUL && m_vRPN[sz - 2].Cmd == cmVAL)) ------------------ | Branch (282:8): [True: 0, False: 1.18k] | 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.18k| else if ( 301| 1.18k| m_vRPN[sz - 1].Cmd == cmVAR && m_vRPN[sz - 2].Cmd == cmVAR && ------------------ | Branch (301:7): [True: 0, False: 1.18k] | Branch (301:38): [True: 0, False: 0] ------------------ 302| 1.18k| 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.18k| break; 310| | 311| 1.18k| case cmDIV: ------------------ | Branch (311:5): [True: 1.18k, False: 65.2k] ------------------ 312| 1.18k| if (m_vRPN[sz - 1].Cmd == cmVAL && m_vRPN[sz - 2].Cmd == cmVARMUL && m_vRPN[sz - 1].Val.data2 != 0) ------------------ | Branch (312:10): [True: 808, False: 380] | Branch (312:41): [True: 0, False: 808] | 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| 1.18k| break; 321| | 322| | // no optimization for other opcodes 323| 2.51k| default: ------------------ | Branch (323:5): [True: 2.51k, False: 63.9k] ------------------ 324| 2.51k| break; 325| 66.4k| } // switch a_Oprt 326| 66.4k| } 327| 152k| } 328| | 329| | // If optimization can't be applied just write the value 330| 152k| if (!bOptimized) ------------------ | Branch (330:7): [True: 66.4k, False: 85.5k] ------------------ 331| 66.4k| { 332| 66.4k| --m_iStackPos; 333| 66.4k| SToken tok; 334| 66.4k| tok.Cmd = a_Oprt; 335| 66.4k| m_vRPN.push_back(tok); 336| 66.4k| } 337| 152k| } _ZN2mu14ParserByteCode9AddIfElseENS_8ECmdCodeE: 341| 517k| { 342| 517k| SToken tok; 343| 517k| tok.Cmd = a_Oprt; 344| 517k| m_vRPN.push_back(tok); 345| 517k| } _ZN2mu14ParserByteCode6AddFunENS_21generic_callable_typeEib: 375| 89.2k| { 376| 89.2k| std::size_t sz = m_vRPN.size(); 377| 89.2k| bool optimize = false; 378| | 379| | // only optimize functions with fixed number of more than a single arguments 380| 89.2k| if (isFunctionOptimizable && m_bEnableOptimizer && a_iArgc > 0) ------------------ | Branch (380:7): [True: 89.2k, False: 0] | Branch (380:32): [True: 89.2k, False: 0] | Branch (380:54): [True: 85.6k, False: 3.58k] ------------------ 381| 85.6k| { 382| | // Unary Plus is a no-op 383| 85.6k| if (a_pFun == generic_callable_type{(erased_fun_type)&MathImpl::UnaryPlus, nullptr}) ------------------ | Branch (383:8): [True: 5.78k, False: 79.8k] ------------------ 384| 5.78k| return; 385| | 386| 79.8k| optimize = true; 387| | 388| 88.5k| for (int i = 0; i < std::abs(a_iArgc); ++i) ------------------ | Branch (388:20): [True: 80.0k, False: 8.48k] ------------------ 389| 80.0k| { 390| 80.0k| if (m_vRPN[sz - i - 1].Cmd != cmVAL) ------------------ | Branch (390:9): [True: 71.3k, False: 8.68k] ------------------ 391| 71.3k| { 392| 71.3k| optimize = false; 393| 71.3k| break; 394| 71.3k| } 395| 80.0k| } 396| 79.8k| } 397| | 398| 83.4k| if (optimize) ------------------ | Branch (398:7): [True: 8.48k, False: 74.9k] ------------------ 399| 8.48k| { 400| 8.48k| value_type val = 0; 401| 8.48k| switch (a_iArgc) 402| 8.48k| { 403| 8.29k| case 1: val = a_pFun.call_fun<1>(m_vRPN[sz - 1].Val.data2); break; ------------------ | Branch (403:4): [True: 8.29k, 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: 8.29k] ------------------ 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: 8.48k] ------------------ 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: 8.48k] ------------------ 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: 8.48k] ------------------ 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: 8.48k] ------------------ 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: 8.48k] ------------------ 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: 8.48k] ------------------ 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: 8.48k] ------------------ 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: 8.48k] ------------------ 413| 0| default: ------------------ | Branch (413:4): [True: 0, False: 8.48k] ------------------ 414| | // For now functions with unlimited number of arguments are not optimized 415| 0| throw ParserError(ecINTERNAL_ERROR); 416| 8.48k| } 417| | 418| | // remove the folded values 419| 8.48k| m_vRPN.erase(m_vRPN.end() - a_iArgc, m_vRPN.end()); 420| | 421| 8.48k| SToken tok; 422| 8.48k| tok.Cmd = cmVAL; 423| 8.48k| tok.Val.data = 0; 424| 8.48k| tok.Val.data2 = val; 425| 8.48k| tok.Val.ptr = nullptr; 426| 8.48k| m_vRPN.push_back(tok); 427| 8.48k| } 428| 74.9k| else 429| 74.9k| { 430| 74.9k| SToken tok; 431| 74.9k| tok.Cmd = cmFUNC; 432| 74.9k| tok.Fun.argc = a_iArgc; 433| 74.9k| tok.Fun.cb = a_pFun; 434| 74.9k| m_vRPN.push_back(tok); 435| 74.9k| } 436| | 437| 83.4k| m_iStackPos = m_iStackPos - std::abs(a_iArgc) + 1; 438| 83.4k| m_iMaxStackSize = std::max(m_iMaxStackSize, (size_t)m_iStackPos); 439| | 440| 83.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.10M| for (int i = 0; i < (int)m_vRPN.size(); ++i) ------------------ | Branch (497:19): [True: 1.10M, False: 1.78k] ------------------ 498| 1.10M| { 499| 1.10M| switch (m_vRPN[i].Cmd) 500| 1.10M| { 501| 242k| case cmIF: ------------------ | Branch (501:4): [True: 242k, False: 857k] ------------------ 502| 242k| stIf.push(i); 503| 242k| break; 504| | 505| 105k| case cmELSE: ------------------ | Branch (505:4): [True: 105k, False: 995k] ------------------ 506| 105k| stElse.push(i); 507| 105k| idx = stIf.top(); 508| 105k| stIf.pop(); 509| 105k| m_vRPN[idx].Oprt.offset = i - idx; 510| 105k| break; 511| | 512| 74.2k| case cmENDIF: ------------------ | Branch (512:4): [True: 74.2k, False: 1.02M] ------------------ 513| 74.2k| idx = stElse.top(); 514| 74.2k| stElse.pop(); 515| 74.2k| m_vRPN[idx].Oprt.offset = i - idx; 516| 74.2k| break; 517| | 518| 678k| default: ------------------ | Branch (518:4): [True: 678k, False: 421k] ------------------ 519| 678k| break; 520| 1.10M| } 521| 1.10M| } 522| 1.78k| } _ZNK2mu14ParserByteCode15GetMaxStackSizeEv: 526| 1.51k| { 527| 1.51k| return m_iMaxStackSize + 1; 528| 1.51k| } _ZN2mu14ParserByteCode5clearEv: 540| 128k| { 541| 128k| m_vRPN.clear(); 542| 128k| m_iStackPos = 0; 543| 128k| m_iMaxStackSize = 0; 544| 128k| } _ZN2mu14ParserCallbackC2EPFddEbiNS_8ECmdCodeE: 73| 92.0k| {} _ZN2mu14ParserCallbackC2EPFddEb: 78| 84.0k| {} _ZN2mu14ParserCallbackC2EPFdddEb: 92| 4.00k| {} _ZN2mu14ParserCallbackC2EPFdPKdiEb: 578| 16.0k| {} _ZN2mu14ParserCallbackC2Ev: 733| 847k| {} _ZN2mu14ParserCallbackC2ERKS0_: 741| 735k| { 742| 735k| Assign(ref); 743| 735k| } _ZN2mu14ParserCallbackaSERKS0_: 746| 112k| { 747| 112k| Assign(ref); 748| 112k| return *this; 749| 112k| } _ZN2mu14ParserCallbackD2Ev: 753| 959k| { 754| 959k| if (m_iArgc & CALLBACK_INTERNAL_WITH_USER_DATA) ------------------ | Branch (754:7): [True: 0, False: 959k] ------------------ 755| 0| delete reinterpret_cast(m_pFun); 756| 959k| } _ZN2mu14ParserCallback6AssignERKS0_: 764| 847k| { 765| 847k| if (this == &ref) ------------------ | Branch (765:7): [True: 0, False: 847k] ------------------ 766| 0| return; 767| | 768| 847k| if (m_iArgc & CALLBACK_INTERNAL_WITH_USER_DATA) { ------------------ | Branch (768:7): [True: 0, False: 847k] ------------------ 769| 0| delete reinterpret_cast(m_pFun); 770| 0| m_pFun = nullptr; 771| 0| } 772| | 773| 847k| if (ref.m_iArgc & CALLBACK_INTERNAL_WITH_USER_DATA) ------------------ | Branch (773:7): [True: 0, False: 847k] ------------------ 774| 0| m_pFun = new CbWithUserData(*reinterpret_cast(ref.m_pFun)); 775| 847k| else 776| 847k| m_pFun = ref.m_pFun; 777| 847k| m_iArgc = ref.m_iArgc; 778| 847k| m_bAllowOpti = ref.m_bAllowOpti; 779| 847k| m_iCode = ref.m_iCode; 780| 847k| m_iType = ref.m_iType; 781| 847k| m_iPri = ref.m_iPri; 782| 847k| m_eOprtAsct = ref.m_eOprtAsct; 783| 847k| } _ZNK2mu14ParserCallback5CloneEv: 788| 628k| { 789| 628k| return new ParserCallback(*this); 790| 628k| } _ZNK2mu14ParserCallback13IsOptimizableEv: 799| 89.2k| { 800| 89.2k| return m_bAllowOpti; 801| 89.2k| } _ZNK2mu14ParserCallback7GetAddrEv: 812| 941k| { 813| 941k| if (m_iArgc & CALLBACK_INTERNAL_WITH_USER_DATA) ------------------ | Branch (813:7): [True: 0, False: 941k] ------------------ 814| 0| return reinterpret_cast(m_pFun)->pFun; 815| 941k| else 816| 941k| return m_pFun; 817| 941k| } _ZNK2mu14ParserCallback11GetUserDataEv: 825| 276k| { 826| 276k| if (m_iArgc & CALLBACK_INTERNAL_WITH_USER_DATA) ------------------ | Branch (826:7): [True: 0, False: 276k] ------------------ 827| 0| return reinterpret_cast(m_pFun)->pUserData; 828| 276k| else 829| 276k| return nullptr; 830| 276k| } _ZNK2mu14ParserCallback7IsValidEv: 840| 665k| { 841| 665k| return GetAddr() != nullptr ------------------ | Branch (841:10): [True: 665k, False: 0] ------------------ 842| 665k| && !((m_iArgc & CALLBACK_INTERNAL_WITH_USER_DATA) ------------------ | Branch (842:9): [True: 0, False: 665k] ------------------ 843| 665k| && GetUserData() == nullptr); ------------------ | Branch (843:12): [True: 0, False: 0] ------------------ 844| 665k| } _ZNK2mu14ParserCallback7GetCodeEv: 849| 1.45M| { 850| 1.45M| return m_iCode; 851| 1.45M| } _ZNK2mu14ParserCallback7GetTypeEv: 855| 178k| { 856| 178k| return m_iType; 857| 178k| } _ZNK2mu14ParserCallback6GetPriEv: 866| 78.8k| { 867| 78.8k| return m_iPri; 868| 78.8k| } _ZNK2mu14ParserCallback7GetArgcEv: 887| 356k| { 888| 356k| return (m_iArgc & CALLBACK_INTERNAL_VAR_ARGS) ? -1 : (m_iArgc & CALLBACK_INTERNAL_FIXED_ARGS_MASK); ------------------ | Branch (888:10): [True: 14.3k, False: 342k] ------------------ 889| 356k| } _ZN2mu14ParserErrorMsg8InstanceEv: 41| 2.49k| { 42| 2.49k| static const ParserErrorMsg instance; 43| 2.49k| return instance; 44| 2.49k| } _ZNK2mu14ParserErrorMsgixEj: 48| 2.49k| { 49| 2.49k| return (a_iIdx < m_vErrMsg.size()) ? m_vErrMsg[a_iIdx] : string_type(); ------------------ | Branch (49:10): [True: 2.49k, False: 0] ------------------ 50| 2.49k| } _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| 2| { 136| 2| m_strMsg = m_ErrMsg[m_iErrc]; 137| 2| stringstream_type stream; 138| 2| stream << (int)m_iPos; 139| 2| ReplaceSubString(m_strMsg, _T("$POS$"), stream.str()); ------------------ | | 69| 2| #define _T(x) x ------------------ 140| 2| ReplaceSubString(m_strMsg, _T("$TOK$"), m_strTok); ------------------ | | 69| 2| #define _T(x) x ------------------ 141| 2| } _ZN2mu11ParserErrorC2ENS_11EErrorCodesERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEESA_i: 169| 2.44k| { 170| 2.44k| m_strMsg = m_ErrMsg[m_iErrc]; 171| 2.44k| stringstream_type stream; 172| 2.44k| stream << (int)m_iPos; 173| 2.44k| ReplaceSubString(m_strMsg, _T("$POS$"), stream.str()); ------------------ | | 69| 2.44k| #define _T(x) x ------------------ 174| 2.44k| ReplaceSubString(m_strMsg, _T("$TOK$"), m_strTok); ------------------ | | 69| 2.44k| #define _T(x) x ------------------ 175| 2.44k| } _ZN2mu11ParserErrorC2ENS_11EErrorCodesEiRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 190| 50| { 191| 50| m_strMsg = m_ErrMsg[m_iErrc]; 192| 50| stringstream_type stream; 193| 50| stream << (int)m_iPos; 194| 50| ReplaceSubString(m_strMsg, _T("$POS$"), stream.str()); ------------------ | | 69| 50| #define _T(x) x ------------------ 195| 50| ReplaceSubString(m_strMsg, _T("$TOK$"), m_strTok); ------------------ | | 69| 50| #define _T(x) x ------------------ 196| 50| } _ZN2mu11ParserErrorD2Ev: 247| 2.49k| {} _ZN2mu11ParserError16ReplaceSubStringERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKS7_SA_: 257| 4.98k| { 258| 4.98k| string_type strResult; 259| 4.98k| string_type::size_type iPos(0), iNext(0); 260| | 261| 4.98k| for (;;) 262| 7.57k| { 263| 7.57k| iNext = strSource.find(strFind, iPos); 264| 7.57k| strResult.append(strSource, iPos, iNext - iPos); 265| | 266| 7.57k| if (iNext == string_type::npos) ------------------ | Branch (266:8): [True: 4.98k, False: 2.58k] ------------------ 267| 4.98k| break; 268| | 269| 2.58k| strResult.append(strReplaceWith); 270| 2.58k| iPos = iNext + strFind.length(); 271| 2.58k| } 272| | 273| 4.98k| strSource.swap(strResult); 274| 4.98k| } _ZN2mu11ParserError10SetFormulaERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 290| 2.46k| { 291| 2.46k| m_strFormula = a_strFormula; 292| 2.46k| } _ZN2mu17ParserTokenReaderC2EPNS_10ParserBaseE: 141| 4.00k| { 142| 4.00k| MUP_ASSERT(m_pParser != nullptr); ------------------ | | 78| 4.00k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 4.00k] | | ------------------ | | 79| 4.00k| { \ | | 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| 4.00k| SetParent(m_pParser); 144| 4.00k| } _ZN2mu17ParserTokenReader16SaveBeforeReturnERKNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE: 164| 2.95M| { 165| 2.95M| m_lastTok = tok; 166| 2.95M| return m_lastTok; 167| 2.95M| } _ZN2mu17ParserTokenReader11AddValIdentEPFiPKcPiPdE: 171| 4.00k| { 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| 4.00k| m_vIdentFun.push_front(a_pCallback); 179| 4.00k| } _ZNK2mu17ParserTokenReader6GetPosEv: 195| 328| { 196| 328| return m_iPos; 197| 328| } _ZNK2mu17ParserTokenReader7GetExprEv: 206| 8.87k| { 207| 8.87k| return m_strFormula; 208| 8.87k| } _ZN2mu17ParserTokenReader10SetFormulaERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 224| 3.97k| { 225| 3.97k| m_strFormula = a_strFormula; 226| 3.97k| ReInit(); 227| 3.97k| } _ZN2mu17ParserTokenReader6ReInitEv: 253| 132k| { 254| 132k| m_iPos = 0; 255| 132k| m_iSynFlags = sfSTART_OF_LINE; 256| 132k| m_bracketStack = std::stack(); 257| 132k| m_UsedVar.clear(); 258| 132k| m_lastTok = token_type(); 259| 132k| } _ZN2mu17ParserTokenReader13ReadNextTokenEv: 264| 2.96M| { 265| 2.96M| MUP_ASSERT(m_pParser != nullptr); ------------------ | | 78| 2.96M| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 2.96M] | | ------------------ | | 79| 2.96M| { \ | | 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.96M| const char_type* szExpr = m_strFormula.c_str(); 268| 2.96M| token_type tok; 269| | 270| | // Ignore all non printable characters when reading the expression 271| 2.96M| while (szExpr[m_iPos] > 0 && szExpr[m_iPos] <= 0x20) ------------------ | Branch (271:10): [True: 2.96M, False: 2.77k] | Branch (271:32): [True: 3.78k, False: 2.95M] ------------------ 272| 3.78k| { 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.78k| if (szExpr[m_iPos] >= 14 && szExpr[m_iPos] <= 31) ------------------ | Branch (275:8): [True: 3.04k, False: 735] | Branch (275:32): [True: 8, False: 3.03k] ------------------ 276| 8| Error(ecINVALID_CHARACTERS_FOUND, m_iPos); 277| | 278| 3.78k| ++m_iPos; 279| 3.78k| } 280| | 281| | // Check for end of formula 282| 2.96M| if (IsEOF(tok)) ------------------ | Branch (282:7): [True: 1.85k, False: 2.95M] ------------------ 283| 1.85k| return SaveBeforeReturn(tok); 284| | 285| | // Check for user defined binary operator 286| 2.95M| if (IsOprt(tok)) ------------------ | Branch (286:7): [True: 0, False: 2.95M] ------------------ 287| 0| return SaveBeforeReturn(tok); 288| | 289| | // Check for function token 290| 2.95M| if (IsFunTok(tok)) ------------------ | Branch (290:7): [True: 9.99k, False: 2.94M] ------------------ 291| 9.99k| return SaveBeforeReturn(tok); 292| | 293| | // Check built in operators / tokens 294| 2.94M| if (IsBuiltIn(tok)) ------------------ | Branch (294:7): [True: 1.88M, False: 1.06M] ------------------ 295| 1.88M| return SaveBeforeReturn(tok); 296| | 297| | // Check for function argument separators 298| 1.06M| if (IsArgSep(tok)) ------------------ | Branch (298:7): [True: 258k, False: 803k] ------------------ 299| 258k| return SaveBeforeReturn(tok); 300| | 301| | // Check for values / constant tokens 302| 803k| if (IsValTok(tok)) ------------------ | Branch (302:7): [True: 774k, False: 29.1k] ------------------ 303| 774k| return SaveBeforeReturn(tok); 304| | 305| | // Check for variable tokens 306| 29.1k| if (IsVarTok(tok)) ------------------ | Branch (306:7): [True: 0, False: 29.1k] ------------------ 307| 0| return SaveBeforeReturn(tok); 308| | 309| | // Check for string variables 310| 29.1k| if (IsStrVarTok(tok)) ------------------ | Branch (310:7): [True: 0, False: 29.1k] ------------------ 311| 0| return SaveBeforeReturn(tok); 312| | 313| | // Check for String tokens 314| 29.1k| if (IsString(tok)) ------------------ | Branch (314:7): [True: 27.3k, False: 1.81k] ------------------ 315| 27.3k| 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: 591] | Branch (332:29): [True: 0, False: 591] | 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: 490, False: 1.32k] ------------------ 342| 490| 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| 4.00k| { 351| 4.00k| m_pParser = a_pParent; 352| 4.00k| m_pFunDef = &a_pParent->m_FunDef; 353| 4.00k| m_pOprtDef = &a_pParent->m_OprtDef; 354| 4.00k| m_pInfixOprtDef = &a_pParent->m_InfixOprtDef; 355| 4.00k| m_pPostOprtDef = &a_pParent->m_PostOprtDef; 356| 4.00k| m_pVarDef = &a_pParent->m_VarDef; 357| 4.00k| m_pStrVarDef = &a_pParent->m_StrVarDef; 358| 4.00k| m_pConstDef = &a_pParent->m_ConstDef; 359| 4.00k| } _ZNK2mu17ParserTokenReader12ExtractTokenEPKcRNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEm: 371| 6.22M| { 372| 6.22M| auto iEnd = m_strFormula.find_first_not_of(a_szCharSet, a_iPos); 373| | 374| 6.22M| if (iEnd == string_type::npos) ------------------ | Branch (374:7): [True: 0, False: 6.22M] ------------------ 375| 0| iEnd = m_strFormula.length(); 376| | 377| | // Assign token string if there was something found 378| 6.22M| if (a_iPos != iEnd) ------------------ | Branch (378:7): [True: 1.65M, False: 4.56M] ------------------ 379| 1.65M| a_sTok = string_type(m_strFormula.begin() + a_iPos, m_strFormula.begin() + iEnd); 380| | 381| 6.22M| return static_cast(iEnd); 382| 6.22M| } _ZNK2mu17ParserTokenReader20ExtractOperatorTokenERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEm: 393| 2.95M| { 394| | // Changed as per Issue 6: https://code.google.com/p/muparser/issues/detail?id=6 395| 2.95M| auto iEnd = m_strFormula.find_first_not_of(m_pParser->ValidOprtChars(), a_iPos); 396| 2.95M| if (iEnd == string_type::npos) ------------------ | Branch (396:7): [True: 0, False: 2.95M] ------------------ 397| 0| iEnd = m_strFormula.length(); 398| | 399| | // Assign token string if there was something found 400| 2.95M| if (a_iPos != iEnd) ------------------ | Branch (400:7): [True: 599k, False: 2.35M] ------------------ 401| 599k| { 402| 599k| a_sTok = string_type(m_strFormula.begin() + a_iPos, m_strFormula.begin() + iEnd); 403| 599k| return static_cast(iEnd); 404| 599k| } 405| 2.35M| else 406| 2.35M| { 407| | // There is still the chance of having to deal with an operator consisting exclusively 408| | // of alphabetic characters. 409| 2.35M| return ExtractToken(_T("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"), a_sTok, (std::size_t)a_iPos); ------------------ | | 69| 2.35M| #define _T(x) x ------------------ 410| 2.35M| } 411| 2.95M| } _ZN2mu17ParserTokenReader9IsBuiltInERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE: 419| 2.94M| { 420| 2.94M| const char_type** const pOprtDef = m_pParser->GetOprtDef(), 421| 2.94M| * const szFormula = m_strFormula.c_str(); 422| | 423| | // Compare token with function and operator strings 424| | // check string for operator/function 425| 48.0M| for (int i = 0; pOprtDef[i]; i++) ------------------ | Branch (425:19): [True: 46.9M, False: 1.06M] ------------------ 426| 46.9M| { 427| 46.9M| std::size_t len(std::char_traits::length(pOprtDef[i])); 428| 46.9M| if (string_type(pOprtDef[i]) == string_type(szFormula + m_iPos, szFormula + m_iPos + len)) ------------------ | Branch (428:8): [True: 1.88M, False: 45.0M] ------------------ 429| 1.88M| { 430| 1.88M| switch (i) 431| 1.88M| { 432| 1.91k| case cmLAND: ------------------ | Branch (432:5): [True: 1.91k, False: 1.88M] ------------------ 433| 4.36k| case cmLOR: ------------------ | Branch (433:5): [True: 2.44k, False: 1.88M] ------------------ 434| 6.61k| case cmLT: ------------------ | Branch (434:5): [True: 2.25k, False: 1.88M] ------------------ 435| 9.11k| case cmGT: ------------------ | Branch (435:5): [True: 2.50k, False: 1.88M] ------------------ 436| 10.6k| case cmLE: ------------------ | Branch (436:5): [True: 1.50k, False: 1.88M] ------------------ 437| 11.8k| case cmGE: ------------------ | Branch (437:5): [True: 1.27k, False: 1.88M] ------------------ 438| 13.3k| case cmNEQ: ------------------ | Branch (438:5): [True: 1.41k, False: 1.88M] ------------------ 439| 14.5k| case cmEQ: ------------------ | Branch (439:5): [True: 1.25k, False: 1.88M] ------------------ 440| 39.8k| case cmADD: ------------------ | Branch (440:5): [True: 25.2k, False: 1.86M] ------------------ 441| 118k| case cmSUB: ------------------ | Branch (441:5): [True: 78.4k, False: 1.80M] ------------------ 442| 121k| case cmMUL: ------------------ | Branch (442:5): [True: 3.22k, False: 1.88M] ------------------ 443| 125k| case cmDIV: ------------------ | Branch (443:5): [True: 3.73k, False: 1.88M] ------------------ 444| 281k| case cmPOW: ------------------ | Branch (444:5): [True: 155k, False: 1.73M] ------------------ 445| 281k| case cmASSIGN: ------------------ | Branch (445:5): [True: 6, False: 1.88M] ------------------ 446| | // The assignment operator need special treatment 447| 281k| if (i == cmASSIGN && m_iSynFlags & noASSIGN) ------------------ | Branch (447:10): [True: 6, False: 281k] | Branch (447:27): [True: 5, False: 1] ------------------ 448| 5| Error(ecUNEXPECTED_OPERATOR, m_iPos, pOprtDef[i]); 449| | 450| 281k| if (!m_pParser->HasBuiltInOprt()) continue; ------------------ | Branch (450:10): [True: 0, False: 281k] ------------------ 451| 281k| if (m_iSynFlags & noOPT) ------------------ | Branch (451:10): [True: 97.4k, False: 183k] ------------------ 452| 97.4k| { 453| | // Maybe its an infix operator not an operator 454| | // Both operator types can share characters in 455| | // their identifiers 456| 97.4k| if (IsInfixOpTok(a_Tok)) ------------------ | Branch (456:11): [True: 97.2k, False: 195] ------------------ 457| 97.2k| return true; 458| | 459| 195| Error(ecUNEXPECTED_OPERATOR, m_iPos, pOprtDef[i]); 460| 195| } 461| | 462| 184k| m_iSynFlags = noBC | noOPT | noARG_SEP | noPOSTOP | noASSIGN | noIF | noELSE | noEND; 463| 184k| break; 464| | 465| 1.06M| case cmBO: ------------------ | Branch (465:5): [True: 1.06M, False: 823k] ------------------ 466| 1.06M| if (m_iSynFlags & noBO) ------------------ | Branch (466:10): [True: 2, False: 1.06M] ------------------ 467| 2| Error(ecUNEXPECTED_PARENS, m_iPos, pOprtDef[i]); 468| | 469| 1.06M| if (m_lastTok.GetCode() == cmFUNC) ------------------ | Branch (469:10): [True: 9.99k, False: 1.05M] ------------------ 470| 9.99k| m_iSynFlags = noOPT | noEND | noARG_SEP | noPOSTOP | noASSIGN | noIF | noELSE; 471| 1.05M| else 472| 1.05M| m_iSynFlags = noBC | noOPT | noEND | noARG_SEP | noPOSTOP | noASSIGN | noIF | noELSE; 473| | 474| 1.06M| m_bracketStack.push(cmBO); 475| 1.06M| break; 476| | 477| 108k| case cmBC: ------------------ | Branch (477:5): [True: 108k, False: 1.77M] ------------------ 478| 108k| if (m_iSynFlags & noBC) ------------------ | Branch (478:10): [True: 4, False: 108k] ------------------ 479| 4| Error(ecUNEXPECTED_PARENS, m_iPos, pOprtDef[i]); 480| | 481| 108k| m_iSynFlags = noBO | noVAR | noVAL | noFUN | noINFIXOP | noSTR | noASSIGN; 482| | 483| 108k| if (!m_bracketStack.empty()) ------------------ | Branch (483:10): [True: 108k, False: 17] ------------------ 484| 108k| m_bracketStack.pop(); 485| 17| else 486| 17| Error(ecUNEXPECTED_PARENS, m_iPos, pOprtDef[i]); 487| 108k| break; 488| | 489| 127k| case cmELSE: ------------------ | Branch (489:5): [True: 127k, False: 1.75M] ------------------ 490| 127k| if (m_iSynFlags & noELSE) ------------------ | Branch (490:10): [True: 5, False: 127k] ------------------ 491| 5| Error(ecUNEXPECTED_CONDITIONAL, m_iPos, pOprtDef[i]); 492| | 493| 127k| m_iSynFlags = noBC | noPOSTOP | noEND | noOPT | noIF | noELSE | noSTR; 494| 127k| break; 495| | 496| 305k| case cmIF: ------------------ | Branch (496:5): [True: 305k, False: 1.58M] ------------------ 497| 305k| if (m_iSynFlags & noIF) ------------------ | Branch (497:10): [True: 20, False: 305k] ------------------ 498| 20| Error(ecUNEXPECTED_CONDITIONAL, m_iPos, pOprtDef[i]); 499| | 500| 305k| m_iSynFlags = noBC | noPOSTOP | noEND | noOPT | noIF | noELSE | noSTR; 501| 305k| 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.88M] ------------------ 504| 0| Error(ecINTERNAL_ERROR); 505| 1.88M| } // switch operator id 506| | 507| 1.79M| m_iPos += (int)len; 508| 1.79M| a_Tok.Set((ECmdCode)i, pOprtDef[i]); 509| 1.79M| return true; 510| 1.88M| } // if operator string found 511| 46.9M| } // end of for all operator strings 512| | 513| 1.06M| return false; 514| 2.94M| } _ZN2mu17ParserTokenReader8IsArgSepERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE: 518| 1.06M| { 519| 1.06M| const char_type* szFormula = m_strFormula.c_str(); 520| | 521| 1.06M| if (szFormula[m_iPos] == m_cArgSep) ------------------ | Branch (521:7): [True: 258k, False: 802k] ------------------ 522| 258k| { 523| | // copy the separator into null terminated string 524| 258k| char_type szSep[2]; 525| 258k| szSep[0] = m_cArgSep; 526| 258k| szSep[1] = 0; 527| | 528| 258k| if (m_iSynFlags & noARG_SEP) ------------------ | Branch (528:8): [True: 2, False: 258k] ------------------ 529| 2| Error(ecUNEXPECTED_ARG_SEP, m_iPos, szSep); 530| | 531| 258k| m_iSynFlags = noBC | noOPT | noEND | noARG_SEP | noPOSTOP | noASSIGN; 532| 258k| m_iPos++; 533| 258k| a_Tok.Set(cmARG_SEP, szSep); 534| 258k| return true; 535| 258k| } 536| | 537| 802k| return false; 538| 1.06M| } _ZN2mu17ParserTokenReader5IsEOFERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE: 549| 2.96M| { 550| 2.96M| const char_type* szFormula = m_strFormula.c_str(); 551| | 552| | // check for EOF 553| 2.96M| if (!szFormula[m_iPos] /*|| szFormula[m_iPos] == '\n'*/) ------------------ | Branch (553:7): [True: 2.72k, False: 2.95M] ------------------ 554| 2.72k| { 555| 2.72k| if (m_iSynFlags & noEND) ------------------ | Branch (555:8): [True: 664, False: 2.05k] ------------------ 556| 664| Error(ecUNEXPECTED_EOF, m_iPos); 557| | 558| 2.72k| if (!m_bracketStack.empty()) ------------------ | Branch (558:8): [True: 201, False: 2.52k] ------------------ 559| 201| Error(ecMISSING_PARENS, m_iPos, _T(")")); ------------------ | | 69| 201| #define _T(x) x ------------------ 560| | 561| 2.72k| m_iSynFlags = 0; 562| 2.72k| a_Tok.Set(cmEND); 563| 2.72k| return true; 564| 2.72k| } 565| | 566| 2.95M| return false; 567| 2.96M| } _ZN2mu17ParserTokenReader12IsInfixOpTokERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE: 574| 98.0k| { 575| 98.0k| string_type sTok; 576| 98.0k| auto iEnd = ExtractToken(m_pParser->ValidInfixOprtChars(), sTok, (std::size_t)m_iPos); 577| 98.0k| if (iEnd == m_iPos) ------------------ | Branch (577:7): [True: 340, False: 97.6k] ------------------ 578| 340| return false; 579| | 580| | // iterate over all postfix operator strings 581| 97.6k| funmap_type::const_reverse_iterator it = m_pInfixOprtDef->rbegin(); 582| 120k| for (; it != m_pInfixOprtDef->rend(); ++it) ------------------ | Branch (582:10): [True: 119k, False: 383] ------------------ 583| 119k| { 584| 119k| if (sTok.find(it->first) != 0) ------------------ | Branch (584:8): [True: 22.3k, False: 97.3k] ------------------ 585| 22.3k| continue; 586| | 587| 97.3k| a_Tok.Set(it->second, it->first); 588| 97.3k| m_iPos += (int)it->first.length(); 589| | 590| 97.3k| if (m_iSynFlags & noINFIXOP) ------------------ | Branch (590:8): [True: 63, False: 97.2k] ------------------ 591| 63| Error(ecUNEXPECTED_OPERATOR, m_iPos, a_Tok.GetAsString()); 592| | 593| 97.3k| m_iSynFlags = noPOSTOP | noINFIXOP | noOPT | noBC | noSTR | noASSIGN | noARG_SEP; 594| 97.3k| return true; 595| 119k| } 596| | 597| 383| 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| 97.6k| } _ZN2mu17ParserTokenReader8IsFunTokERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE: 619| 2.95M| { 620| 2.95M| string_type strTok; 621| 2.95M| auto iEnd = ExtractToken(m_pParser->ValidNameChars(), strTok, (std::size_t)m_iPos); 622| 2.95M| if (iEnd == m_iPos) ------------------ | Branch (622:7): [True: 2.17M, False: 784k] ------------------ 623| 2.17M| return false; 624| | 625| 784k| funmap_type::const_iterator item = m_pFunDef->find(strTok); 626| 784k| if (item == m_pFunDef->end()) ------------------ | Branch (626:7): [True: 774k, False: 10.0k] ------------------ 627| 774k| return false; 628| | 629| | // Check if the next sign is an opening bracket 630| 10.0k| const char_type* szFormula = m_strFormula.c_str(); 631| 10.0k| if (szFormula[iEnd] != '(') ------------------ | Branch (631:7): [True: 19, False: 9.99k] ------------------ 632| 19| return false; 633| | 634| 9.99k| a_Tok.Set(item->second, strTok); 635| | 636| 9.99k| m_iPos = (int)iEnd; 637| 9.99k| if (m_iSynFlags & noFUN) ------------------ | Branch (637:7): [True: 1, False: 9.99k] ------------------ 638| 1| Error(ecUNEXPECTED_FUN, m_iPos - (int)a_Tok.GetAsString().length(), a_Tok.GetAsString()); 639| | 640| 9.99k| m_iSynFlags = noANY ^ noBO; 641| 9.99k| return true; 642| 10.0k| } _ZN2mu17ParserTokenReader6IsOprtERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE: 650| 2.95M| { 651| 2.95M| const char_type* const szExpr = m_strFormula.c_str(); 652| 2.95M| string_type strTok; 653| | 654| 2.95M| auto iEnd = ExtractOperatorToken(strTok, (std::size_t)m_iPos); 655| 2.95M| if (iEnd == m_iPos) ------------------ | Branch (655:7): [True: 2.35M, False: 599k] ------------------ 656| 2.35M| return false; 657| | 658| | // Check if the operator is a built in operator, if so ignore it here 659| 599k| const char_type** const pOprtDef = m_pParser->GetOprtDef(); 660| 9.14M| for (int i = 0; m_pParser->HasBuiltInOprt() && pOprtDef[i]; ++i) ------------------ | Branch (660:19): [True: 9.14M, False: 0] | Branch (660:50): [True: 8.97M, False: 169k] ------------------ 661| 8.97M| { 662| 8.97M| if (string_type(pOprtDef[i]) == strTok) ------------------ | Branch (662:8): [True: 430k, False: 8.54M] ------------------ 663| 430k| return false; 664| 8.97M| } 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| 169k| funmap_type::const_reverse_iterator it = m_pOprtDef->rbegin(); 673| 169k| for (; it != m_pOprtDef->rend(); ++it) ------------------ | Branch (673:10): [True: 0, False: 169k] ------------------ 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| 169k| return false; 705| 169k| } _ZN2mu17ParserTokenReader11IsPostOpTokERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE: 710| 591| { 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| 591| if (m_iSynFlags & noPOSTOP) ------------------ | Branch (718:7): [True: 423, False: 168] ------------------ 719| 423| 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| 168| string_type sTok; 732| 168| auto iEnd = ExtractToken(m_pParser->ValidOprtChars(), sTok, (std::size_t)m_iPos); 733| 168| if (iEnd == m_iPos) ------------------ | Branch (733:7): [True: 23, False: 145] ------------------ 734| 23| return false; 735| | 736| | // iterate over all postfix operator strings 737| 145| funmap_type::const_reverse_iterator it = m_pPostOprtDef->rbegin(); 738| 145| for (; it != m_pPostOprtDef->rend(); ++it) ------------------ | Branch (738:10): [True: 0, False: 145] ------------------ 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| 145| return false; 751| 145| } _ZN2mu17ParserTokenReader8IsValTokERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE: 762| 802k| { 763| 802k| MUP_ASSERT(m_pConstDef != nullptr); ------------------ | | 78| 802k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 802k] | | ------------------ | | 79| 802k| { \ | | 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| 802k| MUP_ASSERT(m_pParser != nullptr); ------------------ | | 78| 802k| if (!(COND)) \ | | ------------------ | | | Branch (78:17): [True: 0, False: 802k] | | ------------------ | | 79| 802k| { \ | | 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| 802k| string_type strTok; 767| 802k| value_type fVal(0); 768| | 769| | // 2.) Check for user defined constant 770| | // Read everything that could be a constant name 771| 802k| auto iEnd = ExtractToken(m_pParser->ValidNameChars(), strTok, (std::size_t)m_iPos); 772| 802k| if (iEnd != m_iPos) ------------------ | Branch (772:7): [True: 775k, False: 27.5k] ------------------ 773| 775k| { 774| 775k| valmap_type::const_iterator item = m_pConstDef->find(strTok); 775| 775k| if (item != m_pConstDef->end()) ------------------ | Branch (775:8): [True: 1.39k, False: 773k] ------------------ 776| 1.39k| { 777| 1.39k| m_iPos = iEnd; 778| 1.39k| a_Tok.SetVal(item->second, strTok); 779| | 780| 1.39k| if (m_iSynFlags & noVAL) ------------------ | Branch (780:9): [True: 3, False: 1.38k] ------------------ 781| 3| Error(ecUNEXPECTED_VAL, m_iPos - (int)strTok.length(), strTok); 782| | 783| 1.39k| m_iSynFlags = noVAL | noVAR | noFUN | noBO | noINFIXOP | noSTR | noASSIGN; 784| 1.39k| return true; 785| 1.39k| } 786| 775k| } 787| | 788| | // 3.call the value recognition functions provided by the user 789| | // Call user defined value recognition functions 790| 801k| std::list::const_iterator item = m_vIdentFun.begin(); 791| 829k| for (item = m_vIdentFun.begin(); item != m_vIdentFun.end(); ++item) ------------------ | Branch (791:36): [True: 801k, False: 28.0k] ------------------ 792| 801k| { 793| 801k| int iStart = m_iPos; 794| 801k| if ((*item)(m_strFormula.c_str() + m_iPos, &m_iPos, &fVal) == 1) ------------------ | Branch (794:8): [True: 773k, False: 28.0k] ------------------ 795| 773k| { 796| | // 2013-11-27 Issue 2: https://code.google.com/p/muparser/issues/detail?id=2 797| 773k| strTok.assign(m_strFormula.c_str(), iStart, (std::size_t)m_iPos - iStart); 798| | 799| 773k| if (m_iSynFlags & noVAL) ------------------ | Branch (799:9): [True: 4, False: 773k] ------------------ 800| 4| Error(ecUNEXPECTED_VAL, m_iPos - (int)strTok.length(), strTok); 801| | 802| 773k| a_Tok.SetVal(fVal, strTok); 803| 773k| m_iSynFlags = noVAL | noVAR | noFUN | noBO | noINFIXOP | noSTR | noASSIGN; 804| 773k| return true; 805| 773k| } 806| 801k| } 807| | 808| 28.0k| return false; 809| 801k| } _ZN2mu17ParserTokenReader8IsVarTokERNS_11ParserTokenIdNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE: 817| 28.0k| { 818| 28.0k| if (m_pVarDef->empty()) ------------------ | Branch (818:7): [True: 28.0k, False: 0] ------------------ 819| 28.0k| 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| 28.0k| { 849| 28.0k| if (!m_pStrVarDef || m_pStrVarDef->empty()) ------------------ | Branch (849:7): [True: 0, False: 28.0k] | Branch (849:24): [True: 28.0k, False: 0] ------------------ 850| 28.0k| 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| 28.0k| { 936| 28.0k| if (m_strFormula[m_iPos] != '"') ------------------ | Branch (936:7): [True: 591, False: 27.4k] ------------------ 937| 591| return false; 938| | 939| 27.4k| string_type strBuf(&m_strFormula[(std::size_t)m_iPos + 1]); 940| 27.4k| std::size_t iEnd(0), iSkip(0); 941| | 942| | // parser over escaped '\"' end replace them with '"' 943| 27.7k| for (iEnd = (int)strBuf.find(_T('\"')); iEnd != 0 && iEnd != string_type::npos; iEnd = (int)strBuf.find(_T('\"'), iEnd)) ------------------ | | 69| 27.4k| #define _T(x) x ------------------ for (iEnd = (int)strBuf.find(_T('\"')); iEnd != 0 && iEnd != string_type::npos; iEnd = (int)strBuf.find(_T('\"'), iEnd)) ------------------ | | 69| 318| #define _T(x) x ------------------ | Branch (943:43): [True: 2.26k, False: 25.5k] | Branch (943:56): [True: 2.22k, False: 38] ------------------ 944| 2.22k| { 945| 2.22k| if (strBuf[iEnd - 1] != '\\') break; ------------------ | Branch (945:8): [True: 1.90k, False: 318] ------------------ 946| 318| strBuf.replace(iEnd - 1, 2, _T("\"")); ------------------ | | 69| 318| #define _T(x) x ------------------ 947| 318| iSkip++; 948| 318| } 949| | 950| 27.4k| if (iEnd == string_type::npos) ------------------ | Branch (950:7): [True: 38, False: 27.4k] ------------------ 951| 38| Error(ecUNTERMINATED_STRING, m_iPos, _T("\"")); ------------------ | | 69| 38| #define _T(x) x ------------------ 952| | 953| 27.4k| string_type strTok(strBuf.begin(), strBuf.begin() + iEnd); 954| | 955| 27.4k| if (m_iSynFlags & noSTR) ------------------ | Branch (955:7): [True: 62, False: 27.3k] ------------------ 956| 62| Error(ecUNEXPECTED_STR, m_iPos, strTok); 957| | 958| 27.4k| m_pParser->m_vStringBuf.push_back(strTok); // Store string in internal buffer 959| 27.4k| a_Tok.SetString(strTok, m_pParser->m_vStringBuf.size()); 960| | 961| 27.4k| m_iPos += (int)strTok.length() + 2 + (int)iSkip; // +2 for quotes; +iSkip for escape characters 962| 27.4k| m_iSynFlags = noANY ^ (noARG_SEP | noBC | noOPT | noEND); 963| | 964| 27.4k| return true; 965| 28.0k| } _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| 4.00k| { 991| 4.00k| return m_cArgSep; 992| 4.00k| } LLVMFuzzerTestOneInput: 22| 4.00k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 23| 4.00k| std::string line_string((char *)data, size); 24| 4.00k| try { 25| 4.00k| mu::Parser parser; 26| 4.00k| parser.SetExpr(line_string); 27| 4.00k| parser.Eval(); 28| 4.00k| } catch (mu::Parser::exception_type &e) { 29| 2.49k| } catch (mu::ParserError &e) { 30| 0| } 31| 4.00k| return 0; 32| 4.00k|}