std :: regex_iterator इस डेटा के साथ एक स्टैक ओवरफ़्लो क्यों करता है?

Question

मैं लॉग फ़ाइलों को पार्स करने के लिए std::regex_iterator का उपयोग कर रहा हूं। मेरा कार्यक्रम कुछ हफ्तों के लिए काफी अच्छी तरह से काम कर रहा है और आज तक लाखों लॉग लाइनों को पार्स कर चुका है, जब आज मैंने इसे लॉग फ़ाइल के खिलाफ चलाया और एक स्टैक ओवरफ्लो प्राप्त किया। यह पता चला कि लॉग फ़ाइल में केवल एक लॉग लाइन समस्या पैदा कर रही थी। क्या किसी को पता है कि मेरा रेगेक्स इतनी भारी रिकर्सन क्यों कर रहा है? यहां एक छोटा सा निहित कार्यक्रम है जो इस मुद्दे को दिखाता है (मेरा कंपाइलर वीसी2012 है):

#include <string> 
#include <regex> 
#include <iostream> 

using namespace std; 

std::wstring test = L"L3 T15356 79726859 [CreateRegistryAction] Creating REGISTRY Action:\n" 
       L" Identity: 272A4FE2-A7EE-49B7-ABAF-7C57BEA0E081\n" 
       L" Description: Set Registry Value: \"SortOrder\" in Key HKEY_CURRENT_USER\\Software\\Hummingbird\\PowerDOCS\\Core\\Plugins\\Fusion\\Settings\\DetailColumns\\LONEDOCS1\\Search Unsaved\\$AUTHOR.FULL_NAME;DOCSADM.PEOPLE.SYSTEM_ID\n" 
       L" Operation: 3\n" 
       L" Hive: HKEY_CURRENT_USER\n" 
       L" Key: Software\\Hummingbird\\PowerDOCS\\Core\\Plugins\\Fusion\\Settings\\DetailColumns\\LONEDOCS1\\Search Unsaved\\$AUTHOR.FULL_NAME;DOCSADM.PEOPLE.SYSTEM_ID\n" 
       L" ValueName: SortOrder\n" 
       L" ValueType: REG_DWORD\n" 
       L" ValueData: 0\n" 
       L"L4 T15356 79726859 [CEMRegistryValueAction::ClearRevertData] [ENTER]\n"; 

int wmain(int argc, wchar_t* argv[]) 
{ 
    static wregex rgx_log_lines(
     L"^L(\\d+)\\s+"    // Level 
     L"T(\\d+)\\s+"    // TID 
     L"(\\d+)\\s+"    // Timestamp 
     L"\\[((?:\\w|\\:)+)\\]"  // Function name 
     L"((?:"      // Complex pattern 
      L"(?!"     // Stop matching when... 
      L"^L\\d"    // New log statement at the beginning of a line 
      L")"      
      L"[^]"     // Matching all until then 
     L")*)"      // 
     ); 

    try 
    { 
     for (std::wsregex_iterator it(test.begin(), test.end(), rgx_log_lines), end; it != end; ++it) 
     { 
      wcout << (*it)[1] << endl; 
      wcout << (*it)[2] << endl; 
      wcout << (*it)[3] << endl; 
      wcout << (*it)[4] << endl; 
      wcout << (*it)[5] << endl; 
     } 
    } 
    catch (std::exception& e) 
    { 
     cout << e.what() << endl; 
    } 

    return 0; 
} 

Answer 1

प्रत्येक चरित्र पर परीक्षण किए गए नकारात्मक लुकहेड पैटर्न सिर्फ मेरे लिए एक बुरा विचार प्रतीत होता है, और आप जो करने की कोशिश कर रहे हैं वह जटिल नहीं है। आप (1) शेष रेखा से मिलान करना चाहते हैं और फिर (2) निम्नलिखित में से कोई भी संख्या (3) रेखाएं जो एल \ डी (छोटी बग; नीचे देखें) के अलावा कुछ और शुरू करती हैं: (एक और संपादन: ये regexes हैं; यदि आप उन्हें स्ट्रिंग शाब्दिक रूप में लिखना चाहते हैं, आप \\ को \ बदलने की जरूरत है।)

.*\n(?:(?:[^L]|L\D).*\n)* 
| | | 
+-1 | +---------------3 
    +---------------------2 

ECMAScript मोड में, . से मेल खाते हैं \ n नहीं होना चाहिए, लेकिन आप हमेशा साथ कि अभिव्यक्ति में दो . रों बदल सकते [^\n]

जोड़ने के लिए संपादित: मुझे एहसास है कि लॉग प्रविष्टि के अंत से पहले एक खाली रेखा होने पर यह काम नहीं कर सकता है, लेकिन इसमें उस मामले को शामिल करना चाहिए; मैं अतिरिक्त परिशुद्धता के लिए [^\n] को . बदल दिया है:

[^\n]*\n(?:(?:(?:[^L\n]|L\D)[^\n]*)?\n)* 

Answer 2

रेगेक्स ठीक प्रतीत होता है; कम से कम इसमें कुछ भी नहीं है जो विनाशकारी बैकट्रैकिंग का कारण बन सकता है।

मैं एक छोटे से संभावना regex अनुकूलन करने के लिए, ढेर उपयोग पर नीचे काटने देखें:

static wregex rgx_log_lines(
    L"^L(\\d+)\\s+"    // Level 
    L"T(\\d+)\\s+"    // TID 
    L"(\\d+)\\s+"    // Timestamp 
    L"\\[([\\w:]+)\\]"   // Function name 
    L"((?:"      // Complex pattern 
     L"(?!"     // Stop matching when... 
     L"^L\\d"    // New log statement at the beginning of a line 
     L")"      
     L"[^]"     // Matching all until then 
    L")*)"      // 
    ); 

आप set the ECMAScript option किया? अन्यथा, मुझे लगता है कि रेगेक्स लाइब्रेरी पॉज़िक्स रेगेक्स पर डिफ़ॉल्ट है, और वे लुकहेड दावे का समर्थन नहीं करते हैं।