ICU 56 update step 1

source/i18n/regexcst.txt

 
 #*****************************************************************************
 #
-#   Copyright (C) 2002-2007, International Business Machines Corporation and others.
+#   Copyright (C) 2002-2015, International Business Machines Corporation and others.
 #   All Rights Reserved.
 #
 #*****************************************************************************
 #
 #  file:  regexcst.txt
 #  ICU Regular Expression Parser State Table
 #
 #     This state table is used when reading and parsing a regular expression pattern
 #     The pattern parser uses a state machine; the data in this file define the
 #     state transitions that occur for each input character.
@@ skipping 125 matching lines @@
     'w'                     paren-flag                              doBeginMatchMode
     'x'                     paren-flag                              doBeginMatchMode
     '-'                     paren-flag                              doBeginMatchMode
     '('                  n  errorDeath                              doConditionalExpr
     '{'                  n  errorDeath                              doPerlInline
     default                 errorDeath                              doBadOpenParenType
 
 open-paren-lookbehind:
     '='                  n  term            ^expr-cont              doOpenLookBehind       #  (?<=
     '!'                  n  term            ^expr-cont              doOpenLookBehindNeg    #  (?<!
+    ascii_letter            named-capture                           doBeginNamedCapture    #  (?<name
     default                 errorDeath                              doBadOpenParenType
 
 
 #
 #   paren-comment    We've got a (?# ... )  style comment.  Eat pattern text till we get to the ')'
 #
 paren-comment:
     ')'                  n  pop
     eof                         errorDeath                              doMismatchedParenErr
     default              n  paren-comment
 
 #
 #  paren-flag    Scanned a (?ismx-ismx  flag setting
 #
 paren-flag:
     'i'                  n  paren-flag                              doMatchMode
     'd'                  n  paren-flag                              doMatchMode
     'm'                  n  paren-flag                              doMatchMode
     's'                  n  paren-flag                              doMatchMode
     'u'                  n  paren-flag                              doMatchMode
     'w'                  n  paren-flag                              doMatchMode
     'x'                  n  paren-flag                              doMatchMode
     '-'                  n  paren-flag                              doMatchMode
     ')'                  n  term                                    doSetMatchMode
     ':'                  n  term              ^expr-quant           doMatchModeParen
     default                 errorDeath                              doBadModeFlag
 
+#
+#  named-capture    (?<name> ... ), position currently on the name.
+#
+named-capture:
+    ascii_letter         n  named-capture                           doContinueNamedCapture
+    digit_char           n  named-capture                           doContinueNamedCapture
+    '>'                  n  term               ^expr-quant          doOpenCaptureParen      # common w non-named capture.
+    default                 errorDeath                              doBadNamedCapture
 
 #
 #  quant-star     Scanning a '*' quantifier.  Need to look ahead to decide
 #                 between plain '*', '*?', '*+'
 #
 quant-star:
      '?'                 n  expr-cont                               doNGStar               #  *?
      '+'                 n  expr-cont                               doPossessiveStar       #  *+
      default                expr-cont                               doStar
 
@@ skipping 47 matching lines @@
 #  backslash        #  Backslash.  Figure out which of the \thingies we have encountered.
 #                                  The low level next-char function will have preprocessed
 #                                  some of them already; those won't come here.
 backslash:
    'A'                   n  term                                    doBackslashA
    'B'                   n  term                                    doBackslashB
    'b'                   n  term                                    doBackslashb
    'd'                   n  expr-quant                              doBackslashd
    'D'                   n  expr-quant                              doBackslashD
    'G'                   n  term                                    doBackslashG
+   'h'                   n  expr-quant                              doBackslashh
+   'H'                   n  expr-quant                              doBackslashH
+   'k'                   n  named-backref
    'N'                      expr-quant                              doNamedChar      #   \N{NAME}  named char
    'p'                      expr-quant                              doProperty       #   \p{Lu}  style property
    'P'                      expr-quant                              doProperty
+   'R'                   n  expr-quant                              doBackslashR
    'Q'                   n  term                                    doEnterQuoteMode
    'S'                   n  expr-quant                              doBackslashS
    's'                   n  expr-quant                              doBackslashs
+   'v'                   n  expr-quant                              doBackslashv
+   'V'                   n  expr-quant                              doBackslashV
    'W'                   n  expr-quant                              doBackslashW
    'w'                   n  expr-quant                              doBackslashw
    'X'                   n  expr-quant                              doBackslashX
    'Z'                   n  term                                    doBackslashZ
    'z'                   n  term                                    doBackslashz
    digit_char            n  expr-quant                              doBackRef         #  Will scan multiple digits
    eof                      errorDeath                              doEscapeError
    default               n  expr-quant                              doEscapedLiteralChar
 
 
+# named-backref   Scanned \k
+#                 Leading to \k<captureName>
+#                 Failure to get the full sequence is an error.
+#
+named-backref:
+    '<'                  n  named-backref-2                         doBeginNamedBackRef
+    default                 errorDeath                              doBadNamedCapture
+
+named-backref-2:
+    ascii_letter         n  named-backref-3                         doContinueNamedBackRef
+    default                 errorDeath                              doBadNamedCapture
+
+named-backref-3:
+    ascii_letter         n  named-backref-3                         doContinueNamedBackRef
+    digit_char           n  named-backref-3                         doContinueNamedBackRef
+    '>'                  n  expr-quant                              doCompleteNamedBackRef
+    default                 errorDeath                              doBadNamedCapture
+
 
 #
 # [set expression] parsing,
 #    All states involved in parsing set expressions have names beginning with "set-"
 #
 
 set-open:
    '^'                   n  set-open2                               doSetNegate
    ':'                      set-posix                               doSetPosixProp
    default                  set-open2
@@ skipping 167 matching lines @@
 set-escape:
    'p'                      set-after-set                           doSetProp
    'P'                      set-after-set                           doSetProp
    'N'                      set-after-lit                           doSetNamedChar
    's'                   n  set-after-range                         doSetBackslash_s
    'S'                   n  set-after-range                         doSetBackslash_S
    'w'                   n  set-after-range                         doSetBackslash_w
    'W'                   n  set-after-range                         doSetBackslash_W
    'd'                   n  set-after-range                         doSetBackslash_d
    'D'                   n  set-after-range                         doSetBackslash_D
+   'h'                   n  set-after-range                         doSetBackslash_h
+   'H'                   n  set-after-range                         doSetBackslash_H
+   'v'                   n  set-after-range                         doSetBackslash_v
+   'V'                   n  set-after-range                         doSetBackslash_V
    default               n  set-after-lit                           doSetLiteralEscaped 
 
 #
 # set-finish
 #     Have just encountered the final ']' that completes a [set], and
 #     arrived here via a pop.  From here, we exit the set parsing world, and go
 #     back to generic regular expression parsing.
 #
 set-finish:
     default                 expr-quant                              doSetFinish
 
 
 #
 # errorDeath.   This state is specified as the next state whenever a syntax error
 #               in the source rules is detected.  Barring bugs, the state machine will never
 #               actually get here, but will stop because of the action associated with the error.
 #               But, just in case, this state asks the state machine to exit.
 errorDeath:
     default              n errorDeath                               doExit