base58.cpp:_ZL6mul128mmPm: 82| 8.62k|static inline uint64_t mul128(uint64_t multiplier, uint64_t multiplicand, uint64_t* product_hi) { 83| | // multiplier = ab = a * 2^32 + b 84| | // multiplicand = cd = c * 2^32 + d 85| | // ab * cd = a * c * 2^64 + (a * d + b * c) * 2^32 + b * d 86| 8.62k| uint64_t a = hi_dword(multiplier); 87| 8.62k| uint64_t b = lo_dword(multiplier); 88| 8.62k| uint64_t c = hi_dword(multiplicand); 89| 8.62k| uint64_t d = lo_dword(multiplicand); 90| | 91| 8.62k| uint64_t ac = a * c; 92| 8.62k| uint64_t ad = a * d; 93| 8.62k| uint64_t bc = b * c; 94| 8.62k| uint64_t bd = b * d; 95| | 96| 8.62k| uint64_t adbc = ad + bc; 97| 8.62k| uint64_t adbc_carry = adbc < ad ? 1 : 0; ------------------ | Branch (97:25): [True: 0, False: 8.62k] ------------------ 98| | 99| | // multiplier * multiplicand = product_hi * 2^64 + product_lo 100| 8.62k| uint64_t product_lo = bd + (adbc << 32); 101| 8.62k| uint64_t product_lo_carry = product_lo < bd ? 1 : 0; ------------------ | Branch (101:31): [True: 0, False: 8.62k] ------------------ 102| 8.62k| *product_hi = ac + (adbc >> 32) + (adbc_carry << 32) + product_lo_carry; 103| 8.62k| assert(ac <= *product_hi); 104| | 105| 8.62k| return product_lo; 106| 8.62k|} base58.cpp:_ZL8hi_dwordm: 74| 17.2k|static inline uint64_t hi_dword(uint64_t val) { 75| 17.2k| return val >> 32; 76| 17.2k|} base58.cpp:_ZL8lo_dwordm: 78| 17.2k|static inline uint64_t lo_dword(uint64_t val) { 79| 17.2k| return val & 0xFFFFFFFF; 80| 17.2k|} _ZN2el4base5debug12CrashHandlerC2Eb: 3310| 2|CrashHandler::CrashHandler(bool useDefault) { 3311| 2| if (useDefault) { ------------------ | Branch (3311:7): [True: 0, False: 2] ------------------ 3312| 0| setHandler(defaultCrashHandler); 3313| 0| } 3314| 2|} _ZN2el11LevelHelper12forEachLevelEPjRKNSt3__18functionIFbvEEE: 251| 96|void LevelHelper::forEachLevel(base::type::EnumType* startIndex, const std::function& fn) { 252| 96| base::type::EnumType lIndexMax = LevelHelper::kMaxValid; 253| 672| do { 254| 672| if (fn()) { ------------------ | Branch (254:9): [True: 0, False: 672] ------------------ 255| 0| break; 256| 0| } 257| 672| *startIndex = static_cast(*startIndex << 1); 258| 672| } while (*startIndex <= lIndexMax); ------------------ | Branch (258:12): [True: 576, False: 96] ------------------ 259| 96|} _ZN2el13ConfigurationC2ENS_5LevelENS_17ConfigurationTypeERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 333| 288| m_level(level), 334| 288| m_configurationType(configurationType), 335| 288| m_value(value) { 336| 288|} _ZN2el13Configuration9PredicateC2ENS_5LevelENS_17ConfigurationTypeE: 346| 802| m_level(level), 347| 802| m_configurationType(configurationType) { 348| 802|} _ZNK2el13Configuration9PredicateclEPKS0_: 350| 29.5k|bool Configuration::Predicate::operator()(const Configuration* conf) const { 351| 29.5k| return ((conf != nullptr) && (conf->level() == m_level) && (conf->configurationType() == m_configurationType)); ------------------ | Branch (351:11): [True: 29.5k, False: 0] | Branch (351:32): [True: 3.76k, False: 25.7k] | Branch (351:62): [True: 514, False: 3.24k] ------------------ 352| 29.5k|} _ZN2el14ConfigurationsC2Ev: 357| 4| m_configurationFile(std::string()), 358| 4| m_isFromFile(false) { 359| 4|} _ZN2el14Configurations11setFromBaseEPS0_: 393| 2|void Configurations::setFromBase(Configurations* base) { 394| 2| if (base == nullptr || base == this) { ------------------ | Branch (394:7): [True: 0, False: 2] | Branch (394:26): [True: 0, False: 2] ------------------ 395| 0| return; 396| 0| } 397| 2| base::threading::ScopedLock scopedLock(base->lock()); 398| 144| for (Configuration*& conf : base->list()) { ------------------ | Branch (398:29): [True: 144, False: 2] ------------------ 399| 144| set(conf); 400| 144| } 401| 2|} _ZN2el14Configurations3setENS_5LevelENS_17ConfigurationTypeERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 426| 298|void Configurations::set(Level level, ConfigurationType configurationType, const std::string& value) { 427| 298| base::threading::ScopedLock scopedLock(lock()); 428| 298| unsafeSet(level, configurationType, value); // This is not unsafe anymore as we have locked mutex 429| 298| if (level == Level::Global) { ------------------ | Branch (429:7): [True: 36, False: 262] ------------------ 430| 36| unsafeSetGlobally(configurationType, value, false); // Again this is not unsafe either 431| 36| } 432| 298|} _ZN2el14Configurations3setEPNS_13ConfigurationE: 434| 144|void Configurations::set(Configuration* conf) { 435| 144| if (conf == nullptr) { ------------------ | Branch (435:7): [True: 0, False: 144] ------------------ 436| 0| return; 437| 0| } 438| 144| set(conf->level(), conf->configurationType(), conf->value()); 439| 144|} _ZN2el14Configurations12setToDefaultEv: 441| 2|void Configurations::setToDefault(void) { 442| 2| setGlobally(ConfigurationType::Enabled, std::string("true"), true); 443| 2| setGlobally(ConfigurationType::Filename, std::string(base::consts::kDefaultLogFile), true); 444| |#if defined(ELPP_NO_LOG_TO_FILE) 445| | setGlobally(ConfigurationType::ToFile, std::string("false"), true); 446| |#else 447| 2| setGlobally(ConfigurationType::ToFile, std::string("true"), true); 448| 2|#endif // defined(ELPP_NO_LOG_TO_FILE) 449| 2| setGlobally(ConfigurationType::ToStandardOutput, std::string("true"), true); 450| 2| setGlobally(ConfigurationType::SubsecondPrecision, std::string("3"), true); 451| 2| setGlobally(ConfigurationType::PerformanceTracking, std::string("true"), true); 452| 2| setGlobally(ConfigurationType::MaxLogFileSize, std::string("0"), true); 453| 2| setGlobally(ConfigurationType::LogFlushThreshold, std::string("0"), true); 454| | 455| 2| setGlobally(ConfigurationType::Format, std::string("%datetime %level [%logger] %msg"), true); 456| 2| set(Level::Debug, ConfigurationType::Format, 457| 2| std::string("%datetime %level [%logger] [%user@%host] [%func] [%loc] %msg")); 458| | // INFO and WARNING are set to default by Level::Global 459| 2| set(Level::Error, ConfigurationType::Format, std::string("%datetime %level [%logger] %msg")); 460| 2| set(Level::Fatal, ConfigurationType::Format, std::string("%datetime %level [%logger] %msg")); 461| 2| set(Level::Verbose, ConfigurationType::Format, std::string("%datetime %level-%vlevel [%logger] %msg")); 462| 2| set(Level::Trace, ConfigurationType::Format, std::string("%datetime %level [%logger] [%func] [%loc] %msg")); 463| 2|} _ZN2el14Configurations9unsafeSetENS_5LevelENS_17ConfigurationTypeERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 624| 802|void Configurations::unsafeSet(Level level, ConfigurationType configurationType, const std::string& value) { 625| 802| Configuration* conf = RegistryWithPred::get(level, configurationType); 626| 802| if (conf == nullptr) { ------------------ | Branch (626:7): [True: 288, False: 514] ------------------ 627| 288| registerNew(new Configuration(level, configurationType, value)); 628| 514| } else { 629| 514| conf->setValue(value); 630| 514| } 631| 802| if (level == Level::Global) { ------------------ | Branch (631:7): [True: 36, False: 766] ------------------ 632| 36| unsafeSetGlobally(configurationType, value, false); 633| 36| } 634| 802|} _ZN2el14Configurations11setGloballyENS_17ConfigurationTypeERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEb: 637| 18| bool includeGlobalLevel) { 638| 18| if (includeGlobalLevel) { ------------------ | Branch (638:7): [True: 18, False: 0] ------------------ 639| 18| set(Level::Global, configurationType, value); 640| 18| } 641| 18| base::type::EnumType lIndex = LevelHelper::kMinValid; 642| 18| LevelHelper::forEachLevel(&lIndex, [&](void) -> bool { 643| 18| set(LevelHelper::castFromInt(lIndex), configurationType, value); 644| 18| return false; // Do not break lambda function yet as we need to set all levels regardless 645| 18| }); 646| 18|} _ZN2el14Configurations17unsafeSetGloballyENS_17ConfigurationTypeERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEb: 649| 72| bool includeGlobalLevel) { 650| 72| if (includeGlobalLevel) { ------------------ | Branch (650:7): [True: 0, False: 72] ------------------ 651| 0| unsafeSet(Level::Global, configurationType, value); 652| 0| } 653| 72| base::type::EnumType lIndex = LevelHelper::kMinValid; 654| 72| LevelHelper::forEachLevel(&lIndex, [&](void) -> bool { 655| 72| unsafeSet(LevelHelper::castFromInt(lIndex), configurationType, value); 656| 72| return false; // Do not break lambda function yet as we need to set all levels regardless 657| 72| }); 658| 72|} _ZN2el6LoggerC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS_14ConfigurationsEPNS1_13unordered_mapIS7_NS1_10shared_ptrINS1_13basic_fstreamIcS4_EEEENS1_4hashIS7_EENS1_8equal_toIS7_EENS5_INS1_4pairIS8_SH_EEEEEE: 712| 2| m_id(id), 713| 2| m_typedConfigurations(nullptr), 714| 2| m_parentApplicationName(std::string()), 715| 2| m_isConfigured(false), 716| 2| m_logStreamsReference(logStreamsReference) { 717| 2| initUnflushedCount(); 718| 2| configure(configurations); 719| 2|} _ZN2el6Logger9configureERKNS_14ConfigurationsE: 745| 2|void Logger::configure(const Configurations& configurations) { 746| 2| m_isConfigured = false; // we set it to false in case if we fail 747| 2| initUnflushedCount(); 748| 2| if (m_typedConfigurations != nullptr) { ------------------ | Branch (748:7): [True: 0, False: 2] ------------------ 749| 0| Configurations* c = const_cast(m_typedConfigurations->configurations()); 750| 0| if (c->hasConfiguration(Level::Global, ConfigurationType::Filename)) { ------------------ | Branch (750:9): [True: 0, False: 0] ------------------ 751| 0| flush(); 752| 0| } 753| 0| } 754| 2| base::threading::ScopedLock scopedLock(lock()); 755| 2| if (m_configurations != configurations) { ------------------ | Branch (755:7): [True: 2, False: 0] ------------------ 756| 2| m_configurations.setFromBase(const_cast(&configurations)); 757| 2| } 758| 2| base::utils::safeDelete(m_typedConfigurations); 759| 2| m_typedConfigurations = new base::TypedConfigurations(&m_configurations, m_logStreamsReference); 760| 2| resolveLoggerFormatSpec(); 761| 2| m_isConfigured = true; 762| 2|} _ZN2el6Logger9isValidIdERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 769| 2|bool Logger::isValidId(const std::string& id) { 770| 16| for (std::string::const_iterator it = id.begin(); it != id.end(); ++it) { ------------------ | Branch (770:53): [True: 14, False: 2] ------------------ 771| 14| if (!base::utils::Str::contains(base::consts::kValidLoggerIdSymbols, *it)) { ------------------ | Branch (771:9): [True: 0, False: 14] ------------------ 772| 0| return false; 773| 0| } 774| 14| } 775| 2| return true; 776| 2|} _ZN2el6Logger18initUnflushedCountEv: 802| 4|void Logger::initUnflushedCount(void) { 803| 4| m_unflushedCount.clear(); 804| 4| base::type::EnumType lIndex = LevelHelper::kMinValid; 805| 4| LevelHelper::forEachLevel(&lIndex, [&](void) -> bool { 806| 4| m_unflushedCount.insert(std::make_pair(LevelHelper::castFromInt(lIndex), 0)); 807| 4| return false; 808| 4| }); 809| 4|} _ZNK2el6Logger23resolveLoggerFormatSpecEv: 811| 2|void Logger::resolveLoggerFormatSpec(void) const { 812| 2| base::type::EnumType lIndex = LevelHelper::kMinValid; 813| 2| LevelHelper::forEachLevel(&lIndex, [&](void) -> bool { 814| 2| base::LogFormat* logFormat = 815| 2| const_cast(&m_typedConfigurations->logFormat(LevelHelper::castFromInt(lIndex))); 816| 2| base::utils::Str::replaceFirstWithEscape(logFormat->m_format, base::consts::kLoggerIdFormatSpecifier, m_id); 817| 2| return false; 818| 2| }); 819| 2|} _ZN2el4base5utils3Str5ltrimERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 988| 112|std::string& Str::ltrim(std::string& str) { 989| 112| str.erase(str.begin(), std::find_if(str.begin(), str.end(), [](char c) { 990| 112| return !std::isspace(c); 991| 112| } )); 992| 112| return str; 993| 112|} _ZN2el4base5utils3Str5rtrimERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 995| 112|std::string& Str::rtrim(std::string& str) { 996| 112| str.erase(std::find_if(str.rbegin(), str.rend(), [](char c) { 997| 112| return !std::isspace(c); 998| 112| }).base(), str.end()); 999| 112| return str; 1000| 112|} _ZN2el4base5utils3Str4trimERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 1002| 112|std::string& Str::trim(std::string& str) { 1003| 112| return ltrim(rtrim(str)); 1004| 112|} _ZN2el4base5utils3Str22replaceFirstWithEscapeERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERKS9_SC_: 1031| 46| const base::type::string_t& replaceWith) { 1032| 46| std::size_t foundAt = base::type::string_t::npos; 1033| 46| while ((foundAt = str.find(replaceWhat, foundAt + 1)) != base::type::string_t::npos) { ------------------ | Branch (1033:10): [True: 32, False: 14] ------------------ 1034| 32| if (foundAt > 0 && str[foundAt - 1] == base::consts::kFormatSpecifierChar) { ------------------ | Branch (1034:9): [True: 32, False: 0] | Branch (1034:24): [True: 0, False: 32] ------------------ 1035| 0| str.erase(foundAt - 1, 1); 1036| 0| ++foundAt; 1037| 32| } else { 1038| 32| str.replace(foundAt, replaceWhat.length(), replaceWith); 1039| 32| return; 1040| 32| } 1041| 32| } 1042| 46|} _ZN2el4base5utils3Str8containsEPKcc: 1083| 14|bool Str::contains(const char* str, char c) { 1084| 138| for (; *str; ++str) { ------------------ | Branch (1084:10): [True: 138, False: 0] ------------------ 1085| 138| if (*str == c) ------------------ | Branch (1085:9): [True: 14, False: 124] ------------------ 1086| 14| return true; 1087| 138| } 1088| 0| return false; 1089| 14|} _ZN2el4base5utils2OS22getEnvironmentVariableEPKcS4_S4_: 1198| 34| const char* alternativeBashCommand) { 1199| 34|#if ELPP_OS_UNIX 1200| 34| const char* val = getenv(variableName); 1201| |#elif ELPP_OS_WINDOWS 1202| | const char* val = getWindowsEnvironmentVariable(variableName); 1203| |#endif // ELPP_OS_UNIX 1204| 34| if ((val == nullptr) || ((strcmp(val, "") == 0))) { ------------------ | Branch (1204:7): [True: 18, False: 16] | Branch (1204:27): [True: 0, False: 16] ------------------ 1205| |#if ELPP_OS_UNIX && defined(ELPP_FORCE_ENV_VAR_FROM_BASH) 1206| | // Try harder on unix-based systems 1207| | std::string valBash = base::utils::OS::getBashOutput(alternativeBashCommand); 1208| | if (valBash.empty()) { 1209| | return std::string(defaultVal); 1210| | } else { 1211| | return valBash; 1212| | } 1213| |#elif ELPP_OS_WINDOWS || ELPP_OS_UNIX 1214| 18| ELPP_UNUSED(alternativeBashCommand); ------------------ | | 240| 18|#define ELPP_UNUSED(x) (void)x ------------------ 1215| 18| return std::string(defaultVal); 1216| 18|#endif // ELPP_OS_UNIX && defined(ELPP_FORCE_ENV_VAR_FROM_BASH) 1217| 18| } 1218| 16| return std::string(val); 1219| 34|} _ZN2el4base5utils2OS11currentUserEv: 1221| 16|std::string OS::currentUser(void) { 1222| 16|#if ELPP_OS_UNIX && !ELPP_OS_ANDROID 1223| 16| return getEnvironmentVariable("USER", base::consts::kUnknownUser, "whoami"); 1224| |#elif ELPP_OS_WINDOWS 1225| | return getEnvironmentVariable("USERNAME", base::consts::kUnknownUser); 1226| |#elif ELPP_OS_ANDROID 1227| | ELPP_UNUSED(base::consts::kUnknownUser); 1228| | return std::string("android"); 1229| |#else 1230| | return std::string(); 1231| |#endif // ELPP_OS_UNIX && !ELPP_OS_ANDROID 1232| 16|} _ZN2el4base5utils2OS11currentHostEv: 1234| 16|std::string OS::currentHost(void) { 1235| 16|#if ELPP_OS_UNIX && !ELPP_OS_ANDROID 1236| 16| return getEnvironmentVariable("HOSTNAME", base::consts::kUnknownHost, "hostname"); 1237| |#elif ELPP_OS_WINDOWS 1238| | return getEnvironmentVariable("COMPUTERNAME", base::consts::kUnknownHost); 1239| |#elif ELPP_OS_ANDROID 1240| | ELPP_UNUSED(base::consts::kUnknownHost); 1241| | return getDeviceName(); 1242| |#else 1243| | return std::string(); 1244| |#endif // ELPP_OS_UNIX && !ELPP_OS_ANDROID 1245| 16|} _ZN2el4base5utils2OS17termSupportsColorEv: 1247| 2|bool OS::termSupportsColor(void) { 1248| 2| std::string term = getEnvironmentVariable("TERM", ""); 1249| 2| return term == "xterm" || term == "xterm-color" || term == "xterm-256color" ------------------ | Branch (1249:10): [True: 0, False: 2] | Branch (1249:29): [True: 0, False: 2] | Branch (1249:54): [True: 0, False: 2] ------------------ 1250| 2| || term == "screen" || term == "linux" || term == "cygwin" ------------------ | Branch (1250:13): [True: 0, False: 2] | Branch (1250:33): [True: 0, False: 2] | Branch (1250:52): [True: 0, False: 2] ------------------ 1251| 2| || term == "screen-256color" || term == "screen.xterm-256color"; ------------------ | Branch (1251:13): [True: 0, False: 2] | Branch (1251:42): [True: 0, False: 2] ------------------ 1252| 2|} _ZN2el4base5utils15CommandLineArgs7setArgsEiPPc: 1423| 2|void CommandLineArgs::setArgs(int argc, char** argv) { 1424| 2| m_params.clear(); 1425| 2| m_paramsWithValue.clear(); 1426| 2| if (argc == 0 || argv == nullptr) { ------------------ | Branch (1426:7): [True: 2, False: 0] | Branch (1426:20): [True: 0, False: 0] ------------------ 1427| 2| return; 1428| 2| } 1429| 0| m_argc = argc; 1430| 0| m_argv = argv; 1431| 0| for (int i = 1; i < m_argc; ++i) { ------------------ | Branch (1431:19): [True: 0, False: 0] ------------------ 1432| 0| const char* v = (strstr(m_argv[i], "=")); 1433| 0| if (v != nullptr && strlen(v) > 0) { ------------------ | Branch (1433:9): [True: 0, False: 0] | Branch (1433:25): [True: 0, False: 0] ------------------ 1434| 0| std::string key = std::string(m_argv[i]); 1435| 0| key = key.substr(0, key.find_first_of('=')); 1436| 0| if (hasParamWithValue(key.c_str())) { ------------------ | Branch (1436:11): [True: 0, False: 0] ------------------ 1437| 0| ELPP_INTERNAL_INFO(1, "Skipping [" << key << "] arg since it already has value [" 1438| 0| << getParamValue(key.c_str()) << "]"); 1439| 0| } else { 1440| 0| m_paramsWithValue.insert(std::make_pair(key, std::string(v + 1))); 1441| 0| } 1442| 0| } 1443| 0| if (v == nullptr) { ------------------ | Branch (1443:9): [True: 0, False: 0] ------------------ 1444| 0| if (hasParam(m_argv[i])) { ------------------ | Branch (1444:11): [True: 0, False: 0] ------------------ 1445| 0| ELPP_INTERNAL_INFO(1, "Skipping [" << m_argv[i] << "] arg since it already exists"); 1446| 0| } else { 1447| 0| m_params.push_back(std::string(m_argv[i])); 1448| 0| } 1449| 0| } 1450| 0| } 1451| 0|} _ZN2el4base18SubsecondPrecision4initEi: 1510| 16|void SubsecondPrecision::init(int width) { 1511| 16| if (width < 1 || width > 6) { ------------------ | Branch (1511:7): [True: 0, False: 16] | Branch (1511:20): [True: 0, False: 16] ------------------ 1512| 0| width = base::consts::kDefaultSubsecondPrecision; 1513| 0| } 1514| 16| m_width = width; 1515| 16| switch (m_width) { 1516| 16| case 3: ------------------ | Branch (1516:3): [True: 16, False: 0] ------------------ 1517| 16| m_offset = 1000; 1518| 16| break; 1519| 0| case 4: ------------------ | Branch (1519:3): [True: 0, False: 16] ------------------ 1520| 0| m_offset = 100; 1521| 0| break; 1522| 0| case 5: ------------------ | Branch (1522:3): [True: 0, False: 16] ------------------ 1523| 0| m_offset = 10; 1524| 0| break; 1525| 0| case 6: ------------------ | Branch (1525:3): [True: 0, False: 16] ------------------ 1526| 0| m_offset = 1; 1527| 0| break; 1528| 0| default: ------------------ | Branch (1528:3): [True: 0, False: 16] ------------------ 1529| 0| m_offset = 1000; 1530| 0| break; 1531| 16| } 1532| 16|} _ZN2el4base9LogFormatC2ENS_5LevelERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 1547| 16| : m_level(level), m_userFormat(format), m_currentUser(base::utils::OS::currentUser()), 1548| 16| m_currentHost(base::utils::OS::currentHost()) { 1549| 16| parseFromFormat(m_userFormat); 1550| 16|} _ZN2el4base9LogFormatC2ERKS1_: 1553| 16| m_level(logFormat.m_level), 1554| 16| m_userFormat(logFormat.m_userFormat), 1555| 16| m_format(logFormat.m_format), 1556| 16| m_dateTimeFormat(logFormat.m_dateTimeFormat), 1557| 16| m_flags(logFormat.m_flags), 1558| 16| m_currentUser(logFormat.m_currentUser), 1559| 16| m_currentHost(logFormat.m_currentHost) { 1560| 16|} _ZN2el4base9LogFormatC2EOS1_: 1562| 16|LogFormat::LogFormat(LogFormat&& logFormat) { 1563| 16| m_level = std::move(logFormat.m_level); 1564| 16| m_userFormat = std::move(logFormat.m_userFormat); 1565| 16| m_format = std::move(logFormat.m_format); 1566| 16| m_dateTimeFormat = std::move(logFormat.m_dateTimeFormat); 1567| 16| m_flags = std::move(logFormat.m_flags); 1568| 16| m_currentUser = std::move(logFormat.m_currentUser); 1569| 16| m_currentHost = std::move(logFormat.m_currentHost); 1570| 16|} _ZN2el4base9LogFormateqERKS1_: 1584| 14|bool LogFormat::operator==(const LogFormat& other) { 1585| 14| return m_level == other.m_level && m_userFormat == other.m_userFormat && m_format == other.m_format && ------------------ | Branch (1585:10): [True: 0, False: 14] | Branch (1585:38): [True: 0, False: 0] | Branch (1585:76): [True: 0, False: 0] ------------------ 1586| 14| m_dateTimeFormat == other.m_dateTimeFormat && m_flags == other.m_flags; ------------------ | Branch (1586:10): [True: 0, False: 0] | Branch (1586:56): [True: 0, False: 0] ------------------ 1587| 14|} _ZN2el4base9LogFormat15parseFromFormatERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 1591| 16|void LogFormat::parseFromFormat(const base::type::string_t& userFormat) { 1592| | // We make copy because we will be changing the format 1593| | // i.e, removing user provided date format from original format 1594| | // and then storing it. 1595| 16| base::type::string_t formatCopy = userFormat; 1596| 16| m_flags = 0x0; 1597| 16| auto conditionalAddFlag = [&](const base::type::char_t* specifier, base::FormatFlags flag) { 1598| 16| std::size_t foundAt = base::type::string_t::npos; 1599| 16| while ((foundAt = formatCopy.find(specifier, foundAt + 1)) != base::type::string_t::npos) { 1600| 16| if (foundAt > 0 && formatCopy[foundAt - 1] == base::consts::kFormatSpecifierChar) { 1601| 16| if (hasFlag(flag)) { 1602| | // If we already have flag we remove the escape chars so that '%%' is turned to '%' 1603| | // even after specifier resolution - this is because we only replaceFirst specifier 1604| 16| formatCopy.erase(foundAt - 1, 1); 1605| 16| ++foundAt; 1606| 16| } 1607| 16| } else { 1608| 16| if (!hasFlag(flag)) addFlag(flag); 1609| 16| } 1610| 16| } 1611| 16| }; 1612| 16| conditionalAddFlag(base::consts::kAppNameFormatSpecifier, base::FormatFlags::AppName); 1613| 16| conditionalAddFlag(base::consts::kSeverityLevelFormatSpecifier, base::FormatFlags::Level); 1614| 16| conditionalAddFlag(base::consts::kSeverityLevelShortFormatSpecifier, base::FormatFlags::LevelShort); 1615| 16| conditionalAddFlag(base::consts::kLoggerIdFormatSpecifier, base::FormatFlags::LoggerId); 1616| 16| conditionalAddFlag(base::consts::kThreadIdFormatSpecifier, base::FormatFlags::ThreadId); 1617| 16| conditionalAddFlag(base::consts::kLogFileFormatSpecifier, base::FormatFlags::File); 1618| 16| conditionalAddFlag(base::consts::kLogFileBaseFormatSpecifier, base::FormatFlags::FileBase); 1619| 16| conditionalAddFlag(base::consts::kLogLineFormatSpecifier, base::FormatFlags::Line); 1620| 16| conditionalAddFlag(base::consts::kLogLocationFormatSpecifier, base::FormatFlags::Location); 1621| 16| conditionalAddFlag(base::consts::kLogFunctionFormatSpecifier, base::FormatFlags::Function); 1622| 16| conditionalAddFlag(base::consts::kCurrentUserFormatSpecifier, base::FormatFlags::User); 1623| 16| conditionalAddFlag(base::consts::kCurrentHostFormatSpecifier, base::FormatFlags::Host); 1624| 16| conditionalAddFlag(base::consts::kMessageFormatSpecifier, base::FormatFlags::LogMessage); 1625| 16| conditionalAddFlag(base::consts::kVerboseLevelFormatSpecifier, base::FormatFlags::VerboseLevel); 1626| | // For date/time we need to extract user's date format first 1627| 16| std::size_t dateIndex = std::string::npos; 1628| 16| if ((dateIndex = formatCopy.find(base::consts::kDateTimeFormatSpecifier)) != std::string::npos) { ------------------ | Branch (1628:7): [True: 16, False: 0] ------------------ 1629| 16| while (dateIndex > 0 && formatCopy[dateIndex - 1] == base::consts::kFormatSpecifierChar) { ------------------ | Branch (1629:12): [True: 0, False: 16] | Branch (1629:29): [True: 0, False: 0] ------------------ 1630| 0| dateIndex = formatCopy.find(base::consts::kDateTimeFormatSpecifier, dateIndex + 1); 1631| 0| } 1632| 16| if (dateIndex != std::string::npos) { ------------------ | Branch (1632:9): [True: 16, False: 0] ------------------ 1633| 16| addFlag(base::FormatFlags::DateTime); 1634| 16| updateDateFormat(dateIndex, formatCopy); 1635| 16| } 1636| 16| } 1637| 16| m_format = formatCopy; 1638| 16| updateFormatSpec(); 1639| 16|} _ZN2el4base9LogFormat16updateDateFormatEmRNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 1641| 16|void LogFormat::updateDateFormat(std::size_t index, base::type::string_t& currFormat) { 1642| 16| if (hasFlag(base::FormatFlags::DateTime)) { ------------------ | Branch (1642:7): [True: 16, False: 0] ------------------ 1643| 16| index += ELPP_STRLEN(base::consts::kDateTimeFormatSpecifier); ------------------ | | 540| 16|# define ELPP_STRLEN strlen ------------------ 1644| 16| } 1645| 16| const base::type::char_t* ptr = currFormat.c_str() + index; 1646| 16| if ((currFormat.size() > index) && (ptr[0] == '{')) { ------------------ | Branch (1646:7): [True: 16, False: 0] | Branch (1646:38): [True: 0, False: 16] ------------------ 1647| | // User has provided format for date/time 1648| 0| ++ptr; 1649| 0| int count = 1; // Start by 1 in order to remove starting brace 1650| 0| std::stringstream ss; 1651| 0| for (; *ptr; ++ptr, ++count) { ------------------ | Branch (1651:12): [True: 0, False: 0] ------------------ 1652| 0| if (*ptr == '}') { ------------------ | Branch (1652:11): [True: 0, False: 0] ------------------ 1653| 0| ++count; // In order to remove ending brace 1654| 0| break; 1655| 0| } 1656| 0| ss << static_cast(*ptr); 1657| 0| } 1658| 0| currFormat.erase(index, count); 1659| 0| m_dateTimeFormat = ss.str(); 1660| 16| } else { 1661| | // No format provided, use default 1662| 16| if (hasFlag(base::FormatFlags::DateTime)) { ------------------ | Branch (1662:9): [True: 16, False: 0] ------------------ 1663| 16| m_dateTimeFormat = std::string(base::consts::kDefaultDateTimeFormat); 1664| 16| } 1665| 16| } 1666| 16|} _ZN2el4base9LogFormat16updateFormatSpecEv: 1668| 16|void LogFormat::updateFormatSpec(void) { 1669| | // Do not use switch over strongly typed enums because Intel C++ compilers dont support them yet. 1670| 16| if (m_level == Level::Debug) { ------------------ | Branch (1670:7): [True: 2, False: 14] ------------------ 1671| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier, 1672| 2| base::consts::kDebugLevelLogValue); 1673| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier, 1674| 2| base::consts::kDebugLevelShortLogValue); 1675| 14| } else if (m_level == Level::Info) { ------------------ | Branch (1675:14): [True: 2, False: 12] ------------------ 1676| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier, 1677| 2| base::consts::kInfoLevelLogValue); 1678| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier, 1679| 2| base::consts::kInfoLevelShortLogValue); 1680| 12| } else if (m_level == Level::Warning) { ------------------ | Branch (1680:14): [True: 2, False: 10] ------------------ 1681| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier, 1682| 2| base::consts::kWarningLevelLogValue); 1683| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier, 1684| 2| base::consts::kWarningLevelShortLogValue); 1685| 10| } else if (m_level == Level::Error) { ------------------ | Branch (1685:14): [True: 2, False: 8] ------------------ 1686| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier, 1687| 2| base::consts::kErrorLevelLogValue); 1688| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier, 1689| 2| base::consts::kErrorLevelShortLogValue); 1690| 8| } else if (m_level == Level::Fatal) { ------------------ | Branch (1690:14): [True: 2, False: 6] ------------------ 1691| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier, 1692| 2| base::consts::kFatalLevelLogValue); 1693| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier, 1694| 2| base::consts::kFatalLevelShortLogValue); 1695| 6| } else if (m_level == Level::Verbose) { ------------------ | Branch (1695:14): [True: 2, False: 4] ------------------ 1696| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier, 1697| 2| base::consts::kVerboseLevelLogValue); 1698| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier, 1699| 2| base::consts::kVerboseLevelShortLogValue); 1700| 4| } else if (m_level == Level::Trace) { ------------------ | Branch (1700:14): [True: 2, False: 2] ------------------ 1701| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier, 1702| 2| base::consts::kTraceLevelLogValue); 1703| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier, 1704| 2| base::consts::kTraceLevelShortLogValue); 1705| 2| } 1706| 16| if (hasFlag(base::FormatFlags::User)) { ------------------ | Branch (1706:7): [True: 2, False: 14] ------------------ 1707| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kCurrentUserFormatSpecifier, 1708| 2| m_currentUser); 1709| 2| } 1710| 16| if (hasFlag(base::FormatFlags::Host)) { ------------------ | Branch (1710:7): [True: 2, False: 14] ------------------ 1711| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kCurrentHostFormatSpecifier, 1712| 2| m_currentHost); 1713| 2| } 1714| | // Ignore Level::Global and Level::Unknown 1715| 16|} _ZN2el4base19TypedConfigurationsC2EPNS_14ConfigurationsEPNSt3__113unordered_mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS4_10shared_ptrINS4_13basic_fstreamIcS8_EEEENS4_4hashISB_EENS4_8equal_toISB_EENS9_INS4_4pairIKSB_SF_EEEEEE: 1720| 2| base::LogStreamsReferenceMap* logStreamsReference) { 1721| 2| m_configurations = configurations; 1722| 2| m_logStreamsReference = logStreamsReference; 1723| 2| build(m_configurations); 1724| 2|} _ZN2el4base19TypedConfigurations9logFormatENS_5LevelE: 1748| 14|const base::LogFormat& TypedConfigurations::logFormat(Level level) { 1749| 14| return getConfigByRef(level, &m_logFormatMap, "logFormat"); 1750| 14|} _ZN2el4base19TypedConfigurations5buildEPNS_14ConfigurationsE: 1776| 2|void TypedConfigurations::build(Configurations* configurations) { 1777| 2| base::threading::ScopedLock scopedLock(lock()); 1778| 2| auto getBool = [] (std::string boolStr) -> bool { // Pass by value for trimming 1779| 2| base::utils::Str::trim(boolStr); 1780| 2| return (boolStr == "TRUE" || boolStr == "true" || boolStr == "1"); 1781| 2| }; 1782| 2| setValue(Level::Global, base::FileStreamPtr(NULL), &m_fileStreamMap); 1783| 2| std::vector withFileSizeLimit; 1784| 146| for (Configurations::const_iterator it = configurations->begin(); it != configurations->end(); ++it) { ------------------ | Branch (1784:69): [True: 144, False: 2] ------------------ 1785| 144| Configuration* conf = *it; 1786| | // We cannot use switch on strong enums because Intel C++ dont support them yet 1787| 144| if (conf->configurationType() == ConfigurationType::Enabled) { ------------------ | Branch (1787:9): [True: 16, False: 128] ------------------ 1788| 16| setValue(conf->level(), getBool(conf->value()), &m_enabledMap); 1789| 128| } else if (conf->configurationType() == ConfigurationType::ToFile) { ------------------ | Branch (1789:16): [True: 16, False: 112] ------------------ 1790| 16| setValue(conf->level(), getBool(conf->value()), &m_toFileMap); 1791| 112| } else if (conf->configurationType() == ConfigurationType::ToStandardOutput) { ------------------ | Branch (1791:16): [True: 16, False: 96] ------------------ 1792| 16| setValue(conf->level(), getBool(conf->value()), &m_toStandardOutputMap); 1793| 96| } else if (conf->configurationType() == ConfigurationType::Filename) { ------------------ | Branch (1793:16): [True: 16, False: 80] ------------------ 1794| | // We do not yet configure filename but we will configure in another 1795| | // loop. This is because if file cannot be created, we will force ToFile 1796| | // to be false. Because configuring logger is not necessarily performance 1797| | // sensative operation, we can live with another loop; (by the way this loop 1798| | // is not very heavy either) 1799| 80| } else if (conf->configurationType() == ConfigurationType::Format) { ------------------ | Branch (1799:16): [True: 16, False: 64] ------------------ 1800| 16| setValue(conf->level(), base::LogFormat(conf->level(), 1801| 16| base::type::string_t(conf->value().begin(), conf->value().end())), &m_logFormatMap); 1802| 64| } else if (conf->configurationType() == ConfigurationType::SubsecondPrecision) { ------------------ | Branch (1802:16): [True: 16, False: 48] ------------------ 1803| 16| setValue(Level::Global, 1804| 16| base::SubsecondPrecision(static_cast(getULong(conf->value()))), &m_subsecondPrecisionMap); 1805| 48| } else if (conf->configurationType() == ConfigurationType::PerformanceTracking) { ------------------ | Branch (1805:16): [True: 16, False: 32] ------------------ 1806| 16| setValue(Level::Global, getBool(conf->value()), &m_performanceTrackingMap); 1807| 32| } else if (conf->configurationType() == ConfigurationType::MaxLogFileSize) { ------------------ | Branch (1807:16): [True: 16, False: 16] ------------------ 1808| 16| auto v = getULong(conf->value()); 1809| 16| setValue(conf->level(), static_cast(v), &m_maxLogFileSizeMap); 1810| 16| if (v != 0) { ------------------ | Branch (1810:11): [True: 0, False: 16] ------------------ 1811| 0| withFileSizeLimit.push_back(conf); 1812| 0| } 1813| 16| } else if (conf->configurationType() == ConfigurationType::LogFlushThreshold) { ------------------ | Branch (1813:16): [True: 16, False: 0] ------------------ 1814| 16| setValue(conf->level(), static_cast(getULong(conf->value())), &m_logFlushThresholdMap); 1815| 16| } 1816| 144| } 1817| | // As mentioned earlier, we will now set filename configuration in separate loop to deal with non-existent files 1818| 146| for (Configurations::const_iterator it = configurations->begin(); it != configurations->end(); ++it) { ------------------ | Branch (1818:69): [True: 144, False: 2] ------------------ 1819| 144| Configuration* conf = *it; 1820| 144| if (conf->configurationType() == ConfigurationType::Filename) { ------------------ | Branch (1820:9): [True: 16, False: 128] ------------------ 1821| 16| insertFile(conf->level(), conf->value()); 1822| 16| } 1823| 144| } 1824| 2| for (std::vector::iterator conf = withFileSizeLimit.begin(); 1825| 2| conf != withFileSizeLimit.end(); ++conf) { ------------------ | Branch (1825:8): [True: 0, False: 2] ------------------ 1826| | // This is not unsafe as mutex is locked in currect scope 1827| 0| unsafeValidateFileRolling((*conf)->level(), base::defaultPreRollOutCallback); 1828| 0| } 1829| 2|} _ZN2el4base19TypedConfigurations8getULongENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 1831| 48|unsigned long TypedConfigurations::getULong(std::string confVal) { 1832| 48| bool valid = true; 1833| 48| base::utils::Str::trim(confVal); 1834| 48| valid = !confVal.empty() && std::find_if(confVal.begin(), confVal.end(), ------------------ | Branch (1834:11): [True: 48, False: 0] | Branch (1834:31): [True: 48, False: 0] ------------------ 1835| 48| [](char c) { 1836| 48| return !base::utils::Str::isDigit(c); 1837| 48| }) == confVal.end(); 1838| 48| if (!valid) { ------------------ | Branch (1838:7): [True: 0, False: 48] ------------------ 1839| 0| valid = false; 1840| 0| ELPP_ASSERT(valid, "Configuration value not a valid integer [" << confVal << "]"); ------------------ | | 178| 0|# define ELPP_ASSERT(expr, msg) if (!(expr)) { \ | | ------------------ | | | Branch (178:40): [True: 0, False: 0] | | ------------------ | | 179| 0|std::stringstream internalInfoStream; internalInfoStream << msg; \ | | ------------------ | | | | 160| 0|# define ELPP_INTERNAL_DEBUGGING_OUT_ERROR std::cerr | | ------------------ | | 180| 0|ELPP_INTERNAL_DEBUGGING_OUT_ERROR\ | | 181| 0|<< "ASSERTION FAILURE FROM EASYLOGGING++ (LINE: " \ | | 182| 0|<< __LINE__ << ") [" #expr << "] WITH MESSAGE \"" << ELPP_INTERNAL_DEBUGGING_MSG(internalInfoStream.str()) << "\"" \ | | ------------------ | | | | 166| 0|# define ELPP_INTERNAL_DEBUGGING_MSG(msg) msg | | ------------------ | | 183| 0|<< ELPP_INTERNAL_DEBUGGING_ENDL; } | | ------------------ | | | | 163| 0|# define ELPP_INTERNAL_DEBUGGING_ENDL std::endl | | ------------------ ------------------ 1841| 0| return 0; 1842| 0| } 1843| 48| return atol(confVal.c_str()); 1844| 48|} _ZN2el4base19TypedConfigurations10insertFileENS_5LevelERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 1885| 16|void TypedConfigurations::insertFile(Level level, const std::string& fullFilename) { 1886| 16| if (fullFilename.empty()) ------------------ | Branch (1886:7): [True: 16, False: 0] ------------------ 1887| 16| return; 1888| 0| std::string resolvedFilename = resolveFilename(fullFilename); 1889| 0| if (resolvedFilename.empty()) { ------------------ | Branch (1889:7): [True: 0, False: 0] ------------------ 1890| 0| std::cerr << "Could not load empty file for logging, please re-check your configurations for level [" 1891| 0| << LevelHelper::convertToString(level) << "]"; 1892| 0| } 1893| 0| std::string filePath = base::utils::File::extractPathFromFilename(resolvedFilename, base::consts::kFilePathSeperator); 1894| 0| if (filePath.size() < resolvedFilename.size()) { ------------------ | Branch (1894:7): [True: 0, False: 0] ------------------ 1895| 0| base::utils::File::createPath(filePath); 1896| 0| } 1897| 0| auto create = [&](Level level) { 1898| 0| base::LogStreamsReferenceMap::iterator filestreamIter = m_logStreamsReference->find(resolvedFilename); 1899| 0| base::type::fstream_t* fs = nullptr; 1900| 0| if (filestreamIter == m_logStreamsReference->end()) { 1901| | // We need a completely new stream, nothing to share with 1902| 0| fs = base::utils::File::newFileStream(resolvedFilename); 1903| 0| m_filenameMap.insert(std::make_pair(level, resolvedFilename)); 1904| 0| m_fileStreamMap.insert(std::make_pair(level, base::FileStreamPtr(fs))); 1905| 0| m_logStreamsReference->insert(std::make_pair(resolvedFilename, base::FileStreamPtr(m_fileStreamMap.at(level)))); 1906| 0| } else { 1907| | // Woops! we have an existing one, share it! 1908| 0| m_filenameMap.insert(std::make_pair(level, filestreamIter->first)); 1909| 0| m_fileStreamMap.insert(std::make_pair(level, base::FileStreamPtr(filestreamIter->second))); 1910| 0| fs = filestreamIter->second.get(); 1911| 0| } 1912| 0| if (fs == nullptr) { 1913| | // We display bad file error from newFileStream() 1914| 0| ELPP_INTERNAL_ERROR("Setting [TO_FILE] of [" 1915| 0| << LevelHelper::convertToString(level) << "] to FALSE", false); 1916| 0| setValue(level, false, &m_toFileMap); 1917| 0| } 1918| 0| }; 1919| | // If we dont have file conf for any level, create it for Level::Global first 1920| | // otherwise create for specified level 1921| 0| create(m_filenameMap.empty() && m_fileStreamMap.empty() ? Level::Global : level); ------------------ | Branch (1921:10): [True: 0, False: 0] | Branch (1921:35): [True: 0, False: 0] ------------------ 1922| 0|} _ZN2el4base17RegisteredLoggersC2ERKNSt3__110shared_ptrINS_10LogBuilderEEE: 1991| 2| m_defaultLogBuilder(defaultLogBuilder) { 1992| 2| m_defaultConfigurations.setToDefault(); 1993| 2|} _ZN2el4base17RegisteredLoggers3getERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEb: 1995| 4|Logger* RegisteredLoggers::get(const std::string& id, bool forceCreation) { 1996| 4| base::threading::ScopedLock scopedLock(lock()); 1997| 4| Logger* logger_ = base::utils::Registry::get(id); 1998| 4| if (logger_ == nullptr && forceCreation) { ------------------ | Branch (1998:7): [True: 2, False: 2] | Branch (1998:29): [True: 2, False: 0] ------------------ 1999| 2| bool validId = Logger::isValidId(id); 2000| 2| if (!validId) { ------------------ | Branch (2000:9): [True: 0, False: 2] ------------------ 2001| 0| ELPP_ASSERT(validId, "Invalid logger ID [" << id << "]. Not registering this logger."); ------------------ | | 178| 0|# define ELPP_ASSERT(expr, msg) if (!(expr)) { \ | | ------------------ | | | Branch (178:40): [True: 0, False: 0] | | ------------------ | | 179| 0|std::stringstream internalInfoStream; internalInfoStream << msg; \ | | ------------------ | | | | 160| 0|# define ELPP_INTERNAL_DEBUGGING_OUT_ERROR std::cerr | | ------------------ | | 180| 0|ELPP_INTERNAL_DEBUGGING_OUT_ERROR\ | | 181| 0|<< "ASSERTION FAILURE FROM EASYLOGGING++ (LINE: " \ | | 182| 0|<< __LINE__ << ") [" #expr << "] WITH MESSAGE \"" << ELPP_INTERNAL_DEBUGGING_MSG(internalInfoStream.str()) << "\"" \ | | ------------------ | | | | 166| 0|# define ELPP_INTERNAL_DEBUGGING_MSG(msg) msg | | ------------------ | | 183| 0|<< ELPP_INTERNAL_DEBUGGING_ENDL; } | | ------------------ | | | | 163| 0|# define ELPP_INTERNAL_DEBUGGING_ENDL std::endl | | ------------------ ------------------ 2002| 0| return nullptr; 2003| 0| } 2004| 2| logger_ = new Logger(id, m_defaultConfigurations, &m_logStreamsReference); 2005| 2| logger_->m_logBuilder = m_defaultLogBuilder; 2006| 2| registerNew(id, logger_); 2007| 2| LoggerRegistrationCallback* callback = nullptr; 2008| 2| for (const std::pair& h 2009| 2| : m_loggerRegistrationCallbacks) { ------------------ | Branch (2009:10): [True: 0, False: 2] ------------------ 2010| 0| callback = h.second.get(); 2011| 0| if (callback != nullptr && callback->enabled()) { ------------------ | Branch (2011:11): [True: 0, False: 0] | Branch (2011:34): [True: 0, False: 0] ------------------ 2012| 0| callback->handle(logger_); 2013| 0| } 2014| 0| } 2015| 2| } 2016| 4| return logger_; 2017| 4|} _ZN2el4base17RegisteredLoggers14unsafeFlushAllEv: 2032| 1|void RegisteredLoggers::unsafeFlushAll(void) { 2033| 1| ELPP_INTERNAL_INFO(1, "Flushing all log files"); 2034| 1| for (base::LogStreamsReferenceMap::iterator it = m_logStreamsReference.begin(); 2035| 1| it != m_logStreamsReference.end(); ++it) { ------------------ | Branch (2035:8): [True: 0, False: 1] ------------------ 2036| 0| if (it->second.get() == nullptr) continue; ------------------ | Branch (2036:9): [True: 0, False: 0] ------------------ 2037| 0| it->second->flush(); 2038| 0| } 2039| 1|} _ZN2el4base9VRegistryC2EtPj: 2043| 2|VRegistry::VRegistry(base::type::VerboseLevel level, base::type::EnumType* pFlags) : m_level(level), m_pFlags(pFlags) { 2044| 2|} _ZN2el4base7Storage7getELPPEv: 2283| 2|{ 2284| 2| if (!el::base::elStorage) ------------------ | Branch (2284:7): [True: 0, False: 2] ------------------ 2285| 0| el::base::elStorage = new el::base::Storage(el::LogBuilderPtr(new el::base::DefaultLogBuilder())); 2286| 2| return el::base::elStorage; 2287| 2|} _ZN2el4base7StorageC2ERKNSt3__110shared_ptrINS_10LogBuilderEEE: 2294| 2| m_registeredHitCounters(new base::RegisteredHitCounters()), 2295| 2| m_registeredLoggers(new base::RegisteredLoggers(defaultLogBuilder)), 2296| 2| m_flags(ELPP_DEFAULT_LOGGING_FLAGS), ------------------ | | 2279| 2|# define ELPP_DEFAULT_LOGGING_FLAGS 0x0 ------------------ 2297| 2| m_vRegistry(new base::VRegistry(0, &m_flags)), 2298| | 2299| |#if ELPP_ASYNC_LOGGING 2300| | m_asyncLogQueue(new base::AsyncLogQueue()), 2301| | m_asyncDispatchWorker(asyncDispatchWorker), 2302| |#endif // ELPP_ASYNC_LOGGING 2303| | 2304| 2| m_preRollOutCallback(base::defaultPreRollOutCallback) { 2305| | // Register default logger 2306| 2| m_registeredLoggers->get(std::string(base::consts::kDefaultLoggerId)); 2307| | // We register default logger anyway (worse case it's not going to register) just in case 2308| 2| m_registeredLoggers->get("default"); 2309| | 2310| |#if defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING) 2311| | // Register performance logger and reconfigure format 2312| | Logger* performanceLogger = m_registeredLoggers->get(std::string(base::consts::kPerformanceLoggerId)); 2313| | m_registeredLoggers->get("performance"); 2314| | performanceLogger->configurations()->setGlobally(ConfigurationType::Format, std::string("%datetime %level %msg")); 2315| | performanceLogger->reconfigure(); 2316| |#endif // defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING) 2317| | 2318| |#if defined(ELPP_SYSLOG) 2319| | // Register syslog logger and reconfigure format 2320| | Logger* sysLogLogger = m_registeredLoggers->get(std::string(base::consts::kSysLogLoggerId)); 2321| | sysLogLogger->configurations()->setGlobally(ConfigurationType::Format, std::string("%level: %msg")); 2322| | sysLogLogger->reconfigure(); 2323| |#endif // defined(ELPP_SYSLOG) 2324| 2| addFlag(LoggingFlag::AllowVerboseIfModuleNotSpecified); 2325| 2| addFlag(LoggingFlag::CreateLoggerAutomatically); 2326| |#if ELPP_ASYNC_LOGGING 2327| | installLogDispatchCallback(std::string("AsyncLogDispatchCallback")); 2328| |#else 2329| 2| installLogDispatchCallback(std::string("DefaultLogDispatchCallback")); 2330| 2|#endif // ELPP_ASYNC_LOGGING 2331| |#if defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING) 2332| | installPerformanceTrackingCallback 2333| | (std::string("DefaultPerformanceTrackingCallback")); 2334| |#endif // defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING) 2335| 2| ELPP_INTERNAL_INFO(1, "Easylogging++ has been initialized"); 2336| |#if ELPP_ASYNC_LOGGING 2337| | m_asyncDispatchWorker->start(); 2338| |#endif // ELPP_ASYNC_LOGGING 2339| 2|} _ZN2el4base7StorageD2Ev: 2341| 1|Storage::~Storage(void) { 2342| 1| ELPP_INTERNAL_INFO(4, "Destroying storage"); 2343| |#if ELPP_ASYNC_LOGGING 2344| | ELPP_INTERNAL_INFO(5, "Replacing log dispatch callback to synchronous"); 2345| | uninstallLogDispatchCallback(std::string("AsyncLogDispatchCallback")); 2346| | installLogDispatchCallback(std::string("DefaultLogDispatchCallback")); 2347| | ELPP_INTERNAL_INFO(5, "Destroying asyncDispatchWorker"); 2348| | base::utils::safeDelete(m_asyncDispatchWorker); 2349| | ELPP_INTERNAL_INFO(5, "Destroying asyncLogQueue"); 2350| | base::utils::safeDelete(m_asyncLogQueue); 2351| |#endif // ELPP_ASYNC_LOGGING 2352| 1| ELPP_INTERNAL_INFO(5, "Destroying registeredHitCounters"); 2353| 1| base::utils::safeDelete(m_registeredHitCounters); 2354| 1| ELPP_INTERNAL_INFO(5, "Destroying registeredLoggers"); 2355| 1| base::utils::safeDelete(m_registeredLoggers); 2356| 1| ELPP_INTERNAL_INFO(5, "Destroying vRegistry"); 2357| 1| base::utils::safeDelete(m_vRegistry); 2358| 1|} easylogging++.cc:_ZZN2el4base9LogFormat15parseFromFormatERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEENK3$_0clEPKcNS0_11FormatFlagsE: 1597| 224| auto conditionalAddFlag = [&](const base::type::char_t* specifier, base::FormatFlags flag) { 1598| 224| std::size_t foundAt = base::type::string_t::npos; 1599| 286| while ((foundAt = formatCopy.find(specifier, foundAt + 1)) != base::type::string_t::npos) { ------------------ | Branch (1599:12): [True: 62, False: 224] ------------------ 1600| 62| if (foundAt > 0 && formatCopy[foundAt - 1] == base::consts::kFormatSpecifierChar) { ------------------ | Branch (1600:11): [True: 62, False: 0] | Branch (1600:26): [True: 0, False: 62] ------------------ 1601| 0| if (hasFlag(flag)) { ------------------ | Branch (1601:13): [True: 0, False: 0] ------------------ 1602| | // If we already have flag we remove the escape chars so that '%%' is turned to '%' 1603| | // even after specifier resolution - this is because we only replaceFirst specifier 1604| 0| formatCopy.erase(foundAt - 1, 1); 1605| 0| ++foundAt; 1606| 0| } 1607| 62| } else { 1608| 62| if (!hasFlag(flag)) addFlag(flag); ------------------ | Branch (1608:13): [True: 62, False: 0] ------------------ 1609| 62| } 1610| 62| } 1611| 224| }; easylogging++.cc:_ZZN2el4base19TypedConfigurations5buildEPNS_14ConfigurationsEENK3$_0clENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE: 1778| 64| auto getBool = [] (std::string boolStr) -> bool { // Pass by value for trimming 1779| 64| base::utils::Str::trim(boolStr); 1780| 64| return (boolStr == "TRUE" || boolStr == "true" || boolStr == "1"); ------------------ | Branch (1780:13): [True: 0, False: 64] | Branch (1780:34): [True: 64, False: 0] | Branch (1780:55): [True: 0, False: 0] ------------------ 1781| 64| }; _ZN2el4base10EnsureELPPC2Ev: 2288| 2|static struct EnsureELPP { EnsureELPP() { el::base::Storage::getELPP(); } } ensureELPP; easylogging++.cc:_ZZN2el14Configurations11setGloballyENS_17ConfigurationTypeERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEbENK3$_0clEv: 642| 126| LevelHelper::forEachLevel(&lIndex, [&](void) -> bool { 643| 126| set(LevelHelper::castFromInt(lIndex), configurationType, value); 644| 126| return false; // Do not break lambda function yet as we need to set all levels regardless 645| 126| }); easylogging++.cc:_ZZN2el14Configurations17unsafeSetGloballyENS_17ConfigurationTypeERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEbENK3$_0clEv: 654| 504| LevelHelper::forEachLevel(&lIndex, [&](void) -> bool { 655| 504| unsafeSet(LevelHelper::castFromInt(lIndex), configurationType, value); 656| 504| return false; // Do not break lambda function yet as we need to set all levels regardless 657| 504| }); easylogging++.cc:_ZZN2el6Logger18initUnflushedCountEvENK3$_0clEv: 805| 28| LevelHelper::forEachLevel(&lIndex, [&](void) -> bool { 806| 28| m_unflushedCount.insert(std::make_pair(LevelHelper::castFromInt(lIndex), 0)); 807| 28| return false; 808| 28| }); easylogging++.cc:_ZZNK2el6Logger23resolveLoggerFormatSpecEvENK3$_0clEv: 813| 14| LevelHelper::forEachLevel(&lIndex, [&](void) -> bool { 814| 14| base::LogFormat* logFormat = 815| 14| const_cast(&m_typedConfigurations->logFormat(LevelHelper::castFromInt(lIndex))); 816| 14| base::utils::Str::replaceFirstWithEscape(logFormat->m_format, base::consts::kLoggerIdFormatSpecifier, m_id); 817| 14| return false; 818| 14| }); easylogging++.cc:_ZZN2el4base5utils3Str5ltrimERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEENK3$_0clEc: 989| 112| str.erase(str.begin(), std::find_if(str.begin(), str.end(), [](char c) { 990| 112| return !std::isspace(c); 991| 112| } )); easylogging++.cc:_ZZN2el4base5utils3Str5rtrimERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEENK3$_0clEc: 996| 112| str.erase(std::find_if(str.rbegin(), str.rend(), [](char c) { 997| 112| return !std::isspace(c); 998| 112| }).base(), str.end()); easylogging++.cc:_ZZN2el4base19TypedConfigurations8getULongENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEENK3$_0clEc: 1835| 48| [](char c) { 1836| 48| return !base::utils::Str::isDigit(c); 1837| 48| }) == confVal.end(); _ZN2el4base6NoCopyC2Ev: 571| 8| NoCopy(void) {} _ZNKSt3__14hashIN2el5LevelEEclERKS2_: 624| 200| std::size_t operator()(const el::Level& l) const { 625| 200| return hash {}(static_cast(l)); 626| 200| } _ZN2el11LevelHelper11castFromIntEj: 642| 672| static Level castFromInt(base::type::EnumType l) { 643| 672| return static_cast(l); 644| 672| } _ZN2el4base18SubsecondPrecisionC2Ei: 870| 16| explicit SubsecondPrecision(int width) { 871| 16| init(width); 872| 16| } _ZN2el4base18SubsecondPrecisioneqERKS1_: 873| 14| bool operator==(const SubsecondPrecision& ssPrec) { 874| 14| return m_width == ssPrec.m_width && m_offset == ssPrec.m_offset; ------------------ | Branch (874:12): [True: 14, False: 0] | Branch (874:41): [True: 14, False: 0] ------------------ 875| 14| } _ZN2el4base9threading10ThreadSafe4lockEv: 1037| 322| virtual inline base::threading::Mutex& lock(void) ELPP_FINAL { return m_mutex; } _ZN2el4base9threading10ThreadSafeC2Ev: 1039| 18| ThreadSafe(void) {} _ZN2el4base9threading10ThreadSafeD2Ev: 1040| 9| virtual ~ThreadSafe(void) {} _ZN2el4base5utils3Str7isDigitEc: 1107| 48| static inline bool isDigit(char c) { 1108| 48| return c >= '0' && c <= '9'; ------------------ | Branch (1108:12): [True: 48, False: 0] | Branch (1108:24): [True: 48, False: 0] ------------------ 1109| 48| } _ZN2el4base5utils15CommandLineArgsC2Ev: 1251| 2| CommandLineArgs(void) { 1252| 2| setArgs(0, static_cast(nullptr)); 1253| 2| } _ZN2el4base5utils15CommandLineArgsD2Ev: 1260| 1| virtual ~CommandLineArgs(void) {} _ZN2el8LoggableD2Ev: 1603| 185| virtual ~Loggable(void) {} _ZN2el4base9LogFormatD2Ev: 1620| 40| virtual ~LogFormat(void) {} _ZNK2el4base9LogFormat7hasFlagENS0_11FormatFlagsE: 1647| 126| inline bool hasFlag(base::FormatFlags flag) const { 1648| 126| return base::utils::hasFlag(flag, m_flags); 1649| 126| } _ZN2el4base9LogFormat7addFlagENS0_11FormatFlagsE: 1664| 78| inline void addFlag(base::FormatFlags flag) { 1665| 78| base::utils::addFlag(flag, &m_flags); 1666| 78| } _ZN2el13ConfigurationD2Ev: 1716| 144| virtual ~Configuration(void) { 1717| 144| } _ZNK2el13Configuration5levelEv: 1723| 29.8k| inline Level level(void) const { 1724| 29.8k| return m_level; 1725| 29.8k| } _ZNK2el13Configuration17configurationTypeEv: 1728| 4.77k| inline ConfigurationType configurationType(void) const { 1729| 4.77k| return m_configurationType; 1730| 4.77k| } _ZNK2el13Configuration5valueEv: 1733| 304| inline const std::string& value(void) const { 1734| 304| return m_value; 1735| 304| } _ZN2el13Configuration8setValueERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 1740| 514| inline void setValue(const std::string& value) { 1741| 514| m_value = value; 1742| 514| } _ZN2el14ConfigurationsD2Ev: 1781| 2| virtual ~Configurations(void) { 1782| 2| } _ZN2el4base19TypedConfigurationsD2Ev: 1950| 1| virtual ~TypedConfigurations(void) { 1951| 1| } _ZN2el10LogBuilderC2Ev: 2237| 2| LogBuilder() : m_termSupportsColor(base::utils::OS::termSupportsColor()) {} _ZN2el10LogBuilderD2Ev: 2238| 1| virtual ~LogBuilder(void) { 2239| 1| ELPP_INTERNAL_INFO(3, "Destroying log builder...") 2240| 1| } _ZN2el6LoggerD2Ev: 2259| 1| virtual ~Logger(void) { 2260| 1| base::utils::safeDelete(m_typedConfigurations); 2261| 1| } _ZN2el4base17RegisteredLoggersD2Ev: 2390| 1| virtual ~RegisteredLoggers(void) { 2391| 1| unsafeFlushAll(); 2392| 1| } _ZN2el4base7Storage7addFlagENS_11LoggingFlagE: 2659| 4| inline void addFlag(LoggingFlag flag) { 2660| 4| base::utils::addFlag(flag, &m_flags); 2661| 4| } _ZN2el4base5utils16RegistryWithPredINS_13ConfigurationENS3_9PredicateEE3getINS_5LevelENS_17ConfigurationTypeEEEPS3_RKT_T0_: 1554| 802| T_Ptr* get(const T& arg1, const T2 arg2) { 1555| 802| iterator iter = std::find_if(this->list().begin(), this->list().end(), Pred(arg1, arg2)); 1556| 802| if (iter != this->list().end() && *iter != nullptr) { ------------------ | Branch (1556:9): [True: 514, False: 288] | Branch (1556:9): [True: 514, False: 288] | Branch (1556:39): [True: 514, False: 0] ------------------ 1557| 514| return *iter; 1558| 514| } 1559| 288| return nullptr; 1560| 802| } _ZN2el4base5utils16RegistryWithPredINS_13ConfigurationENS3_9PredicateEE13unregisterAllEv: 1523| 2| virtual void unregisterAll(void) ELPP_FINAL { 1524| 2| if (!this->empty()) { ------------------ | Branch (1524:9): [True: 2, False: 0] ------------------ 1525| 144| for (auto&& curr : this->list()) { ------------------ | Branch (1525:24): [True: 144, False: 2] ------------------ 1526| 144| base::utils::safeDelete(curr); 1527| 144| } 1528| 2| this->list().clear(); 1529| 2| } 1530| 2| } _ZN2el4base5utils8RegistryINS_6LoggerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEE10unregisterERKSA_: 1455| 2| void unregister(const T_Key& uniqKey) { 1456| 2| T_Ptr* existing = get(uniqKey); 1457| 2| if (existing != nullptr) { ------------------ | Branch (1457:9): [True: 0, False: 2] ------------------ 1458| 0| this->list().erase(uniqKey); 1459| 0| base::utils::safeDelete(existing); 1460| 0| } 1461| 2| } _ZN2el4base5utils8RegistryINS_6LoggerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEE3getERKSA_: 1464| 6| T_Ptr* get(const T_Key& uniqKey) { 1465| 6| iterator it = this->list().find(uniqKey); 1466| 6| return it == this->list().end() ------------------ | Branch (1466:12): [True: 4, False: 2] ------------------ 1467| 6| ? nullptr 1468| 6| : it->second; 1469| 6| } _ZN2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEE5beginEv: 1348| 4| virtual inline iterator begin(void) ELPP_FINAL { 1349| 4| return m_list.begin(); 1350| 4| } _ZN2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEE3endEv: 1353| 292| virtual inline iterator end(void) ELPP_FINAL { 1354| 292| return m_list.end(); 1355| 292| } _ZNK2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEE5emptyEv: 1369| 2| virtual inline bool empty(void) const ELPP_FINAL { 1370| 2| return m_list.empty(); 1371| 2| } _ZNK2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEE4sizeEv: 1374| 4| virtual inline std::size_t size(void) const ELPP_FINAL { 1375| 4| return m_list.size(); 1376| 4| } _ZN2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEE4listEv: 1379| 2.70k| virtual inline Container& list(void) ELPP_FINAL { 1380| 2.70k| return m_list; 1381| 2.70k| } _ZN2el4base5utils16RegistryWithPredINS_13ConfigurationENS3_9PredicateEE11registerNewEPS3_: 1547| 288| virtual inline void registerNew(T_Ptr* ptr) ELPP_FINAL { 1548| 288| this->list().push_back(ptr); 1549| 288| } _ZNK2el4base5utils16AbstractRegistryINS_6LoggerENSt3__113unordered_mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPS3_NS4_4hashISB_EENS4_8equal_toISB_EENS9_INS4_4pairIKSB_SC_EEEEEEE5emptyEv: 1369| 1| virtual inline bool empty(void) const ELPP_FINAL { 1370| 1| return m_list.empty(); 1371| 1| } _ZN2el4base5utils16AbstractRegistryINS_6LoggerENSt3__113unordered_mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPS3_NS4_4hashISB_EENS4_8equal_toISB_EENS9_INS4_4pairIKSB_SC_EEEEEEE4listEv: 1379| 16| virtual inline Container& list(void) ELPP_FINAL { 1380| 16| return m_list; 1381| 16| } _ZN2el4base5utils8RegistryINS_6LoggerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEE13unregisterAllEv: 1439| 1| virtual void unregisterAll(void) ELPP_FINAL { 1440| 1| if (!this->empty()) { ------------------ | Branch (1440:9): [True: 1, False: 0] ------------------ 1441| 1| for (auto&& curr : this->list()) { ------------------ | Branch (1441:24): [True: 1, False: 1] ------------------ 1442| 1| base::utils::safeDelete(curr.second); 1443| 1| } 1444| 1| this->list().clear(); 1445| 1| } 1446| 1| } _ZN2el4base5utils8RegistryINS_6LoggerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEE11registerNewERKSA_PS3_: 1449| 2| virtual void registerNew(const T_Key& uniqKey, T_Ptr* ptr) ELPP_FINAL { 1450| 2| unregister(uniqKey); 1451| 2| this->list().insert(std::make_pair(uniqKey, ptr)); 1452| 2| } easylogging++.cc:_ZN2el4base5utilsL7addFlagINS0_11FormatFlagsEEEvT_Pj: 912| 78|static inline void addFlag(Enum e, base::type::EnumType* flag) { 913| 78| *flag = base::utils::bitwise::Or(e, *flag); 914| 78|} easylogging++.cc:_ZN2el4base5utils7bitwiseL2OrINS0_11FormatFlagsEEEjT_j: 907| 78|static inline base::type::EnumType Or(Enum e, base::type::EnumType flag) { 908| 78| return static_cast(flag) | static_cast(e); 909| 78|} easylogging++.cc:_ZN2el4base5utilsL7hasFlagINS0_11FormatFlagsEEEbT_j: 920| 126|static inline bool hasFlag(Enum e, base::type::EnumType flag) { 921| 126| return base::utils::bitwise::And(e, flag) > 0x0; 922| 126|} easylogging++.cc:_ZN2el4base5utils7bitwiseL3AndINS0_11FormatFlagsEEEjT_j: 899| 126|static inline base::type::EnumType And(Enum e, base::type::EnumType flag) { 900| 126| return static_cast(flag) & static_cast(e); 901| 126|} easylogging++.cc:_ZN2el4base5utilsL10safeDeleteINS_6LoggerEEENSt3__19enable_ifIXsr3std10is_pointerIPT_EE5valueEvE4typeERS7_: 889| 1|safeDelete(T*& pointer) { 890| 1| if (pointer == nullptr) ------------------ | Branch (890:7): [True: 0, False: 1] ------------------ 891| 0| return; 892| 1| delete pointer; 893| 1| pointer = nullptr; 894| 1|} _ZN2el4base5utils16RegistryWithPredINS0_10HitCounterENS3_9PredicateEEC2Ev: 1489| 2| RegistryWithPred(void) { 1490| 2| } _ZN2el4base5utils16AbstractRegistryINS0_10HitCounterENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEEC2Ev: 1299| 2| AbstractRegistry(void) {} _ZN2el4base5utils16AbstractRegistryINS0_10HitCounterENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEED2Ev: 1344| 1| virtual ~AbstractRegistry(void) { 1345| 1| } _ZN2el4base5utils16RegistryWithPredINS0_10HitCounterENS3_9PredicateEED2Ev: 1492| 1| virtual ~RegistryWithPred(void) { 1493| 1| unregisterAll(); 1494| 1| } _ZNK2el4base5utils16AbstractRegistryINS0_10HitCounterENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEE5emptyEv: 1369| 1| virtual inline bool empty(void) const ELPP_FINAL { 1370| 1| return m_list.empty(); 1371| 1| } _ZN2el4base5utils16RegistryWithPredINS0_10HitCounterENS3_9PredicateEE13unregisterAllEv: 1523| 1| virtual void unregisterAll(void) ELPP_FINAL { 1524| 1| if (!this->empty()) { ------------------ | Branch (1524:9): [True: 0, False: 1] ------------------ 1525| 0| for (auto&& curr : this->list()) { ------------------ | Branch (1525:24): [True: 0, False: 0] ------------------ 1526| 0| base::utils::safeDelete(curr); 1527| 0| } 1528| 0| this->list().clear(); 1529| 0| } 1530| 1| } easylogging++.cc:_ZN2el4base5utilsL7addFlagINS_11LoggingFlagEEEvT_Pj: 912| 4|static inline void addFlag(Enum e, base::type::EnumType* flag) { 913| 4| *flag = base::utils::bitwise::Or(e, *flag); 914| 4|} easylogging++.cc:_ZN2el4base5utils7bitwiseL2OrINS_11LoggingFlagEEEjT_j: 907| 4|static inline base::type::EnumType Or(Enum e, base::type::EnumType flag) { 908| 4| return static_cast(flag) | static_cast(e); 909| 4|} _ZN2el4base5utils16RegistryWithPredINS_13ConfigurationENS3_9PredicateEED2Ev: 1492| 2| virtual ~RegistryWithPred(void) { 1493| 2| unregisterAll(); 1494| 2| } _ZN2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEED2Ev: 1344| 2| virtual ~AbstractRegistry(void) { 1345| 2| } easylogging++.cc:_ZN2el4base5utilsL10safeDeleteINS0_19TypedConfigurationsEEENSt3__19enable_ifIXsr3std10is_pointerIPT_EE5valueEvE4typeERS7_: 889| 3|safeDelete(T*& pointer) { 890| 3| if (pointer == nullptr) ------------------ | Branch (890:7): [True: 2, False: 1] ------------------ 891| 2| return; 892| 1| delete pointer; 893| 1| pointer = nullptr; 894| 1|} _ZN2el4base5utils8RegistryINS_6LoggerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEED2Ev: 1434| 1| virtual ~Registry(void) { 1435| 1| unregisterAll(); 1436| 1| } _ZN2el4base5utils16AbstractRegistryINS_6LoggerENSt3__113unordered_mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPS3_NS4_4hashISB_EENS4_8equal_toISB_EENS9_INS4_4pairIKSB_SC_EEEEEEED2Ev: 1344| 1| virtual ~AbstractRegistry(void) { 1345| 1| } _ZN2el4base5utils16RegistryWithPredINS_13ConfigurationENS3_9PredicateEEC2Ev: 1489| 4| RegistryWithPred(void) { 1490| 4| } _ZN2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEEC2Ev: 1299| 4| AbstractRegistry(void) {} _ZN2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEEneERKSA_: 1322| 2| bool operator!=(const AbstractRegistry& other) { 1323| 2| if (size() != other.size()) { ------------------ | Branch (1323:9): [True: 2, False: 0] ------------------ 1324| 2| return true; 1325| 2| } 1326| 0| for (std::size_t i = 0; i < m_list.size(); ++i) { ------------------ | Branch (1326:29): [True: 0, False: 0] ------------------ 1327| 0| if (m_list.at(i) != other.m_list.at(i)) { ------------------ | Branch (1327:11): [True: 0, False: 0] ------------------ 1328| 0| return true; 1329| 0| } 1330| 0| } 1331| 0| return false; 1332| 0| } _ZN2el4base19TypedConfigurations14getConfigByRefINS0_9LogFormatEEERT_NS_5LevelEPNSt3__113unordered_mapIS6_S4_NS7_4hashIS6_EENS7_8equal_toIS6_EENS7_9allocatorINS7_4pairIKS6_S4_EEEEEEPKc: 1996| 14| inline Conf_T& getConfigByRef(Level level, std::unordered_map* confMap, const char* confName) { 1997| 14| base::threading::ScopedLock scopedLock(lock()); 1998| 14| return unsafeGetConfigByRef(level, confMap, confName); // This is not unsafe anymore - mutex locked in scope 1999| 14| } _ZN2el4base19TypedConfigurations20unsafeGetConfigByRefINS0_9LogFormatEEERT_NS_5LevelEPNSt3__113unordered_mapIS6_S4_NS7_4hashIS6_EENS7_8equal_toIS6_EENS7_9allocatorINS7_4pairIKS6_S4_EEEEEEPKc: 2019| 14| Conf_T& unsafeGetConfigByRef(Level level, std::unordered_map* confMap, const char* confName) { 2020| 14| ELPP_UNUSED(confName); ------------------ | | 240| 14|#define ELPP_UNUSED(x) (void)x ------------------ 2021| 14| typename std::unordered_map::iterator it = confMap->find(level); 2022| 14| if (it == confMap->end()) { ------------------ | Branch (2022:9): [True: 0, False: 14] ------------------ 2023| 0| try { 2024| 0| return confMap->at(Level::Global); 2025| 0| } catch (...) { 2026| 0| ELPP_INTERNAL_ERROR("Unable to get configuration [" << confName << "] for level [" 2027| 0| << LevelHelper::convertToString(level) << "]" 2028| 0| << std::endl << "Please ensure you have properly configured logger.", false); 2029| 0| throw; // The exception has to be rethrown, to abort a branch leading to UB. 2030| 0| } 2031| 0| } 2032| 14| return it->second; 2033| 14| } _ZN2el4base19TypedConfigurations8setValueINSt3__110shared_ptrINS3_13basic_fstreamIcNS3_11char_traitsIcEEEEEEEEvNS_5LevelERKT_PNS3_13unordered_mapISA_SB_NS3_4hashISA_EENS3_8equal_toISA_EENS3_9allocatorINS3_4pairIKSA_SB_EEEEEEb: 2037| 2| bool includeGlobalLevel = true) { 2038| | // If map is empty and we are allowed to add into generic level (Level::Global), do it! 2039| 2| if (confMap->empty() && includeGlobalLevel) { ------------------ | Branch (2039:9): [True: 2, False: 0] | Branch (2039:29): [True: 2, False: 0] ------------------ 2040| 2| confMap->insert(std::make_pair(Level::Global, value)); 2041| 2| return; 2042| 2| } 2043| | // If same value exist in generic level already, dont add it to explicit level 2044| 0| typename std::unordered_map::iterator it = confMap->find(Level::Global); 2045| 0| if (it != confMap->end() && it->second == value) { ------------------ | Branch (2045:9): [True: 0, False: 0] | Branch (2045:9): [True: 0, False: 0] | Branch (2045:33): [True: 0, False: 0] ------------------ 2046| 0| return; 2047| 0| } 2048| | // Now make sure we dont double up values if we really need to add it to explicit level 2049| 0| it = confMap->find(level); 2050| 0| if (it == confMap->end()) { ------------------ | Branch (2050:9): [True: 0, False: 0] ------------------ 2051| | // Value not found for level, add new 2052| 0| confMap->insert(std::make_pair(level, value)); 2053| 0| } else { 2054| | // Value found, just update value 2055| 0| confMap->at(level) = value; 2056| 0| } 2057| 0| } _ZN2el4base19TypedConfigurations8setValueIbEEvNS_5LevelERKT_PNSt3__113unordered_mapIS3_S4_NS7_4hashIS3_EENS7_8equal_toIS3_EENS7_9allocatorINS7_4pairIKS3_S4_EEEEEEb: 2037| 64| bool includeGlobalLevel = true) { 2038| | // If map is empty and we are allowed to add into generic level (Level::Global), do it! 2039| 64| if (confMap->empty() && includeGlobalLevel) { ------------------ | Branch (2039:9): [True: 8, False: 56] | Branch (2039:29): [True: 8, False: 0] ------------------ 2040| 8| confMap->insert(std::make_pair(Level::Global, value)); 2041| 8| return; 2042| 8| } 2043| | // If same value exist in generic level already, dont add it to explicit level 2044| 56| typename std::unordered_map::iterator it = confMap->find(Level::Global); 2045| 56| if (it != confMap->end() && it->second == value) { ------------------ | Branch (2045:9): [True: 56, False: 0] | Branch (2045:9): [True: 56, False: 0] | Branch (2045:33): [True: 56, False: 0] ------------------ 2046| 56| return; 2047| 56| } 2048| | // Now make sure we dont double up values if we really need to add it to explicit level 2049| 0| it = confMap->find(level); 2050| 0| if (it == confMap->end()) { ------------------ | Branch (2050:9): [True: 0, False: 0] ------------------ 2051| | // Value not found for level, add new 2052| 0| confMap->insert(std::make_pair(level, value)); 2053| 0| } else { 2054| | // Value found, just update value 2055| 0| confMap->at(level) = value; 2056| 0| } 2057| 0| } _ZN2el4base19TypedConfigurations8setValueINS0_9LogFormatEEEvNS_5LevelERKT_PNSt3__113unordered_mapIS4_S5_NS8_4hashIS4_EENS8_8equal_toIS4_EENS8_9allocatorINS8_4pairIKS4_S5_EEEEEEb: 2037| 16| bool includeGlobalLevel = true) { 2038| | // If map is empty and we are allowed to add into generic level (Level::Global), do it! 2039| 16| if (confMap->empty() && includeGlobalLevel) { ------------------ | Branch (2039:9): [True: 2, False: 14] | Branch (2039:29): [True: 2, False: 0] ------------------ 2040| 2| confMap->insert(std::make_pair(Level::Global, value)); 2041| 2| return; 2042| 2| } 2043| | // If same value exist in generic level already, dont add it to explicit level 2044| 14| typename std::unordered_map::iterator it = confMap->find(Level::Global); 2045| 14| if (it != confMap->end() && it->second == value) { ------------------ | Branch (2045:9): [True: 14, False: 0] | Branch (2045:9): [True: 0, False: 14] | Branch (2045:33): [True: 0, False: 14] ------------------ 2046| 0| return; 2047| 0| } 2048| | // Now make sure we dont double up values if we really need to add it to explicit level 2049| 14| it = confMap->find(level); 2050| 14| if (it == confMap->end()) { ------------------ | Branch (2050:9): [True: 14, False: 0] ------------------ 2051| | // Value not found for level, add new 2052| 14| confMap->insert(std::make_pair(level, value)); 2053| 14| } else { 2054| | // Value found, just update value 2055| 0| confMap->at(level) = value; 2056| 0| } 2057| 14| } _ZN2el4base19TypedConfigurations8setValueINS0_18SubsecondPrecisionEEEvNS_5LevelERKT_PNSt3__113unordered_mapIS4_S5_NS8_4hashIS4_EENS8_8equal_toIS4_EENS8_9allocatorINS8_4pairIKS4_S5_EEEEEEb: 2037| 16| bool includeGlobalLevel = true) { 2038| | // If map is empty and we are allowed to add into generic level (Level::Global), do it! 2039| 16| if (confMap->empty() && includeGlobalLevel) { ------------------ | Branch (2039:9): [True: 2, False: 14] | Branch (2039:29): [True: 2, False: 0] ------------------ 2040| 2| confMap->insert(std::make_pair(Level::Global, value)); 2041| 2| return; 2042| 2| } 2043| | // If same value exist in generic level already, dont add it to explicit level 2044| 14| typename std::unordered_map::iterator it = confMap->find(Level::Global); 2045| 14| if (it != confMap->end() && it->second == value) { ------------------ | Branch (2045:9): [True: 14, False: 0] | Branch (2045:9): [True: 14, False: 0] | Branch (2045:33): [True: 14, False: 0] ------------------ 2046| 14| return; 2047| 14| } 2048| | // Now make sure we dont double up values if we really need to add it to explicit level 2049| 0| it = confMap->find(level); 2050| 0| if (it == confMap->end()) { ------------------ | Branch (2050:9): [True: 0, False: 0] ------------------ 2051| | // Value not found for level, add new 2052| 0| confMap->insert(std::make_pair(level, value)); 2053| 0| } else { 2054| | // Value found, just update value 2055| 0| confMap->at(level) = value; 2056| 0| } 2057| 0| } _ZN2el4base19TypedConfigurations8setValueImEEvNS_5LevelERKT_PNSt3__113unordered_mapIS3_S4_NS7_4hashIS3_EENS7_8equal_toIS3_EENS7_9allocatorINS7_4pairIKS3_S4_EEEEEEb: 2037| 32| bool includeGlobalLevel = true) { 2038| | // If map is empty and we are allowed to add into generic level (Level::Global), do it! 2039| 32| if (confMap->empty() && includeGlobalLevel) { ------------------ | Branch (2039:9): [True: 4, False: 28] | Branch (2039:29): [True: 4, False: 0] ------------------ 2040| 4| confMap->insert(std::make_pair(Level::Global, value)); 2041| 4| return; 2042| 4| } 2043| | // If same value exist in generic level already, dont add it to explicit level 2044| 28| typename std::unordered_map::iterator it = confMap->find(Level::Global); 2045| 28| if (it != confMap->end() && it->second == value) { ------------------ | Branch (2045:9): [True: 28, False: 0] | Branch (2045:9): [True: 28, False: 0] | Branch (2045:33): [True: 28, False: 0] ------------------ 2046| 28| return; 2047| 28| } 2048| | // Now make sure we dont double up values if we really need to add it to explicit level 2049| 0| it = confMap->find(level); 2050| 0| if (it == confMap->end()) { ------------------ | Branch (2050:9): [True: 0, False: 0] ------------------ 2051| | // Value not found for level, add new 2052| 0| confMap->insert(std::make_pair(level, value)); 2053| 0| } else { 2054| | // Value found, just update value 2055| 0| confMap->at(level) = value; 2056| 0| } 2057| 0| } _ZN2el4base5utils8RegistryINS_6LoggerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEC2Ev: 1413| 2| Registry(void) {} _ZN2el4base5utils16AbstractRegistryINS_6LoggerENSt3__113unordered_mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPS3_NS4_4hashISB_EENS4_8equal_toISB_EENS9_INS4_4pairIKSB_SC_EEEEEEEC2Ev: 1299| 2| AbstractRegistry(void) {} _ZN2el4base7Storage26installLogDispatchCallbackINS0_26DefaultLogDispatchCallbackEEEbRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE: 2708| 2| inline bool installLogDispatchCallback(const std::string& id) { 2709| 2| return base::utils::Utils::installCallback(id, &m_logDispatchCallbacks); 2710| 2| } _ZN2el4base5utils5Utils15installCallbackINS0_26DefaultLogDispatchCallbackENSt3__110shared_ptrINS_19LogDispatchCallbackEEEEEbRKNS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEPNS5_13unordered_mapISE_T0_NS5_4hashISE_EENS5_8equal_toISE_EENSC_INS5_4pairISF_SI_EEEEEE: 1572| 2| static bool installCallback(const std::string& id, std::unordered_map* mapT) { 1573| 2| if (mapT->find(id) == mapT->end()) { ------------------ | Branch (1573:9): [True: 2, False: 0] ------------------ 1574| 2| mapT->insert(std::make_pair(id, TPtr(new T()))); 1575| 2| return true; 1576| 2| } 1577| 0| return false; 1578| 2| } _ZN2el8CallbackINS_15LogDispatchDataEEC2Ev: 2184| 2| Callback(void) : m_enabled(true) {} easylogging++.cc:_ZN2el4base5utilsL10safeDeleteINS0_21RegisteredHitCountersEEENSt3__19enable_ifIXsr3std10is_pointerIPT_EE5valueEvE4typeERS7_: 889| 1|safeDelete(T*& pointer) { 890| 1| if (pointer == nullptr) ------------------ | Branch (890:7): [True: 0, False: 1] ------------------ 891| 0| return; 892| 1| delete pointer; 893| 1| pointer = nullptr; 894| 1|} easylogging++.cc:_ZN2el4base5utilsL10safeDeleteINS0_17RegisteredLoggersEEENSt3__19enable_ifIXsr3std10is_pointerIPT_EE5valueEvE4typeERS7_: 889| 1|safeDelete(T*& pointer) { 890| 1| if (pointer == nullptr) ------------------ | Branch (890:7): [True: 0, False: 1] ------------------ 891| 0| return; 892| 1| delete pointer; 893| 1| pointer = nullptr; 894| 1|} easylogging++.cc:_ZN2el4base5utilsL10safeDeleteINS0_9VRegistryEEENSt3__19enable_ifIXsr3std10is_pointerIPT_EE5valueEvE4typeERS7_: 889| 1|safeDelete(T*& pointer) { 890| 1| if (pointer == nullptr) ------------------ | Branch (890:7): [True: 0, False: 1] ------------------ 891| 0| return; 892| 1| delete pointer; 893| 1| pointer = nullptr; 894| 1|} easylogging++.cc:_ZN2el4base5utilsL10safeDeleteINS_13ConfigurationEEENSt3__19enable_ifIXsr3std10is_pointerIPT_EE5valueEvE4typeERS7_: 889| 144|safeDelete(T*& pointer) { 890| 144| if (pointer == nullptr) ------------------ | Branch (890:7): [True: 0, False: 144] ------------------ 891| 0| return; 892| 144| delete pointer; 893| 144| pointer = nullptr; 894| 144|} _ZN5tools6base586decodeERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERS7_: 196| 368| { 197| 368| if (enc.empty()) ------------------ | Branch (197:11): [True: 0, False: 368] ------------------ 198| 0| { 199| 0| data.clear(); 200| 0| return true; 201| 0| } 202| | 203| 368| size_t full_block_count = enc.size() / full_encoded_block_size; 204| 368| size_t last_block_size = enc.size() % full_encoded_block_size; 205| 368| int last_block_decoded_size = decoded_block_sizes::instance(last_block_size); 206| 368| if (last_block_decoded_size < 0) ------------------ | Branch (206:11): [True: 23, False: 345] ------------------ 207| 23| return false; // Invalid enc length 208| 345| size_t data_size = full_block_count * full_block_size + last_block_decoded_size; 209| | 210| 345| data.resize(data_size, 0); 211| 993| for (size_t i = 0; i < full_block_count; ++i) ------------------ | Branch (211:26): [True: 844, False: 149] ------------------ 212| 844| { 213| 844| if (!decode_block(enc.data() + i * full_encoded_block_size, full_encoded_block_size, &data[i * full_block_size])) ------------------ | Branch (213:13): [True: 196, False: 648] ------------------ 214| 196| return false; 215| 844| } 216| | 217| 149| if (0 < last_block_size) ------------------ | Branch (217:11): [True: 100, False: 49] ------------------ 218| 100| { 219| 100| if (!decode_block(enc.data() + full_block_count * full_encoded_block_size, last_block_size, ------------------ | Branch (219:13): [True: 83, False: 17] ------------------ 220| 100| &data[full_block_count * full_block_size])) 221| 83| return false; 222| 100| } 223| | 224| 66| return true; 225| 149| } base58.cpp:_ZN5tools6base5812_GLOBAL__N_116reverse_alphabetC2Ev: 57| 2| { 58| 2| m_data.resize(alphabet[alphabet_size - 1] - alphabet[0] + 1, -1); 59| | 60| 118| for (size_t i = 0; i < alphabet_size; ++i) ------------------ | Branch (60:30): [True: 116, False: 2] ------------------ 61| 116| { 62| 116| size_t idx = static_cast(alphabet[i] - alphabet[0]); 63| 116| m_data[idx] = static_cast(i); 64| 116| } 65| 2| } base58.cpp:_ZN5tools6base5812_GLOBAL__N_119decoded_block_sizesC2Ev: 84| 2| { 85| 2| m_data.resize(encoded_block_sizes[full_block_size] + 1, -1); 86| 20| for (size_t i = 0; i <= full_block_size; ++i) ------------------ | Branch (86:30): [True: 18, False: 2] ------------------ 87| 18| { 88| 18| m_data[encoded_block_sizes[i]] = static_cast(i); 89| 18| } 90| 2| } base58.cpp:_ZNK5tools6base5812_GLOBAL__N_119decoded_block_sizesclEm: 93| 1.31k| { 94| 1.31k| assert(encoded_block_size <= full_encoded_block_size); 95| 1.31k| return m_data[encoded_block_size]; 96| 1.31k| } base58.cpp:_ZN5tools6base5812_GLOBAL__N_112decode_blockEPKcmPc: 139| 944| { 140| 944| assert(1 <= size && size <= full_encoded_block_size); 141| | 142| 944| int res_size = decoded_block_sizes::instance(size); 143| 944| if (res_size <= 0) ------------------ | Branch (143:13): [True: 0, False: 944] ------------------ 144| 0| return false; // Invalid block size 145| | 146| 944| uint64_t res_num = 0; 147| 944| uint64_t order = 1; 148| 9.56k| for (size_t i = size - 1; i < size; --i) ------------------ | Branch (148:35): [True: 8.82k, False: 732] ------------------ 149| 8.82k| { 150| 8.82k| int digit = reverse_alphabet::instance(block[i]); 151| 8.82k| if (digit < 0) ------------------ | Branch (151:15): [True: 199, False: 8.62k] ------------------ 152| 199| return false; // Invalid symbol 153| | 154| 8.62k| uint64_t product_hi; 155| 8.62k| uint64_t tmp = res_num + mul128(order, digit, &product_hi); 156| 8.62k| if (tmp < res_num || 0 != product_hi) ------------------ | Branch (156:15): [True: 3, False: 8.62k] | Branch (156:32): [True: 10, False: 8.61k] ------------------ 157| 13| return false; // Overflow 158| | 159| 8.61k| res_num = tmp; 160| 8.61k| order *= alphabet_size; // Never overflows, 58^10 < 2^64 161| 8.61k| } 162| | 163| 732| if (static_cast(res_size) < full_block_size && (UINT64_C(1) << (8 * res_size)) <= res_num) ------------------ | Branch (163:13): [True: 84, False: 648] | Branch (163:64): [True: 67, False: 17] ------------------ 164| 67| return false; // Overflow 165| | 166| 665| uint_64_to_8be(res_num, res_size, reinterpret_cast(res)); 167| | 168| 665| return true; 169| 732| } base58.cpp:_ZNK5tools6base5812_GLOBAL__N_116reverse_alphabetclEc: 68| 8.82k| { 69| 8.82k| size_t idx = static_cast(letter - alphabet[0]); 70| 8.82k| return idx < m_data.size() ? m_data[idx] : -1; ------------------ | Branch (70:18): [True: 8.65k, False: 178] ------------------ 71| 8.82k| } base58.cpp:_ZN5tools6base5812_GLOBAL__N_114uint_64_to_8beEmmPh: 116| 665| { 117| 665| assert(1 <= size && size <= sizeof(uint64_t)); 118| | 119| 665| uint64_t num_be = SWAP64BE(num); ------------------ | | 286| 665|#define SWAP64BE SWAP64 | | ------------------ | | | | 162| 665|#define SWAP64(x) ((((uint64_t) (x) & 0x00000000000000ff) << 56) | \ | | | | 163| 665| (((uint64_t) (x) & 0x000000000000ff00) << 40) | \ | | | | 164| 665| (((uint64_t) (x) & 0x0000000000ff0000) << 24) | \ | | | | 165| 665| (((uint64_t) (x) & 0x00000000ff000000) << 8) | \ | | | | 166| 665| (((uint64_t) (x) & 0x000000ff00000000) >> 8) | \ | | | | 167| 665| (((uint64_t) (x) & 0x0000ff0000000000) >> 24) | \ | | | | 168| 665| (((uint64_t) (x) & 0x00ff000000000000) >> 40) | \ | | | | 169| 665| (((uint64_t) (x) & 0xff00000000000000) >> 56)) | | ------------------ ------------------ 120| 665| memcpy(data, reinterpret_cast(&num_be) + sizeof(uint64_t) - size, size); 121| 665| } LLVMFuzzerTestOneInput: 36| 736|BEGIN_SIMPLE_FUZZER() ------------------ | | 53| 368| { \ | | 54| 368| try \ | | 55| 368| { \ | | 56| 368| static bool first = true; \ | | 57| 368| if (first) \ | | ------------------ | | | Branch (57:11): [True: 1, False: 367] | | ------------------ | | 58| 368| { \ | | 59| 1| if (init()) \ | | ------------------ | | | Branch (59:13): [True: 0, False: 1] | | ------------------ | | 60| 1| return 1; \ | | 61| 1| first = false; \ | | 62| 1| } \ ------------------ 37| 368| std::string data; 38| 368| tools::base58::decode(std::string((const char*)buf, len), data); 39| 368|END_SIMPLE_FUZZER() ------------------ | | 65| 368| } \ | | 66| 368| catch (const std::exception &e) \ | | 67| 368| { \ | | 68| 0| fprintf(stderr, "Exception: %s\n", e.what()); \ | | 69| 0| delete el::base::elStorage; \ | | 70| 0| el::base::elStorage = NULL; \ | | 71| 0| return 0; \ | | 72| 0| } \ | | 73| 368| delete el::base::elStorage; \ | | 74| 368| el::base::elStorage = NULL; \ | | 75| 368| return 0; \ | | 76| 368| } \ ------------------ base58.cpp:_ZL4initv: 33| 2|BEGIN_INIT_SIMPLE_FUZZER() ------------------ | | 36| 1| { \ | | 37| 1| try \ | | 38| 1| { ------------------ 34| 2|END_INIT_SIMPLE_FUZZER() ------------------ | | 41| 1| } \ | | 42| 1| catch (const std::exception &e) \ | | 43| 1| { \ | | 44| 0| fprintf(stderr, "Exception: %s\n", e.what()); \ | | 45| 0| return 1; \ | | 46| 0| } \ | | 47| 1| return 0; \ | | 48| 1| } ------------------