Annotation of embedaddon/pcre/testdata/testinput11, revision 1.1

1.1     ! misho       1: /-- These tests are for the Perl >= 5.10 features that PCRE supports. --/
        !             2: 
        !             3: /\H\h\V\v/
        !             4:     X X\x0a
        !             5:     X\x09X\x0b
        !             6:     ** Failers
        !             7:     \xa0 X\x0a   
        !             8:     
        !             9: /\H*\h+\V?\v{3,4}/ 
        !            10:     \x09\x20\xa0X\x0a\x0b\x0c\x0d\x0a
        !            11:     \x09\x20\xa0\x0a\x0b\x0c\x0d\x0a
        !            12:     \x09\x20\xa0\x0a\x0b\x0c
        !            13:     ** Failers 
        !            14:     \x09\x20\xa0\x0a\x0b
        !            15:      
        !            16: /\H{3,4}/
        !            17:     XY  ABCDE
        !            18:     XY  PQR ST 
        !            19:     
        !            20: /.\h{3,4}./
        !            21:     XY  AB    PQRS
        !            22: 
        !            23: /\h*X\h?\H+Y\H?Z/
        !            24:     >XNNNYZ
        !            25:     >  X NYQZ
        !            26:     ** Failers
        !            27:     >XYZ   
        !            28:     >  X NY Z
        !            29: 
        !            30: /\v*X\v?Y\v+Z\V*\x0a\V+\x0b\V{2,3}\x0c/
        !            31:     >XY\x0aZ\x0aA\x0bNN\x0c
        !            32:     >\x0a\x0dX\x0aY\x0a\x0bZZZ\x0aAAA\x0bNNN\x0c
        !            33: 
        !            34: /(foo)\Kbar/
        !            35:     foobar
        !            36:    
        !            37: /(foo)(\Kbar|baz)/
        !            38:     foobar
        !            39:     foobaz 
        !            40: 
        !            41: /(foo\Kbar)baz/
        !            42:     foobarbaz
        !            43: 
        !            44: /abc\K|def\K/g+
        !            45:     Xabcdefghi
        !            46: 
        !            47: /ab\Kc|de\Kf/g+
        !            48:     Xabcdefghi
        !            49:     
        !            50: /(?=C)/g+
        !            51:     ABCDECBA
        !            52:     
        !            53: /^abc\K/+
        !            54:     abcdef
        !            55:     ** Failers
        !            56:     defabcxyz   
        !            57: 
        !            58: /^(a(b))\1\g1\g{1}\g-1\g{-1}\g{-02}Z/
        !            59:     ababababbbabZXXXX
        !            60: 
        !            61: /(?<A>tom|bon)-\g{A}/
        !            62:     tom-tom
        !            63:     bon-bon 
        !            64:     
        !            65: /(^(a|b\g{-1}))/
        !            66:     bacxxx
        !            67: 
        !            68: /(?|(abc)|(xyz))\1/
        !            69:     abcabc
        !            70:     xyzxyz 
        !            71:     ** Failers
        !            72:     abcxyz
        !            73:     xyzabc   
        !            74:     
        !            75: /(?|(abc)|(xyz))(?1)/
        !            76:     abcabc
        !            77:     xyzabc 
        !            78:     ** Failers 
        !            79:     xyzxyz 
        !            80:  
        !            81: /^X(?5)(a)(?|(b)|(q))(c)(d)(Y)/
        !            82:     XYabcdY
        !            83: 
        !            84: /^X(?7)(a)(?|(b|(r)(s))|(q))(c)(d)(Y)/
        !            85:     XYabcdY
        !            86: 
        !            87: /^X(?7)(a)(?|(b|(?|(r)|(t))(s))|(q))(c)(d)(Y)/
        !            88:     XYabcdY
        !            89: 
        !            90: /(?'abc'\w+):\k<abc>{2}/
        !            91:     a:aaxyz
        !            92:     ab:ababxyz
        !            93:     ** Failers
        !            94:     a:axyz
        !            95:     ab:abxyz
        !            96: 
        !            97: /(?'abc'\w+):\g{abc}{2}/
        !            98:     a:aaxyz
        !            99:     ab:ababxyz
        !           100:     ** Failers
        !           101:     a:axyz
        !           102:     ab:abxyz
        !           103: 
        !           104: /^(?<ab>a)? (?(<ab>)b|c) (?('ab')d|e)/x
        !           105:     abd
        !           106:     ce
        !           107: 
        !           108: /^(a.)\g-1Z/
        !           109:     aXaXZ
        !           110: 
        !           111: /^(a.)\g{-1}Z/
        !           112:     aXaXZ
        !           113: 
        !           114: /^(?(DEFINE) (?<A> a) (?<B> b) )  (?&A) (?&B) /x
        !           115:     abcd
        !           116: 
        !           117: /(?<NAME>(?&NAME_PAT))\s+(?<ADDR>(?&ADDRESS_PAT))
        !           118:   (?(DEFINE)
        !           119:   (?<NAME_PAT>[a-z]+)
        !           120:   (?<ADDRESS_PAT>\d+)
        !           121:   )/x
        !           122:     metcalfe 33
        !           123: 
        !           124: /(?(DEFINE)(?<byte>2[0-4]\d|25[0-5]|1\d\d|[1-9]?\d))\b(?&byte)(\.(?&byte)){3}/
        !           125:     1.2.3.4
        !           126:     131.111.10.206
        !           127:     10.0.0.0
        !           128:     ** Failers
        !           129:     10.6
        !           130:     455.3.4.5
        !           131: 
        !           132: /\b(?&byte)(\.(?&byte)){3}(?(DEFINE)(?<byte>2[0-4]\d|25[0-5]|1\d\d|[1-9]?\d))/
        !           133:     1.2.3.4
        !           134:     131.111.10.206
        !           135:     10.0.0.0
        !           136:     ** Failers
        !           137:     10.6
        !           138:     455.3.4.5
        !           139: 
        !           140: /^(\w++|\s++)*$/
        !           141:     now is the time for all good men to come to the aid of the party
        !           142:     *** Failers
        !           143:     this is not a line with only words and spaces!
        !           144: 
        !           145: /(\d++)(\w)/
        !           146:     12345a
        !           147:     *** Failers
        !           148:     12345+
        !           149: 
        !           150: /a++b/
        !           151:     aaab
        !           152: 
        !           153: /(a++b)/
        !           154:     aaab
        !           155: 
        !           156: /(a++)b/
        !           157:     aaab
        !           158: 
        !           159: /([^()]++|\([^()]*\))+/
        !           160:     ((abc(ade)ufh()()x
        !           161: 
        !           162: /\(([^()]++|\([^()]+\))+\)/
        !           163:     (abc)
        !           164:     (abc(def)xyz)
        !           165:     *** Failers
        !           166:     ((()aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
        !           167: 
        !           168: /^([^()]|\((?1)*\))*$/
        !           169:     abc
        !           170:     a(b)c
        !           171:     a(b(c))d
        !           172:     *** Failers)
        !           173:     a(b(c)d
        !           174: 
        !           175: /^>abc>([^()]|\((?1)*\))*<xyz<$/
        !           176:    >abc>123<xyz<
        !           177:    >abc>1(2)3<xyz<
        !           178:    >abc>(1(2)3)<xyz<
        !           179: 
        !           180: /^(?:((.)(?1)\2|)|((.)(?3)\4|.))$/i
        !           181:     1221
        !           182:     Satanoscillatemymetallicsonatas
        !           183:     AmanaplanacanalPanama
        !           184:     AblewasIereIsawElba
        !           185:     *** Failers
        !           186:     Thequickbrownfox
        !           187: 
        !           188: /^(\d+|\((?1)([+*-])(?1)\)|-(?1))$/
        !           189:     12
        !           190:     (((2+2)*-3)-7)
        !           191:     -12
        !           192:     *** Failers
        !           193:     ((2+2)*-3)-7)
        !           194: 
        !           195: /^(x(y|(?1){2})z)/
        !           196:     xyz
        !           197:     xxyzxyzz
        !           198:     *** Failers
        !           199:     xxyzz
        !           200:     xxyzxyzxyzz
        !           201: 
        !           202: /((< (?: (?(R) \d++  | [^<>]*+) | (?2)) * >))/x
        !           203:     <>
        !           204:     <abcd>
        !           205:     <abc <123> hij>
        !           206:     <abc <def> hij>
        !           207:     <abc<>def>
        !           208:     <abc<>
        !           209:     *** Failers
        !           210:     <abc
        !           211: 
        !           212: /^a+(*FAIL)/
        !           213:     aaaaaa
        !           214:     
        !           215: /a+b?c+(*FAIL)/
        !           216:     aaabccc
        !           217: 
        !           218: /a+b?(*PRUNE)c+(*FAIL)/
        !           219:     aaabccc
        !           220: 
        !           221: /a+b?(*COMMIT)c+(*FAIL)/
        !           222:     aaabccc
        !           223:     
        !           224: /a+b?(*SKIP)c+(*FAIL)/
        !           225:     aaabcccaaabccc
        !           226: 
        !           227: /^(?:aaa(*THEN)\w{6}|bbb(*THEN)\w{5}|ccc(*THEN)\w{4}|\w{3})/
        !           228:     aaaxxxxxx
        !           229:     aaa++++++ 
        !           230:     bbbxxxxx
        !           231:     bbb+++++ 
        !           232:     cccxxxx
        !           233:     ccc++++ 
        !           234:     dddddddd   
        !           235: 
        !           236: /^(aaa(*THEN)\w{6}|bbb(*THEN)\w{5}|ccc(*THEN)\w{4}|\w{3})/
        !           237:     aaaxxxxxx
        !           238:     aaa++++++ 
        !           239:     bbbxxxxx
        !           240:     bbb+++++ 
        !           241:     cccxxxx
        !           242:     ccc++++ 
        !           243:     dddddddd   
        !           244: 
        !           245: /a+b?(*THEN)c+(*FAIL)/
        !           246:     aaabccc
        !           247: 
        !           248: /(A (A|B(*ACCEPT)|C) D)(E)/x
        !           249:     AB
        !           250:     ABX
        !           251:     AADE
        !           252:     ACDE
        !           253:     ** Failers
        !           254:     AD 
        !           255:         
        !           256: /^\W*+(?:((.)\W*+(?1)\W*+\2|)|((.)\W*+(?3)\W*+\4|\W*+.\W*+))\W*+$/i
        !           257:     1221
        !           258:     Satan, oscillate my metallic sonatas!
        !           259:     A man, a plan, a canal: Panama!
        !           260:     Able was I ere I saw Elba.
        !           261:     *** Failers
        !           262:     The quick brown fox
        !           263: 
        !           264: /^((.)(?1)\2|.)$/
        !           265:     a
        !           266:     aba
        !           267:     aabaa  
        !           268:     abcdcba 
        !           269:     pqaabaaqp  
        !           270:     ablewasiereisawelba
        !           271:     rhubarb
        !           272:     the quick brown fox  
        !           273: 
        !           274: /(a)(?<=b(?1))/
        !           275:     baz
        !           276:     ** Failers
        !           277:     caz  
        !           278:     
        !           279: /(?<=b(?1))(a)/
        !           280:     zbaaz
        !           281:     ** Failers
        !           282:     aaa  
        !           283:     
        !           284: /(?<X>a)(?<=b(?&X))/
        !           285:     baz
        !           286: 
        !           287: /^(?|(abc)|(def))\1/
        !           288:     abcabc
        !           289:     defdef 
        !           290:     ** Failers
        !           291:     abcdef
        !           292:     defabc   
        !           293:     
        !           294: /^(?|(abc)|(def))(?1)/
        !           295:     abcabc
        !           296:     defabc
        !           297:     ** Failers
        !           298:     defdef
        !           299:     abcdef    
        !           300: 
        !           301: /(?:a(?<quote> (?<apostrophe>')|(?<realquote>")) |b(?<quote> (?<apostrophe>')|(?<realquote>")) ) (?('quote')[a-z]+|[0-9]+)/xJ
        !           302:     a\"aaaaa
        !           303:     b\"aaaaa 
        !           304:     ** Failers 
        !           305:     b\"11111
        !           306: 
        !           307: /(?:(?1)|B)(A(*F)|C)/
        !           308:     ABCD
        !           309:     CCD
        !           310:     ** Failers
        !           311:     CAD   
        !           312: 
        !           313: /^(?:(?1)|B)(A(*F)|C)/
        !           314:     CCD
        !           315:     BCD 
        !           316:     ** Failers
        !           317:     ABCD
        !           318:     CAD
        !           319:     BAD    
        !           320: 
        !           321: /(?:(?1)|B)(A(*ACCEPT)XX|C)D/
        !           322:     AAD
        !           323:     ACD
        !           324:     BAD
        !           325:     BCD
        !           326:     BAX  
        !           327:     ** Failers
        !           328:     ACX
        !           329:     ABC   
        !           330: 
        !           331: /(?(DEFINE)(A))B(?1)C/
        !           332:     BAC
        !           333: 
        !           334: /(?(DEFINE)((A)\2))B(?1)C/
        !           335:     BAAC
        !           336: 
        !           337: /(?<pn> \( ( [^()]++ | (?&pn) )* \) )/x
        !           338:     (ab(cd)ef)
        !           339: 
        !           340: /^(?!a(*SKIP)b)/
        !           341:     ac
        !           342:     
        !           343: /^(?=a(*SKIP)b|ac)/
        !           344:     ** Failers
        !           345:     ac
        !           346:     
        !           347: /^(?=a(*THEN)b|ac)/
        !           348:     ac
        !           349:     
        !           350: /^(?=a(*PRUNE)b)/
        !           351:     ab  
        !           352:     ** Failers 
        !           353:     ac
        !           354: 
        !           355: /^(?=a(*ACCEPT)b)/
        !           356:     ac
        !           357: 
        !           358: /^(?(?!a(*SKIP)b))/
        !           359:     ac
        !           360: 
        !           361: /(?>a\Kb)/
        !           362:     ab
        !           363: 
        !           364: /((?>a\Kb))/
        !           365:     ab
        !           366: 
        !           367: /(a\Kb)/
        !           368:     ab
        !           369:     
        !           370: /^a\Kcz|ac/
        !           371:     ac
        !           372:     
        !           373: /(?>a\Kbz|ab)/
        !           374:     ab 
        !           375: 
        !           376: /^(?&t)(?(DEFINE)(?<t>a\Kb))$/
        !           377:     ab
        !           378: 
        !           379: /^([^()]|\((?1)*\))*$/
        !           380:     a(b)c
        !           381:     a(b(c)d)e 
        !           382: 
        !           383: /(?P<L1>(?P<L2>0)(?P>L1)|(?P>L2))/
        !           384:     0
        !           385:     00
        !           386:     0000  
        !           387: 
        !           388: /(?P<L1>(?P<L2>0)|(?P>L2)(?P>L1))/
        !           389:     0
        !           390:     00
        !           391:     0000  
        !           392: 
        !           393: /--- This one does fail, as expected, in Perl. It needs the complex item at the
        !           394:      end of the pattern. A single letter instead of (B|D) makes it not fail,
        !           395:      which I think is a Perl bug. --- /
        !           396: 
        !           397: /A(*COMMIT)(B|D)/
        !           398:     ACABX
        !           399: 
        !           400: /--- Check the use of names for failure ---/
        !           401: 
        !           402: /^(A(*PRUNE:A)B|C(*PRUNE:B)D)/K
        !           403:     ** Failers
        !           404:     AC
        !           405:     CB    
        !           406:     
        !           407: /--- Force no study, otherwise mark is not seen. The studied version is in
        !           408:      test 2 because it isn't Perl-compatible. ---/
        !           409: 
        !           410: /(*MARK:A)(*SKIP:B)(C|X)/KSS
        !           411:     C
        !           412:     D
        !           413:      
        !           414: /^(A(*THEN:A)B|C(*THEN:B)D)/K
        !           415:     ** Failers
        !           416:     CB    
        !           417: 
        !           418: /^(?:A(*THEN:A)B|C(*THEN:B)D)/K
        !           419:     CB    
        !           420:     
        !           421: /^(?>A(*THEN:A)B|C(*THEN:B)D)/K
        !           422:     CB    
        !           423:     
        !           424: /--- This should succeed, as the skip causes bump to offset 1 (the mark). Note
        !           425: that we have to have something complicated such as (B|Z) at the end because,
        !           426: for Perl, a simple character somehow causes an unwanted optimization to mess
        !           427: with the handling of backtracking verbs. ---/
        !           428: 
        !           429: /A(*MARK:A)A+(*SKIP:A)(B|Z) | AC/xK
        !           430:     AAAC
        !           431:     
        !           432: /--- Test skipping over a non-matching mark. ---/
        !           433: 
        !           434: /A(*MARK:A)A+(*MARK:B)(*SKIP:A)(B|Z) | AC/xK
        !           435:     AAAC
        !           436:     
        !           437: /--- Check shorthand for MARK ---/
        !           438: 
        !           439: /A(*:A)A+(*SKIP:A)(B|Z) | AC/xK
        !           440:     AAAC
        !           441: 
        !           442: /--- Don't loop! Force no study, otherwise mark is not seen. ---/
        !           443: 
        !           444: /(*:A)A+(*SKIP:A)(B|Z)/KSS
        !           445:     AAAC
        !           446: 
        !           447: /--- This should succeed, as a non-existent skip name disables the skip ---/ 
        !           448: 
        !           449: /A(*MARK:A)A+(*SKIP:B)(B|Z) | AC/xK
        !           450:     AAAC
        !           451: 
        !           452: /A(*MARK:A)A+(*SKIP:B)(B|Z) | AC(*:B)/xK
        !           453:     AAAC
        !           454: 
        !           455: /--- COMMIT at the start of a pattern should act like an anchor. Again, 
        !           456: however, we need the complication for Perl. ---/
        !           457: 
        !           458: /(*COMMIT)(A|P)(B|P)(C|P)/
        !           459:     ABCDEFG
        !           460:     ** Failers
        !           461:     DEFGABC  
        !           462: 
        !           463: /--- COMMIT inside an atomic group can't stop backtracking over the group. ---/
        !           464: 
        !           465: /(\w+)(?>b(*COMMIT))\w{2}/
        !           466:     abbb
        !           467: 
        !           468: /(\w+)b(*COMMIT)\w{2}/
        !           469:     abbb
        !           470: 
        !           471: /--- Check opening parens in comment when seeking forward reference. ---/ 
        !           472: 
        !           473: /(?&t)(?#()(?(DEFINE)(?<t>a))/
        !           474:     bac
        !           475: 
        !           476: /--- COMMIT should override THEN ---/
        !           477: 
        !           478: /(?>(*COMMIT)(?>yes|no)(*THEN)(*F))?/
        !           479:   yes
        !           480: 
        !           481: /(?>(*COMMIT)(yes|no)(*THEN)(*F))?/
        !           482:   yes
        !           483: 
        !           484: /b?(*SKIP)c/
        !           485:     bc
        !           486:     abc
        !           487:    
        !           488: /(*SKIP)bc/
        !           489:     a
        !           490: 
        !           491: /(*SKIP)b/
        !           492:     a 
        !           493: 
        !           494: /(?P<abn>(?P=abn)xxx|)+/
        !           495:     xxx
        !           496: 
        !           497: /(?i:([^b]))(?1)/
        !           498:     aa
        !           499:     aA     
        !           500:     ** Failers
        !           501:     ab
        !           502:     aB
        !           503:     Ba
        !           504:     ba
        !           505: 
        !           506: /^(?&t)*+(?(DEFINE)(?<t>a))\w$/
        !           507:     aaaaaaX
        !           508:     ** Failers 
        !           509:     aaaaaa 
        !           510: 
        !           511: /^(?&t)*(?(DEFINE)(?<t>a))\w$/
        !           512:     aaaaaaX
        !           513:     aaaaaa 
        !           514: 
        !           515: /^(a)*+(\w)/
        !           516:     aaaaX
        !           517:     YZ 
        !           518:     ** Failers 
        !           519:     aaaa
        !           520: 
        !           521: /^(?:a)*+(\w)/
        !           522:     aaaaX
        !           523:     YZ 
        !           524:     ** Failers 
        !           525:     aaaa
        !           526: 
        !           527: /^(a)++(\w)/
        !           528:     aaaaX
        !           529:     ** Failers 
        !           530:     aaaa
        !           531:     YZ 
        !           532: 
        !           533: /^(?:a)++(\w)/
        !           534:     aaaaX
        !           535:     ** Failers 
        !           536:     aaaa
        !           537:     YZ 
        !           538: 
        !           539: /^(a)?+(\w)/
        !           540:     aaaaX
        !           541:     YZ 
        !           542: 
        !           543: /^(?:a)?+(\w)/
        !           544:     aaaaX
        !           545:     YZ 
        !           546: 
        !           547: /^(a){2,}+(\w)/
        !           548:     aaaaX
        !           549:     ** Failers
        !           550:     aaa
        !           551:     YZ 
        !           552: 
        !           553: /^(?:a){2,}+(\w)/
        !           554:     aaaaX
        !           555:     ** Failers
        !           556:     aaa
        !           557:     YZ 
        !           558: 
        !           559: /(a|)*(?1)b/
        !           560:     b
        !           561:     ab
        !           562:     aab  
        !           563: 
        !           564: /(a)++(?1)b/
        !           565:     ** Failers
        !           566:     ab 
        !           567:     aab
        !           568: 
        !           569: /(a)*+(?1)b/
        !           570:     ** Failers
        !           571:     ab
        !           572:     aab  
        !           573: 
        !           574: /(?1)(?:(b)){0}/
        !           575:     b
        !           576: 
        !           577: /(foo ( \( ((?:(?> [^()]+ )|(?2))*) \) ) )/x
        !           578:     foo(bar(baz)+baz(bop))
        !           579: 
        !           580: /(A (A|B(*ACCEPT)|C) D)(E)/x
        !           581:     AB
        !           582: 
        !           583: /\A.*?(?:a|b(*THEN)c)/
        !           584:     ba
        !           585: 
        !           586: /\A.*?(?:a|bc)/
        !           587:     ba
        !           588: 
        !           589: /\A.*?(a|b(*THEN)c)/
        !           590:     ba
        !           591: 
        !           592: /\A.*?(a|bc)/
        !           593:     ba
        !           594: 
        !           595: /\A.*?(?:a|b(*THEN)c)++/
        !           596:     ba
        !           597: 
        !           598: /\A.*?(?:a|bc)++/
        !           599:     ba
        !           600: 
        !           601: /\A.*?(a|b(*THEN)c)++/
        !           602:     ba
        !           603: 
        !           604: /\A.*?(a|bc)++/
        !           605:     ba
        !           606: 
        !           607: /\A.*?(?:a|b(*THEN)c|d)/
        !           608:     ba
        !           609: 
        !           610: /\A.*?(?:a|bc|d)/
        !           611:     ba
        !           612: 
        !           613: /(?:(b))++/
        !           614:     beetle
        !           615: 
        !           616: /(?(?=(a(*ACCEPT)z))a)/
        !           617:     a
        !           618: 
        !           619: /^(a)(?1)+ab/
        !           620:     aaaab
        !           621:     
        !           622: /^(a)(?1)++ab/
        !           623:     aaaab
        !           624: 
        !           625: /^(?=a(*:M))aZ/K
        !           626:     aZbc
        !           627: 
        !           628: /^(?!(*:M)b)aZ/K
        !           629:     aZbc
        !           630: 
        !           631: /(?(DEFINE)(a))?b(?1)/
        !           632:     backgammon
        !           633: 
        !           634: /^\N+/
        !           635:     abc\ndef
        !           636:     
        !           637: /^\N{1,}/
        !           638:     abc\ndef 
        !           639: 
        !           640: /(?(R)a+|(?R)b)/
        !           641:     aaaabcde
        !           642: 
        !           643: /(?(R)a+|((?R))b)/
        !           644:     aaaabcde
        !           645: 
        !           646: /((?(R)a+|(?1)b))/
        !           647:     aaaabcde
        !           648: 
        !           649: /((?(R1)a+|(?1)b))/
        !           650:     aaaabcde
        !           651: 
        !           652: /a(*:any 
        !           653: name)/K
        !           654:     abc
        !           655:     
        !           656: /(?>(?&t)c|(?&t))(?(DEFINE)(?<t>a|b(*PRUNE)c))/
        !           657:     a
        !           658:     ba
        !           659:     bba 
        !           660:     
        !           661: /--- Checking revised (*THEN) handling ---/ 
        !           662: 
        !           663: /--- Capture ---/
        !           664: 
        !           665: /^.*? (a(*THEN)b) c/x
        !           666:     aabc
        !           667: 
        !           668: /^.*? (a(*THEN)b|(*F)) c/x
        !           669:     aabc
        !           670: 
        !           671: /^.*? ( (a(*THEN)b) | (*F) ) c/x
        !           672:     aabc
        !           673: 
        !           674: /^.*? ( (a(*THEN)b) ) c/x
        !           675:     aabc
        !           676: 
        !           677: /--- Non-capture ---/
        !           678: 
        !           679: /^.*? (?:a(*THEN)b) c/x
        !           680:     aabc
        !           681: 
        !           682: /^.*? (?:a(*THEN)b|(*F)) c/x
        !           683:     aabc
        !           684: 
        !           685: /^.*? (?: (?:a(*THEN)b) | (*F) ) c/x
        !           686:     aabc
        !           687: 
        !           688: /^.*? (?: (?:a(*THEN)b) ) c/x
        !           689:     aabc
        !           690: 
        !           691: /--- Atomic ---/
        !           692: 
        !           693: /^.*? (?>a(*THEN)b) c/x
        !           694:     aabc
        !           695: 
        !           696: /^.*? (?>a(*THEN)b|(*F)) c/x
        !           697:     aabc
        !           698: 
        !           699: /^.*? (?> (?>a(*THEN)b) | (*F) ) c/x
        !           700:     aabc
        !           701: 
        !           702: /^.*? (?> (?>a(*THEN)b) ) c/x
        !           703:     aabc
        !           704: 
        !           705: /--- Possessive capture ---/
        !           706: 
        !           707: /^.*? (a(*THEN)b)++ c/x
        !           708:     aabc
        !           709: 
        !           710: /^.*? (a(*THEN)b|(*F))++ c/x
        !           711:     aabc
        !           712: 
        !           713: /^.*? ( (a(*THEN)b)++ | (*F) )++ c/x
        !           714:     aabc
        !           715: 
        !           716: /^.*? ( (a(*THEN)b)++ )++ c/x
        !           717:     aabc
        !           718: 
        !           719: /--- Possessive non-capture ---/
        !           720: 
        !           721: /^.*? (?:a(*THEN)b)++ c/x
        !           722:     aabc
        !           723: 
        !           724: /^.*? (?:a(*THEN)b|(*F))++ c/x
        !           725:     aabc
        !           726: 
        !           727: /^.*? (?: (?:a(*THEN)b)++ | (*F) )++ c/x
        !           728:     aabc
        !           729: 
        !           730: /^.*? (?: (?:a(*THEN)b)++ )++ c/x
        !           731:     aabc
        !           732:     
        !           733: /--- Condition assertion ---/
        !           734: 
        !           735: /^(?(?=a(*THEN)b)ab|ac)/
        !           736:     ac
        !           737:  
        !           738: /--- Condition ---/
        !           739: 
        !           740: /^.*?(?(?=a)a|b(*THEN)c)/
        !           741:     ba
        !           742: 
        !           743: /^.*?(?:(?(?=a)a|b(*THEN)c)|d)/
        !           744:     ba
        !           745: 
        !           746: /^.*?(?(?=a)a(*THEN)b|c)/
        !           747:     ac
        !           748: 
        !           749: /--- Assertion ---/
        !           750: 
        !           751: /^.*(?=a(*THEN)b)/ 
        !           752:     aabc
        !           753: 
        !           754: /------------------------------/
        !           755: 
        !           756: /(?>a(*:m))/imsxSK 
        !           757:     a
        !           758: 
        !           759: /(?>(a)(*:m))/imsxSK 
        !           760:     a
        !           761: 
        !           762: /(?<=a(*ACCEPT)b)c/
        !           763:     xacd
        !           764: 
        !           765: /(?<=(a(*ACCEPT)b))c/
        !           766:     xacd
        !           767: 
        !           768: /(?<=(a(*COMMIT)b))c/
        !           769:     xabcd
        !           770:     ** Failers 
        !           771:     xacd
        !           772:     
        !           773: /(?<!a(*FAIL)b)c/
        !           774:     xcd
        !           775:     acd 
        !           776: 
        !           777: /(?<=a(*:N)b)c/K
        !           778:     xabcd
        !           779:     
        !           780: /(?<=a(*PRUNE)b)c/
        !           781:     xabcd 
        !           782: 
        !           783: /(?<=a(*SKIP)b)c/
        !           784:     xabcd 
        !           785: 
        !           786: /(?<=a(*THEN)b)c/
        !           787:     xabcd 
        !           788: 
        !           789: /(a)(?2){2}(.)/
        !           790:     abcd
        !           791: 
        !           792: /(*MARK:A)(*PRUNE:B)(C|X)/KS
        !           793:     C
        !           794:     D 
        !           795: 
        !           796: /(*MARK:A)(*PRUNE:B)(C|X)/KSS
        !           797:     C
        !           798:     D 
        !           799: 
        !           800: /(*MARK:A)(*THEN:B)(C|X)/KS
        !           801:     C
        !           802:     D 
        !           803: 
        !           804: /(*MARK:A)(*THEN:B)(C|X)/KSY
        !           805:     C
        !           806:     D 
        !           807: 
        !           808: /(*MARK:A)(*THEN:B)(C|X)/KSS
        !           809:     C
        !           810:     D 
        !           811: 
        !           812: /--- This should fail, as the skip causes a bump to offset 3 (the skip) ---/
        !           813: 
        !           814: /A(*MARK:A)A+(*SKIP)(B|Z) | AC/xK
        !           815:     AAAC
        !           816: 
        !           817: /--- Same --/
        !           818: 
        !           819: /A(*MARK:A)A+(*MARK:B)(*SKIP:B)(B|Z) | AC/xK
        !           820:     AAAC
        !           821: 
        !           822: /A(*:A)A+(*SKIP)(B|Z) | AC/xK
        !           823:     AAAC
        !           824: 
        !           825: /--- This should fail, as a null name is the same as no name ---/
        !           826: 
        !           827: /A(*MARK:A)A+(*SKIP:)(B|Z) | AC/xK
        !           828:     AAAC
        !           829: 
        !           830: /--- A check on what happens after hitting a mark and them bumping along to
        !           831: something that does not even start. Perl reports tags after the failures here, 
        !           832: though it does not when the individual letters are made into something 
        !           833: more complicated. ---/
        !           834: 
        !           835: /A(*:A)B|XX(*:B)Y/K
        !           836:     AABC
        !           837:     XXYZ 
        !           838:     ** Failers
        !           839:     XAQQ  
        !           840:     XAQQXZZ  
        !           841:     AXQQQ 
        !           842:     AXXQQQ 
        !           843:     
        !           844: /^(A(*THEN:A)B|C(*THEN:B)D)/K
        !           845:     AB
        !           846:     CD
        !           847:     ** Failers
        !           848:     AC
        !           849:     CB    
        !           850:     
        !           851: /^(A(*PRUNE:A)B|C(*PRUNE:B)D)/K
        !           852:     AB
        !           853:     CD
        !           854:     ** Failers
        !           855:     AC
        !           856:     CB    
        !           857:     
        !           858: /--- An empty name does not pass back an empty string. It is the same as if no
        !           859: name were given. ---/ 
        !           860: 
        !           861: /^(A(*PRUNE:)B|C(*PRUNE:B)D)/K
        !           862:     AB
        !           863:     CD 
        !           864: 
        !           865: /--- PRUNE goes to next bumpalong; COMMIT does not. ---/
        !           866:     
        !           867: /A(*PRUNE:A)B/K
        !           868:     ACAB
        !           869: 
        !           870: /--- Mark names can be duplicated ---/
        !           871: 
        !           872: /A(*:A)B|X(*:A)Y/K
        !           873:     AABC
        !           874:     XXYZ 
        !           875:     
        !           876: /b(*:m)f|a(*:n)w/K
        !           877:     aw 
        !           878:     ** Failers 
        !           879:     abc
        !           880: 
        !           881: /b(*:m)f|aw/K
        !           882:     abaw
        !           883:     ** Failers 
        !           884:     abc
        !           885:     abax 
        !           886: 
        !           887: /A(*MARK:A)A+(*SKIP:B)(B|Z) | AAC/xK
        !           888:     AAAC
        !           889: 
        !           890: /a(*PRUNE:X)bc|qq/KY
        !           891:     ** Failers
        !           892:     axy
        !           893: 
        !           894: /a(*THEN:X)bc|qq/KY
        !           895:     ** Failers
        !           896:     axy
        !           897: 
        !           898: /(?=a(*MARK:A)b)..x/K
        !           899:     abxy
        !           900:     ** Failers
        !           901:     abpq  
        !           902: 
        !           903: /(?=a(*MARK:A)b)..(*:Y)x/K
        !           904:     abxy
        !           905:     ** Failers
        !           906:     abpq  
        !           907: 
        !           908: /(?=a(*PRUNE:A)b)..x/K
        !           909:     abxy
        !           910:     ** Failers
        !           911:     abpq  
        !           912: 
        !           913: /(?=a(*PRUNE:A)b)..(*:Y)x/K
        !           914:     abxy
        !           915:     ** Failers
        !           916:     abpq  
        !           917: 
        !           918: /(?=a(*THEN:A)b)..x/K
        !           919:     abxy
        !           920:     ** Failers
        !           921:     abpq  
        !           922: 
        !           923: /(?=a(*THEN:A)b)..(*:Y)x/K
        !           924:     abxy
        !           925:     ** Failers
        !           926:     abpq  
        !           927: 
        !           928: /-- End of testinput11 --/

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>