regextest 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 530438fd0ca372511d5dcc1154e0bbabe06a66d3
+  data.tar.gz: 90c8e3a8d8786a269f770817fcb864ab63e1536b
+SHA512:
+  metadata.gz: 138de62d533d4c0040edf228901cee008f92e1ad50c94a7527c8de57f09c450b4b7397851ccac3af353fc64ddca1a694415b196bbacb3fe7ded4a4c68cdeaaa9
+  data.tar.gz: ecee2e7b6994a1feaa151ad9976481721a44a7545a520f7f0f87430dee6f942c56765cda93110011873e198a5c21680ff7b5befe940a0ab2313d068d22163b8a

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/work/
+/*.gem

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.0.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in regextest.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,25 @@
+Copyright (c) 2016, Mikio Ikoma. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without 
+modification, are permitted provided that the following conditions 
+are met:
+
+1. Redistributions of source code must retain the above copyright 
+notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright 
+notice, this list of conditions and the following disclaimer in the 
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
+FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
+COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 
+ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,88 @@
+# Regextest
+Regextest generates sample string that matches with regular expression. Unlike similar tools, it recognizes anchors, charactor classes and other advanced notation of ruby regex. Target users are programmers or students for debugging/learning regular expression.
+
+## Installation
+
+You can use [sample application](https://regtestweb.herokuapp.com/test_data/home) without installation. For using at your local machine, add this line to your application's Gemfile:
+
+```ruby
+gem 'regextest'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install regextest
+
+
+## Usage
+
+```ruby
+require "regextest"
+
+/\d{5}/.sample                   #=> "62853"
+5.times.map{/\w{5}/.sample}      #=> ["mCcA5", "1s3Ae", "9HYbe", "x3T0A", "TJHlQ"]
+/(?<=pre)body(?=post)/.sample    #=> "prebodypost"
+/(?=[a-z])\w{5}(?<=_\d)/.sample  #=> "nCc_0"
+
+/(?<=pre)body(?=post)/.match_data        #=> #<MatchData "body">
+
+palindrome = /\A(?<a>|.|(?:(?<b>.)\g<a>\k<b+0>))\z/
+palindrome.sample                #=> "a]r\\CC\\r]a"
+palindrome.match_data            #=> #<MatchData "z2#2z" a:"z2#2z" b:"2">
+```
+
+## Parameters (environment variables)
+- **REGEXTEST_DEBUG**
+    - Specify "1" to print verbose debugging information
+- **REGEXTEST_MAX_RETRY**
+    - Retry count for generation. 5 retry by default.
+- **REGEXTEST_MAX_REPEAT**
+    - Maximum repeat of element when * or + specified. Default value is 32.
+- **REGEXTEST_MAX_RECURSION**
+    - Maximum nest of \g<..>. Default value is 32.
+- **REGEXTEST_UNICODE_CHAR_SET**
+    - Whole character set at unicode mode. Specify unicode char-set names joined with "|". Default value is 'ascii|katakana|hiragana'
+- **REGEXTEST_TIMEOUT**
+    - Specify timeout second for verifying generated string (by ruby regexp). Default value is 1 second. Note no timeout detected for generating string. It can be used for fuzzering.
+
+
+## Exceptions
+- **Regextest::RegextestError**
+    - Impossible to generate string. It is sub-class of standard exception RuntimeError. 
+- **Regextest::RegextestFailedToGenerate**
+    - Failed to generate string. It is sub-class of standard exception RuntimeError. In many cases, caused by Regextest's restriction)
+- **RuntimeError**
+    - Bug of Regextest
+- **Regextest::RegextestTimeout**
+    - Timeout (default is 1 sec) detected while verification. It is sub-class of standard exception RuntimeError. For ignoring verification, you can use sample method with 'verification: false' option.
+
+```ruby
+  require "regextest"
+  /(1|11){100}$/.sample                       #=> raise Regextest::Common::RegextestTimeout: ...
+  /(1|11){100}$/.sample(verification: false)  #=> '11111111...'
+```
+
+## Development
+
+  Visit [git repository](https://bitbucket.org/ikomamik/regextest/src) for developing
+
+## Contributing
+
+1. Fork it ( https://bitbucket.org/ikomamik/regextest/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+## Major Bugs/Restrictions
+1. Insufficient support of unicode classes
+2. Too slow to process regex contains "Han" class
+3. Limited support of possesive repeat
+4. Limited support of grapheme cluster (\R or \X)
+
+See [issues tracker](https://bitbucket.org/ikomamik/regextest/issues?status=new&status=open) for more detail. 
+

data/Rakefile

@@ -0,0 +1,55 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+# task :default => :spec
+
+task :default => [:make, :spec]
+
+# Generating parser
+file 'lib/regextest/front/parser.rb' => 'lib/regextest/front/parser.y' do
+  puts 'making regextest/front/parser.rb'
+  sh 'racc lib/regextest/front/parser.y -o lib/regextest/front/parser.rb'
+end
+
+# Generating bracket parser
+file 'lib/regextest/front/bracket-parser.rb' => 'lib/regextest/front/bracket-parser.y' do
+  puts 'making regextest/front/bracket-parser.rb'
+  sh 'racc lib/regextest/front/bracket-parser.y -o lib/regextest/front/bracket-parser.rb'
+end
+
+# Generating Unicode parser
+file 'lib/regextest/front/unicode.rb' => 'lib/pre-unicode.rb' do
+  puts "making regextest/front/unicode.rb"
+  sh 'ruby  lib/pre-unicode.rb'
+end
+
+# Generating case-folding mapping
+file 'lib/regextest/front/case-folding.rb' => 'lib/pre-case-folding.rb' do
+  puts "making regextest/front/case-folding.rb"
+  sh 'ruby  lib/pre-case-folding.rb'
+end
+
+# Generating documents
+file 'doc/index.html' => ['lib/regextest.rb', 'lib/regextest/regexp.rb', 'README.md'] do
+  puts "making document for Regextest"
+  sh 'yardoc lib/regextest.rb lib/regextest/regexp.rb'
+end
+
+task :make =>
+        ['lib/regextest/front/parser.rb',
+         'lib/regextest/front/bracket-parser.rb',
+         'lib/regextest/front/unicode.rb',
+         'lib/regextest/front/case-folding.rb',
+         'doc/index.html',
+        ] do 
+  puts "Rake it!"
+end
+
+task :test => :make do 
+  puts "Test it!"
+  sh 'ruby test.rb'
+end
+
+

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "regextest"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/regextest

@@ -0,0 +1,4 @@
+#!/usr/bin/ruby
+ENV['RUBYLIB'] = "../lib"   # File.dirname(__FILE__)
+command = 'ruby "${RUBYLIB}/regextest.rb" ' + $*.map{|e| e.inspect}.join(" ")
+system command

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/contrib/Onigmo/RE.txt

@@ -0,0 +1,522 @@
+Onigmo (Oniguruma-mod) Regular Expressions Version 5.13.0    2012/01/19
+
+syntax: ONIG_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)
+  \f           form feed      (0x0C)
+  \a           bell           (0x07)
+  \e           escape         (0x1B)
+  \nnn         octal char            (encoded byte value)
+  \xHH         hexadecimal char      (encoded byte value)
+  \x{7HHHHHHH} wide hexadecimal char (character code point value)
+  \cx          control char          (character code point value)
+  \C-x         control char          (character code point value)
+  \M-x         meta  (x|0x80)        (character code point value)
+  \M-\C-x      meta control char     (character code point value)
+
+ (* \b is effective in character class [...] only)
+
+
+3. Character types
+
+  .        any character (except newline)
+
+  \w       word character
+
+           Not Unicode:
+             alphanumeric and "_".
+
+           Unicode:
+             General_Category -- (Letter|Mark|Number|Connector_Punctuation)
+
+           It depends on ONIG_OPTION_ASCII_RANGE option that non-ASCII char
+           includes or not.
+
+  \W       non word char
+
+  \s       whitespace char
+
+           Not Unicode:
+             \t, \n, \v, \f, \r, \x20
+
+           Unicode:
+             0009, 000A, 000B, 000C, 000D, 0085(NEL),
+             General_Category -- Line_Separator
+                              -- Paragraph_Separator
+                              -- Space_Separator
+
+           It depends on ONIG_OPTION_ASCII_RANGE option that non-ASCII char
+           includes or not.
+
+  \S       non whitespace char
+
+  \d       decimal digit char
+
+           Unicode: General_Category -- Decimal_Number
+
+           It depends on ONIG_OPTION_ASCII_RANGE option that non-ASCII char
+           includes or not.
+
+  \D       non decimal digit char
+
+  \h       hexadecimal digit char   [0-9a-fA-F]
+
+  \H       non hexadecimal digit char
+
+
+  Character Property
+
+    * \p{property-name}
+    * \p{^property-name}    (negative)
+    * \P{property-name}     (negative)
+
+    property-name:
+
+     + works on all encodings
+       Alnum, Alpha, Blank, Cntrl, Digit, Graph, Lower,
+       Print, Punct, Space, Upper, XDigit, Word, ASCII,
+
+     + works on EUC_JP, Shift_JIS, CP932
+       Hiragana, Katakana, Han, Latin, Greek, Cyrillic
+
+     + works on UTF8, UTF16, UTF32
+       see UnicodeProps.txt
+
+
+  \R       Linebreak
+
+           Unicode:
+             (?>\x0D\x0A|[\x0A-\x0D\x{85}\x{2028}\x{2029}])
+
+           Not Unicode:
+             (?>\x0D\x0A|[\x0A-\x0D])
+
+  \X       eXtended grapheme cluster
+
+           Unicode:
+             (?>\P{M}\p{M}*)
+
+           Not Unicode:
+             (?m:.)
+
+
+
+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}    at least 0 but not more than n times ({0,n})
+    {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}?   at least 0 but not more than n times (== {0,n}?)
+
+  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 possessive op. in ONIG_SYNTAX_JAVA and
+    ONIG_SYNTAX_PERL 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      matching start 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:])
+
+    Not Unicode Case:
+
+      alnum    alphabet or digit char
+      alpha    alphabet
+      ascii    code value: [0 - 127]
+      blank    \t, \x20
+      cntrl
+      digit    0-9
+      graph    \x21-\x7E and all of multibyte encoded characters
+      lower
+      print    \x20-\x7E and all of multibyte encoded characters
+      punct
+      space    \t, \n, \v, \f, \r, \x20
+      upper
+      xdigit   0-9, a-f, A-F
+      word     alphanumeric, "_" and multibyte characters
+
+
+    Unicode Case:
+
+      alnum    Letter | Mark | Decimal_Number
+      alpha    Letter | Mark
+      ascii    0000 - 007F
+      blank    Space_Separator | 0009
+      cntrl    Control | Format | Unassigned | Private_Use | Surrogate
+      digit    Decimal_Number
+      graph    [[:^space:]] && ^Control && ^Unassigned && ^Surrogate
+      lower    Lowercase_Letter
+      print    [[:graph:]] | Space_Separator
+      punct    Connector_Punctuation | Dash_Punctuation | Close_Punctuation |
+               Final_Punctuation | Initial_Punctuation | Other_Punctuation |
+               Open_Punctuation
+      space    Space_Separator | Line_Separator | Paragraph_Separator |
+               0009 | 000A | 000B | 000C | 000D | 0085
+      upper    Uppercase_Letter
+      xdigit   0030 - 0039 | 0041 - 0046 | 0061 - 0066
+               (0-9, a-f, A-F)
+      word     Letter | Mark | Decimal_Number | Connector_Punctuation
+
+
+    It depends on ONIG_OPTION_ASCII_RANGE option and
+    ONIG_OPTION_POSIX_BRACKET_ALL_RANGE option that POSIX brackets
+    match non-ASCII char or not.
+
+
+
+7. Extended groups
+
+  (?#...)            comment
+
+  (?imxdau-imx)      option on/off
+                         i: ignore case
+                         m: multi-line (dot(.) match newline)
+                         x: extended form
+
+                       character set option (character range option)
+                         d: Default (compatible with Ruby 1.9.3)
+                            \w, \d and \s doesn't match non-ASCII characters.
+                            \b, \B and POSIX brackets use the each encoding's
+                            rules.
+                         a: ASCII
+                            ONIG_OPTION_ASCII_RANGE option is turned on.
+                            \w, \d, \s and POSIX brackets doesn't match
+                            non-ASCII characters.
+                            \b and \B use the ASCII rules.
+                         u: Unicode
+                            ONIG_OPTION_ASCII_RANGE option is turned off.
+                            \w (\W), \d (\D), \s (\S), \b (\B) and POSIX
+                            brackets use the each encoding's rules.
+
+  (?imxdau-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.
+
+  \K                 keep
+                     Another expression of look-behind. Keep the stuff left
+                     of the \K, don't include it in the result.
+
+  (?>subexp)         atomic group
+                     don't backtrack in subexp.
+
+  (?<name>subexp), (?'name'subexp)
+                     define named group
+                     (All characters of the name must be a word character.)
+
+                     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.
+                     (ONIG_SYNTAX_PERL: a subexp call is allowed in this case.)
+
+  (?(cond)yes-subexp), (?(cond)yes-subexp|no-subexp)
+                    conditional expression
+                    Matches yes-subexp if (cond) yields a true value, matches
+                    no-subexp otherwise.
+                    Following (cond) can be used:
+
+                    (n)  (n >= 1)
+                        Checks if the numbered capturing group has matched
+                        something.
+
+                    (<name>), ('name')
+                        Checks if a group with the given name has matched
+                        something.
+
+
+8. Back reference
+
+  \n          back reference by group number (n >= 1)
+  \k<n>       back reference by group number (n >= 1)
+  \k'n'       back reference by group number (n >= 1)
+  \k<-n>      back reference by relative group number (n >= 1)
+  \k'-n'      back reference by relative group number (n >= 1)
+  \k<name>    back reference by group name
+  \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 ONIG_OPTION_CAPTURE_GROUP is not set.
+
+  * ONIG_SYNTAX_PERL: \g{n}, \g{-n} and \g{name} can also be used.
+
+
+  back reference with nest level
+
+    level: 0, 1, 2, ...
+
+    \k<n+level>     (n >= 1)
+    \k<n-level>     (n >= 1)
+    \k'n+level'     (n >= 1)
+    \k'n-level'     (n >= 1)
+    \k<-n+level>    (n >= 1)
+    \k<-n-level>    (n >= 1)
+    \k'-n+level'    (n >= 1)
+    \k'-n-level'    (n >= 1)
+
+    \k<name+level>
+    \k<name-level>
+    \k'name+level'
+    \k'name-level'
+
+    Destinate relative nest level from back reference position.
+
+    ex 1.
+
+      /\A(?<a>|.|(?:(?<b>.)\g<a>\k<b+0>))\z/.match("reer")
+
+    ex 2.
+
+      r = Regexp.compile(<<'__REGEXP__'.strip, Regexp::EXTENDED)
+      (?<element> \g<stag> \g<content>* \g<etag> ){0}
+      (?<stag> < \g<name> \s* > ){0}
+      (?<name> [a-zA-Z_:]+ ){0}
+      (?<content> [^<&]+ (\g<element> | [^<&]+)* ){0}
+      (?<etag> </ \k<name+1> >){0}
+      \g<element>
+      __REGEXP__
+
+      p r.match('<foo>f<bar>bbb</bar>f</foo>').captures
+
+
+
+9. Subexp call ("Tanaka Akira special")
+
+  \g<name>    call by group name
+  \g'name'    call by group name
+  \g<n>       call by group number (n >= 1)
+  \g'n'       call by group number (n >= 1)
+  \g<0>       call the whole pattern recursively
+  \g'0'       call the whole pattern recursively
+  \g<-n>      call by relative group number (n >= 1)
+  \g'-n'      call by relative group number (n >= 1)
+  \g<+n>      call by relative group number (n >= 1)
+  \g'+n'      call by relative 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 ONIG_OPTION_CAPTURE_GROUP is not set.
+
+  * 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"
+
+  * ONIG_SYNTAX_PERL: use (?&name), (?n), (?-n), (?+n), (?R) or (?0) instead.
+
+
+10. Captured group
+
+  Behavior of the no-named group (...) changes with the following conditions.
+  (But named group is not changed.)
+
+  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: ONIG_OPTION_DONT_CAPTURE_GROUP
+    G: ONIG_OPTION_CAPTURE_GROUP
+
+  ('g' and 'G' options are argued in ruby-dev ML)
+
+
+
+-----------------------------
+A-1. Syntax depend options
+
+   + ONIG_SYNTAX_RUBY
+     (?m): dot(.) match newline
+
+   + ONIG_SYNTAX_PERL, ONIG_SYNTAX_JAVA and ONIG_SYNTAX_PYTHON
+     (?s): dot(.) match newline
+     (?m): ^ match after newline, $ match before newline
+
+   + ONIG_SYNTAX_PERL
+     (?d), (?l): same as (?u)
+
+
+A-2. Original extensions
+
+   + hexadecimal digit char type  \h, \H
+   + named group                  (?<name>...), (?'name'...)
+   + named backref                \k<name>
+   + subexp call                  \g<name>, \g<group-num>
+
+
+A-3. Lacked features compare with perl 5.14.0
+
+   + \N{name}, \N{U+xxxx}, \N
+   + \l,\u,\L,\U, \C
+   + \v, \V, \h, \H, \o{xxx}
+   + (?{code})
+   + (??{code})
+   + (?|...)
+   + (*VERB:ARG)
+
+   * \Q...\E
+     This is effective on ONIG_SYNTAX_PERL and ONIG_SYNTAX_JAVA.
+
+
+A-4. Differences with Japanized GNU regex(version 0.12) of Ruby 1.8
+
+   + add character property (\p{property}, \P{property})
+   + add hexadecimal digit char type (\h, \H)
+   + 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])
+   + allow the range of single byte char and multibyte char in character
+     class.
+     ex. /[a-<<any EUC-JP character>>]/ in EUC-JP encoding.
+   + 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 incomplete 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"
+   + In the range quantifier, the number of the minimum is omissible.
+     /a{,n}/ == /a{0,n}/
+     The simultaneous abbreviation of the number of times of the minimum
+     and the maximum is not allowed. (/a{,}/)
+   + /a{n}?/ is not a non-greedy operator.
+     /a{n}?/ == /(?:a{n})?/
+   + invalid back reference is checked and cause error.
+     /\1/, /(a)\2/
+   + Zero-length match in infinite repeat stops the repeat,
+     then changes of the capture group status are checked as stop condition.
+     /(?:()|())*\1\2/ =~ ""
+     /(?:\1a|())*/ =~ "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 file.
+
+
+A-6. Problems
+
+   + Invalid encoding byte sequence is not checked.
+
+     ex. UTF-8
+
+     * Invalid first byte is treated as a character.
+       /./u =~ "\xa3"
+
+     * Incomplete byte sequence is not checked.
+       /\w+/ =~ "a\xf3\x8ec"
+
+// END