/
^                                             # 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
/

이것은 재귀 정규식이며 많은 정규식 엔진에서 지원하지 않습니다. PCRE 기반 제품이이를 지원해야합니다.

공백과 주석이없는 경우 :

/^((?:(?:[^?+*{}()[\]\\|]+|\\.|\[(?:\^?\\.|\^[^\\]|[^\\^])(?:[^\]\\]+|\\.)*\]|\((?:\?[:=!]|\?<[=!]|\?>)?(?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>/.../

이론적으로 모든 유효한 정규식 문법을 정규식과 일치시키는 것은 불가능합니다.

정규식 엔진이 PCRE와 같은 재귀를 지원하는 경우 가능하지만 더 이상 정규 표현식이라고 할 수는 없습니다.

실제로 “재귀 정규 표현식”은 정규 표현식이 아닙니다. 그러나 이것은 정규 표현식 엔진에 자주 사용되는 확장입니다 … 아이러니하게도이 확장 정규 표현식은 확장 정규 표현식과 일치하지 않습니다.

“이론적으로 이론과 실제는 동일합니다. 실제로는 그렇지 않습니다.” 정규 표현식을 알고있는 거의 모든 사람은 정규 표현식이 재귀를 지원하지 않는다는 것을 알고 있습니다. 그러나 PCRE 및 대부분의 다른 구현은 기본 정규식보다 훨씬 많은 기능을 지원합니다.

grep 명령에서 쉘 스크립트와 함께 이것을 사용하면 오류가 표시됩니다. grep : {}의 유효하지 않은 내용. 정규 표현식이 포함 된 모든 파일을 찾기 위해 코드베이스를 grep 할 수있는 스크립트를 만들고 있습니다

이 패턴은 재귀 정규 표현식이라는 확장을 이용합니다. 이것은 POSIX 버전의 정규식에서 지원되지 않습니다. -P 스위치를 사용하여 PCRE 정규 표현식을 사용할 수 있습니다.

정규 표현식 자체는 “정규 언어가 아니므로 정규식으로 구문 분석 할 수 없습니다 …”

이것은 고전적인 정규식에 해당됩니다. 일부 현대 구현에서는 재귀를 허용 하므로이 작업에는 다소 장황하지만 문맥 자유 언어로 만듭니다.

일치하는 부분이 표시 []()/\됩니다. 다른 특수 정규식 문자. 비 특수 문자를 어디에서 허용합니까? 이것은 일치하는 것처럼 보이지만 ^(?:[\.]+)$그렇지 않습니다 ^abcdefg$. 유효한 정규식입니다.

[^?+*{}()[\]\\|]다른 구문의 일부가 아닌 단일 문자와 일치합니다. (이 두 문자 포함 a– z), 특정 특수 문자 ( ^, $, .).

답변

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; }
}

@preg_match($regexToTest, '');