Regex validando regex [cerrado]

Cerrado. Esta pregunta está fuera de tema . Actualmente no está aceptando respuestas.

¿Quieres mejorar esta pregunta? Actualice la pregunta para que sea sobre el tema de Code Golf Stack Exchange.

Cerrado el año pasado .

Cree una expresión regular que acepte una cadena de expresión regular como entrada y verifique si es válida. Básicamente, su expresión regular debería poder validarse. (Cualquier expresión regular no válida no debe validarse, por lo que no puede usarla .*.)

Su sabor debe ser totalmente compatible con implementaciones bien conocidas (Perl, sed, grep, gawk, etc.), y debe ser totalmente compatible con lo que esas implementaciones admiten. [No te preocupes por el abogado habla; Solo estoy tratando de eliminar cualquier posible escapatoria para los *** inteligentes.]

Lo codificaría , pero me preocupa que les dé una ventaja a aquellos que conocen y usan sabores no ricos en características. ¿O son mis preocupaciones infundadas?

code-challenge code-golf code-golf game sudoku code-challenge math ai-player code-challenge sorting rosetta-stone code-challenge code-challenge programming-puzzle code-golf number code-golf maze code-golf math regular-expression code-golf sequence code-golf graph-theory code-golf string word-puzzle natural-language brainfuck metagolf optimized-output fastest-algorithm code-golf game-of-life cellular-automata code-golf puzzle-solver grid code-golf combinatorics binary-tree popularity-contest code-challenge code-golf ascii-art kolmogorov-complexity brainfuck metagolf code-golf c date code-golf word-puzzle crossword word-search code-golf code-golf quine code-golf string random

— Mateen Ulhaq
fuente

no es posible, los corchetes de anidación arbitrarios hacen que una expresión regular sea una gramática libre de contexto, (reemplazarla con una notación polaca también necesita una pila)

— monstruo de trinquete

@ratchet Augh, puede que tengas razón.

— Mateen Ulhaq

existen algunas extensiones en los idiomas regulares que pueden permitir coincidir con los corchetes, pero no sé cómo hacerlo

— Ratchet freak

Seguro que será posible con expresiones regulares de Perl.

— Peter Taylor

Las expresiones regulares de @BrianVandenberg implementadas en los idiomas modernos son prácticamente no regulares ... tan pronto como agregue referencias, puede hacer coincidir los idiomas no regulares. Además, tanto Perl / PCRE como .NET son lo suficientemente potentes como para coincidir con la anidación correcta.

— Martin Ender

Rubí

Traté de hacer coincidir la sintaxis real del sabor de la expresión regular de Ruby tanto como sea posible, pero hay algunas peculiaridades: acepta algunos aspectos retrospectivos que en realidad no son válidos (como (?<=(?<!))) y reconoce rangos de caracteres vacíos como D-A. Este último podría repararse para ASCII, pero la expresión regular es lo suficientemente larga como es.

\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

Versión ilegible:

\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

— Lowjacker
fuente

¿No son ambos la versión ilegible?

— Kibbee

@Kibbee El primero es razonablemente legible si conoce bien la expresión regular.

— Lowjacker

¿Cómo se asegura esto de que no hay referencias numéricas inválidas?

— Martin Ender

Supongo que no. Por otra parte, no es la única limitación que tiene (ver arriba). Algunas cosas podrían arreglarse, pero la expresión regular se volvería ridículamente larga.

— Lowjacker