एक वैध नियमित अभिव्यक्ति का पता लगाने के लिए एक नियमित अभिव्यक्ति है?

Question

क्या एक अन्य नियमित अभिव्यक्ति के साथ एक वैध नियमित अभिव्यक्ति का पता लगाना संभव है? यदि हां, तो कृपया नीचे उदाहरण कोड दें।

Comments

तो आपकी समस्या एक रेगेक्स को मान्य कर रही है, आपने इसे हल करने के लिए एक रेगेक्स को चुना। मुझे आश्चर्य है कि अगर रेगेक्स की समस्या-संख्या-बढ़ती संपत्ति एडिटिव या गुणा है। यह 2 के बजाय 4 समस्याओं की तरह लगता है :)

— abesto

नियमित अभिव्यक्तियों के लिए कई अधिसूचनाएं हैं - कुछ विशेषताएं और उनके वर्तनी सबसे आम हैं, कुछ अलग-अलग वर्तनी हैं या केवल एक विशेष अंकन में उपलब्ध हैं। नियमित व्याकरण के अर्थों में अधिकांश सूचनाएं "नियमित" नहीं हैं - आपको उप-संदर्भों के निर्बाध घोंसले को संभालने के लिए एक संदर्भ मुक्त पार्सर की आवश्यकता होगी - हालांकि कई आधुनिक "नियमित अभिव्यक्ति" संकेतन में एक्सटेंशन हैं जो मूल औपचारिक परिभाषा से परे हैं। अपने स्वयं के संकेतन को मान्यता दे सकते हैं। किसी भी मामले में, यदि प्रत्येक रेगेक्स मान्य है, तो बस अपने रेगेक्स पुस्तकालय से क्यों न पूछें?

— स्टीव 314

@bevacqua मुझे XML स्कीमा में regexp को मान्य करने की आवश्यकता है। मैं इसे दूसरे रेगेक्सपी के बिना कैसे कर सकता हूं?

— zenden2k

वास्तव में आपकी भाषा के पास एक अपवाद-हैंडलिंग तंत्र के तहत, regex (पैटर्न) को संकलित / चलाना। तो भाषा का रेगेक्स इंजन / कंपाइलर खुद इसकी जाँच करेगा। (यह मानता है कि मूल वाक्यविन्यास सही है, ताकि प्रोग्राम चलता रहे, लेकिन वह आपकी भाषा की सुविधाओं का उपयोग करके

— रीगेक्स के

यह अजगर उपयोगकर्ताओं के लिए एकदम सही जवाब है: stackoverflow.com/questions/19630994/…

— gianni

Answer 1

/
^                                             # start of string
(                                             # first group start
  (?:
    (?:[^?+*{}()[\]\\|]+                      # literals and ^, $
     | \\.                                    # escaped characters
     | \[ (?: \^?\\. | \^[^\\] | [^\\^] )     # character classes
          (?: [^\]\\]+ | \\. )* \]
     | \( (?:\?[:=!]|\?<[=!]|\?>)? (?1)?? \)  # parenthesis, with recursive content
     | \(\? (?:R|[+-]?\d+) \)                 # recursive matching
     )
    (?: (?:[?+*]|\{\d+(?:,\d*)?\}) [?+]? )?   # quantifiers
  | \|                                        # alternative
  )*                                          # repeat content
)                                             # end first group
$                                             # end of string
/

यह एक पुनरावर्ती रेगेक्स है, और कई रेगेक्स इंजनों द्वारा समर्थित नहीं है। पीसीआरई आधारित लोगों को इसका समर्थन करना चाहिए।

व्हॉट्सएप और टिप्पणियों के बिना:

/^((?:(?:[^?+*{}()[\]\\|]+|\\.|\[(?:\^?\\.|\^[^\\]|[^\\^])(?:[^\]\\]+|\\.)*\]|\((?:\?[:=!]|\?<[=!]|\?>)?(?1)??\)|\(\?(?:R|[+-]?\d+)\))(?:(?:[?+*]|\{\d+(?:,\d*)?\})[?+]?)?|\|)*)$/

---

.NET सीधे पुनरावृत्ति का समर्थन नहीं करता है। ( (?1)और (?R)निर्माण करता है।) पुनरावर्तन को संतुलित समूहों की गिनती में बदलना होगा:

^                                         # start of string
(?:
  (?: [^?+*{}()[\]\\|]+                   # literals and ^, $
   | \\.                                  # escaped characters
   | \[ (?: \^?\\. | \^[^\\] | [^\\^] )   # character classes
        (?: [^\]\\]+ | \\. )* \]
   | \( (?:\?[:=!]
         | \?<[=!]
         | \?>
         | \?<[^\W\d]\w*>
         | \?'[^\W\d]\w*'
         )?                               # opening of group
     (?<N>)                               #   increment counter
   | \)                                   # closing of group
     (?<-N>)                              #   decrement counter
   )
  (?: (?:[?+*]|\{\d+(?:,\d*)?\}) [?+]? )? # quantifiers
| \|                                      # alternative
)*                                        # repeat content
$                                         # end of string
(?(N)(?!))                                # fail if counter is non-zero.

जमा:

^(?:(?:[^?+*{}()[\]\\|]+|\\.|\[(?:\^?\\.|\^[^\\]|[^\\^])(?:[^\]\\]+|\\.)*\]|\((?:\?[:=!]|\?<[=!]|\?>|\?<[^\W\d]\w*>|\?'[^\W\d]\w*')?(?<N>)|\)(?<-N>))(?:(?:[?+*]|\{\d+(?:,\d*)?\})[?+]?)?|\|)*$(?(N)(?!))

टिप्पणियों से:

क्या यह प्रतिस्थापन और अनुवाद को मान्य करेगा?

यह प्रतिस्थापन और अनुवाद के सिर्फ रेगेक्स भाग को मान्य करेगा। s/<this part>/.../

सैद्धांतिक रूप से सभी वैध रेगेक्स व्याकरणों को एक रेगेक्स के साथ मैच करना संभव नहीं है।

यह संभव है अगर रेगेक्स इंजन पुनरावृत्ति का समर्थन करता है, जैसे कि पीसीआरई, लेकिन यह वास्तव में किसी भी अधिक नियमित अभिव्यक्ति नहीं कहा जा सकता है।

वास्तव में, "पुनरावर्ती नियमित अभिव्यक्ति" एक नियमित अभिव्यक्ति नहीं है। लेकिन यह रेगेक्स इंजनों के लिए एक अक्सर स्वीकृत एक्सटेंशन है ... विडंबना यह है कि यह विस्तारित रेगेक्स विस्तारित रेगेक्स से मेल नहीं खाता है।

"सिद्धांत, सिद्धांत और व्यवहार में समान हैं। व्यवहार में, वे नहीं हैं।" नियमित अभिव्यक्ति जानने वाले लगभग सभी लोग जानते हैं कि नियमित अभिव्यक्तियाँ पुनरावृत्ति का समर्थन नहीं करती हैं। लेकिन पीसीआरई और अधिकांश अन्य कार्यान्वयन बुनियादी नियमित अभिव्यक्तियों की तुलना में बहुत अधिक समर्थन करते हैं।

grep कमांड में शेल स्क्रिप्ट के साथ इसका उपयोग करते हुए, यह मुझे कुछ त्रुटि दिखाता है .. grep: {} की अमान्य सामग्री। मैं एक ऐसी स्क्रिप्ट बना रहा हूं, जो उन सभी फाइलों को ढूंढने के लिए एक कोड आधार तैयार कर सकती है जिनमें नियमित अभिव्यक्ति होती है

यह पैटर्न पुनरावर्ती नियमित अभिव्यक्ति नामक एक एक्सटेंशन का शोषण करता है। यह रेगेक्स के पोसिक्स स्वाद द्वारा समर्थित नहीं है। आप पीसी स्विच regex स्वाद को सक्षम करने के लिए -P स्विच के साथ कोशिश कर सकते हैं।

रेगेक्स ही "एक नियमित भाषा नहीं है और इसलिए इसे नियमित अभिव्यक्ति द्वारा पार्स नहीं किया जा सकता ..."

यह शास्त्रीय नियमित अभिव्यक्तियों के लिए सच है। कुछ आधुनिक कार्यान्वयन पुनरावृत्ति की अनुमति देते हैं, जो इसे एक प्रसंग मुक्त भाषा में बनाता है, हालांकि यह इस कार्य के लिए कुछ हद तक क्रिया है।

मैं देख रहा हूं कि आप कहां मिलान कर रहे हैं []()/\। और अन्य विशेष regex वर्ण। आप गैर-विशेष पात्रों को कहां अनुमति दे रहे हैं? ऐसा लगता है कि यह मैच होगा ^(?:[\.]+)$, लेकिन नहीं ^abcdefg$। यह एक वैध रेगेक्स है।

[^?+*{}()[\]\\|]किसी भी एकल वर्ण से मेल खाएगा, किसी भी अन्य निर्माण का हिस्सा नहीं। (यह दोनों शाब्दिक शामिल a- z), और कुछ विशेष वर्ण ( ^, $, .)।

Comments

यह उत्तर लोगों को पूरी तरह से गलत दिशा में भेजता है। उन्हें रेगुलर एक्सप्रेशंस का पता लगाने के लिए regEx का उपयोग कभी नहीं करना चाहिए, क्योंकि यह सभी मामलों में सही तरीके से काम नहीं कर सकता है। मेरे उत्तर को देखें।

— १

.{,1}बेजोड़ है। ^((?:(?:[^?+*{}()[\]\\|]+|\\.|\[(?:\^?\\.|\^[^\\]|[^\\^])(?:[^\]\\]+|\\.)*\]|\((?:\?[:=!]|\?<[=!]|\?>)?(?1)??\)|\(\?(?:R|[+-]?\d+)\))(?:(?:[?+*]|\{\d*(?:,\d*)?\})[?+]?)?|\|)*)$मैचों में बदलें । चेंज \d+टू\d*

— यूजेन

डीईजी द्वारा रेगेक्स में पुनरावृत्ति नहीं होनी चाहिए, कम से कम उर जवाब में ऐसा कुछ कहें, उर रेगेक्स इंजन शायद "बहुत शक्तिशाली" है और वास्तव में रेगेक्स इंजन नहीं है।

— चार्ली पार्कर

बस एक नोट आप x ध्वज भूल गए

— RedClover

यह सत्यापनकर्ता PCRE अभिव्यक्तियों के लिए बनाया गया लगता है, लेकिन यह कई अमान्य POSIX EREs को पास कर देगा। विशेष रूप से, वे वर्ण वर्ग की श्रेणियों में थोड़ा सा पिकर हैं, उदाहरण के लिए यह पीसीआरई में मान्य है, लेकिन ईआरई में नहीं [a-b-c]।

— पेड्रो जिमनो

Answer 2

संभावना नहीं है।

try..catchअपनी या जो भी भाषा प्रदान करती है, उसमें इसका मूल्यांकन करें।

Answer 3

नहीं, यदि आप नियमित अभिव्यक्ति के बारे में कड़ाई से बोल रहे हैं और कुछ नियमित अभिव्यक्ति कार्यान्वयनों को शामिल नहीं कर रहे हैं जो वास्तव में संदर्भ मुक्त व्याकरण हैं।

नियमित अभिव्यक्तियों की एक सीमा है जो एक regex लिखना असंभव बनाता है जो सभी और केवल regexes से मेल खाता है। आप लागू नहीं कर सकते जैसे ब्रेसिज़ जो युग्मित हैं। Regexes ऐसे कई निर्माणों का उपयोग करते हैं, आइए []एक उदाहरण के रूप में लेते हैं । जब भी वहाँ [एक मिलान होना चाहिए ], जो एक रेगेक्स के लिए पर्याप्त सरल है "\[.*\]"।

Regexes के लिए यह असंभव है कि उन्हें नेस्टेड किया जा सकता है। आप नेस्टेड कोष्ठक से मेल खाने वाला रेगेक्स कैसे लिख सकते हैं? जवाब है कि आप एक असीम लंबे रेगेक्स के बिना नहीं कर सकते। आप ब्रूट बल के माध्यम से किसी भी संख्या में नेस्टेड कोष्ठक का मिलान कर सकते हैं, लेकिन आप कभी भी नेस्टेड ब्रैकेट्स के मनमाने ढंग से लंबे सेट से मेल नहीं खा सकते हैं।

इस क्षमता को अक्सर गिनती के रूप में संदर्भित किया जाता है, क्योंकि आप घोंसले के शिकार की गहराई की गिनती कर रहे हैं। परिभाषा के अनुसार रेगेक्स में गिनती करने की क्षमता नहीं होती है।

---

मैंने इस बारे में " नियमित अभिव्यक्ति की सीमाएं " लिखना समाप्त कर दिया ।

Answer 4

अच्छा प्रश्न।

सच्ची नियमित भाषाएँ मनमाने ढंग से गहरी नेस्टेड कोष्ठक को तय नहीं कर सकती हैं। यदि आपकी वर्णमाला में शामिल है '('और ')'लक्ष्य तय करना है कि क्या इनमें से एक स्ट्रिंग में अच्छी तरह से गठित मिलान कोष्ठक है। चूंकि यह नियमित अभिव्यक्ति के लिए एक आवश्यक आवश्यकता है, इसलिए उत्तर नहीं है।

हालांकि, यदि आप आवश्यकता को ढीला कर देते हैं और पुनरावृत्ति जोड़ते हैं तो आप शायद कर सकते हैं। कारण यह है कि पुनरावृत्ति एक स्टैक के रूप में कार्य कर सकता है जो आपको इस स्टैक पर धक्का देकर वर्तमान घोंसले के शिकार की गहराई से "गिनती" करने देगा।

रस कॉक्स ने लिखा " रेगुलर एक्सप्रेशन मैचिंग कैन बी सिंपल एंड फास्ट " जो रेगेक्स इंजन कार्यान्वयन पर एक अद्भुत ग्रंथ है।

Answer 5

नहीं, यदि आप मानक नियमित अभिव्यक्ति का उपयोग करते हैं।

इसका कारण यह है कि आप नियमित भाषाओं के लिए पम्पिंग लेम्मा को संतुष्ट नहीं कर सकते हैं। पम्पिंग लेम्मा राज्यों एक स्ट्रिंग भाषा के लिए "L" संबंधित अगर वहाँ एक नंबर "एन" ऐसा है कि, तीन सबस्ट्रिंग में स्ट्रिंग को विभाजित करने के बाद मौजूद है नियमित रूप से है कि x, y, z, ऐसा है कि |x|>=1 && |xy|<=N, आप को दोहरा सकते हैं yकई बार के रूप के रूप में आप चाहते हैं और पूरे तार अभी भी संबंधित होंगे L।

पम्पिंग लेम्मा का एक परिणाम यह होता है कि आपके पास फॉर्म में नियमित स्ट्रिंग्स नहीं हो सकते हैं a^Nb^Mc^N, अर्थात्, दो सब्सट्रिंग्स समान लंबाई वाले होते हैं जो एक और स्ट्रिंग द्वारा अलग होते हैं। किसी भी तरह से आप इस तरह के तारों को विभाजित करते हैं x, yऔर z, आप y"क" और "ग" की एक अलग संख्या के साथ एक स्ट्रिंग प्राप्त किए बिना "पंप" नहीं कर सकते हैं , इस प्रकार मूल भाषा को छोड़ सकते हैं। उदाहरण के लिए, नियमित अभिव्यक्तियों में कोष्ठक के साथ ऐसा ही है।

Comments

यह पंपिंग लेम्मा का बहुत सटीक वर्णन नहीं है। सबसे पहले, यह पूरी भाषा है जो नियमित हो सकती है या नहीं, एक स्ट्रिंग नहीं। दूसरा, यह आवश्यक है, नियमितता के लिए पर्याप्त, पर्याप्त स्थिति नहीं है। अंत में, केवल पर्याप्त रूप से लंबे तार पंप करने योग्य हैं।

— darij grinberg

Answer 6

हालांकि एक पुनरावर्ती rexx का उपयोग करना पूरी तरह से संभव है क्योंकि MizardX ने पोस्ट किया है, इस तरह की चीजों के लिए यह बहुत अधिक उपयोगी है। रेगेक्स को मूल रूप से नियमित भाषाओं के साथ उपयोग करने का इरादा था, पुनरावर्ती होना या समूह को संतुलित करना सिर्फ एक पैच है।

मान्य रीजैक्स को परिभाषित करने वाली भाषा वास्तव में एक संदर्भ मुक्त व्याकरण है, और आपको इसे संभालने के लिए एक उपयुक्त पार्सर का उपयोग करना चाहिए। यहाँ सरल रीगेक्स (अधिकांश निर्माणों के बिना) को पार्स करने के लिए एक विश्वविद्यालय परियोजना के लिए एक उदाहरण है। यह JavaCC का उपयोग करता है। और हाँ, टिप्पणियाँ स्पेनिश में हैं, हालांकि विधि नाम बहुत आत्म-व्याख्यात्मक हैं।

SKIP :
{
    " "
|   "\r"
|   "\t"
|   "\n"
}
TOKEN : 
{
    < DIGITO: ["0" - "9"] >
|   < MAYUSCULA: ["A" - "Z"] >
|   < MINUSCULA: ["a" - "z"] >
|   < LAMBDA: "LAMBDA" >
|   < VACIO: "VACIO" >
}

IRegularExpression Expression() :
{
    IRegularExpression r; 
}
{
    r=Alternation() { return r; }
}

// Matchea disyunciones: ER | ER
IRegularExpression Alternation() :
{
    IRegularExpression r1 = null, r2 = null; 
}
{
    r1=Concatenation() ( "|" r2=Alternation() )?
    { 
        if (r2 == null) {
            return r1;
        } else {
            return createAlternation(r1,r2);
        } 
    }
}

// Matchea concatenaciones: ER.ER
IRegularExpression Concatenation() :
{
    IRegularExpression r1 = null, r2 = null; 
}
{
    r1=Repetition() ( "." r2=Repetition() { r1 = createConcatenation(r1,r2); } )*
    { return r1; }
}

// Matchea repeticiones: ER*
IRegularExpression Repetition() :
{
    IRegularExpression r; 
}
{
    r=Atom() ( "*" { r = createRepetition(r); } )*
    { return r; }
}

// Matchea regex atomicas: (ER), Terminal, Vacio, Lambda
IRegularExpression Atom() :
{
    String t;
    IRegularExpression r;
}
{
    ( "(" r=Expression() ")" {return r;}) 
    | t=Terminal() { return createTerminal(t); }
    | <LAMBDA> { return createLambda(); }
    | <VACIO> { return createEmpty(); }
}

// Matchea un terminal (digito o minuscula) y devuelve su valor
String Terminal() :
{
    Token t;
}
{
    ( t=<DIGITO> | t=<MINUSCULA> ) { return t.image; }
}

Answer 7

आप रेगेक्स जमा कर सकते हैं, preg_matchजो रेगेक्स मान्य नहीं होने पर वापस लौट आएगा। @त्रुटि संदेशों को दबाने के लिए उपयोग करना न भूलें :

@preg_match($regexToTest, '');

• अगर रेगेक्स है तो 1 लौटेगा //।
• रीगेक्स ठीक होने पर 0 वापस आ जाएगा।
• अन्यथा झूठे लौटेंगे।

Answer 8

पॉल मैकगायर द्वारा निम्नलिखित उदाहरण, मूल रूप से पाइपरसिंग विकी से, लेकिन अब केवल वेबैक मशीन के माध्यम से उपलब्ध है , मैचिंग स्ट्रिंग्स के सेट को वापस करने के उद्देश्य से, कुछ रेगेक्स को पार्स करने के लिए एक व्याकरण देता है । जैसे, यह उन पुन: को अस्वीकार करता है, जिनमें '+' और '*' जैसे अनपेक्षित दोहराव शब्द शामिल हैं। लेकिन यह आपको इस बारे में एक विचार देना चाहिए कि एक पार्सर को कैसे फिर से तैयार करना है।

# 
# invRegex.py
#
# Copyright 2008, Paul McGuire
#
# pyparsing script to expand a regular expression into all possible matching strings
# Supports:
# - {n} and {m,n} repetition, but not unbounded + or * repetition
# - ? optional elements
# - [] character ranges
# - () grouping
# - | alternation
#
__all__ = ["count","invert"]

from pyparsing import (Literal, oneOf, printables, ParserElement, Combine, 
    SkipTo, operatorPrecedence, ParseFatalException, Word, nums, opAssoc,
    Suppress, ParseResults, srange)

class CharacterRangeEmitter(object):
    def __init__(self,chars):
        # remove duplicate chars in character range, but preserve original order
        seen = set()
        self.charset = "".join( seen.add(c) or c for c in chars if c not in seen )
    def __str__(self):
        return '['+self.charset+']'
    def __repr__(self):
        return '['+self.charset+']'
    def makeGenerator(self):
        def genChars():
            for s in self.charset:
                yield s
        return genChars

class OptionalEmitter(object):
    def __init__(self,expr):
        self.expr = expr
    def makeGenerator(self):
        def optionalGen():
            yield ""
            for s in self.expr.makeGenerator()():
                yield s
        return optionalGen

class DotEmitter(object):
    def makeGenerator(self):
        def dotGen():
            for c in printables:
                yield c
        return dotGen

class GroupEmitter(object):
    def __init__(self,exprs):
        self.exprs = ParseResults(exprs)
    def makeGenerator(self):
        def groupGen():
            def recurseList(elist):
                if len(elist)==1:
                    for s in elist[0].makeGenerator()():
                        yield s
                else:
                    for s in elist[0].makeGenerator()():
                        for s2 in recurseList(elist[1:]):
                            yield s + s2
            if self.exprs:
                for s in recurseList(self.exprs):
                    yield s
        return groupGen

class AlternativeEmitter(object):
    def __init__(self,exprs):
        self.exprs = exprs
    def makeGenerator(self):
        def altGen():
            for e in self.exprs:
                for s in e.makeGenerator()():
                    yield s
        return altGen

class LiteralEmitter(object):
    def __init__(self,lit):
        self.lit = lit
    def __str__(self):
        return "Lit:"+self.lit
    def __repr__(self):
        return "Lit:"+self.lit
    def makeGenerator(self):
        def litGen():
            yield self.lit
        return litGen

def handleRange(toks):
    return CharacterRangeEmitter(srange(toks[0]))

def handleRepetition(toks):
    toks=toks[0]
    if toks[1] in "*+":
        raise ParseFatalException("",0,"unbounded repetition operators not supported")
    if toks[1] == "?":
        return OptionalEmitter(toks[0])
    if "count" in toks:
        return GroupEmitter([toks[0]] * int(toks.count))
    if "minCount" in toks:
        mincount = int(toks.minCount)
        maxcount = int(toks.maxCount)
        optcount = maxcount - mincount
        if optcount:
            opt = OptionalEmitter(toks[0])
            for i in range(1,optcount):
                opt = OptionalEmitter(GroupEmitter([toks[0],opt]))
            return GroupEmitter([toks[0]] * mincount + [opt])
        else:
            return [toks[0]] * mincount

def handleLiteral(toks):
    lit = ""
    for t in toks:
        if t[0] == "\\":
            if t[1] == "t":
                lit += '\t'
            else:
                lit += t[1]
        else:
            lit += t
    return LiteralEmitter(lit)    

def handleMacro(toks):
    macroChar = toks[0][1]
    if macroChar == "d":
        return CharacterRangeEmitter("0123456789")
    elif macroChar == "w":
        return CharacterRangeEmitter(srange("[A-Za-z0-9_]"))
    elif macroChar == "s":
        return LiteralEmitter(" ")
    else:
        raise ParseFatalException("",0,"unsupported macro character (" + macroChar + ")")

def handleSequence(toks):
    return GroupEmitter(toks[0])

def handleDot():
    return CharacterRangeEmitter(printables)

def handleAlternative(toks):
    return AlternativeEmitter(toks[0])


_parser = None
def parser():
    global _parser
    if _parser is None:
        ParserElement.setDefaultWhitespaceChars("")
        lbrack,rbrack,lbrace,rbrace,lparen,rparen = map(Literal,"[]{}()")

        reMacro = Combine("\\" + oneOf(list("dws")))
        escapedChar = ~reMacro + Combine("\\" + oneOf(list(printables)))
        reLiteralChar = "".join(c for c in printables if c not in r"\[]{}().*?+|") + " \t"

        reRange = Combine(lbrack + SkipTo(rbrack,ignore=escapedChar) + rbrack)
        reLiteral = ( escapedChar | oneOf(list(reLiteralChar)) )
        reDot = Literal(".")
        repetition = (
            ( lbrace + Word(nums).setResultsName("count") + rbrace ) |
            ( lbrace + Word(nums).setResultsName("minCount")+","+ Word(nums).setResultsName("maxCount") + rbrace ) |
            oneOf(list("*+?")) 
            )

        reRange.setParseAction(handleRange)
        reLiteral.setParseAction(handleLiteral)
        reMacro.setParseAction(handleMacro)
        reDot.setParseAction(handleDot)

        reTerm = ( reLiteral | reRange | reMacro | reDot )
        reExpr = operatorPrecedence( reTerm,
            [
            (repetition, 1, opAssoc.LEFT, handleRepetition),
            (None, 2, opAssoc.LEFT, handleSequence),
            (Suppress('|'), 2, opAssoc.LEFT, handleAlternative),
            ]
            )
        _parser = reExpr

    return _parser

def count(gen):
    """Simple function to count the number of elements returned by a generator."""
    i = 0
    for s in gen:
        i += 1
    return i

def invert(regex):
    """Call this routine as a generator to return all the strings that
       match the input regular expression.
           for s in invert("[A-Z]{3}\d{3}"):
               print s
    """
    invReGenerator = GroupEmitter(parser().parseString(regex)).makeGenerator()
    return invReGenerator()

def main():
    tests = r"""
    [A-EA]
    [A-D]*
    [A-D]{3}
    X[A-C]{3}Y
    X[A-C]{3}\(
    X\d
    foobar\d\d
    foobar{2}
    foobar{2,9}
    fooba[rz]{2}
    (foobar){2}
    ([01]\d)|(2[0-5])
    ([01]\d\d)|(2[0-4]\d)|(25[0-5])
    [A-C]{1,2}
    [A-C]{0,3}
    [A-C]\s[A-C]\s[A-C]
    [A-C]\s?[A-C][A-C]
    [A-C]\s([A-C][A-C])
    [A-C]\s([A-C][A-C])?
    [A-C]{2}\d{2}
    @|TH[12]
    @(@|TH[12])?
    @(@|TH[12]|AL[12]|SP[123]|TB(1[0-9]?|20?|[3-9]))?
    @(@|TH[12]|AL[12]|SP[123]|TB(1[0-9]?|20?|[3-9])|OH(1[0-9]?|2[0-9]?|30?|[4-9]))?
    (([ECMP]|HA|AK)[SD]|HS)T
    [A-CV]{2}
    A[cglmrstu]|B[aehikr]?|C[adeflmorsu]?|D[bsy]|E[rsu]|F[emr]?|G[ade]|H[efgos]?|I[nr]?|Kr?|L[airu]|M[dgnot]|N[abdeiop]?|Os?|P[abdmortu]?|R[abefghnu]|S[bcegimnr]?|T[abcehilm]|Uu[bhopqst]|U|V|W|Xe|Yb?|Z[nr]
    (a|b)|(x|y)
    (a|b) (x|y)
    """.split('\n')

    for t in tests:
        t = t.strip()
        if not t: continue
        print '-'*50
        print t
        try:
            print count(invert(t))
            for s in invert(t):
                print s
        except ParseFatalException,pfe:
            print pfe.msg
            print
            continue
        print

if __name__ == "__main__":
    main()