Regex validating regex [chiuso]


17

Costruisci una regex che accetti una stringa regex come input e controlla se è valida. Fondamentalmente, il tuo regex dovrebbe essere in grado di validare se stesso. (Qualsiasi regex non valida non deve essere convalidata, quindi non puoi usarla .*.;))

Il tuo sapore deve essere pienamente supportato da implementazioni ben note (Perl, sed, grep, gawk, ecc.) E deve supportare pienamente ciò che supportano quelle implementazioni. [Non preoccuparti per l'avvocato parlare; Sto solo cercando di rimuovere eventuali scappatoie per gli smart ***.]


Avevo , ma sono preoccupato che darà un vantaggio a coloro che conoscono e utilizzano sapori ricchi di non-funzionalità. O le mie preoccupazioni sono infondate?


8
impossibile, le parentesi quadre arbitrarie rendono una regex una grammatica libera dal contesto, (sostituirla con una notazione polacca ha anche bisogno di una pila)
maniaco del cricchetto

@ratchet Augh, potresti avere ragione.
Mateen Ulhaq,

1
esistono alcune estensioni sulle lingue normali che possono consentire la corrispondenza delle parentesi, ma non so come farlo
maniaco del cricchetto

8
È sicuramente possibile con le regex del Perl.
Peter Taylor,

1
Le espressioni regolari di @BrianVandenberg implementate nelle lingue moderne sono praticamente tutte non regolari ... non appena si aggiungono riferimenti secondari, è possibile abbinare le lingue non regolari. Inoltre, sia Perl / PCRE che .NET sono abbastanza potenti da adattarsi al nesting corretto.
Martin Ender,

Risposte:


22

Rubino

Ho cercato di abbinare il più possibile la sintassi reale del sapore regex di Ruby, ma ci sono alcune stranezze: accetta alcuni lookbehind non validi (come (?<=(?<!))) e riconosce intervalli di caratteri vuoti come D-A. Quest'ultimo potrebbe essere risolto per ASCII, ma il regex è abbastanza lungo com'è.

\A(?<main>
    (?!
        \{(\d+)?,(\d+)?\} # do not match lone counted repetition
    )
    (?:
        [^()\[\]\\*+?|<'] | # anything but metacharacters
        (?<cclass>
            \[ \^? (?: # character class
                (?: # character class
                    [^\[\]\\-] | # anything but square brackets,  backslashes or dashes
                    \g<esc> |
                    \[ : \^? (?: # POSIX char-class
                        alnum | alpha | word | blank | cntrl | x?digit | graph | lower | print | punct | space | upper
                    ) : \] |
                    - (?!
                        \\[dwhsDWHS]
                    ) # range / dash not succeeded by a character class
                )+ |
                \g<cclass> # more than one bracket as delimiter
            ) \]
        ) |
        (?<esc>
            \\[^cuxkg] | # any escaped character
            \\x \h\h? | # hex escape
            \\u \h{4} | # Unicode escape
            \\c . # control escape
        ) |
        \\[kg] (?:
            < \w[^>]* (?: > | \Z) |
            ' \w[^']* (?: ' | \Z)
        )? | # named backrefs
        (?<! (?<! \\) \\[kg]) [<'] | # don't match < or ' if preceded by \k or \g
        \| (?! \g<rep> ) | # alternation
        \( (?: # group
            (?:
                \?
                (?:
                    [>:=!] | # atomic / non-capturing / lookahead
                    (?<namedg>
                        < [_a-zA-Z][^>]* > |
                        ' [_a-zA-Z][^']* ' # named group
                    ) |
                    [xmi-]+: # regex options
                )
            )?
            \g<main>*
        ) \) |
        \(\?<[!=] (?<lbpat>
            (?! \{(\d+)?,(\d+)?\} )
            [^()\[\]\\*+?] |
            \g<esc>  (?<! \\[zZ]) |
            \g<cclass> |
            \( (?: # group
                (?:
                    \?: |
                    \? \g<namedg> |
                    \? <[!=]
                )?
                \g<lbpat>*
            ) \) |
            \(\?\# [^)]* \)
        )* \)
        |
        \(\? [xmi-]+ \) # option group
        (?! \g<rep> ) 
        |
        \(\?\# [^)]*+ \) # comment
        (?! \g<rep> )
    )+
    (?<rep>
        (?:
            [*+?] | # repetition
            \{(\d+)?,(\d+)?\} # counted repetition
        )
        [+?]? # with a possessive/lazy modifier
    )?
)*\Z

Versione illeggibile:

\A(?<main>(?!\{(\d+)?,(\d+)?\})(?:[^()\[\]\\*+?|<']|(?<cclass>\[\^?(?:(?:[^\[\]\\-]|\g<esc>|\[:\^?(?:alnum|alpha|word|blank|cntrl|x?digit|graph|lower|print|punct|space|upper):\]|-(?!\\[dwhsDWHS]))+|\g<cclass>)\])|(?<esc>\\[^cuxkg]|\\x\h\h?|\\u\h{4}|\\c.)|\\[kg](?:<\w[^>]*(?:>|\Z)|'\w[^']*(?:'|\Z))?|(?<!(?<!\\)\\[kg])[<']|\|(?!\g<rep>)|\((?:(?:\?(?:[>:=!]|(?<namedg><[_a-zA-Z][^>]*>|'[_a-zA-Z][^']*')|[xmi-]+:))?\g<main>*)\)|\(\?<[!=](?<lbpat>(?!\{(\d+)?,(\d+)?\})[^()\[\]\\*+?]|\g<esc>(?<!\\[zZ])|\g<cclass>|\((?:(?:\?:|\?\g<namedg>|\?<[!=])?\g<lbpat>*)\)|\(\?#[^)]*\))*\)|\(\?[xmi-]+\)(?!\g<rep>)|\(\?#[^)]*+\)(?!\g<rep>))+(?<rep>(?:[*+?]|\{(\d+)?,(\d+)?\})[+?]?)?)*\Z

28
Non sono entrambe la versione illeggibile?
Kibbee,

2
@Kibbee Il primo è ragionevolmente leggibile se conosci bene regex.
Lowjacker

1
In che modo ciò garantisce che non vi siano riferimenti indietro numerici non validi?
Martin Ender,

1
Immagino di no. Inoltre, non è l'unica limitazione che ha (vedi sopra). Alcune cose potrebbero essere risolte, ma la regex diventerebbe ridicolmente lunga.
Lowjacker
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.