Oniguruma Regular Expressions     2003/12/24

syntax: REG_SYNTAX_RUBY (default)


1. Syntax elements

  \       escape (enable or disable meta character meaning)
  |       alternation
  (...)   group
  [...]   character class  


2. Characters

  \t           horizontal tab (0x09)
  \v           vertical tab   (0x0B)
  \n           newline        (0x0A)
  \r           return         (0x0D)
  \b           back space     (0x08) (* in character class only)
  \f           form feed      (0x0C)
  \a           bell           (0x07)
  \e           escape         (0x1B)
  \nnn         octal char
  \xHH         hexadecimal char
  \x{7HHHHHHH} wide hexadecimal char
  \cx          control char
  \C-x         control char
  \M-x         meta  (x|0x80)  
  \M-\C-x      meta control char


3. Character types

  .        any character (except newline)
  \w       word character (alphanumeric, "_" and multibyte char)
  \W       non-word char
  \s       whitespace char (\t, \n, \v, \f, \r, \x20)
  \S       non-whitespace char
  \d       digit char
  \D       non-digit char


4. Quantifier

  greedy

    ?       1 or 0 times
    *       0 or more times
    +       1 or more times
    {n,m}   at least n but not more than m times  
    {n,}    at least n times
    {n}     n times

  reluctant

    ??      1 or 0 times
    *?      0 or more times
    +?      1 or more times
    {n,m}?  at least n but not more than m times  
    {n,}?   at least n times
    {n}?    n times (no meaning, but same as Perl)

  possessive (greedy and does not backtrack after repeated)

    ?+      1 or 0 times
    *+      0 or more times
    ++      1 or more times

    ({n,m}+, {n,}+, {n}+ are possesive operators in REG_SYNTAX_JAVA only)

    ex. /a*+/ === /(?>a*)/


5. Anchors

  ^       beginning of the line
  $       end of the line
  \b      word boundary
  \B      not word boundary
  \A      beginning of string
  \Z      end of string, or before newline at the end
  \z      end of string
  \G      previous end-of-match position


6. Character class

  [^...]  negative class (lowest precedence operator)
  x-y     range from x to y
  [...]   set (character class in character class)
  ..&&..  intersection (low precedence at the next of ^)
          
    ex. [a-w&&[^c-g]z] ==> ([a-w] and ([^c-g] or z)) ==> [abh-w]

  * If you want to use '[', '-', ']' as a normal character
     in a character class, you should escape these characters by '\'.


  POSIX bracket ([:xxxxx:], negate [:^xxxxx:])

    alnum    alphabet or digit char
    alpha    alphabet
    ascii    code value: [0 - 127]
    blank    \t, \x20
    cntrl
    digit    0-9
    graph
    lower
    print
    punct
    space    \t, \n, \v, \f, \r, \x20
    upper
    xdigit   0-9, a-f, A-F


7. Extended groups

  (?#...)            comment
  (?imx-imx)         option on/off
                         i: ignore case
                         m: multi-line (dot(.) match newline)
                         x: extended form
  (?imx-imx:subexp)  option on/off for subexp
  (?:subexp)         not captured group
  (subexp)           captured group
  (?=subexp)         look-ahead
  (?!subexp)         negative look-ahead
  (?<=subexp)        look-behind
  (?<!subexp)        negative look-behind

                     Subexp of look-behind must be fixed character length.
                     But different character length is allowed in top level
                     alternatives only.
                     ex. (?<=a|bc) is OK. (?<=aaa(?:b|cd)) is not allowed.

                     In negative-look-behind, captured group isn't allowed, 
                     but shy group(?:) is allowed.

  (?>subexp)         don't backtrack
  (?<name>subexp)    define named group
                     (characters of the name must be alphabet, digit or '_'.
                     And first character must not be a digit or uppper case)

                     Not only a name but a number is assigned like a captured
                     group.

                     Assigning the same name as two or more subexps is allowed.
                     In this case, a subexp call can not be performed although
                     the back reference is possible.


8. Back reference

  \n          back reference by group number (n >= 1)
  \k<name>    back reference by group name

  In the back reference by the multiplex definition name,
  a subexp with a large number is referred to preferentially.
  (When not matched, a group of the small number is referred to.)

  * Back reference by group number is forbidden if named group is defined 
    in the pattern and REG_OPTION_CAPTURE_GROUP is not setted.


9. Subexp call ("Tanaka Akira special")

  \g<name>    call by group name
  \g<n>       call by group number (n >= 1)

  * left-most recursive call is not allowed.
     ex. (?<name>a|\g<name>b)   => error
         (?<name>a|b\g<name>c)  => OK

  * Call by group number is forbidden if named group is defined in the pattern
    and REG_OPTION_CAPTURE_GROUP is not setted.

  * If the option status of called group is different from calling position
    then the group's option is effective.

    ex. (?-i:\g<name>)(?i:(?<name>a)){0}  match to "A"


10. Captured group

  Behavior of the no-named group changes with the following conditions.
  (But named group is captured always.)

  case 1. /.../     (named group is not used, no option)

     (...) is treated as a captured group.

  case 2. /.../g    (named group is not used, 'g' option)

     (...) is treated as a no-captured group (?:...).

  case 3. /..(?<name>..)../   (named group is used, no option)

     (...) is treated as a no-captured group (?:...).
     numbered-backref/call is not allowed.

  case 4. /..(?<name>..)../G  (named group is used, 'G' option)

     (...) is treated as a captured group.
     numbered-backref/call is allowed.

  where
    g: REG_OPTION_DONT_CAPTURE_GROUP
    G: REG_OPTION_CAPTURE_GROUP

  ('g' and 'G' options are argued in ruby-dev ML)

  These options are not implemented in Ruby level.


-----------------------------
A-1. Syntax depend options

   + REG_SYNTAX_RUBY
     (?m): dot(.) match newline

   + REG_SYNTAX_PERL and REG_SYNTAX_JAVA
     (?s): dot(.) match newline
     (?m): ^ match after newline, $ match before newline


A-2. Original extensions

   + named group     (?<name>...)
   + named backref   \k<name>
   + subexp call     \g<name>, \g<group-num>


A-3. Lacked features compare with perl 5.8.0

   + [:word:]
   + \N{name}
   + \l,\u,\L,\U, \p, \P, \X, \C
   + (?{code})
   + (??{code})
   + (?(condition)yes-pat|no-pat)

   + \Q...\E  (* But this is effective on REG_SYNTAX_PERL and REG_SYNTAX_JAVA)


A-4. Differences with Japanized GNU regex(version 0.12) of Ruby

   + add look-behind
     (?<=fixed-char-length-pattern), (?<!fixed-char-length-pattern)
   + add possessive quantifier. ?+, *+, ++
   + add operations in character class. [], &&
     ('[' must be escaped as an usual char in character class.)
   + add named group and subexp call.
   + octal or hexadecimal number sequence can be treated as 
     a multibyte code char in character class if multibyte encoding
     is specified.
     (ex. [\xa1\xa2], [\xa1\xa7-\xa4\xa1])
   + effect range of isolated option is to next ')'.
     ex. (?:(?i)a|b) is interpreted as (?:(?i:a|b)), not (?:(?i:a)|b).
   + isolated option is not transparent to previous pattern.
     ex. a(?i)* is a syntax error pattern.
   + allowed incompleted left brace as an usual string.
     ex. /{/, /({)/, /a{2,3/ etc...
   + negative POSIX bracket [:^xxxx:] is supported.
   + POSIX bracket [:ascii:] is added.
   + repeat of look-ahead is not allowed.
     ex. /(?=a)*/, /(?!b){5}/
   + Ignore case option is effective to numbered character.
     ex. /\x61/i =~ "A"


A-5. Disabled functions by default syntax

   + capture history

     (?@...) and (?@<name>...)

     ex. /(?@a)*/.match("aaa") ==> [<0-1>, <1-2>, <2-3>]

     see sample/listcap.c


A-6. Problems

   + Invalid first byte as a character in UTF-8 is allowed.
     (which is the same as GNU regex of Ruby)

       /./u =~ "\xa3"

     Although it is possible to validate,
     it will become slower than now.


   + Character type of multibyte encoded character is not correct.

     All multibyte encoded characters are treated as word(\w) character.
     But in UTF-8, only the multibyte character in code point
     [U+0080 - U+00FF] is correctly judged in a character type.


   + Zero-length match in infinite repeat stops the repeat,
     then change of captured group status isn't checked as stop condition.

       /()*\1/ =~ ""            #=> match
       /(?:()|())*\1\2/ =~ ""   #=> fail

       /(?:\1a|())*/ =~ "a"     #=> match with ""

// END
