Regexp-Common-2017060201/000755 000765 000024 00000000000 13114360502 015324 5ustar00abigailstaff000000 000000 Regexp-Common-2017060201/Changes000644 000765 000024 00000034110 13114356460 016626 0ustar00abigailstaff000000 000000 Version 2017060201 Fri Jun 2 23:48:32 CEST 2017 + Prepare for 5.26: don't rely on '.' being present in @INC when testing. Version 2016060801 Wed Jun 8 14:40:04 CEST 2016 + Removed the optional leading 0 from Australian postal codes -- use -lax to enable this feature. + Improved the patterns for Belgian, Danish, Greenlandic, Swiss, Italian, German, French, and Norwegian postal codes, only matching actual valid codes. This implies rewriting their tests from scratch. + Added patterns for postal codes for Liechtenstein, Luxembourg, Monaco, San Marino, and Vatican City. + 2315992 tests in 73 files. Version 2016060201 Thu Jun 2 02:58:35 CEST 2016 + Improved Australian zip code pattern; pattern matches current zip codes + Tests for Australian zip now use Test::Regexp. + Stop distributing author tests. + 522126 tests in 68 files. Version 2016060101 Wed Jun 1 00:34:17 CEST 2016 + We ceased to support pre-5.10.0 perls. + Fix warnings for older perls ($RE {delimited}) + Removed t/test_keep.t + Improved testing for square numbers. + Updated the Copyright notices to include the current year. + 481918 tests in 72 files. Version 2016053101 Tue May 31 00:16:57 CEST 2016 + Added a pattern for Austrian postal codes. (RT 53299) Version 2016053001 Mon May 30 14:12:17 CEST 2016 + No change at all, work around PAUSE issues. Version 2016052901 Sun May 29 22:46:42 CEST 2016 + Fix POD nit (RT 103850) + Don't run author only tests, unless AUTHOR_TESTING is set (RT 90600) + Added a 'strict' option to matching IPv4 addresses. (RT 93437) + 392978 tests in 71 files. Version 2016052804 Sat May 28 23:24:37 CEST 2016 + Fix issues with matching Roman numerals, where the pattern wasn't greedy enough. (RT 104353) + Allow Roman numerals to match sequences of 4 Is, Xs, Cs and Ms. This raises the maximum number to be matched to 4999 (MMMMCMXCIX) + POD nits (Debian Perl Group) + 387994 tests in 67 files. Version 2016052803 Sat May 28 12:24:06 CEST 2016 + POD nits (Debian Perl Group) + Eliminate the use of s///r (Slaven Rezix) + Require 5.014 for the 'bquote' pattern. Version 2016052802 Sat May 28 01:40:43 CEST 2016 + Document what is captured for the 'bquote' pattern. Version 2016052801 Sat May 28 00:40:22 CEST 2016 + When multiple delimiters are given, wrap the clauses inside a (?|). This makes that, under -keep, the used delimiters are always in $2 and $4, and the string between the delimiters is always in $3. A requirement on 5.10.0 is now in place for the 'delimited' and 'quoted' patterns. + The 'delimited' pattern now allows specifying closing delimiters which are different from the opening delimiters. + Added a 'bquoted' pattern, which is a shortcut for using the 'delimited' pattern with 85 mirror imaged bracketing constructs. + 248427 tests in 67 files. Version 2016020301 Wed Feb 3 20:00:13 CET 2016 + Fixed POD issue (Hernan Lopes) Version 2016010801 Fri Jan 8 12:52:36 CET 2016 + Use 'done_testing ()' instead of 'done_testing', so the test file compiles even if the user uses an old Test::More. Version 2016010701 Thu Jan 7 19:31:34 CET 2016 + Removed the 29143 tests from t/number/integer.t, and replaced them with 34689 spread over 7 new files. The reason is, there are sporadic failures reported by CPAN testers in the t/number/integer.t file, but this file uses the random number generator to generate tests. Which makes issues very hard to debug, as failures cannot be reproduced. The new tests will be deterministic. Version 2015121601 Wed Dec 16 01:12:18 CET 2015 + Force Darwin 10.0 on Perl 5.10.0 to run square tests in 32 bit mode. Version 2013031302 + Doc typo fixes (Jonathan You /RT 67549) and (Gregor Herrmann /RT 71131). Version 2013031301 Wed Mar 13 12:03:41 CET 2013 + Pattern for IPv6 addresses. Requested by Guy Edwards and many others. RT 50693. Version 2013031201 Tue Mar 12 15:44:48 CET 2013 + Allow host/domain names to start with a digit, using $RE{net}{domain}{-rfc1101}. Requested by Guy Edwards and many others. RT 23626. Version 2013031101 Mon Mar 11 21:02:45 CET 2013 + For integers and decimal numbers (reals), allow the user to specify the pattern of the signs (leading sign, and for reals, the sign of the exponent). This gives the user the option to ask for a pattern that matches unsigned numbers (by specifying the empty string as the pattern). Requested by "Wilson, Jonathan" . Version 2013030901 Sat Mar 9 14:51:42 CET 2013 + Use (?-1) instead of (??{ }) for the recursive balanced pattern. This makes the pattern unavailable for pre-5.010 perls. Version 2011121001 Sat Dec 10 21:32:49 CET 2011 + Fixed a few cases where $[ was used instead of $]. (RT 73033 by Father Chrysostomos ) + Typo fix in docs (P Ramakers ) + Add an explicite 1 to end the main module; otherwise it may fail under Mason (Luciano Rocha ) Version 2011041801 Mon Apr 18 11:18:19 CEST 2011 + Created tests for Pascal comments. + https schemes are now included in $RE {URI} + Document non-anchoring (RT 55549) + Fix POD typos (RT 67549 by Salvatore Bonaccorso ) Version 2011041701 Sun Apr 17 14:22:58 CEST 2011 + Fix documentation (matches should be match). Reported by cogent@cpan.org in RT ticket 2833. + Added patterns for JavaDoc comments. (RT 13174 by chris+rt@chrisdolan.net) Version 2011041602 Sat Apr 16 17:06:28 CEST 2011 + Fix typo in repository (avar@cpan.org) Version 2011041601 Sat Apr 16 16:07:29 CEST 2011 + Fix bugs 61712 & 6940: $RE {num} {decimal} and $RE {num} {real} no longer match a single dot. Version 2010010201 Sat Jan 2 17:45:53 CET 2010 + Playing the CPANTS game + Adjustments for 5.005. + Add $VERSION to all submodules (RT #53250) Version 2009123001 Wed Dec 30 03:58:27 2009 +0100 + Added Changes file, removed them from README. + Remove CVS traces. + Modernize Makefile.PL + POD tests + Work around a Darwin 9.0 on 5.8.8 issue. (RT #43786) + Fix POD issues. (RT #34886) (RT #48974) + Fail faster on some URI subpatterns (RT #52309) + Added many people to the Acknowledgements section. Version 2.122 + Added various licenses. Version 2.121 + Removed spurious '=head1' from README. (Smylers) + Comments for 'm4', 'Modula-2', 'Modula-3', 'Ubercode', and 'ZZT-OOP'. + Fix for French zip codes; added Swiss zip codes (Rafael) Version 2.120 Wed Mar 16 01:39:57 CET 2005 + '-base', and '-places' options for $RE {num} {int}. '-group' can now take arguments for the form 'N,M'. + New file: t/number/integer.t + Comments for BML, INTERCAL (JP), and CQL. + Regexp::Common::SEN nits. + Many more tests. + ca. 223k tests in 56 files. Version 2.119 Sat Jan 1 17:57:01 CET 2005 + Changed -keep settings of $RE {zip} {US}. + Replaced occurrences of '\d' with '[0-9]' in number.pm and net.pm, because with Unicode more characters than just 0 - 9 will match '\d'. + Moved part of the tests of t/test_comment.t into different files in t/comment. + t/Common.pm now also tests OO and sub versions. + Fixed regex for J comments. + $VERSION nit in Regexp::Common::URI::RFC2384 + POD nit in Regexp::Common::_support (Mike Castle) + POD nit in Regexp::Common::comment. + 176048 tests in 53 files. Version 2.118 Wed Dec 15 00:16:09 CET 2004 + Introduced Regexp::Common::_support. + Disabled the '-prefix' option for Danish zip codes if the Perl version is older than 5.005_03, as they triggered bugs. 5.005_03 and more recent versions of Perl don't have this problem. + Fixed the generic OO routines. (They never worked correctly). + 134191 tests in 49 files. Version 2.117 Thu Jul 1 12:11:47 CEST 2004 + Fixed problems with squares and 32bit integer Perls. + Pod nits in Regexp::Common (Jim Cromie) + $VERSION fix in Regexp::Common::URI::RFCC2384 (Mike Arms) + Discuss unwanted matching in Regexp::Common::net (Charles Thomas) + 132238 tests in 48 files. Version 2.116 Wed Jun 30 11:37:45 CEST 2004 + Restricted recognition of squares to numbers less than 9000000000000000, to avoid problems with round-off errors. + Fixed an off-by-one error in t/zip/spain.t which caused some test to fail when they shouldn't. + 132235 tests in 48 files. Version 2.115 Wed Jun 9 23:59:13 2004 + Patterns for comments of ABC, Caml, CLU, COBOL, ECMAScript, Icon, J, JavaScript, Lisp, M, MUMPS. + Patterns for postal codes of Norway, Italy and Spain. + Patterns for US SSN. + New way of doing tests using t::Common, giving more control to test program. + Random generators in t::Common. + Cut down on tests in test_lingua_palindrome.t. + Fixed bug in t/zip/australia.t could cause an infinite loop. + 132225 tests in 48 files. Version 2.114 Sun May 25 21:34:56 2003 + Fix to t/zip/greenland.t to avoid generating valid zipcodes when testing for failures. + Fixes to t/URI/gopher.t and t/URI/wais.t to avoid warnings. + Australian postal codes now accept '0909'. (Ron Savage) + Added comments for 'C--', 'C#', 'Cg', 'Nickle', 'PL/SQL', 'QML' and SLIDE. + Fixed the assignment of the version number to $VERSION in 6 classes. + 158287 tests in 44 files. + 134 patterns in 11 classes and 12 subclasses. Version 2.113 Wed Apr 2 22:58:46 2003 + INCOMPATIBLE CHANGE! Regexp::Common used to set $; to '='. This no longer happens, because setting $; breaks Filter::Simple. (Report by Tim Maher). This means that regexps of the form $RE{foo}{"-flag=value"} no longer work! They need to be written as $RE{foo}{"-flag$;value"} or as $RE{foo}{-flag => "value"}. When defining patterns using the pattern function, a = still needs to be used to separate the flag from its default value. This has not been changed. We are very sorry for the inconvenience. + 157762 tests in 44 files. + 127 patterns in 11 classes and 12 subclasses. Version 2.112 Wed Mar 26 00:25:04 2003 + prospero and pop URIs + Fixed documentation of Regexp::Common::lingua to document the lingua stuff instead of Regexp::Common::zip (Murat). + 157761 tests in 44 files. + 127 patterns in 11 classes and 12 subclasses. Version 2.111 Wed Mar 12 23:30:03 2003 + Introduced the -i switch. Important if you are using the functional interface and want to be able to match case insensitive. (Request from Tim Maher). + Introduced the -nospace switch for $RE{net}{domain} (Request from Juerd). + Decimal numbers. + WAIS URIs. + More generic setup to define comments for various languages. + Expanded and redid the documentation for comment.pm. + Comments for Advisor, Advsys, Alan, Algol 60, Algol 68, B, BASIC (mvEnterprise), Forth, Fortran (both fixed and free form), fvwm2, mutt, Oberon, 6 versions of Pascal, PEARL (one of the at least four...), PL/B, PL/I, slrn, Squeak. + 151114 tests in 42 files. + 125 patterns in 11 classes and 10 subclasses. Version 2.110 Fri Feb 21 15:58:14 2003 + Fixed t/test_squares.t. '0x7FFFFFFFFFFFFFFF' cannot be used on non-64bit platforms - eval to the rescue. + Added $VERSION to the .pm files who were missing them. + gopher, news, nntp URIs. + 145013 tests in 39 files. + 100 patterns in 11 classes and 9 subclasses. Version 2.109 Mon Feb 10 22:41:45 2003 + Split out URI.pm into a myriad of files. There is a separate file for each URI scheme, and a separate file for each RFC that's used. URI.pm requires all the URI scheme files, and constructs the combining URI regexp. + file URIs. + Cut down on the number of tests run for certain classes. + 123810 tests in 36 files. + 95 patterns in 11 classes and 7 subclasses. Version 2.108 Sun Feb 9 22:58:56 2003 + Postal codes for Belgium, Denmark and Greenland. + Renamed the postal code patterns. + 194125 tests in 35 files. + 94 patterns in 11 classes. Version 2.107 Fri Feb 7 23:20:35 2003 + telnet URIs; Lua and FPL comments. + common code factored out - created t/Common.pm + 175984 tests in 32 files. + 91 patterns in 11 classes. Version 2.106 Sun Feb 2 18:42:08 2003 + Makefile.PL fixes for Windows. Version 2.105 Sun Feb 2 04:15:54 2003 (In remembrance of the Columbia crew) + Australian postal codes. + Reorganized t/ directory by adding subdirectories. + 88 patterns in 11 classes. + 163355 tests in 31 files. Version 2.104 Fri Jan 24 16:44:19 2003 + Forgot to add t/test_zip_german.t and t/test_zip_french.t to the MANIFEST file. Version 2.103 Thu Jan 23 03:21:17 2003 + Added German and French postal codes. + Fixed some bugs concerning HTTP URIs. + Complete remake of t/test_uri_http, with 15k+ tests. Extended testing exposed the now fixed bugs. + 87 patterns in 11 classes. + 156778 tests in 30 files. Version 1.30 Fri Jan 17 14:20:02 2003 + Fixed a bug concerning HTTP and FTP URIs. (reported by Hermann-Marcus Behrens) Version 1.29 Thu Jan 16 12:07:02 2003 + New since last release: Squares, Roman numbers, TV URIs, Palindromes, Dutch and US postal codes. + 131710 tests in 28 files. + 11 pattern classes. Version 1.20 Tue Aug 27 19:06:13 CEST 2002 + Balanced patterns can now take multiple sets of arbitrary strings as delimiters. + Fax URIs. + More comment patterns. Version 0.09 Tue Aug 6 16:44:57 CEST 2002 + Fixed $RE{URI}{tel}, local phone numbers can have future extensions as well. Version 0.08 Tue Aug 6 15:50:31 CEST 2002 + Added tel URI regexes. Version 0.07 Mon Aug 5 14:31:17 CEST 2002 + Fixed 'Regex::' and 'Rexexp::' typos. + Split t/test_uris.t into t/test_ftp_uri.t, t/test_http_uri.t and t/test_uris.t. Version 0.06 Mon Aug 5 00:56:19 CEST 2002 + URI regexes. Currently only HTTP and FTP. More to come. Version 0.05 Thu Aug 1 12:01:04 CEST 2002 + Improved the 'subs' method of MAC addresses. Version 0.04 Thu Aug 1 01:18:37 CEST 2002 + Added the set of $RE{net}{MAC} regexes, by request of Iain Truskett . + Required minimum Perl version for regexes for Haskell and Dylan comment, as they can be recursive. + Petdance suggested regexes for LOGO comments. Version 0.03 Wed Jul 31 15:21:11 CEST 2002 + Made the entire setup more modular, giving each set of patterns its own .pm file. Loading all goes via Regexp::Common though. + use strict; everywhere - it also runs under -W (localized). + Added comment regexes for many more languages (26 currently). + Fixed some small bugs. Version 0.02 Tue Jul 23 23:18:15 2002 + Added $RE{comment}{HTML} Version 0.01 Thu May 18 14:45:14 2000 + original version; created by h2xs 1.18 Regexp-Common-2017060201/COPYRIGHT000644 000765 000024 00000000626 12736756277 016656 0ustar00abigailstaff000000 000000 This software is Copyright (c) 2001 - 2008, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. Regexp-Common-2017060201/COPYRIGHT.AL000644 000765 000024 00000011605 12116413566 017127 0ustar00abigailstaff000000 000000 The Artistic License Preamble The intent of this document is to state the conditions under which a Package may be copied, such that the Copyright Holder maintains some semblance of artistic control over the development of the package, while giving the users of the package the right to use and distribute the Package in a more-or-less customary fashion, plus the right to make reasonable modifications. Definitions: * "Package" refers to the collection of files distributed by the Copyright Holder, and derivatives of that collection of files created through textual modification. * "Standard Version" refers to such a Package if it has not been modified, or has been modified in accordance with the wishes of the Copyright Holder. * "Copyright Holder" is whoever is named in the copyright or copyrights for the package. * "You" is you, if you're thinking about copying or distributing this Package. * "Reasonable copying fee" is whatever you can justify on the basis of media cost, duplication charges, time of people involved, and so on. (You will not be required to justify it to the Copyright Holder, but only to the computing community at large as a market that must bear the fee.) * "Freely Available" means that no fee is charged for the item itself, though there may be fees involved in handling the item. It also means that recipients of the item may redistribute it under the same conditions they received it. 1. You may make and give away verbatim copies of the source form of the Standard Version of this Package without restriction, provided that you duplicate all of the original copyright notices and associated disclaimers. 2. You may apply bug fixes, portability fixes and other modifications derived from the Public Domain or from the Copyright Holder. A Package modified in such a way shall still be considered the Standard Version. 3. You may otherwise modify your copy of this Package in any way, provided that you insert a prominent notice in each changed file stating how and when you changed that file, and provided that you do at least ONE of the following: a) place your modifications in the Public Domain or otherwise make them Freely Available, such as by posting said modifications to Usenet or an equivalent medium, or placing the modifications on a major archive site such as ftp.uu.net, or by allowing the Copyright Holder to include your modifications in the Standard Version of the Package. b) use the modified Package only within your corporation or organization. c) rename any non-standard executables so the names do not conflict with standard executables, which must also be provided, and provide a separate manual page for each non-standard executable that clearly documents how it differs from the Standard Version. d) make other distribution arrangements with the Copyright Holder. 4. You may distribute the programs of this Package in object code or executable form, provided that you do at least ONE of the following: a) distribute a Standard Version of the executables and library files, together with instructions (in the manual page or equivalent) on where to get the Standard Version. b) accompany the distribution with the machine-readable source of the Package with your modifications. c) accompany any non-standard executables with their corresponding Standard Version executables, giving the non-standard executables non-standard names, and clearly documenting the differences in manual pages (or equivalent), together with instructions on where to get the Standard Version. d) make other distribution arrangements with the Copyright Holder. 5. You may charge a reasonable copying fee for any distribution of this Package. You may charge any fee you choose for support of this Package. You may not charge a fee for this Package itself. However, you may distribute this Package in aggregate with other (possibly commercial) programs as part of a larger (possibly commercial) software distribution provided that you do not advertise this Package as a product of your own. 6. The scripts and library files supplied as input to or produced as output from the programs of this Package do not automatically fall under the copyright of this Package, but belong to whomever generated them, and may be sold commercially, and may be aggregated with this Package. 7. C or perl subroutines supplied by you and linked into this Package shall not be considered part of this Package. 8. The name of the Copyright Holder may not be used to endorse or promote products derived from this software without specific prior written permission. 9. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. The End Regexp-Common-2017060201/COPYRIGHT.AL2000644 000765 000024 00000021004 12116413566 017203 0ustar00abigailstaff000000 000000 Artistic License 2.0 Copyright (c) 2000-2006, The Perl Foundation. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble This license establishes the terms under which a given free software Package may be copied, modified, distributed, and/or redistributed. The intent is that the Copyright Holder maintains some artistic control over the development of that Package while still keeping the Package available as open source and free software. You are always permitted to make arrangements wholly outside of this license directly with the Copyright Holder of a given Package. If the terms of this license do not permit the full use that you propose to make of the Package, you should contact the Copyright Holder and seek a different licensing arrangement. Definitions "Copyright Holder" means the individual(s) or organization(s) named in the copyright notice for the entire Package. "Contributor" means any party that has contributed code or other material to the Package, in accordance with the Copyright Holder's procedures. "You" and "your" means any person who would like to copy, distribute, or modify the Package. "Package" means the collection of files distributed by the Copyright Holder, and derivatives of that collection and/or of those files. A given Package may consist of either the Standard Version, or a Modified Version. "Distribute" means providing a copy of the Package or making it accessible to anyone else, or in the case of a company or organization, to others outside of your company or organization. "Distributor Fee" means any fee that you charge for Distributing this Package or providing support for this Package to another party. It does not mean licensing fees. "Standard Version" refers to the Package if it has not been modified, or has been modified only in ways explicitly requested by the Copyright Holder. "Modified Version" means the Package, if it has been changed, and such changes were not explicitly requested by the Copyright Holder. "Original License" means this Artistic License as Distributed with the Standard Version of the Package, in its current version or as it may be modified by The Perl Foundation in the future. "Source" form means the source code, documentation source, and configuration files for the Package. "Compiled" form means the compiled bytecode, object code, binary, or any other form resulting from mechanical transformation or translation of the Source form. Permission for Use and Modification Without Distribution (1) You are permitted to use the Standard Version and create and use Modified Versions for any purpose without restriction, provided that you do not Distribute the Modified Version. Permissions for Redistribution of the Standard Version (2) You may Distribute verbatim copies of the Source form of the Standard Version of this Package in any medium without restriction, either gratis or for a Distributor Fee, provided that you duplicate all of the original copyright notices and associated disclaimers. At your discretion, such verbatim copies may or may not include a Compiled form of the Package. (3) You may apply any bug fixes, portability changes, and other modifications made available from the Copyright Holder. The resulting Package will still be considered the Standard Version, and as such will be subject to the Original License. Distribution of Modified Versions of the Package as Source (4) You may Distribute your Modified Version as Source (either gratis or for a Distributor Fee, and with or without a Compiled form of the Modified Version) provided that you clearly document how it differs from the Standard Version, including, but not limited to, documenting any non-standard features, executables, or modules, and provided that you do at least ONE of the following: (a) make the Modified Version available to the Copyright Holder of the Standard Version, under the Original License, so that the Copyright Holder may include your modifications in the Standard Version. (b) ensure that installation of your Modified Version does not prevent the user installing or running the Standard Version. In addition, the Modified Version must bear a name that is different from the name of the Standard Version. (c) allow anyone who receives a copy of the Modified Version to make the Source form of the Modified Version available to others under (i) the Original License or (ii) a license that permits the licensee to freely copy, modify and redistribute the Modified Version using the same licensing terms that apply to the copy that the licensee received, and requires that the Source form of the Modified Version, and of any works derived from it, be made freely available in that license fees are prohibited but Distributor Fees are allowed. Distribution of Compiled Forms of the Standard Version or Modified Versions without the Source (5) You may Distribute Compiled forms of the Standard Version without the Source, provided that you include complete instructions on how to get the Source of the Standard Version. Such instructions must be valid at the time of your distribution. If these instructions, at any time while you are carrying out such distribution, become invalid, you must provide new instructions on demand or cease further distribution. If you provide valid instructions or cease distribution within thirty days after you become aware that the instructions are invalid, then you do not forfeit any of your rights under this license. (6) You may Distribute a Modified Version in Compiled form without the Source, provided that you comply with Section 4 with respect to the Source of the Modified Version. Aggregating or Linking the Package (7) You may aggregate the Package (either the Standard Version or Modified Version) with other packages and Distribute the resulting aggregation provided that you do not charge a licensing fee for the Package. Distributor Fees are permitted, and licensing fees for other components in the aggregation are permitted. The terms of this license apply to the use and Distribution of the Standard or Modified Versions as included in the aggregation. (8) You are permitted to link Modified and Standard Versions with other works, to embed the Package in a larger work of your own, or to build stand-alone binary or bytecode versions of applications that include the Package, and Distribute the result without restriction, provided the result does not expose a direct interface to the Package. Items That are Not Considered Part of a Modified Version (9) Works (including, but not limited to, modules and scripts) that merely extend or make use of the Package, do not, by themselves, cause the Package to be a Modified Version. In addition, such works are not considered parts of the Package itself, and are not subject to the terms of this license. General Provisions (10) Any use, modification, and distribution of the Standard or Modified Versions is governed by this Artistic License. By using, modifying or distributing the Package, you accept this license. Do not use, modify, or distribute the Package, if you do not accept this license. (11) If your Modified Version has been derived from a Modified Version made by someone other than you, you are nevertheless required to ensure that your Modified Version complies with the requirements of this license. (12) This license does not grant you the right to use any trademark, service mark, tradename, or logo of the Copyright Holder. (13) This license includes the non-exclusive, worldwide, free-of-charge patent license to make, have made, use, offer to sell, sell, import and otherwise transfer the Package with respect to any patent claims licensable by the Copyright Holder that are necessarily infringed by the Package. If you institute patent litigation (including a cross-claim or counterclaim) against any party alleging that the Package constitutes direct or contributory patent infringement, then this Artistic License to you shall terminate on the date that such litigation is filed. (14) Disclaimer of Warranty: THE PACKAGE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS IS' AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES. THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT ARE DISCLAIMED TO THE EXTENT PERMITTED BY YOUR LOCAL LAW. UNLESS REQUIRED BY LAW, NO COPYRIGHT HOLDER OR CONTRIBUTOR WILL BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING IN ANY WAY OUT OF THE USE OF THE PACKAGE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. Regexp-Common-2017060201/COPYRIGHT.BSD000644 000765 000024 00000002740 12116413566 017243 0ustar00abigailstaff000000 000000 Copyright (c) 2001 - 2008, Damian Conway and Abigail All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. * The names of its contributors may not be used to endorse or promote products derived from this software without specific prior written permission. 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 OWNER 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. Regexp-Common-2017060201/COPYRIGHT.MIT000644 000765 000024 00000002065 12116413566 017264 0ustar00abigailstaff000000 000000 Copyright (c) 2001 - 2008, Damian Conway and Abigail Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Regexp-Common-2017060201/lib/000755 000765 000024 00000000000 13114360501 016071 5ustar00abigailstaff000000 000000 Regexp-Common-2017060201/LICENSE000644 000765 000024 00000000626 12736756277 016370 0ustar00abigailstaff000000 000000 This software is Copyright (c) 2001 - 2008, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. Regexp-Common-2017060201/Makefile.PL000644 000765 000024 00000005773 12724620336 017324 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use 5.10.0; use strict; use ExtUtils::MakeMaker; my @tests = qw [t/*.t t/*/*.t]; my %args = ( NAME => 'Regexp::Common', VERSION_FROM => 'lib/Regexp/Common.pm', ABSTRACT_FROM => 'lib/Regexp/Common.pm', PREREQ_PM => { 'vars' => 0, 'strict' => 0, 'warnings' => 0, 'Config' => 0, }, MIN_PERL_VERSION => 5.010, AUTHOR => 'Abigail ', LICENSE => 'mit', META_MERGE => { "meta-spec" => {version => 2}, license => [qw [mit bsd artistic_1 artistic_2]], # # This section is provided for laughts and giggles only. # It seems to be completely and utterly ignored when # running "perl Makefile.PL", and extracting the information # from PREREQ_PM instead. # # The result will be that less and less tests will be run, # as we're are moving towards using Test::Regexp, which is # never going to be a prerequisite to running Regexp::Common. # prereqs => { configure => { requires => { 'ExtUtils::MakeMaker' => 0, 'strict' => 0, 'warnings' => 0, }, }, runtime => { requires => { 'vars' => 0, 'strict' => 0, 'warnings' => 0, 'Config' => 0, }, }, test => { requires => { 'Test::More' => 0, }, recommends => { 'Test::Regexp' => 0, }, }, }, resources => { repository => 'git://github.com/Abigail/Regexp--Common.git', }, keywords => ['regular expression', 'pattern'], }, test => { TESTS => $^O eq 'MSWin32' ? "@{[map {glob} @tests]}" : "@tests" }, ); $args {BUILD_REQUIRES} = $args {PREREQ_PM}; $args {CONFIGURE_REQUIRES} = $args {PREREQ_PM}; $args {TEST_REQUIRES} = { %{$args {PREREQ_PM}}, "Test::More" => 0, }; my %filter = ( MIN_PERL_VERSION => '6.48', META_MERGE => '6.46', AUTHOR => '6.07', ABSTRACT_FROM => '6.07', LICENSE => '6.07', ); delete $args {$_} for grep {defined $filter {$_} && $ExtUtils::MakeMaker::VERSION lt $filter {$_}} keys %args; WriteMakefile %args; __END__ Regexp-Common-2017060201/MANIFEST000644 000765 000024 00000005154 13114360502 016462 0ustar00abigailstaff000000 000000 Changes COPYRIGHT COPYRIGHT.AL COPYRIGHT.AL2 COPYRIGHT.BSD COPYRIGHT.MIT lib/Regexp/Common.pm lib/Regexp/Common/_support.pm lib/Regexp/Common/balanced.pm lib/Regexp/Common/CC.pm lib/Regexp/Common/comment.pm lib/Regexp/Common/delimited.pm lib/Regexp/Common/lingua.pm lib/Regexp/Common/list.pm lib/Regexp/Common/net.pm lib/Regexp/Common/number.pm lib/Regexp/Common/profanity.pm lib/Regexp/Common/SEN.pm lib/Regexp/Common/URI.pm lib/Regexp/Common/URI/RFC1035.pm lib/Regexp/Common/URI/RFC1738.pm lib/Regexp/Common/URI/RFC1808.pm lib/Regexp/Common/URI/RFC2384.pm lib/Regexp/Common/URI/RFC2396.pm lib/Regexp/Common/URI/RFC2806.pm lib/Regexp/Common/URI/fax.pm lib/Regexp/Common/URI/file.pm lib/Regexp/Common/URI/ftp.pm lib/Regexp/Common/URI/gopher.pm lib/Regexp/Common/URI/http.pm lib/Regexp/Common/URI/news.pm lib/Regexp/Common/URI/pop.pm lib/Regexp/Common/URI/prospero.pm lib/Regexp/Common/URI/tel.pm lib/Regexp/Common/URI/telnet.pm lib/Regexp/Common/URI/tv.pm lib/Regexp/Common/URI/wais.pm lib/Regexp/Common/whitespace.pm lib/Regexp/Common/zip.pm LICENSE MANIFEST Makefile.PL README TODO t/Common.pm t/comment/delimited.t t/comment/html.t t/comment/nested.t t/comment/pascal.t t/comment/single_line.t t/comment/single_or_multiline.t t/delimited/101_delimited.t t/delimited/111_bquoted.t t/net/101_ipv4.t t/net/102_ipv4_strict.t t/net/111_ipv6.t t/net/121_mac.t t/net/131_domain.t t/number/101_integer.t t/number/111_integer_base.t t/number/121_integer_places.t t/number/122_integer_places.t t/number/123_integer_places.t t/number/131_integer_sep.t t/number/141_integer_group.t t/number/701_squares.t t/number/801_roman.t t/number/decimal.t t/number/number.t t/SEN/usa_ssn.t t/test___luhn.t t/test_balanced.t t/test_bases.t t/test_bases_sep.t t/test_comments.t t/test_curry.t t/test_i.t t/test_lingua_palindrome.t t/test_list.t t/test_no_import.t t/test_profanity.t t/test_sub.t t/test_sub_named.t t/test_ws.t t/URI/fax.t t/URI/file.t t/URI/ftp.t t/URI/gopher.t t/URI/http.t t/URI/news.t t/URI/nntp.t t/URI/pop.t t/URI/prospero.t t/URI/tel.t t/URI/telnet.t t/URI/tv.t t/URI/wais.t t/URI/any.t t/zip/101_austria.t t/zip/111_australia.t t/zip/112_australia.t t/zip/121_belgium.t t/zip/131_denmark.t t/zip/141_greenland.t t/zip/151_norway.t t/zip/161_liechtenstein.t t/zip/171_switzerland.t t/zip/181_italy.t t/zip/191_germany.t t/zip/201_luxembourg.t t/zip/211_france.t t/zip/221_monaco.t t/zip/231_san-marino.t t/zip/241_vatican-city.t t/zip/netherlands.t t/zip/spain.t t/zip/us.t t/zip/zip.t t/zip/Zip.pm META.yml Module YAML meta-data (added by MakeMaker) META.json Module JSON meta-data (added by MakeMaker) Regexp-Common-2017060201/META.json000644 000765 000024 00000003224 13114360502 016746 0ustar00abigailstaff000000 000000 { "abstract" : "Provide commonly requested regular expressions", "author" : [ "Abigail " ], "dynamic_config" : 1, "generated_by" : "ExtUtils::MakeMaker version 7.24, CPAN::Meta::Converter version 2.150010", "keywords" : [ "regular expression", "pattern" ], "license" : [ "mit", "mit", "bsd", "artistic_1", "artistic_2" ], "meta-spec" : { "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec", "version" : "2" }, "name" : "Regexp-Common", "no_index" : { "directory" : [ "t", "inc" ] }, "prereqs" : { "build" : { "requires" : { "Config" : "0", "strict" : "0", "vars" : "0", "warnings" : "0" } }, "configure" : { "requires" : { "Config" : "0", "ExtUtils::MakeMaker" : "0", "strict" : "0", "vars" : "0", "warnings" : "0" } }, "runtime" : { "requires" : { "Config" : "0", "perl" : "5.01", "strict" : "0", "vars" : "0", "warnings" : "0" } }, "test" : { "recommends" : { "Test::Regexp" : "0" }, "requires" : { "Config" : "0", "Test::More" : "0", "strict" : "0", "vars" : "0", "warnings" : "0" } } }, "release_status" : "stable", "resources" : {}, "version" : "2017060201", "x_serialization_backend" : "JSON::PP version 2.27400_02" } Regexp-Common-2017060201/META.yml000644 000765 000024 00000001447 13114360501 016602 0ustar00abigailstaff000000 000000 --- abstract: 'Provide commonly requested regular expressions' author: - 'Abigail ' build_requires: Config: '0' Test::More: '0' strict: '0' vars: '0' warnings: '0' configure_requires: Config: '0' ExtUtils::MakeMaker: '0' strict: '0' vars: '0' warnings: '0' dynamic_config: 1 generated_by: 'ExtUtils::MakeMaker version 7.24, CPAN::Meta::Converter version 2.150010' keywords: - 'regular expression' - pattern license: open_source meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.4.html version: '1.4' name: Regexp-Common no_index: directory: - t - inc requires: Config: '0' perl: '5.01' strict: '0' vars: '0' warnings: '0' resources: {} version: '2017060201' x_serialization_backend: 'CPAN::Meta::YAML version 0.018' Regexp-Common-2017060201/README000644 000765 000024 00000010245 13114356476 016225 0ustar00abigailstaff000000 000000 ============================================================================== Release of version 2017060201 of Regexp::Common ============================================================================== IMPORTANT NOTICE: As of version 2016060101, we cease to support pre-5.10.0 perls. 5.10.0 was release over 8 years ago, and it just becomes too painful to support older perls. The main reason for version 2.122 is a change in the license. You now have the option to use this software under either the original Artistic License, the Artistic License 2.0, the MIT license, or the BSD license. WARNINGS: As of version 2016052801, $RE {delimited} and $RE {quoted} are no longer supported on pre-5.10 Perl.s As of version 2013030901, $RE {balanced} is no longer supported for pre-5.10 Perls. INCOMPATIBLE CHANGE in version 2.119: The $N settings for the -keep option of US postal codes ($RE {zip} {US} {-keep}) have been changed. See the Regexp::Common::zip for details. INCOMPATIBLE CHANGE in version 2.113: Regexp::Common used to set $; to '='. This no longer happens, because setting $; breaks Filter::Simple. This means that regexps of the form $RE{foo}{"-flag=value"} no longer work! They need to be written as $RE{foo}{"-flag$;value"} or as $RE{foo}{-flag => "value"}. When defining patterns using the pattern function, a = still needs to be used to separate the flag from its default value. This has not been changed. We are very sorry for the inconvenience. NAME Regexp::Common - Provide commonly requested regular expressions SYNOPSIS use Regexp::Common; while (<>) { /$RE{num}{real}/ and print q{a number\n}; /$RE{quoted}/ and print q{a ['"`] quoted string\n}; /$RE{delimited}{-delim=>'/'}/ and print q{a /.../ sequence\n}; /$RE{balanced}{-parens=>'()'}/ and print q{balanced parentheses\n}; /$RE{profanity}/ and print q{a #*@%-ing word\n}; } DESCRIPTION By default, this module exports a single hash (`%RE') that stores or generates commonly needed regular expressions. Patterns currently provided include: * balanced parentheses and brackets * delimited text (with escapes) * integers and floating-point numbers in any base (up to 36) * comments in 44 languages * offensive language * lists of any pattern * IPv4 addresses * URIs. * Zip codes. Future releases of the module will also provide patterns for the following: * email addresses * HTML/XML tags * mail headers (including multiline ones), * more URIs * telephone numbers of various countries * currency (universal 3 letter format, Latin-1, currency names) * dates * binary formats (e.g. UUencoded, MIMEd) * Credit card numbers. INSTALLATION It's all pure Perl, so just put the .pm files in their appropriate local Perl subdirectory. Alternatively, use the common approach: - untar the archive - run: perl Makefile.PL - run: make - run: make test - run: make install AUTHORS Damian Conway (damian@cs.monash.edu.au) and Abigail (regexp-common@abigail.be) MAINTAINER Abigail (regexp-common@abigail.be) COPYRIGHT and LICENSE This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. ============================================================================== AVAILABILITY Regexp::Common has been uploaded to the CPAN and is also available from: http://github.com/Abigail/Regexp--Common.git ============================================================================== Regexp-Common-2017060201/t/000755 000765 000024 00000000000 13114360501 015566 5ustar00abigailstaff000000 000000 Regexp-Common-2017060201/TODO000644 000765 000024 00000000664 12116413566 016034 0ustar00abigailstaff000000 000000 - URIs: + As defined in RFC 1738. + More of them. - Dates: + localtime dates. + ISO Dates. + An inverse of strftime? - numbers: + Decimal numbers (e.g. 7.5, 0.3, .99, 15, but not 1.23E5). + Roman numbers >= 4000. Unicode? + Prime numbers? Fibonacci? Other special numbers? + Ranges of numbers. - postal codes. + Lots more, especially British and Canadians. - Email addresses. + RFC 822/2822. Regexp-Common-2017060201/t/comment/000755 000765 000024 00000000000 13114360501 017230 5ustar00abigailstaff000000 000000 Regexp-Common-2017060201/t/Common.pm000644 000765 000024 00000067617 13070654573 017415 0ustar00abigailstaff000000 000000 package t::Common; use strict; use lib qw {blib/lib}, "."; use vars qw /@ISA @EXPORT @EXPORT_OK $DEBUG/; use Regexp::Common; use Exporter (); use warnings; @ISA = qw /Exporter/; @EXPORT = qw /run_tests run_new_tests NORMAL_PASS NORMAL_FAIL FAIL $DEBUG/; @EXPORT_OK = qw /cross criss_cross pass fail d pd dd pdd l ll L LL a aa w ww _x xx X XX h hh gimme sample/; my @STATES = qw /pass fail/; our $SKIP; use constant NORMAL_PASS => 0x01; # Normal test, should pass. use constant NORMAL_FAIL => 0x02; # Normal test, should fail. use constant NORMAL => NORMAL_PASS | NORMAL_FAIL; use constant FAIL => 0x04; # Test for failure. sub run_test; sub run_old_keep; sub run_fail; sub count_me; sub is_skipped; my $count; sub stringify; sub stringify { my $arg = shift; if (!defined $arg) {return ""} elsif (!ref $arg) {$arg =~ s/\\/\\\\/g; $arg =~ s/\n/\\n/g; $arg =~ s/\t/\\t/g; return "$arg"} elsif ( ref $arg eq "ARRAY") { local $" = ", "; return "[@{[map {q{'} . stringify ($_) . q{'}} @$arg]}]"; } else {return ref $arg} } sub mess { my $str = stringify $_; my $com = join " " => map {stringify $_} @_; $count ++; if ($SKIP) {printf qq !%4d # SKIP: %s\n! => $count, $SKIP;} else {printf qq !%4d - %-40s (%s)\n! => $count, qq !"$str"!, $com;} } sub pass {print "ok "; &mess} sub fail {print +$SKIP ? "ok " : "not ok "; &mess} sub Fail { my $mess = shift; my %args = @_; if ($args {got} && $args {expected}) { printf "# Expected: '%s'\n", stringify $args {expected}; printf "# Got: '%s'\n", stringify $args {got}; } fail $mess; } sub import { if (@_ > 1 && $_ [-1] =~ /^\d+\.\d+$/) { my $version = pop; if ($version > $]) { print "1..1\n"; print "ok 1\n"; exit; } } __PACKAGE__ -> export_to_level (1, @_); } # # Return a cross product from its arguments. Arguments are array refs. # Result is a list of array refs. # sub cross { my @r = []; @r = map {my $s = $_; map {[@$_ => $s]} @r} @$_ for @_; @r } sub criss_cross { my ($f, $s) = @_; my @r; push @r => cross @$f [0 .. $_ - 1], $$s [$_], @$f [$_ + 1 .. $#$f] for 0 .. $#$f; @r; } sub __ {map {defined () ? $_ : "UNDEF"} @_} sub count_test_runs { my ($tests, $passes, $failures) = @_; my $keep = 0; my $normal = 0; my $fail = 0; foreach my $test (@$tests) { while (my ($name, $mask) = each %{$test -> [2]}) { $normal += @{$passes -> {$name}} if $mask & NORMAL; $keep += @{$passes -> {$name}} if $mask & NORMAL_PASS; $fail += @{$failures -> {$name}} if $mask & FAIL; } } 1 + $normal + $keep + $fail; } # Arguments: # tests: hash ref with the re's, names, and when to (not)match. # good: ref to array with arrays, parts making patterns. # bad: ref to array with arrays, parts not making patterns. # query: code ref, creates query strings. # wanted: code ref, creates list what keep should return. # # Filter arguments are used to filter chunks before trying them. # All of them are code refs. # filter: filter everything. # filter_passes: filter passes. # filter_failures: filter failures. # filter_test: filter called with testname. sub run_tests { my %args = @_; my $tests = $args {tests}; # Collect the names of all tags. my %tag_names; @tag_names {keys %{$_ -> [2]}} = () foreach @$tests; my (@passes, @failures); if ($args {good}) { @passes = cross @{$args {good}}; @failures = (); foreach my $i (0 .. $#{$args {good}}) { push @failures => cross @{$args {good}} [0 .. $i - 1], $args {bad} [$i], @{$args {good}} [$i + 1 .. $#{$args {good}}] } } elsif ($args {good_list}) { @passes = @{$args {good_list}}; } # General filters. @passes = grep {$args {filter_passes} -> ($_)} @passes if defined $args {filter_passes}; @passes = grep {$args {filter} -> ($_)} @passes if defined $args {filter}; @failures = grep {$args {filter_failures} -> ($_)} @failures if defined $args {filter_failures}; @failures = grep {$args {filter} -> ($_)} @failures if defined $args {filter}; my (%passes, %failures); # Specific filters. if (defined $args {filter_test}) { foreach my $name (keys %tag_names) { $passes {$name} = [grep {$args {filter_test} -> (pass => $name, $_)} @passes]; $failures {$name} = [grep {$args {filter_test} -> (failure => $name, $_)} @failures]; } } else { foreach my $name (keys %tag_names) { $passes {$name} = [@passes]; $failures {$name} = [@failures]; } } my $runs = count_test_runs $tests, \%passes, \%failures; print "1..$runs\n"; print "ok ", ++ $count, "\n"; my @test_names = map {$_ -> [1]} @$tests; my @tag_names = keys %tag_names; my $wanted = $args {wanted}; foreach my $test (@$tests) { my ($name, $re, $matches) = @$test; while (my ($tag, $match) = each %$matches) { if ($match & NORMAL) { foreach my $pass (@{$passes {$tag}}) { local $_ = $args {query} -> ($tag => $pass); run_test re => $re, name => $name, match => $match & NORMAL_PASS; run_old_keep re => $re, name => $name, tag => $tag, parts => $pass, wanted => $wanted if $match & NORMAL_PASS; } } if ($match & FAIL) { foreach my $failure (@{$failures {$tag}}) { local $_ = $args {query} -> ($tag => $failure); run_fail re => $re, name => $name; } } } } } sub run_test { my %args = @_; my $re = $args {re}; my $name = $args {name}; my $should_match = $args {match}; my $match = /^$re/; # Not anchored at the end on purpose. my $good = $match && $_ eq $&; my $line = $good ? "match" : $match ? "wrong match (got: $&)" : "no match"; $line .= "; $name"; if ($should_match) {$good ? pass $line : fail $line} else {$match ? fail $line : pass $line} } sub array_cmp { my ($a1, $a2) = @_; return 0 unless @$a1 eq @$a2; foreach my $i (0 .. $#$a1) { # !defined $$a1 [$i] && !defined $$a2 [$i] || # defined $$a1 [$i] && defined $$a2 [$i] && $$a1 [$i] eq $$a2 [$i] (!defined $$a1 [$i] || $$a1 [$i] eq "") && (!defined $$a2 [$i] || $$a2 [$i] eq "") || defined $$a1 [$i] && defined $$a2 [$i] && $$a1 [$i] eq $$a2 [$i] or return 0; } return 1; } sub run_old_keep { my %args = @_; my $re = $args {re}; # Regexp that's being tried. my $name = $args {name}; # Name of the test. my $tag = $args {tag}; # Tag to pass to wanted sub. my $parts = $args {parts}; # Parts to construct string from. my $wanted_sub = $args {wanted}; # Sub to contruct wanted array from. my @chunks = /^$re->{-keep}$/; unless (@chunks) {fail "no match; $name - keep"; return} my $wanted = $wanted_sub -> ($tag => $parts); local $" = ", "; array_cmp (\@chunks, $wanted) ? pass "match; $name - keep" : $DEBUG ? fail "wrong match,\n# got [@{[__ @chunks]}]\n" . "# expected [@{[__ @$wanted]}]" : fail "wrong match [@{[__ @chunks]}]" } ################## # # # New style subs # # # ################## # # Messages printed at end are of the form: # [XX/Y/ZZ], with XX denoting the type of match, Y the expected result, # and ZZ the result. # # XX: - RE: Regular expression # - SB: Subroutine call # - OM: OO -> match # - OS: OO -> subs # - KP: Regular expression with -keep # # Y: - P: Expected to pass # - F: Expected to fail # # ZZ: - MT: Pattern matched correctly # - NM: Pattern did not match # - WM: Pattern matched, but incorrectly. # # Given a regex and a string, test whether the regex fails to match. # Matching anything other than the entire string is a pass (as it regex # fails to match the entire string) # sub run_fail { my %args = @_; my $re = $args {re}; my $name = $args {name}; /^$re/ && $_ eq $& ? fail "[RE/F/MT] $name" : pass "[RE/F/NM] $name"; } # # Same as 'run_fail', except now not a regex, but a subroutine is given. # sub run_sub_fail { my %args = @_; my $sub = $args {sub}; my $name = $args {name}; my @args = $args {sub_args} ? ref $args {sub_args} ? @{$args {sub_args}} : $args {sub_args} : (); $_ =~ $sub -> (@args) && $_ eq $& ? fail "[SB/F/MT] $name" : pass "[SB/F/NM] $name"; } # # We can test whether it matched, but we can't really test whether # it matched the entire string. $& relates to the last successful # match in the current scope, but the match done in $re -> matches() # is done in a subscope. @-/@+ are equally useless. # sub run_OO_pass { my %args = @_; my $re = $args {re}; my $name = $args {name}; my $match = $re -> matches ($_); if ($match) {pass "[OM/P/MT] $name"} else {fail "[OM/P/NM] $name"} } # # Test whether the subroutine gives the right answer. # sub run_sub_pass { my %args = @_; my $sub = $args {sub}; my $name = $args {name}; my @args = $args {sub_args} ? ref $args {sub_args} ? @{$args {sub_args}} : $args {sub_args} : (); my $match = $_ =~ $sub -> (@args); my $good = $match && $_ eq $&; if ($good) {pass "[SB/P/MT] $name"} elsif ($match) {Fail "[SB/P/WM] $name", got => $&, expected => $_} else {fail "[SB/P/NM] $name"} } # # Check whether the substitution (only for OO) works correctly. # sub run_OO_substitution_pass { my %args = @_; my $re = $args {re}; my $name = $args {name}; my $token = $args {token} || "---"; my $sub = $re -> subs ($_, $token); my $good = $sub eq $token; if ($good) {pass "[OS/P/MT] $name"} elsif ($sub ne $_) {Fail "[OS/P/NM] $name", got => $sub, expected => $token} else {fail "[OS/P/WM] $name"} } sub run_pass { my %args = @_; my $re = $args {re}; my $name = $args {name}; my $match = /^$re/; # Not anchored at the end on purpose. my $good = $match && $_ eq $&; my $perfect = $good && !defined $1; # Should *not* set $1 and friends. if ($perfect) {pass "[RE/P/MT] $name"} elsif ($good) {fail "[RE/P/MT], sets \$1; $name"} elsif ($match) {Fail "[RE/P/WM] $name", got => $&, expected => $_} else {fail "[RE/P/NM] $name"} } sub run_keep { my %args = @_; my $re = $args {re}; # Regexp that's being tried. my $name = $args {name}; # Name of the test. my $wanted = $args {wanted}; # Wanted list. my @chunks = /^$re->{-keep}/; unless (@chunks) {fail "[KP/P/NM] $name"; return} array_cmp (\@chunks, $wanted) ? pass "[KP/P/MT] $name" : Fail "[KP/P/WM] $name", got => \@chunks, expected => $wanted; } sub get_args { my $key = shift; foreach my $ref (@_) { next unless exists $$ref {$key}; return ref $$ref {$key} eq 'ARRAY' ? @{$$ref {$key}} : $$ref {$key} } return; } sub run_new_test_set { my %args = @_; my $test_set = $args {test_set}; my $targets = $args {targets}; my $name = $$test_set {name}; my $regex = $$test_set {regex} || $$test_set {re}; # Getting tired of # getting this wrong. my $sub = $$test_set {sub}; my $sub_args = $$test_set {sub_args}; my $keep = $regex -> {-keep}; my $pass = $$test_set {pass}; my $fail = $$test_set {fail}; my $skip_sub = $$test_set {skip_sub}; # # Run the passes. # foreach my $target_info (@$pass) { my $target_name = $$target_info {name}; my $query = $$targets {$target_name} {query}; next unless $$targets {$target_name} {list} && @{$$targets {$target_name} {list}}; my $un_seen = @{$$targets {$target_name} {list}}; my $samples = count_me $$targets {$target_name} {list}, $$target_info {limit}, $$test_set {limit}; foreach my $parts (@{$$targets {$target_name} {list}}) { next unless $samples > rand $un_seen --; $samples --; # # Calculate the sections we're going to skip. # my %skips; foreach my $skip (qw /RE SB OO OM OS KP/) { $skips {$skip} = is_skipped $skip => $target_info, $test_set; } $skips {OM} ||= $skips {OO}; $skips {OS} ||= $skips {OO}; # # Find the thing we need to match against. # Note that we're going to match against $_. # my @args = ref $parts ? @$parts : $parts; my @qargs = get_args query_args => $target_info, $test_set; local $_ = $query ? $query -> (@qargs, @args) : ref $parts ? join "" => @$parts : $parts; # # See whether we want to skip the test # local $SKIP = $skip_sub && $skip_sub -> (pass => $_); # # Find out the things {-keep} should return. # The thing we match agains is in $_. # my @wanted; unless ($skips {KP}) { my @wargs = get_args wanted_args => $target_info, $test_set; my $w_sub = $$target_info {wanted} || $$targets {$target_name} {wanted}; @wanted = $w_sub ? $w_sub -> (@wargs, @args) : $_; if (@wanted == 1 && ref $wanted [0] eq "ARRAY") { @wanted = @{$wanted [0]}; } } run_pass name => $name, re => $regex unless $skips {RE}; run_OO_pass name => $name, re => $regex unless $skips {OM}; run_OO_substitution_pass name => $name, re => $regex unless $skips {OS}; run_sub_pass name => $name, sub_args => $sub_args, sub => $sub if $sub && !$skips {SB}; run_keep name => $name, re => $keep, wanted => \@wanted unless $skips {KP}; } } # # Run the failures. # foreach my $target_info (@$fail) { my $target_name = $$target_info {name}; my $query = $$targets {$target_name} {query}; next unless $$targets {$target_name} {list} && @{$$targets {$target_name} {list}}; my $un_seen = @{$$targets {$target_name} {list}}; my $samples = count_me $$targets {$target_name} {list}, $$target_info {limit}, $$test_set {limit}; foreach my $parts (@{$$targets {$target_name} {list}}) { next unless $samples > rand $un_seen --; $samples --; my @args = ref $parts ? @$parts : $parts; my @qargs = get_args query_args => $target_info, $test_set; local $_ = $query ? $query -> (@qargs, @args) : ref $parts ? join "" => @$parts : $parts; local $SKIP = $skip_sub && $skip_sub -> (fail => $_); my %skips; foreach my $skip (qw /RE SB/) { $skips {$skip} = is_skipped $skip => $target_info, $test_set; } run_fail name => $name, re => $regex unless $skips {RE}; run_sub_fail name => $name, sub_args => $sub_args, sub => $sub if $sub && !$skips {SB}; } } } # # If there's no list, or an empty list, 0 tests have to be run. # If no limits are given, return the size of the list. # Else, for the first defined limit, # if the limit is negative, return the size of the list, # else if the limit is 0, return 0, # else if the limit is less than 1, treat it as a fraction, # else, return the smaller of the limit and the size of the list. # sub count_me { my ($list, @limits) = @_; return 0 unless $list && @$list; foreach my $limit (@limits) { if (defined $limit) { return @$list if $limit < 0; return int (@$list * $limit) if $limit < 1; return $limit if $limit < @$list; return @$list; } } @$list; } # # Normify any 'pass','fail' and 'skip' entries in a test. # What we want is a 'pass' and a 'fail' pointing to an array of hashes, # each hash being a 'target'. # # Since we are passed a reference, the modification is done in situ. # sub normify { my $test = shift; foreach my $state (@STATES) { my @list; foreach my $postfix ("", "_arg") { my $key = "$state$postfix"; next unless exists $$test {$key}; my $targets = $$test {$key}; if (ref $targets eq 'ARRAY') { foreach my $thingy (@$targets) { if (ref $thingy eq 'HASH') { push @list => $thingy; } elsif (!ref $thingy) { push @list => {name => $thingy} } } } elsif (ref $targets eq 'HASH') { push @list => $targets; } else { push @list => {name => $targets}; } delete $$test {$key}; } $$test {$state} = \@list; } # # Skips. # if (!exists $$test {skip}) {$$test {skip} = {}} elsif (ref $$test {skip} eq 'ARRAY') { $$test {skip} = {map {$_ => 1} @{$$test {skip}}} } foreach my $state (@STATES) { foreach my $target (@{$$test {state}}) { if (!exists $$target {skip}) {$$target {skip} = {}} elsif (ref $$target {skip}) { $$target {skip} = {map {$_ => 1} @{$$target {skip}}} } } } } sub is_skipped { my ($type, @things) = @_; foreach my $thingy (@things) { return $$thingy {skip} {$type} if defined $$thingy {skip} {$type}; } return; } sub mult { my ($state, $has_sub, @things) = @_; my $mult; # Regular expression test. $mult ++ unless is_skipped RE => @things; # Subroutine check. $mult ++ if $has_sub && !is_skipped SB => @things; if ($state eq "pass") { # OO checks. $mult ++ unless is_skipped OO => @things or is_skipped OM => @things; $mult ++ unless is_skipped OO => @things or is_skipped OS => @things; # Keep check. $mult ++ unless is_skipped RE => @things or is_skipped KP => @things; } return $mult; } sub run_new_tests { my %args = @_; my ($tests, $targets, $version, $version_from, $extra_runs, $extra_runs_sub) = @args {qw /tests targets version version_from extra_runs extra_runs_sub/}; # # Modify any 'pass' and 'fail' entries to arrays of hashes. # foreach my $test (@$tests) { normify $test; } # # Count the number of runs. # my $runs = defined $version_from; # VERSION test. my $no_tests; if ($extra_runs) { $runs += $extra_runs; $count += $extra_runs; } if (defined $version && $version > $]) { $no_tests = 1; } else { # Count the tests to be run. foreach my $test (@$tests) { # Test: pass: regex, regex/keep, OO, OO-substitution, sub (if given) # fail: regex, sub (if given). my $has_sub = $$test {sub} ? 1 : 0; for my $state (@STATES) { foreach my $target (@{$$test {$state}}) { my $size = count_me $$targets {$$target {name}} {list}, $$target {limit}, $$test {limit}; $runs += $size * mult $state, $has_sub => $target, $test; } } } } print "1..$runs\n"; # Check whether a version is defined. if (defined $version_from) { print "ok ", ++ $count, "\n"; } if ($extra_runs_sub) { $extra_runs_sub -> (\$count) } unless ($no_tests) { foreach my $test (@$tests) { run_new_test_set test_set => $test, targets => $targets; } } } # # Function to produce random strings. # # Digit. sub d {int rand 10} # Positive digit. sub pd {1 + int rand 9} # String of digits. sub dd {my ($min, $max) = @_ > 1 ? (@_) : ($_ [0], $_ [0]); join "" => map {d} 1 .. $min + int rand ($max - $min)} # String of digits, not all 0. sub pdd {my ($min, $max) = @_ > 1 ? (@_) : ($_ [0], $_ [0]); TRY: my $dd = join "" => map {d} 1 .. $min + int rand ($max - $min); goto TRY unless $dd =~ /[^0]/; $dd} # Lowercase letter. sub l {chr (ord ('a') + int rand 26)} # String of lowercase letters. sub ll {my ($min, $max) = @_ > 1 ? (@_) : ($_ [0], $_ [0]); join "" => map {l} 1 .. $min + int rand ($max - $min)} # Uppercase letter. sub L {chr (ord ('a') + int rand 26)} # String of uppercase letters. sub LL {my ($min, $max) = @_ > 1 ? (@_) : ($_ [0], $_ [0]); join "" => map {L} 1 .. $min + int rand ($max - $min)} # Alpha. sub a {50 < rand (100) ? l : L} # String of alphas. sub aa {my ($min, $max) = @_ > 1 ? (@_) : ($_ [0], $_ [0]); join "" => map {a} 1 .. $min + int rand ($max - $min)} # Alphanum. sub w {52 < rand (62) ? d : a} # String of alphanums. sub ww {my ($min, $max) = @_ > 1 ? (@_) : ($_ [0], $_ [0]); join "" => map {w} 1 .. $min + int rand ($max - $min)} # Lowercase hex digit. sub _x {(0 .. 9, 'a' .. 'f') [int rand 16]} # String of lowercase hex digits. sub xx {my ($min, $max) = @_ > 1 ? (@_) : ($_ [0], $_ [0]); join "" => map {_x} 1 .. $min + int rand ($max - $min)} # Uppercase hex digit. sub X {(0 .. 9, 'A' .. 'F') [int rand 16]} # String of uppercase hex digits. sub XX {my ($min, $max) = @_ > 1 ? (@_) : ($_ [0], $_ [0]); join "" => map {X} 1 .. $min + int rand ($max - $min)} # Any case hex digit sub h {(0 .. 9, 'A' .. 'F', 'a' .. 'f') [int rand 22]} # String of anycase hex digits sub hh {my ($min, $max) = @_ > 1 ? (@_) : ($_ [0], $_ [0]); join "" => map {h} 1 .. $min + int rand ($max - $min)} # # Pass a number N and a callback C. Return N different results from C. # Will do at most 100 * N tries. # sub gimme { my ($count, $call) = @_; my %cache; foreach (1 .. 100 * $count) { $cache {$call -> ()} = 1; last if keys %cache >= $count; } keys %cache; } # # Given a number N, and a list of things, return a sample of N # sub sample { my $N = shift; return @_ if @_ <= $N; my @cache = splice @_ => 0, $N; my $count = $N; map {rand ++ $count < $N and splice @cache, rand @cache, 1, $_} @_; @cache; } 1; __END__ =head1 DESCRIPTION C is called with three (named) parameters: =over 4 =item C A references to an array of I (explained below). =item C A reference to a hash of I (explained below). =item C The name of the file that is checked for a version number. =back =head2 Targets Targets provide a set of strings to match against. Targets are indexed by name. Each target is a hash, with the following keys: =over 4 =item C Required. This is a reference to an array that will act as building blocks to build strings to match against. In the simplest form, this is just an array with strings - but typically, this is an array of arrays, each subarray used to create a string. =item C A coderef. For each entry in array given above, this coderef is called. It takes a set of arguments and returns a string to match against. If the corresponding entry in C is reference to an array, all its elements are passed - otherwise, the entry is passed as a whole. Extra arguments provided with C below are prepended. If no coderef is given, C is assumed. =item C A coderef. If the target is used for positive matches (that is, it's expected to match), this sub is called with the same arguments as C - except that C are prepended. It should return a list of strings as if the regular expression was called with C<{-keep}>. The string to match against may be assumed to be C<$_>. If no coderef is given, C is assumed. =back =head2 Tests The tests to run are put in an array, and run in that order. Each test tests a specific pattern. Up to seven types of tests are performed, depending whether the tests includes expected failures, expected passes or both. Expected passes are tested as a regular expression, as a regular expression with the C<{-keep}> option, as a subroutine, as an object using the C method, and as an object using the C method. Expected failures are tested as a regular expression, and as a subroutine. Each test is a hash with the following keys: =over 4 =item C The name of this test - mostly used in the test output. =item C The pattern to test with. =item C The subroutine to test with, if any. =item C Any arguments that need to be passed into the subroutine. If more than one argument needs to be passed, use a reference to an array - the array will be flattened when calling the subroutine. =item C Extra arguments to pass into the C coderef for all the targets belonging to this tests, if not overriden as discussed below. =item C Extra arguments to pass into the C coderef for all the targets belonging to this tests, if not overriden as discussed below. =item C Indicates which targets (discussed above) should be run with expected passes. The value of C is either a reference to an array - the array containing the names of the targets to run, or a reference to a hash. In the latter case, the keys are the targets to be run, while the keys are hash references, containing more configuration options for the target. Values allowed: =over 4 =item C Extra arguments to pass into the C coderef belonging to this test. See discussion above. =item C Extra arguments to pass into the C coderef belonging to this test. See discussion above. =back =item C As C, except that it will list targets with an expected failure. =back Regexp-Common-2017060201/t/delimited/000755 000765 000024 00000000000 13114360501 017526 5ustar00abigailstaff000000 000000 Regexp-Common-2017060201/t/net/000755 000765 000024 00000000000 13114360501 016354 5ustar00abigailstaff000000 000000 Regexp-Common-2017060201/t/number/000755 000765 000024 00000000000 13114360501 017056 5ustar00abigailstaff000000 000000 Regexp-Common-2017060201/t/SEN/000755 000765 000024 00000000000 13114360501 016213 5ustar00abigailstaff000000 000000 Regexp-Common-2017060201/t/test___luhn.t000755 000765 000024 00000002145 12116413566 020276 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use lib qw {blib/lib}; use Regexp::Common; use Regexp::Common::_support qw /luhn/; use warnings; my $TESTS = 100; my @good = qw /49927398716 00000000000/; my @bad = qw /49927398717 49927398715/; # Generate a bunch of valid, and invalid, numbers. my %cache; foreach (1 .. $TESTS) { my $length = 1 + int rand (1 > rand 10 ? 100 : 20); my $s = join "" => map {int rand 10} 1 .. $length; redo if $cache {$s} ++; my $even = 1; my $sum = 0; foreach my $n (split // => $s) { $n *= 2 if $even; $sum += ($n % 10) + int ($n / 10); $even = !$even; } my $c = $sum % 10 ? 10 - ($sum % 10) : 0; my $d = $c; $d = int rand 10 while $d == $c; my $g = reverse ($s) . $c; my $b = reverse ($s) . $d; push @good => $g; push @bad => $b; } my $total = @good + @bad; print "1..$total\n"; my $c = 0; foreach my $g (@good) { print "not " unless luhn $g; print "ok ", ++ $c, " # luhn ($g)\n"; } foreach my $b (@bad) { print "not " if luhn $b; print "ok ", ++ $c, " # !luhn ($b)\n"; } __END__ Regexp-Common-2017060201/t/test_balanced.t000755 000765 000024 00000006443 12723313224 020562 0ustar00abigailstaff000000 000000 # VOODOO LINE-NOISE my($C,$M,$P,$N,$S);END{print"1..$C\n$M";print"\nfailed: $N\n"if$N} sub ok{$C++; $M.= ($_[0]||!@_)?"ok $C\n":($N++,"not ok $C (". ((caller 1)[1]||(caller 0)[1]).":".((caller 1)[2]||(caller 0)[2]).")\n")} sub try{$P=qr/^$_[0]$/}sub fail{ok($S=$_[0]!~$P)}sub pass{ok($S=$_[0]=~$P)} # LOAD use Regexp::Common; ok; # SIMPLE BALANCING ACT try $RE{balanced}; pass "()"; pass "(a)"; pass "(a b)"; pass "(a()b)"; pass "(a( )b)"; pass "(a(b))"; pass "(a(b)(c)(d(e)))"; pass "(a(])b)"; pass "(a({{{)b)"; fail "("; fail "(a"; fail "(a(b)"; fail "(a( b)"; fail "(a(]b)"; fail "(a({{{)b"; # MULTIPLE BALANCING ACT try $RE{balanced}{-parens=>"()[]"}; pass "()"; pass "(a)"; pass "(a b)"; pass "(a()b)"; pass "(a( )b)"; pass "(a(b))"; pass "(a(b)(c)(d(e)))"; pass "(a(})b)"; pass "(a([[()]])b)"; fail "("; fail "(a"; fail "(a(b)"; fail "(a( b)"; fail "(a(]b)"; fail "(a([[[)b"; try $RE{balanced}{-begin => 'begin'}{-end => 'end'}; pass 'begin end'; fail 'begin en'; fail 'begin nd'; pass 'begin begin end end'; pass 'beginend'; pass 'beginbeginbeginendendend'; pass 'begin begin end begin begin end begin end end end'; fail 'begin begin end begin egin end begin end end end'; fail 'begin end begin end'; try $RE{balanced}{-begin => 'start'}{-end => 'stop'}; pass 'start stop'; fail 'start st'; fail 'start op'; pass 'start start stop stop'; pass 'startstop'; pass 'startstartstartstopstopstop'; pass 'start start stop start start stop start stop stop stop'; fail 'start start stop start tart stop start stop stop stop'; fail 'start stop start stop'; try $RE{balanced}{-parens => '()[]'}{-begin => 'start'}{-end => 'stop'}; pass 'start stop'; fail 'start st'; fail 'start op'; pass 'start start stop stop'; pass 'startstop'; pass 'startstartstartstopstopstop'; pass 'start start stop start start stop start stop stop stop'; fail 'start start stop start tart stop start stop stop stop'; fail 'start stop start stop'; try $RE{balanced}{-begin => 'S'}{-end => 'T'}; pass 'S T'; fail 'S Q'; pass 'S S T T'; pass 'ST'; pass 'SSSTTT'; pass 'S S T S S T S T T T'; fail 'S S T S Q T S T T T'; fail 'S T S T'; try $RE{balanced}{-start => "(|["}{-end => ")|]"}; pass "()"; pass "(a)"; pass "(a b)"; pass "(a()b)"; pass "(a( )b)"; pass "(a(b))"; pass "(a(b)(c)(d(e)))"; pass "(a(})b)"; pass "(a([[()]])b)"; fail "("; fail "(a"; fail "(a(b)"; fail "(a( b)"; fail "(a(]b)"; fail "(a([[[)b"; # Test '|' delimiters. try $RE{balanced}{-begin => '\|'}{-end => '-'}; pass '| -'; fail '| Q'; pass '| | - -'; pass '|-'; pass '|||---'; pass '| | - | | - | - - -'; fail '| | - | Q - | - - -'; fail '| - | -'; try $RE{balanced}{-begin => '!'}{-end => '\|'}; pass '! |'; fail '! Q'; pass '! ! | |'; pass '!|'; pass '!!!|||'; pass '! ! | ! ! | ! | | |'; fail '! ! | ! Q | ! | | |'; fail '! | ! |'; try $RE{balanced}{-begin => '\||['} {-end => ')|]'}; pass "|)"; pass "|a)"; pass "|a b)"; pass "|a|)b)"; pass "|a| )b)"; pass "|a|b))"; pass "|a|b)|c)|d|e)))"; pass "|a|})b)"; pass "|a|[[|)]])b)"; fail "|"; fail "|a"; fail "|a|b)"; fail "|a| b)"; fail "|a|]b)"; fail "|a|[[[)b"; try $RE{balanced}{-begin => '(|['}{-end => ']'}; pass "(]"; pass "(a]"; pass "(a b]"; pass "(a(]b]"; pass "(a( ]b]"; pass "(a(b]]"; pass "(a(b](c](d(e]]]"; pass "(a(}]b]"; pass "(a([[(]]]]b]"; fail "("; fail "(a"; fail "(a(b]"; fail "(a( b]"; pass "(a(]b]"; fail "(a([[[]b"; Regexp-Common-2017060201/t/test_bases.t000755 000765 000024 00000012420 12723313224 020116 0ustar00abigailstaff000000 000000 # VOODOO LINE-NOISE my($C,$M,$P,$N,$S);END{print"1..$C\n$M";print"\nfailed: $N\n"if$N} sub ok{$C++; $M.= ($_[0]||!@_)?"ok $C\n":($N++,"not ok $C (". ((caller 1)[1]||(caller 0)[1]).":".((caller 1)[2]||(caller 0)[2]).")\n")} sub try{$P=qr/^$_[0]$/}sub fail{ok($S=$_[0]!~$P)}sub pass{ok($S=$_[0]=~$P)} # LOAD use Regexp::Common; ok; # TEST BASE 10 try $RE{num}{real}{-keep}; pass 0; pass 1; pass 12; pass 1234567; pass 1.23456789; pass '+1'; pass '+12'; pass '+1234567.89'; pass '-1'; pass '-12.333333333333333333333333333333333333333'; pass '-1234567'; pass -1; pass -12; pass -1234567; pass 1.2; fail "a"; fail ""; fail "1a"; fail "- 1234"; fail "1,234,567"; fail "12,345.6789"; fail "1,2345,6789"; fail "1.2345.6789"; try $RE{num}{real}{-places => 2}; pass 0; pass 1; pass 12; pass 1234567; fail 1.23456789; pass 1.23; pass '+1'; pass '+12'; pass '+1234567.89'; pass '-1'; fail '-12.333333333333333333333333333333333333333'; pass '-1234567'; pass -1; pass -12; pass -1234567; fail 1.2; fail "a"; fail ""; fail "1a"; fail "- 1234"; fail "1,234,567"; fail "12,345.6789"; fail "1,2345,6789"; fail "1.2345.6789"; try $RE{num}{real}{-places => '3,8'}; pass 0; pass 1; pass 12; pass 1234567; pass 1.23456789; pass '+1'; pass '+12'; fail '+1234567.89'; pass '-1'; fail '-12.333333333333333333333333333333333333333'; pass '-1234567'; pass -1; pass -12; pass -1234567; fail 1.2; fail "a"; fail ""; fail "1a"; fail "- 1234"; fail "1,234,567"; fail "12,345.6789"; fail "1,2345,6789"; fail "1.2345.6789"; try $RE{num}{dec}; pass 0; pass 1; pass 12; pass 1234567; pass 1.23456789; pass '+1'; pass '+12'; pass '+1234567.89'; pass '-1'; pass '-12.333333333333333333333333333333333333333'; pass '-1234567'; pass -1; pass -12; pass -1234567; pass 1.2; fail "a"; fail ""; fail "1a"; fail "- 1234"; fail "1,234,567"; fail "12,345.6789"; fail "1,2345,6789"; fail "1.2345.6789"; # TEST BASE 2 try $RE{num}{real}{-base => 2}; pass 0; pass 1; fail 12; fail 1234567; fail 1.23456789; pass '+1'; fail '+12'; pass '+101010'; pass '+101010.0001010'; fail '+1234567.89'; pass '-1'; pass -1; fail "a"; fail ""; fail "1a"; fail "- 1010"; fail "1,001,101"; fail "1,010.1110"; fail "1,0101,0011"; fail "1.0011.0011"; try $RE{num}{bin}; pass 0; pass 1; fail 12; fail 1234567; fail 1.23456789; pass '+1'; fail '+12'; pass '+101010'; pass '+101010.0001010'; fail '+1234567.89'; pass '-1'; pass -1; fail "a"; fail ""; fail "1a"; fail "- 1010"; fail "1,001,101"; fail "1,010.1110"; fail "1,0101,0011"; fail "1.0011.0011"; # TEST BASE 8 try $RE{num}{real}{-base => 8}; pass 0; pass 1; pass 12; pass 1234567; fail 12345678; pass 1.23456; pass '+1'; pass '+12'; pass '+1234567.01'; fail '+1234567.09'; pass '-1'; pass '-12.333333333333333333333333333333333333333'; pass '-1234567'; fail '-1234568'; pass -1; pass -12; pass -1234567; fail -1234568; pass 1.2; fail "a"; fail ""; fail "1a"; fail "- 1234"; fail "1,234,567"; fail "12,345.67"; fail "12,345.68"; fail "1,2345,5670"; fail "1.234.567"; try $RE{num}{oct}; pass 0; pass 1; pass 12; pass 1234567; fail 12345678; pass 1.23456; pass '+1'; pass '+12'; pass '+1234567.01'; fail '+1234567.09'; pass '-1'; pass '-12.333333333333333333333333333333333333333'; pass '-1234567'; fail '-1234568'; pass -1; pass -12; pass -1234567; fail -1234568; pass 1.2; fail "a"; fail ""; fail "1a"; fail "- 1234"; fail "1,234,567"; fail "12,345.67"; fail "12,345.68"; fail "1,2345,5670"; fail "1.234.567"; # TEST BASE 16 try $RE{num}{real}{-base => 16}; pass 0; pass 1; pass 12; pass '12A4C67'; fail '12345678G'; pass '1.23A56'; fail '1.23Z56'; pass '+1'; pass '+12'; pass '+1234567.01A'; fail '+1234567.09Q'; pass '-1'; pass '-12.ddddddddddddddddddddddddddddddddddddddd'; pass '-123B4567'; fail '-123H4567'; pass -1; pass -12; pass -1234567; pass 1.2; pass "a"; fail ""; pass "1a"; pass "a1a"; pass "DeadBeef"; fail "LiveLamb"; fail "- 1234"; fail "1,abc,def"; fail "12,345.67A"; fail "12,3C5,68"; fail "1,23C5,5670"; fail "1.234.567"; try $RE{num}{hex}; pass 0; pass 1; pass 12; pass '12A4C67'; fail '12345678G'; pass '1.23A56'; fail '1.23Z56'; pass '+1'; pass '+12'; pass '+1234567.01A'; fail '+1234567.09Q'; pass '-1'; pass '-12.ddddddddddddddddddddddddddddddddddddddd'; pass '-123B4567'; fail '-123H4567'; pass -1; pass -12; pass -1234567; pass 1.2; pass "a"; fail ""; pass "1a"; pass "a1a"; pass "DeadBeef"; fail "LiveLamb"; fail "- 1234"; fail "1,abc,def"; fail "12,345.67A"; fail "12,3C5,68"; fail "1,23C5,5670"; fail "1.234.567"; # TEST BASE 34 try $RE{num}{real}{-base => 34}; pass 0; pass 1; pass 12; pass '12A4C67'; pass '12345678G'; pass '1.23A56'; fail '1.23Z56'; pass '+1'; pass '+12'; pass '+1234567.01A'; pass '+1234567.09Q'; pass '-1'; pass '-12.ddddddddddddddddddddddddddddddddddddddd'; pass '-123B4567'; pass '-123H4567'; pass -1; pass -12; pass -1234567; pass 1.2; pass "a"; fail ""; pass "1a"; pass "a1a"; pass "DeadBeef"; pass "LiveLamb"; fail "- 1234"; fail "1,abc,def"; fail "12,345.67A"; fail "12,3C5,68"; fail "1,23C5,5670"; fail "1.234.567"; # TEST BASE 1 try $RE{num}{real}{-base => 1}; pass 0; pass "00000000000"; pass "00000.00000"; fail "00,000,000,000"; fail "00,000.000000"; fail 1; fail 12; fail '12A4C67'; fail '12345678G'; try $RE{num}{real}{-base => 1}{"-sep$;,"}; pass 0; fail "00000000000"; fail "00000.00000"; pass "00,000,000,000"; pass "00,000.000000"; fail 1; fail 12; fail '12A4C67'; fail '12345678G'; Regexp-Common-2017060201/t/test_bases_sep.t000755 000765 000024 00000012520 12723313224 020766 0ustar00abigailstaff000000 000000 # VOODOO LINE-NOISE my($C,$M,$P,$N,$S);END{print"1..$C\n$M";print"\nfailed: $N\n"if$N} sub ok{$C++; $M.= ($_[0]||!@_)?"ok $C\n":($N++,"not ok $C (". ((caller 1)[1]||(caller 0)[1]).":".((caller 1)[2]||(caller 0)[2]).")\n")} sub try{$P=qr/^$_[0]$/}sub fail{ok($S=$_[0]!~$P)}sub pass{ok($S=$_[0]=~$P)} # LOAD use Regexp::Common; ok; # TEST BASE 10 try $RE{num}{real}{-base => '10'}{-sep}; pass 0; pass 1; pass 12; fail 1234567; pass 1.23456789; pass 12.23456789; pass 123.23456789; fail 1234.23456789; pass '+1'; pass '+12'; fail '+1234567.89'; pass '+1,234,567.89'; pass '-1'; pass '-12.333333333333333333333333333333333333333'; fail '-1234567'; pass -1; pass -12; fail -1234567; pass 1.2; fail "a"; fail ""; fail "1a"; fail "- 1234"; pass "1,234,567"; pass "12,345.6789"; fail "1,2345,6789"; fail "1.2345.6789"; # TRY WIERD ORDERING try $RE{-base => '10'}{num}{'-sep' => ' '}{real}; pass 0; pass 1; pass 12; fail 1234567; pass 1.23456789; pass 12.23456789; pass 123.23456789; fail 1234.23456789; pass '+1'; pass '+12'; fail '+1234567.89'; pass '+1 234 567.89'; pass '-1'; pass '-12.333333333333333333333333333333333333333'; fail '-1234567'; pass -1; pass -12; fail -1234567; pass 1.2; fail "a"; fail ""; fail "1a"; fail "- 1234"; pass "1 234 567"; pass "12 345.6789"; fail "1 2345 6789"; fail "1.2345.6789"; # TRY FANCY FLAGS try $RE{-base=>10}{num}{-sep=>' '}{real}; pass 0; pass 1; pass 12; fail 1234567; pass 1.23456789; pass 12.23456789; pass 123.23456789; fail 1234.23456789; pass '+1'; pass '+12'; fail '+1234567.89'; pass '+1 234 567.89'; pass '-1'; pass '-12.333333333333333333333333333333333333333'; fail '-1234567'; pass -1; pass -12; fail -1234567; pass 1.2; fail "a"; fail ""; fail "1a"; fail "- 1234"; pass "1 234 567"; pass "12 345.6789"; fail "1 2345 6789"; fail "1.2345.6789"; try $RE{num}{dec}{-sep}; pass 0; pass 1; pass 12; fail 1234567; pass 1.23456789; pass '+1'; pass '+12'; fail '+1234567.89'; pass '-1'; pass '-12.333333333333333333333333333333333333333'; fail '-1234567'; pass -1; pass -12; fail -1234567; pass 1.2; fail "a"; fail ""; fail "1a"; fail "- 1234"; pass "1,234,567"; pass "12,345.6789"; fail "1,2345,6789"; fail "1.2345.6789"; # TEST BASE 2 try $RE{num}{real}{'-base' => '2'}{-sep}; pass 0; pass 1; fail 12; fail 1234567; fail 1.23456789; pass '+1'; fail '+12'; fail '+101010'; fail '+101010.0001010'; pass '+101,010.0001010'; fail '+1234567.89'; pass '-1'; pass -1; fail "a"; fail ""; fail "1a"; fail "- 1010"; pass "1,001,101"; pass "1,010.1110"; fail "1,0101,0011"; fail "1.0011.0011"; try $RE{num}{bin}{-sep}; pass 0; pass 1; fail 12; fail 1234567; fail 1.23456789; pass '+1'; fail '+12'; fail '+101010'; fail '+101010.0001010'; fail '+1234567.89'; pass '-1'; pass -1; fail "a"; fail ""; fail "1a"; fail "- 1010"; pass "1,001,101"; pass "1,010.1110"; fail "1,0101,0011"; fail "1.0011.0011"; # TEST BASE 8 try $RE{num}{real}{'-base' => '8'}{-sep}; pass 0; pass 1; pass 12; fail 1234567; fail 12345678; pass 1.23456; pass '+1'; pass '+12'; fail '+1234567.01'; fail '+1234567.09'; pass '-1'; pass '-12.333333333333333333333333333333333333333'; fail '-1234567'; fail '-1234568'; pass -1; pass -12; fail -1234567; fail -1234568; pass 1.2; fail "a"; fail ""; fail "1a"; fail "- 1234"; pass "1,234,567"; pass "12,345.67"; fail "12,345.68"; fail "1,2345,5670"; fail "1.234.567"; try $RE{num}{oct}{-sep}; pass 0; pass 1; pass 12; fail 1234567; fail 12345678; pass 1.23456; pass '+1'; pass '+12'; fail '+1234567.01'; fail '+1234567.09'; pass '-1'; pass '-12.333333333333333333333333333333333333333'; fail '-1234567'; fail '-1234568'; pass -1; pass -12; fail -1234567; fail -1234568; pass 1.2; fail "a"; fail ""; fail "1a"; fail "- 1234"; pass "1,234,567"; pass "12,345.67"; fail "12,345.68"; fail "1,2345,5670"; fail "1.234.567"; # TEST BASE 16 try $RE{num}{real}{'-base' => '16'}{-sep}; pass 0; pass 1; pass 12; fail '12A4C67'; fail '12345678G'; pass '1.23A56'; fail '1.23Z56'; pass '+1'; pass '+12'; fail '+1234567.01A'; fail '+1234567.09Q'; pass '-1'; pass '-12.ddddddddddddddddddddddddddddddddddddddd'; fail '-123B4567'; fail '-123H4567'; pass -1; pass -12; fail -1234567; pass 1.2; pass "a"; fail ""; pass "1a"; pass "a1a"; fail "DeadBeef"; pass "De,adB,eef"; fail "LiveLamb"; fail "- 1234"; pass "1,abc,def"; pass "12,345.67A"; fail "12,3C5,68"; fail "1,23C5,5670"; fail "1.234.567"; try $RE{num}{hex}{-sep}; pass 0; pass 1; pass 12; fail '12A4C67'; fail '12345678G'; pass '1.23A56'; fail '1.23Z56'; pass '+1'; pass '+12'; fail '+1234567.01A'; fail '+1234567.09Q'; pass '-1'; pass '-12.ddddddddddddddddddddddddddddddddddddddd'; fail '-123B4567'; fail '-123H4567'; pass -1; pass -12; fail -1234567; pass 1.2; pass "a"; fail ""; pass "1a"; pass "a1a"; fail "DeadBeef"; fail "LiveLamb"; fail "- 1234"; pass "1,abc,def"; pass "12,345.67A"; fail "12,3C5,68"; fail "1,23C5,5670"; fail "1.234.567"; # TEST BASE 34 try $RE{num}{real}{'-base' => '34'}{-sep}; pass 0; pass 1; pass 12; fail '12A4C67'; fail '12345678G'; pass '1.23A56'; fail '1.23Z56'; pass '+1'; pass '+12'; fail '+1234567.01A'; fail '+1234567.09Q'; pass '-1'; pass '-12.ddddddddddddddddddddddddddddddddddddddd'; fail '-123B4567'; fail '-123H4567'; pass -1; pass -12; fail -1234567; pass 1.2; pass "a"; fail ""; pass "1a"; pass "a1a"; fail "DeadBeef"; fail "LiveLamb"; pass "De,adB,eef"; pass "Li,veL,amb"; fail "- 1234"; pass "1,abc,def"; pass "12,345.67A"; fail "12,3C5,68"; fail "1,23C5,5670"; fail "1.234.567"; Regexp-Common-2017060201/t/test_comments.t000755 000765 000024 00000017447 12723313224 020664 0ustar00abigailstaff000000 000000 # VOODOO LINE-NOISE my($C,$M,$P,$N,$S);END{print"1..$C\n$M";print"\nfailed: $N\n"if$N} sub ok{$C++; $M.= ($_[0]||!@_)?"ok $C\n":($N++,"not ok $C (". ((caller 1)[1]||(caller 0)[1]).":".((caller 1)[2]||(caller 0)[2]).")\n")} sub try{$P=qr/^$_[0]$/}sub fail{ok($S=$_[0]!~$P)}sub pass{ok($S=$_[0]=~$P)} sub try2 {$P = qr /$_[0]$/} sub pass2 {ok ($S=($_[0] =~ $P && $& eq $_[1]))} sub fail2 {ok ($S=($_[0] !~ $P || $& ne $_[1]))} # LOAD use Regexp::Common; ok; my @ids = ( ['"' => [[Pascal => 'Workshop']]], ); my @from_to = ( [[[Pascal => 'Workshop']] => "/*", "*/"], [[qw /Pascal/, [Pascal => 'Workshop']] => "{", "}"], [[qw /Pascal/, [Pascal => 'Workshop']] => "(*", "*)"], [[qw /Pascal/] => "{", "*)"], [[qw /Pascal/] => "(*", "}"], ); foreach my $info (@ids) { my ($mark, $languages) = @$info; my $not_mark = $mark eq '#' ? '!' : '#'; foreach my $language (@$languages) { if (ref $language) { try $RE{comment}{$language -> [0]}{$language -> [1]}; $language = join ":" => @$language; } else { try $RE{comment}{$language}; } $M .= "# $language\n"; pass qq !${mark}${mark}!; pass qq !${mark}a comment${mark}!; pass qq !${mark}/*a comment */${mark}!; pass qq !${mark}/************${mark}!; pass qq !${mark}/////////////${mark}!; fail qq !${mark}a${mark}${mark}multiline${mark}${mark}comment${mark}!; fail qq !${mark}a comment!; fail qq !${mark}/*a comment */!; fail qq !${mark}/************!; fail qq !${mark}/////////////!; fail qq !${not_mark}${mark}!; fail qq !${not_mark}a comment${mark}!; fail qq !${not_mark}/*a comment */${mark}!; fail qq !${not_mark}/************${mark}!; fail qq !${not_mark}${mark}////////////${mark}!; fail qq !//a comment${mark}!; fail qq !///*a comment */${mark}!; fail qq !///************${mark}!; fail qq !///////////////${mark}!; fail qq !//a${mark}//multiline${mark}//comment${mark}!; fail qq !//a comment!; fail qq !///*a comment */!; fail qq !///************!; fail qq !///////////////!; next if $language eq 'Pascal:Workshop'; fail qq !/*a comment */!; fail qq !/************/!; fail qq !/*a${mark}multiline${mark}comment*/!; fail qq !/*a /*pretend*/ nested comment*/!; fail qq !/*a /*pretend*/!; } } foreach my $info (@from_to) { my ($languages, $from, $to) = @$info; my $f = substr $from => 0, 1; my $t = substr $to => 0, 1; foreach my $language (@$languages) { if (ref $language) { try $RE{comment}{$language -> [0]}{$language -> [1]}; $language = join ":" => @$language; } else { try $RE{comment}{$language}; } my $mark = $language eq 'Nickle' ? ';' : '#'; $M .= "# $language\n"; pass "${from}a comment ${to}"; my @str = ("${from}${t}${t}${t}${t}${t}${t}${t}${t}${t}${t}${to}", "${from}${t}${to}", ); if (${to} =~ /^(?:\Q${t}\E)+$/) {fail $_ for @str;} else {pass $_ for @str;} if ($language eq 'Pascal:Alice') { fail "${from}a\nmultiline\ncomment${to}"; } else { pass "${from}a\nmultiline\ncomment${to}"; } pass "${from}${to}"; fail "${from}a ${from}pretend${to} nested comment${to}"; pass "${from}a ${from}pretend${to}"; pass "${from} {) ${to}"; fail "${from}${t}${t}${t}${t}${t}${t}${t}${t}${t}${t}"; fail "${mark}\n"; fail "${mark}a comment\n"; fail "${mark}${from}a comment ${to}\n"; fail "${mark}${from}${t}${t}${t}${t}${t}${t}${t}${t}${t}${t}${t}\n"; fail "${mark}${f}${f}${f}${f}${f}${f}${f}${f}${f}${f}${f}${f}${f}\n"; fail "${mark}a\n${mark}multiline\n${mark}comment\n"; fail "${mark}a comment"; fail "${mark}${from}a comment ${to}"; fail "${mark}${from}${t}${t}${t}${t}${t}${t}${t}${t}${t}${t}${t}"; fail "${mark}${from}${t}${t}${t}${t}${t}${t}${t}${t}${t}${t}${to}"; fail "${mark}${f}${f}${f}${f}${f}${f}${f}${f}${f}${f}${f}${f}${f}"; } } try $RE{comment}{SQL}{MySQL}; $M .= "# SQL:MySQL\n"; pass "-- \n"; pass "-- a comment\n"; pass "-- /*a comment */\n"; pass "-- /************\n"; pass "-- /////////////\n"; pass "-- ---\n"; fail "--- --\n"; fail "--\n"; pass "-- ---/////////////\n"; fail "-- a\n-- multiline\n-- comment\n"; fail "-- a comment"; fail "-- /*a comment */"; fail "-- /************"; fail "-- /////////////"; pass "#\n"; pass "#a comment\n"; pass "#/*a comment */\n"; pass "#/************\n"; pass "#--////////////\n"; fail "//a comment\n"; fail "///*a comment */\n"; fail "///************\n"; fail "///////////////\n"; fail "//a\n//multiline\n//comment\n"; fail "//a comment"; fail "///*a comment */"; fail "///************"; fail "///////////////"; pass '/*a comment */'; pass '/************/'; pass "/*a\nmultiline\ncomment*/"; fail "/*a /*pretend*/ nested comment*/"; pass "/*a /*pretend*/"; fail "/***********"; pass "/* Comment ;"; fail "/* Comment ; */"; pass "/* Comment ';' */"; pass "/* Comment ';' ;"; pass '/* Comment ";" */'; pass '/* Comment ";" ;'; pass "/* Comment '\n;*/' */"; pass "/* Comment '*/' more comment */"; try $RE{comment}{Brainfuck}; $M .= "# Brainfuck\n"; pass "This is a comment"; pass " "; pass "\n"; pass "\x80\x90\xA0"; fail "[]"; fail "<"; fail "------"; fail "This is - a - comment"; try $RE{comment}{'Algol 68'}; $M .= "# Algol 68\n"; pass "# This is a comment #"; pass "co foo bar co"; pass "co co"; pass "co This is a comment co"; pass "comment This code isn't executed comment"; pass "comment\nMultiline\ncomment"; fail "######################"; fail "# This is not a comment\n"; fail "# # #"; fail "co co co"; fail "comment comment comment"; fail "# Wrong closer co"; fail "# Wrong closer comment"; fail "co foo bar baco"; fail " # foo #"; fail "# foo # "; try $RE{comment}{Squeak}; $M .= "# Squeak\n"; pass '"This is a comment"'; pass '"###########"'; pass '"//"'; pass '""'; pass '"Comment "" with "" double "" quotes"'; fail '#####'; fail '"Multiline"' . "\n" . '"comment"'; fail '"Comment'; fail '"Comment " comment"'; fail '"Comment """ comment"'; try2 $RE{comment}{Fortran}{fixed}; $M .= "# Fortran:fixed\n"; pass2 "!This is a comment\n", "!This is a comment\n"; pass2 "CThis is a comment\n", "CThis is a comment\n"; pass2 "cThis is a comment\n", "cThis is a comment\n"; pass2 "*This is a comment\n", "*This is a comment\n"; pass2 " !This is a comment\n", "!This is a comment\n"; fail " CThis is a comment\n"; fail " cThis is a comment\n"; fail " *This is a comment\n"; fail "!This is a comment"; fail "CThis is a comment"; fail "cThis is a comment"; fail "*This is a comment"; pass2 " !This is a comment\n", "!This is a comment\n"; fail " !This is a comment\n"; pass2 " !This is a comment\n", "!This is a comment\n"; try $RE{comment}{Beatnik}; $M .= "# Beatnik\n"; pass "is"; pass "IS"; pass "whiskers"; fail "whisker"; fail "Zulu"; fail "Hello"; fail "Is a"; fail "Is;"; try2 $RE{comment}{COBOL}; $M .= "# COBOL\n"; fail "This is a comment\n"; fail "*This is a comment\n"; fail " *This is a comment\n"; fail " *This is a comment\n"; fail " *This is a comment\n"; fail " *This is a comment\n"; fail " *This is a comment\n"; pass2 " *This is a comment\n", "*This is a comment\n"; fail " *This is a comment\n"; fail " *This is a comment\n"; fail " *This is a comment\n"; fail " !This is a comment\n"; fail " *This is a comment"; fail " *This is a comment\n *This is a comment\n"; pass2 " ******************\n", "******************\n"; Regexp-Common-2017060201/t/test_curry.t000755 000765 000024 00000002742 12116413566 020201 0ustar00abigailstaff000000 000000 # VOODOO LINE-NOISE my($C,$M,$P,$N,$S);END{print"1..$C\n$M";print"\nfailed: $N\n"if$N} sub ok{$C++; $M.= ($_[0]||!@_)?"ok $C\n":($N++,"not ok $C (". ((caller 1)[1]||(caller 0)[1]).":".((caller 1)[2]||(caller 0)[2]).")\n")} sub try{$P=qr/^$_[0]$/}sub fail{ok($S=$_[0]!~$P)}sub pass{ok($S=$_[0]=~$P)} # LOAD use Regexp::Common; ok; my $num = $RE{num}{real}; # TEST BASE 10 try $num->{'-base' => '10'}{-sep}; pass 0; pass 1; pass 12; fail 1234567; pass 1.23456789; pass 12.23456789; pass 123.23456789; fail 1234.23456789; pass '+1'; pass '+12'; fail '+1234567.89'; pass '+1,234,567.89'; pass '-1'; pass '-12.333333333333333333333333333333333333333'; fail '-1234567'; pass -1; pass -12; fail -1234567; pass 1.2; fail "a"; fail ""; fail "1a"; fail "- 1234"; pass "1,234,567"; pass "12,345.6789"; fail "1,2345,6789"; fail "1.2345.6789"; # TEST BASE 2 try $num->{'-base' => '2'}{-sep}; pass 0; pass 1; fail 12; fail 1234567; fail 1.23456789; pass '+1'; fail '+12'; fail '+101010'; fail '+101010.0001010'; pass '+101,010.0001010'; fail '+1234567.89'; pass '-1'; pass -1; fail "a"; fail ""; fail "1a"; fail "- 1010"; pass "1,001,101"; pass "1,010.1110"; fail "1,0101,0011"; fail "1.0011.0011"; try $RE{num}{bin}{-sep}; pass 0; pass 1; fail 12; fail 1234567; fail 1.23456789; pass '+1'; fail '+12'; fail '+101010'; fail '+101010.0001010'; fail '+1234567.89'; pass '-1'; pass -1; fail "a"; fail ""; fail "1a"; fail "- 1010"; pass "1,001,101"; pass "1,010.1110"; fail "1,0101,0011"; fail "1.0011.0011"; Regexp-Common-2017060201/t/test_i.t000755 000765 000024 00000004120 12723313224 017247 0ustar00abigailstaff000000 000000 #!/usr/bin/perl # Eventually, this should be tested from the individual test files. use strict; use lib qw {blib/lib}; use Regexp::Common qw /RE_ALL/; use warnings; my @data = ( [[qw /num hex/] => ["abcdef", "123.456", "1a2B.3c"]], [[qw /comment ILLGOL/] => ["NB foo bar\n", "nb foo bar\n"]], [[qw /net domain/] => ["www.perl.com", "WWW.PERL.COM"]], [[qw /net MAC/] => ["a0:b0:c0:d0:e0:f0", "A0:B0:C0:D0:E0:F0"]], [[qw /zip Dutch/] => ["1234 ab", "1234 AB", "nl-1234 AB"]], [[qw /URI HTTP/] => ["HTTP://WWW.PERL.COM"]], [[qw /profanity/] => [map {local $_ = $_; y/a-zA-Z/n-za-mN-ZA-M/; $_} qw / pbpx-fhpxre srygpuvat zhgure-shpxre zhgun-shpxvat fuvgf fuvgre penccvat nefr-ubyr cvff-gnxr jnaxf/]], [[qw /num roman/] => [qw /I i II ii XvIiI CXxxVIiI MmclXXviI/]], ); push @data => ( [[qw /balanced/] => ["()", "(a( )b)"]], ); my $total = 1; $total += 2 * @{$_ -> [1]} for @data; print "1..$total\n"; print defined $Regexp::Common::VERSION ? "ok 1\n" : "not ok 1\n"; my $count = 1; sub pass { my @a = @_; $a [0] =~ y/a-zA-Z/n-za-mN-ZA-M/ if $a [1] =~ /profanity/; $a [0] =~ s/\n/\\n/g; printf "ok %d - '%s' =~ %s\n", ++ $count, @a } sub fail { my @a = @_; $a [0] =~ y/a-zA-Z/n-za-mN-ZA-M/ if $a [1] =~ /profanity/; $a [0] =~ s/\n/\\n/g; printf "not ok %d - '%s' =~ %s\n", ++ $count, @a } foreach my $data (@data) { my ($name, $queries) = @$data; foreach my $str (@$queries) { local $" = "}{"; eval "\$str =~ /^\$RE{@$name}{-i}\$/ ? pass \$str, '\$RE{@$name}{-i}' : fail \$str, '\$RE{@$name}{-i}'"; die $@ if $@; local $" = "_"; eval "\$str =~ RE_@$name (-i => 1) ? pass \$str, 'RE_@$name (-i => 1)', : fail \$str, 'RE_@$name (-i => 1)'"; die $@ if $@; } } __END__ Regexp-Common-2017060201/t/test_lingua_palindrome.t000755 000765 000024 00000015010 12723313224 022510 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use lib qw {blib/lib}; use Regexp::Common; use warnings; my $count; my $palindrome = qr /^$RE{lingua}{palindrome}$/; my $fail = qr /^$RE{lingua}{palindrome}{-chars => '\d'}$/; my $keep = qr /^$RE{lingua}{palindrome}{-keep}$/; sub mess {print ++ $count, " - $_ (@_)\n"} sub pass {print "ok "; &mess} sub fail {print "not ok "; &mess} my (@passes, @entries, @failures); while () { chomp; last unless /\S/; push @passes => $_; } while () { chomp; last unless /\S/; push @entries => $_; } while () { chomp; push @failures => $_; } push @failures => " ", ""; my $max = 2 * @failures + 3 * (@passes + 3 * grep {!/^[<>] .*:$/} @entries); print "1..$max\n"; # print "$fail\n"; exit; foreach (@passes) { /$palindrome/ ? pass "match" : fail "no match"; /$keep/ ? $1 eq $_ ? pass "match; keep" : fail "match ($1); keep" : fail "no match; keep"; /$fail/ ? fail "match; fail" : pass "no match; fail"; } foreach (@failures) { /$palindrome/ ? fail "match" : pass "no match"; /$keep/ ? fail "match; keep" : pass "no match; keep"; } foreach my $entry (@entries) { if ($entry =~ /^> (.*):/) { $palindrome = qr /^$RE{lingua}{palindrome}{-chars => $1}$/; $keep = qr /^$RE{lingua}{palindrome}{-chars => $1}{-keep}$/; next; } if ($entry =~ /^< (.*):/) { $fail = qr /^$RE{lingua}{palindrome}{-chars => $1}$/; next; } local $_ = $entry; /$palindrome/ ? fail "match" : pass "no match"; /$keep/ ? fail "match; keep" : pass "no match; keep"; /$fail/ ? fail "match; fail" : pass "no match; fail"; local $_ = $entry . reverse $entry; /$palindrome/ ? pass "match" : fail "no match"; /$keep/ ? $1 eq $_ ? pass "match; keep" : fail "match ($1); keep" : fail "no match; keep"; /$fail/ ? fail "match; fail" : pass "no match; fail"; local $_ = reverse ($entry) . substr $entry, 1; /$palindrome/ ? pass "match" : fail "no match"; /$keep/ ? $1 eq $_ ? pass "match; keep" : fail "match ($1); keep" : fail "no match; keep"; /$fail/ ? fail "match; fail" : pass "no match; fail"; } __DATA__ aha ara bib bob boob civic daad dad deed did dood dud ebbe egge eke ene ere etste ewe eye gag gezeg gig goog huh jij kaak kajak kak kazak keek kek kik kok kook lal lel lepel level lil lol lul madam mam meeneem mem mom mum nebben neen negen neggen nekken nellen nemen nepen neppen neren nessen neten netten neven non noon nun oho paap pap peep pep pip pop pup raar radar redder reder refer rekker remmer renner reviver rotator rotor sas sees serres sexes sis solos soos staats stoots sus temet tit toot tot tut wow SFuHaTEaajrNbFeBpEkPN YcIUURmSfRLoFjJe eckIDoGgvoqkCEUsqMBLTWkK pkgwKxLVxQwhQEtAwUesTSogkaIyJf xYjBxdGcCfLFzXNtAqKRUOJxGKXeJ AdXpQMeyEIfyr SfsapxXkpVfbjsmdXUOou PktrbesqhkyfluVnPwHRugocwvuq WODAUSbVppQb efvqfBZLuqYX ByPHDLvRms DhHqdSYYJAKMNiHvXPLbl eKHZtibxzoXlqgILImYzkCctwhku ecKrqPQqBtIpOEvGEmLIhVFWBuh FwrCTwpQnnaJOqPhMPBODgzpBmXnH lDhQ KRYddvyTyUEWYEahlWtihNOpDrd rlEBgFsNFsO nfjVWYpUdgtiab qHbABOUypLKobEaQyBjp NsBpkIzckTmqZycZuQBQxkbfmGaj ZcNRflemqdsWrCnJeFCydBOnJ qDFnPI YiImqMoXUdhnNC nQGnrxzYicL WmoOUKJi NeVHWlCPsIW PzBTPEoraVOMIbZAIzq iOJqVDGCOPTyZsbsaPlg Yl LDuXxKkGOsmcJWUoKbQUuqLrwh LGDDKUmrXJhhKWXeoYhVGEpwWVX ddvJjgOYbVQBlpTB LAZ pRrxZfIukSORIjJxz xYaeftKXISpLasaDZkeWbUDReFJS YElBQsxQdiddncurlxbKVXov EZTpMtSLMCx OAcfWphdMFv Axref XMwzzoMfHOSMgGMBhVOV sCnhq yLYrxgkXDyfMzNqQxvX UrhwiKxtOLeWD blM efhbKlXqBAtnVzfDbf qnoSZfhTTvgTruFcGAyiGVX CFsXnsXF jjqgFrkIpookzlHpKEDPmAtqMP MzPZ > [a-z]: uehbewnkitmcy eqeeaphplt cqmbytmkanwsmkquegylnkuevwxic gsgyunrvb tdhzvufhgcqoqzvmoizyevcvn vmnoqltrdesvnxfyr ipyroepwytimbdrdmyx gicxjfzpqctsfoz wzpksllqjyiyxaquvxbswzgclk wruucflfyqvitzyzwompwetgd edskskyxbryntdkzo jmmigbfxerisfwzwropzxv dyj dmjgxwbuisixuqsmhv jfsdunyulovxszozsuhdoisykwha beljpcjnbidwiej ihpjalczkejyreaygautktqoh zkujheuhkitqsnggnqvo cpfemiavljvvfsgrmrgvkfx yjiamfbajifvnlmwhvxnco zflbfreheohquoehmehklgtijpqekm oywqmgecvv thddjpasasumoy tagxlzsazzwnzzelrp klvxwmvchyrv supbdycwkufqqftc mafws hlpztnbtbgruqukiroksqscniuqd mobbxnqfqrhlmfvjbxgbcsxbfcoeh webaxlcfqsfw rsxhmxneutngvkgeogmbw cdryfjtleqzhsxyhi uuqriyeartlufhmrbutssb bznyd hrlkwexwhxrudfdjefikc nqovsytdjshkupnklycxpxb zm zmtdrfdvcedutdjhu qslxhtkxnrjdxjfyzkedncvbg thlycnbuhszdtcxqhjyfjtrbc thlttfpdjfwksigtyhiopgiry qiwvs zkcxrrbmqixmuon paqtpvptus vbowrpena xujixuzudptoosuaojdj miqjwg yajiqeszalxloaltijpzzhytoij ueputmp itczvgkjdmnfcdalyuvtnjxuo > \w: rDi5YALoea2yGa0 IO EzrPIMK04vif cXSyVEHYbFQ8WzBrAkS0LnsIklfC dBH0qE5dcg PolVi_ ywihyxxZXuIeWbqiuMu5a5_hDTVr DZQ12Cg8g_CTHvZZzHB 5f5NPQwgctuaETEBWi0TaAqLbJS XZ nflye5EapNHktnWyUGcOV9vJoHOP ewoxUSGw_bQr6WiQBJdmVDpNWBM_A daET_OL48NZ2213dcVT3P SYav069GQ 17cT4sCDBqbRyaaaP7Ql1 V49uRZmWo2Pq mVnJOovJarUmvvj6HCWYKcX 3b0q78jBIV4dVkLvqRMDEgmordp3 UiNxe7XNn1suVr3WuXCLn6NNV0voz GMnUJJbyj_g_nHShSkAQJ2q0V6Ik Nu5ZWWWmG8bXWH0klxU1iQy bJm99Sn2IzfaxYHQRYhm74N2U 8rjj9pDVQ2 H9iw8mR4F 2z YuOudFhIgi3l DK_vYQ1lmOOo4Hv1JmM MaEPzGE FEwFsBhr0rad21pZc5vNBZ35sRi M1H90gYO L5Mxi3GuDcrtlOCdmCO7kSmQZAboOA 9Y8CJoGXY2Aj1awnsOehU3pg6_pHHR 3gwnySmFEGhvc7dBcw FYmqwVHuxi0hepGvNhlEHA5R4d8 LxcoA_CCCG6x6 4axbAGGHEjQ4ChVDAIt5YUqHedgg hp qlIj2 SoUXBA0dQc5d7yueCHWL5N1tXWT nxGFfSG8GIRK 9QvGo36LKz_m8xvniiXuMmKla9RrL 9TjcA PJwRkL76mkv0g6RZBDF nzrxgXRI237kKSH6POckTNImHrA JHmkQ OW_JRzG1afVb6eC9 cBsJo5C hp4dUtypQQoToURHf8iEDYPZIuWe C4Va9 FJ1DVeihL2 < [a-z]: > \d: 29980996457893057 21313835378243030333668 091 729409601 9719624 370 3789153763679167124200438111 7213 205106612350732070380126 560 9932022468162 294997433 07622546948740 651026122541173516020300 813133424529744256580 260427038421 595082137168646535 7097770631397070695986287 810892652 1220621475 92013886546801507931905918 3767894100 71804184572999032104977644350 3941946950830399143521798239 985536734 4493935115991509368392962898 9655414455050335 172310303035555466194702906201 2402676066185 8834370 021824572200322891809377668051 03495183957 24151107 571087664136929781569896 551 7538 1265 91 821889 30933868030192296343807 7858 4405659824543046178 167460529774400160101784746938 8067316585 242483834532989211693778145 089226 7917129387435406520218042163 299639586008870965630234891 47714904484521065705502616510 0741473983774 Regexp-Common-2017060201/t/test_list.t000755 000765 000024 00000002637 12116413566 020013 0ustar00abigailstaff000000 000000 # VOODOO LINE-NOISE my($C,$M,$P,$N,$S);END{print"1..$C\n$M";print"\nfailed: $N\n"if$N} sub ok{$C++; $M.= ($_[0]||!@_)?"ok $C\n":($N++,"not ok $C (". ((caller 1)[1]||(caller 0)[1]).":".((caller 1)[2]||(caller 0)[2]).")\n")} sub try{$P=qr/^$_[0]$/}sub fail{ok($S=$_[0]!~$P)}sub pass{ok($S=$_[0]=~$P)} # LOAD use Regexp::Common; ok; # TEST COMMA-SEPARATED try $RE{list}; fail "a"; pass "a,b"; pass "a, b"; pass "a,b,c"; pass "a, b, c"; fail "a b"; fail "a b"; fail "a b c"; fail "a b c"; # TEST TAB-SEPARATED try $RE{list}{"-sep$;\t"}; fail "a"; pass "a\tb"; pass "a\tb"; pass "a\tb\tc"; pass "a\tb\tc"; fail "a b"; fail "a b"; pass "a b\tc"; fail "a b c"; # TEST WORDS try $RE{list}{and}; fail "a"; pass "a and b"; pass "a, b, and c"; pass "a, b and c"; fail "a,b,c"; fail "a, b, c"; try $RE{list}{conj}; fail "a"; pass "a and b"; pass "a, b, and c"; pass "a, b and c"; pass "a, b, or c"; pass "a, b or c"; fail "a,b,c"; fail "a, b, c"; try $RE{list}{conj}{-word => 'ou'}; fail "a"; pass "a ou b"; pass "a, b, ou c"; pass "a, b ou c"; fail "a,b,c"; fail "a, b, c"; # TRY NESTED PATTERNS try $RE{list}{"-pat$;$RE{quoted}"}; fail q{a}; pass q{'a', 'b'}; fail q{'a', 'b' and 'c'}; pass q{'a', "b", `c`}; fail q{a, b, c}; try $RE{list}{"-pat$;$RE{quoted}"}{-lastsep => '\s*(and|or)\s*'}; fail q{a}; pass q{'a' and 'b'}; pass q{'a', 'b' and 'c'}; fail q{'a', "b", `c`}; pass q{'a', "b" or `c`}; fail q{a, b, c}; Regexp-Common-2017060201/t/test_no_import.t000755 000765 000024 00000000420 12116413566 021032 0ustar00abigailstaff000000 000000 # LOAD BEGIN {print "1..3\n";} use Regexp::Common qw /no_defaults/; print "ok 1\n"; print defined &Regexp::Common::URL::pattern ? "not ok 2\n" : "ok 2\n"; # Make sure $; isn't modified. print $; eq "\034" ? "ok 3" : "not ok 3"; print ' # $; eq "\034"', "\n"; __END__ Regexp-Common-2017060201/t/test_profanity.t000755 000765 000024 00000016043 12116413566 021047 0ustar00abigailstaff000000 000000 # VOODOO LINE-NOISE my($C,$M,$P,$N,$S);END{print"1..$C\n$M";print"\nfailed: $N\n"if$N} sub ok{$C++; $M.= ($_[0]||!@_)?"ok $C\n":($N++,"not ok $C (". ((caller 1)[1]||(caller 0)[1]).":".((caller 1)[2]||(caller 0)[2]).")\n")} sub try{$P=qr/^$_[0]$/}sub fail{ok($S=$_[0]!~$P,$_[0])} sub pass{ok($S=$_[0]=~$P,$_[0])} # LOAD use Regexp::Common; ok; # MAKE THEM PROFANE tr/A-Za-z/N-ZA-Mn-za-m/ foreach (@profanity, @contextual); # TEST UNEQUIVOCABLE PROFANITIES try $RE{profanity}; pass $_ foreach @profanity; fail $_ foreach @contextual; fail $_ foreach @non_profanity; # TEST CONTEXTUAL PROFANITIES try $RE{profanity}{contextual}; pass $_ foreach @profanity; pass $_ foreach @contextual; fail $_ foreach @non_profanity; BEGIN { @non_profanity = ( 'love', 'peace', 'joy', 'honour', 'valour', 'house', 'street', 'parse', 'scrape', 'mishit', 'rectum', 'anus', 'clitoris', 'vagina', 'breast', 'nipple', 'penis', 'scrotum', 'foreskin', ); } BEGIN { @profanity = ( 'oybj-wbo', 'oybj-wbof', 'pbpxfhpxvat', 'pbpx-fhpxre', 'pbpx-fhpxref', 'pbpx-fhpxvat', 'phag', 'phagf', 'srygpu', 'srygpuvat', 'srygpure', 'srygpuref', 'srygpurf', 'srygpurq', 'zbgure-shpxre', 'zbgure-shpxref', 'zbgure-shpxvat', 'zhgure-shpxre', 'zhgure-shpxref', 'zhgure-shpxvat', 'zhgun-shpxre', 'zhgun-shpxref', 'zhgun-shpxvat', 'zhgun-shpxn', 'zhgun-shpxn', 'zhgun-shpxn', 'shpx', 'shpxf', 'shpxvat', 'shpxrq', 'ohyy-fuvg', 'ohyy-fuvgf', 'ohyy-fuvggvat', 'ohyy-fuvggrq', 'ohyy-fuvggre', 'ohyy-fuvggref', 'uneq-ba', 'fuvg', 'fuvgf', 'fuvggvat', 'fuvggrq', 'fuvggre', 'fuvggref', 'fuvggl', 'fuvgr', 'fuvgrf', 'fuvgvat', 'fuvgrq', 'fuvgre', 'fuvgref', 'fuvgrl', 'gjng', 'gjngf', 'gheq', 'gheqf', 'phzf', 'phzvat', 'phzzvat', 'penc', 'pencf', 'penccre', 'penccref', 'penccvat', 'penccrq', 'penccl', 'nff-ubyr', 'nff-ubyrf', 'nffvat', 'nffrq', 'unys-nffrq', 'nefr', 'nefrf', 'nefr-ubyr', 'nefvat', 'nefrq', 'unys-nefrq', 'sneg', 'snegf', 'snegre', 'snegvat', 'snegrq', 'snegl', 'cvff', 'cvffrf', 'cvffre', 'cvffref', 'cvffvat', 'cvffrq', 'cvffl', 'cvff-gnxr', 'zreqr', 'zreq', 'dhvz', 'dhvzf', 'qvpx-urnq', 'qvpxyrff', 'qvpxvat', 'qvpxrq', 'qvpxf', 'jnax', 'jnaxf', 'jnaxre', 'jnaxref', 'jnaxvat', 'jnaxrq', 'oybj wbo', 'oybj wbof', 'pbpx fhpxre', 'pbpx fhpxref', 'pbpx fhpxvat', 'zbgure shpxre', 'zbgure shpxref', 'zbgure shpxvat', 'zhgure shpxre', 'zhgure shpxref', 'zhgure shpxvat', 'zhgun shpxre', 'zhgun shpxref', 'zhgun shpxvat', 'zhgun shpxn', 'zhgun shpxn', 'zhgun shpxn', 'ohyy fuvg', 'ohyy fuvgf', 'ohyy fuvggvat', 'ohyy fuvggrq', 'ohyy fuvggre', 'ohyy fuvggref', 'uneq ba', 'nff ubyr', 'nff ubyrf', 'unys nffrq', 'nefr ubyr', 'unys nefrq', 'cvff gnxr', 'qvpx urnq', 'oybjwbo', 'oybjwbof', 'pbpxfhpxre', 'pbpxfhpxref', 'pbpxfhpxvat', 'zbgureshpxre', 'zbgureshpxref', 'zbgureshpxvat', 'zhgureshpxre', 'zhgureshpxref', 'zhgureshpxvat', 'zhgunshpxre', 'zhgunshpxref', 'zhgunshpxvat', 'zhgunshpxn', 'zhgunshpxn', 'zhgunshpxn', 'ohyyfuvg', 'ohyyfuvgf', 'ohyyfuvggvat', 'ohyyfuvggrq', 'ohyyfuvggre', 'ohyyfuvggref', 'uneqba', 'nffubyr', 'nffubyrf', 'unysnffrq', 'nefrubyr', 'unysnefrq', 'cvffgnxr', 'qvpxurnq' ); @contextual = ( 'onyy', 'onyyf', 'onyyvat', 'onyyrq', 'onyyre', 'onyyref', 'onfgneq', 'oybbql', 'obar', 'obarf', 'obavat', 'obare', 'obaref', 'ohttre', 'pbpx', 'pbpxf', 'qvpx', 'qbat', 'qbatf', 'uhzc', 'uhzcre', 'uhzcref', 'uhzcf', 'uhzcvat', 'uhzcrq', 'cevpx', 'cevpxf', 'cebax', 'cbex', 'chffl', 'chffvrf', 'ebbg', 'ebbgf', 'ebbgre', 'ebbgref', 'ebbgvat', 'ebbgrq', 'fperj', 'fperjf', 'fperjvat', 'fperjrq', 'funt', 'funtf', 'funttvat', 'funttrq', 'funttre', 'funttref', 'fbq', 'fbqf', 'fbqqvat', 'fbqqrq', 'fchax', 'gvg', 'gvgf' ); } Regexp-Common-2017060201/t/test_sub.t000755 000765 000024 00000003065 12723313224 017617 0ustar00abigailstaff000000 000000 # VOODOO LINE-NOISE my($C,$M,$P,$N,$S);END{print"1..$C\n$M";print"\nfailed: $N\n"if$N} sub ok{$C++; $M.= ($_[0]||!@_)?"ok $C\n":($N++,"not ok $C (". ((caller 1)[1]||(caller 0)[1]).":".((caller 1)[2]||(caller 0)[2]).")\n")} sub try{$P=qr/^$_[0]$/}sub fail{ok($S=$_[0]!~$P)}sub pass{ok($S=$_[0]=~$P)} # LOAD use Regexp::Common 'RE_ALL'; ok; try RE_balanced; pass '(a(b))'; fail '(a(b)'; try RE_num_real; pass '-1.234e+567', qw( - 1.234 1 . 234 e +567 + 567 ); try RE_num_dec; pass '-1.234e+567', qw( - 1.234 1 . 234 e +567 + 567 ); try RE_num_real(-base=>2,-expon=>'x2\^'); pass '-101.010x2^101010', qw( - 101.010 101 . 010 x2^ 101010 ), "", "101010"; try RE_num_bin; pass '-101.010E101010', qw( - 101.010 101 . 010 E 101010 ), "", "101010"; try RE_num_real(-base=>10, -sep); pass '-1,234,567.234e+567'; try RE_comment_C; pass '/*abc*/', qw( /* abc */ ); try RE_comment_CXX; pass '/*abc*/'; pass "// abc\n"; try RE_comment_Perl; pass "# abc\n", "#", " abc", "\n"; try RE_comment_shell; pass "# abc\n", "#", " abc", "\n"; try RE_comment_HTML; pass "", ""; try RE_delimited(-delim=>'/'); pass '/a\/b/', qw( / a\/b / ); try RE_delimited(-delim=>'/', -esc=>'/'); pass '/a//b/', qw( / a//b / ); try RE_net_IPv4; pass '123.234.1.0', qw( 123 234 1 0 ); try RE_list_conj(-word=>'(?:and|or)'); pass 'a, b, and c', ', and '; my $profane = 'uneqba'; my $contextual = 'funttref'; foreach ($profane, $contextual) { tr/A-Za-z/N-ZA-Mn-za-m/ } try RE_profanity; pass $profane; try RE_profanity_contextual; pass $contextual; Regexp-Common-2017060201/t/test_sub_named.t000755 000765 000024 00000001133 12723313224 020755 0ustar00abigailstaff000000 000000 # VOODOO LINE-NOISE my($C,$M,$P,$N,$S);END{print"1..$C\n$M";print"\nfailed: $N\n"if$N} sub ok{$C++; $M.= ($_[0]||!@_)?"ok $C\n":($N++,"not ok $C (". ((caller 1)[1]||(caller 0)[1]).":".((caller 1)[2]||(caller 0)[2]).")\n")} sub try{$P=qr/^$_[0]$/}sub fail{ok($S=$_[0]!~$P)}sub pass{ok($S=$_[0]=~$P)} # LOAD use Regexp::Common qw (RE_balanced RE_num_real); ok; try RE_balanced; pass '(a(b))'; fail '(a(b)'; try RE_num_real; pass '-1.234e+567', qw( - 1.234 1 . 234 e +567 + 567 ); try RE_num_real(-base=>2,-expon=>'x2\^'); pass '-101.010x2^101010', qw( - 101.010 101 . 010 x2^ 101010 ), "", "101010"; Regexp-Common-2017060201/t/test_ws.t000755 000765 000024 00000001637 12116413566 017470 0ustar00abigailstaff000000 000000 # VOODOO LINE-NOISE my($C,$M,$P,$N,$S);END{print"1..$C\n$M";print"\nfailed: $N\n"if$N} sub ok{$C++; $M.= ($_[0]||!@_)?"ok $C\n":($N++,"not ok $C (". ((caller 1)[1]||(caller 0)[1]).":".((caller 1)[2]||(caller 0)[2]).")\n")} sub try{$P=qr/$_[0]/}sub fail{ok($S=$_[0]!~$P)}sub pass{ok($S=$_[0]=~$P)} # LOAD use Regexp::Common; ok; try $RE{ws}{crop}; pass " a sentence here\t\t"; pass " a sentence here"; pass "a sentence here\t\t"; fail "a sentence here"; ok $RE{ws}{crop}->matches(" a sentence here\t\t"); ok $RE{ws}{crop}->matches(" a sentence here"); ok $RE{ws}{crop}->matches("a sentence here\t\t"); ok ! $RE{ws}{crop}->matches("a sentence here"); ok 'a sentence here' eq $RE{ws}{crop}->subs(" a sentence here\t\t"); ok 'a sentence here' eq $RE{ws}{crop}->subs(" a sentence here"); ok 'a sentence here' eq $RE{ws}{crop}->subs("a sentence here\t\t"); ok 'a sentence here' eq $RE{ws}{crop}->subs("a sentence here"); Regexp-Common-2017060201/t/URI/000755 000765 000024 00000000000 13114360501 016225 5ustar00abigailstaff000000 000000 Regexp-Common-2017060201/t/zip/000755 000765 000024 00000000000 13114360501 016370 5ustar00abigailstaff000000 000000 Regexp-Common-2017060201/t/zip/101_austria.t000755 000765 000024 00000002440 13114353631 020617 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use warnings; no warnings 'syntax'; use lib "."; use Regexp::Common; use Test::More; use t::zip::Zip; my $r = eval "require Test::Regexp; 1"; unless ($r) { print "1..0 # SKIP Test::Regexp not found\n"; exit; } test_zips country => "Austria", name => "Austrian zip codes", prefix => { iso => "AT", cept => "AUT", invalid => "FR", }, prefix_test_set => [2491, 5114], ; done_testing; sub valid_zip_codes { 1000 .. 1901, 2000 .. 2413, 2421 .. 2425, 2431 .. 2472, 2473 .. 2475, 2481 .. 2490, 2491, 2492 .. 2881, 3001 .. 3333, 3334 .. 3335, 3340 .. 3973, 4000 .. 4294, 4300 .. 4303, 4310 .. 4391, 4392, 4400 .. 4421, 4431 .. 4441, 4442 .. 4481, 4482, 4483 .. 4985, 5000 .. 5114, 5120 .. 5145, 5151 .. 5205, 5211 .. 5283, 5300 .. 5303, 5310 .. 5311, 5321 .. 5351, 5360, 5400 .. 5771, 6000 .. 6691, 6700 .. 6993, 7000 .. 7413, 7421, 7422 .. 7573, 8000 .. 8363, 8380 .. 8385, 8401 .. 8993, 9000 .. 9322, 9323, 9324 .. 9781, 9782, 9800 .. 9873, 9900 .. 9992, } __END__ Regexp-Common-2017060201/t/zip/111_australia.t000755 000765 000024 00000030007 12724114111 021127 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use warnings; no warnings 'syntax'; use Regexp::Common; use Test::More; my $r = eval "require Test::Regexp; 1"; unless ($r) { print "1..0 # SKIP Test::Regexp not found\n"; exit; } my @valid = ((map {sprintf "%04d" => $_} 200, 800 .. 801, 804, 810 .. 815, 820 .. 822, 828 .. 832, 834 .. 840, 845 .. 847, 850 .. 854, 860 .. 862, 870 .. 875, 880 .. 881, 885 .. 886, 909), 1215, 1220, 1225, 1230, 1235, 1240, 1300, 1335, 1340, 1350, 1355, 1360, 1435, 1445, 1450, 1455, 1460, 1465 .. 1466, 1470, 1475, 1480 .. 1481, 1485, 1490, 1495, 1499, 1515, 1560, 1565, 1570, 1585, 1590, 1595, 1630, 1635, 1640, 1655, 1660, 1670, 1675, 1680, 1685, 1700 .. 1701, 1710, 1715, 1730, 1750, 1755, 1765, 1790, 1800, 1805, 1811, 1825, 1835, 1851, 1860, 1871, 1875, 1885, 1890, 2000 .. 2002, 2004, 2006 .. 2012, 2015 .. 2050, 2052, 2057, 2059 .. 2077, 2079 .. 2090, 2092 .. 2097, 2099 .. 2138, 2140 .. 2148, 2150 .. 2168, 2170 .. 2179, 2190 .. 2200, 2203 .. 2214, 2216 .. 2234, 2250 .. 2251, 2256 .. 2265, 2267, 2278, 2280 .. 2287, 2289 .. 2300, 2302 .. 2312, 2314 .. 2330, 2333 .. 2348, 2350 .. 2361, 2365, 2369 .. 2372, 2379 .. 2382, 2386 .. 2388, 2390, 2395 .. 2406, 2408 .. 2411, 2415, 2420 .. 2431, 2439 .. 2441, 2443 .. 2450, 2452 .. 2456, 2460, 2462 .. 2466, 2469 .. 2490, 2500, 2502, 2505 .. 2506, 2508, 2515 .. 2520, 2522, 2525 .. 2530, 2533 .. 2541, 2545 .. 2546, 2548 .. 2551, 2555 .. 2560, 2563 .. 2588, 2590, 2594, 2600 .. 2612, 2614 .. 2633, 2640 .. 2653, 2655 .. 2656, 2658 .. 2661, 2663, 2665 .. 2666, 2668 .. 2669, 2671 .. 2672, 2675, 2678, 2680 .. 2681, 2700 .. 2703, 2705 .. 2708, 2710 .. 2717, 2720 .. 2722, 2725 .. 2727, 2729 .. 2739, 2745, 2747 .. 2754, 2756 .. 2763, 2765 .. 2770, 2773 .. 2780, 2782 .. 2787, 2790 .. 2795, 2797 .. 2800, 2803 .. 2810, 2817 .. 2818, 2820 .. 2836, 2838 .. 2840, 2842 .. 2850, 2852, 2864 .. 2871, 2873 .. 2880, 2890, 2898 .. 2906, 2911 .. 2914, 3000 .. 3004, 3006, 3008, 3010 .. 3013, 3015 .. 3016, 3018 .. 3034, 3036 .. 3068, 3070 .. 3076, 3078 .. 3079, 3081 .. 3085, 3087 .. 3091, 3093 .. 3097, 3099, 3101 .. 3109, 3111, 3113 .. 3116, 3121 .. 3156, 3158 .. 3202, 3204 .. 3207, 3211 .. 3228, 3230 .. 3243, 3249 .. 3251, 3254, 3260, 3264 .. 3287, 3289, 3292 .. 3294, 3300 .. 3305, 3309 .. 3312, 3314 .. 3315, 3317 .. 3319, 3321 .. 3325, 3328 .. 3335, 3337 .. 3338, 3340 .. 3342, 3345, 3350 .. 3357, 3360 .. 3361, 3363 .. 3364, 3370 .. 3371, 3373 .. 3375, 3377 .. 3381, 3384 .. 3385, 3387 .. 3388, 3390 .. 3393, 3395 .. 3396, 3400 .. 3402, 3407, 3409, 3412 .. 3415, 3418 .. 3420, 3423 .. 3424, 3427 .. 3435, 3437 .. 3438, 3440 .. 3442, 3444, 3446 .. 3448, 3450 .. 3451, 3453, 3458, 3460 .. 3465, 3467 .. 3469, 3472, 3475, 3477 .. 3478, 3480, 3482 .. 3483, 3485, 3487 .. 3491, 3494, 3496, 3498, 3500 .. 3502, 3505 .. 3507, 3509, 3512, 3515 .. 3518, 3520 .. 3523, 3525, 3527, 3529 .. 3531, 3533, 3537, 3540, 3542, 3544, 3546, 3549 .. 3552, 3554 .. 3559, 3561 .. 3568, 3570 .. 3573, 3575 .. 3576, 3579 .. 3581, 3583 .. 3586, 3588 .. 3591, 3594 .. 3597, 3599, 3607 .. 3608, 3610, 3612, 3614, 3616 .. 3624, 3629 .. 3641, 3643 .. 3644, 3646 .. 3647, 3649, 3658 .. 3666, 3669 .. 3673, 3675 .. 3678, 3682 .. 3683, 3685, 3687 .. 3691, 3694 .. 3695, 3697 .. 3701, 3704 .. 3705, 3707 .. 3709, 3711 .. 3715, 3717 .. 3720, 3722 .. 3728, 3730, 3732 .. 3733, 3735 .. 3741, 3744, 3746 .. 3747, 3749 .. 3767, 3770, 3775, 3777 .. 3779, 3781 .. 3783, 3785 .. 3789, 3791 .. 3793, 3795 .. 3797, 3799 .. 3800, 3802 .. 3810, 3812 .. 3816, 3818, 3820 .. 3825, 3831 .. 3833, 3835, 3840 .. 3842, 3844, 3847, 3850 .. 3854, 3856 .. 3860, 3862, 3864 .. 3865, 3869 .. 3871, 3873 .. 3875, 3878, 3880, 3882, 3885 .. 3893, 3895 .. 3896, 3898, 3900, 3902 .. 3904, 3909 .. 3913, 3915 .. 3916, 3918 .. 3923, 3925 .. 3931, 3933 .. 3934, 3936 .. 3946, 3950 .. 3951, 3953 .. 3954, 3956 .. 3960, 3962, 3964 .. 3967, 3971, 3975 .. 3981, 3984, 3987 .. 3988, 3990 .. 3992, 3995 .. 3996, 4000 .. 4014, 4017 .. 4022, 4025, 4029 .. 4032, 4034 .. 4037, 4051, 4053 .. 4055, 4059 .. 4061, 4064 .. 4070, 4072 .. 4078, 4101 .. 4125, 4127 .. 4133, 4151 .. 4161, 4163 .. 4165, 4169 .. 4174, 4178 .. 4179, 4183 .. 4184, 4205, 4207 .. 4230, 4270 .. 4272, 4275, 4280, 4285, 4287, 4300 .. 4301, 4303 .. 4307, 4309 .. 4313, 4340 .. 4347, 4350, 4352 .. 4365, 4370 .. 4378, 4380 .. 4385, 4387 .. 4388, 4390, 4400 .. 4408, 4410 .. 4413, 4415 .. 4428, 4454 .. 4455, 4461 .. 4462, 4465, 4467 .. 4468, 4470 .. 4472, 4474 .. 4475, 4477 .. 4482, 4486 .. 4494, 4496 .. 4498, 4500 .. 4512, 4514 .. 4521, 4550 .. 4575, 4580 .. 4581, 4600 .. 4601, 4605 .. 4606, 4608, 4610 .. 4615, 4620 .. 4621, 4625 .. 4627, 4630, 4650, 4655, 4659 .. 4660, 4662, 4670 .. 4671, 4673 .. 4674, 4676 .. 4678, 4680, 4694 .. 4695, 4697, 4699 .. 4707, 4709 .. 4728, 4730 .. 4733, 4735 .. 4746, 4750 .. 4751, 4753 .. 4754, 4756 .. 4757, 4798 .. 4800, 4802 .. 4825, 4828 .. 4830, 4849 .. 4850, 4852, 4854 .. 4861, 4865, 4868 .. 4888, 4890 .. 4892, 4895, 5000 .. 5001, 5006 .. 5025, 5031 .. 5035, 5037 .. 5052, 5061 .. 5076, 5081 .. 5098, 5106 .. 5118, 5120 .. 5121, 5125 .. 5127, 5131 .. 5134, 5136 .. 5142, 5144, 5150 .. 5174, 5201 .. 5204, 5210 .. 5214, 5220 .. 5223, 5231 .. 5238, 5240 .. 5245, 5250 .. 5256, 5259 .. 5273, 5275 .. 5280, 5290 .. 5291, 5301 .. 5304, 5306 .. 5311, 5320 .. 5322, 5330 .. 5333, 5340 .. 5346, 5350 .. 5357, 5360, 5371 .. 5374, 5381, 5400 .. 5401, 5410 .. 5422, 5431 .. 5434, 5440, 5451 .. 5455, 5460 .. 5462, 5464, 5470 .. 5473, 5480 .. 5483, 5485, 5490 .. 5491, 5493, 5495, 5501 .. 5502, 5510, 5520 .. 5523, 5540, 5550, 5552, 5554 .. 5556, 5558, 5560, 5570 .. 5573, 5575 .. 5577, 5580 .. 5583, 5600 .. 5609, 5630 .. 5633, 5640 .. 5642, 5650 .. 5655, 5660 .. 5661, 5670 .. 5671, 5680, 5690, 5700 .. 5701, 5710, 5719 .. 5720, 5722 .. 5725, 5730 .. 5734, 5942, 5950, 6000 .. 6001, 6003 .. 6012, 6014 .. 6038, 6041 .. 6044, 6050 .. 6074, 6076 .. 6079, 6081 .. 6084, 6090, 6100 .. 6112, 6121 .. 6126, 6147 .. 6176, 6180 .. 6182, 6207 .. 6211, 6213 .. 6215, 6218, 6220 .. 6221, 6223 .. 6233, 6236 .. 6237, 6239 .. 6240, 6243 .. 6244, 6251 .. 6256, 6258, 6260, 6262, 6271, 6275, 6280 .. 6282, 6284 .. 6286, 6288, 6290, 6302, 6304, 6306, 6308 .. 6309, 6311 .. 6313, 6315 .. 6318, 6320 .. 6324, 6326 .. 6328, 6330 .. 6333, 6335 .. 6338, 6341, 6343, 6346, 6348, 6350 .. 6353, 6355 .. 6359, 6361, 6363, 6365, 6367 .. 6370, 6372 .. 6373, 6375, 6383 .. 6386, 6390 .. 6398, 6401, 6403, 6405, 6407, 6409 .. 6415, 6418 .. 6434, 6436 .. 6438, 6440, 6442 .. 6443, 6445 .. 6448, 6450, 6452, 6460 .. 6463, 6465 .. 6468, 6470, 6472 .. 6473, 6475 .. 6477, 6479 .. 6480, 6484 .. 6485, 6487 .. 6490, 6501 .. 6507, 6509 .. 6519, 6521 .. 6522, 6525, 6528, 6530 .. 6532, 6535 .. 6537, 6556, 6558, 6560, 6562, 6564, 6566 .. 6569, 6571 .. 6572, 6574 .. 6575, 6603, 6605 .. 6606, 6608 .. 6609, 6612 .. 6614, 6616, 6620, 6623, 6625, 6627 .. 6628, 6630 .. 6632, 6635, 6638 .. 6640, 6642, 6646, 6701, 6705, 6707, 6710 .. 6714, 6716, 6718, 6720 .. 6722, 6725 .. 6726, 6728, 6731, 6733, 6740, 6743, 6751, 6753 .. 6754, 6758, 6760, 6762, 6765, 6770, 6798 .. 6799, 6831, 6837 .. 6850, 6865, 6872, 6892, 6901 .. 6907, 6909 .. 6926, 6929, 6931 .. 6936, 6939, 6941 .. 6947, 6951 .. 6961, 6963 .. 6970, 6979, 6981 .. 6992, 6997, 7000 .. 7002, 7004 .. 7012, 7015 .. 7027, 7030, 7050 .. 7055, 7109, 7112 .. 7113, 7116 .. 7117, 7119 .. 7120, 7139 .. 7140, 7150 .. 7151, 7155, 7162 .. 7163, 7170 .. 7180, 7182 .. 7187, 7190, 7209 .. 7216, 7248 .. 7250, 7252 .. 7265, 7267 .. 7268, 7270, 7275 .. 7277, 7290 .. 7292, 7300 .. 7307, 7310, 7315 .. 7316, 7320 .. 7322, 7325, 7330 .. 7331, 7466 .. 7470, 8001 .. 8012, 9726, ); my %valid = map {$_ => 1} @valid; my %invalid = map {$_ => 1} grep {!$valid {$_}} "0000" .. "9999"; my @invalid = sort {$a <=> $b} keys %invalid; my $Test = Test::Regexp:: -> new -> init ( pattern => $RE {zip} {Australia}, keep_pattern => $RE {zip} {Australia} {-keep}, name => "Australian zip codes", ); my $Test_lax = Test::Regexp:: -> new -> init ( pattern => $RE {zip} {Australia} {-lax}, keep_pattern => $RE {zip} {Australia} {-keep} {-lax}, name => "Australian zip codes, leading zero optional", ); # # Test all valid numbers # foreach my $valid (@valid) { $Test -> match ($valid, [$valid, undef, $valid], test => "Postal code $valid"); $Test_lax -> match ($valid, [$valid, undef, $valid], test => "Postal code $valid"); if ($valid =~ /^0/) { my $shorter = substr $valid, 1; $Test -> no_match ($shorter, reason => "Leading 0 not optional"); $Test_lax -> match ($shorter, [$shorter, undef, $shorter], test => "Postal code $valid with leading 0 omitted"); } } # # Test all invalid 4-digit numbers # foreach my $invalid (@invalid) { $Test -> no_match ($invalid, reason => "Unused zip code $invalid"); $Test_lax -> no_match ($invalid, reason => "Unused zip code $invalid"); } # # Can we prefix the zip code? # foreach my $test_obj ($Test, $Test_lax) { $test_obj -> match ("AU-0909", ["AU-0909", "AU", "0909"], test => "Use iso prefix"); $test_obj -> match ("AUS-0909", ["AUS-0909", "AUS", "0909"], test => "Use cept prefix"); $test_obj -> no_match ("AUT-0909", reason => "Invalid prefix"); } done_testing; Regexp-Common-2017060201/t/zip/112_australia.t000755 000765 000024 00000006526 12723702702 021151 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use warnings; no warnings 'syntax'; use Regexp::Common; use Test::More; my $r = eval "require Test::Regexp; 1"; unless ($r) { print "1..0 # SKIP Test::Regexp not found\n"; exit; } my $Test = Test::Regexp:: -> new -> init ( pattern => $RE {zip} {Australia}, keep_pattern => $RE {zip} {Australia} {-keep}, name => "Australian zip codes", ); my $Test_none = Test::Regexp:: -> new -> init ( pattern => $RE {zip} {Australia} {-prefix => 'no'}, keep_pattern => $RE {zip} {Australia} {-prefix => 'no'} {-keep}, name => "Australian zip codes (no prefix allowed)", ); my $Test_iso = Test::Regexp:: -> new -> init ( pattern => $RE {zip} {Australia} {-prefix => 'yes'} {-country => 'iso'}, keep_pattern => $RE {zip} {Australia} {-prefix => 'yes'} {-country => 'iso'} {-keep}, name => "Australian zip codes (ISO prefix required)", ); my $Test_cept = Test::Regexp:: -> new -> init ( pattern => $RE {zip} {Australia} {-prefix => 'yes'} {-country => 'cept'}, keep_pattern => $RE {zip} {Australia} {-prefix => 'yes'} {-country => 'cept'} {-keep}, name => "Australian zip codes (CEPT prefix required)", ); my @valid = ("0909", 1445, 3500, 9726); # Some selection. my $ISO = "AU"; my $CEPT = "AUS"; foreach my $zip (@valid) { # # No prefix # $Test -> match ($zip, [$zip, undef, $zip], test => "No prefix"); $Test_none -> match ($zip, [$zip, undef, $zip], test => "No prefix"); $Test_iso -> no_match ($zip, reason => "No prefix present"); $Test_cept -> no_match ($zip, reason => "No prefix present"); # # Can we prefix the zip code? # my $zip_iso = "$ISO-$zip"; my $zip_cept = "$CEPT-$zip"; # # ISO prefix # $Test -> match ($zip_iso, [$zip_iso, $ISO, $zip], test => "Use ISO prefix"); $Test_none -> no_match ($zip_iso, reason => "Prefix used"); $Test_iso -> match ($zip_iso, [$zip_iso, $ISO, $zip], test => "Use ISO prefix"); $Test_cept -> no_match ($zip_iso, reason => "ISO prefix used"); # # CEPT prefix # $Test -> match ($zip_cept, [$zip_cept, $CEPT, $zip], test => "Use CEPT prefix"); $Test_none -> no_match ($zip_cept, reason => "Prefix used"); $Test_iso -> no_match ($zip_cept, reason => "CEPT prefix used"); $Test_cept -> match ($zip_cept, [$zip_cept, $CEPT, $zip], test => "Use CEPT prefix"); # # An illegal prefix should never match # my $zip_illegal = "DE-$zip"; $Test -> no_match ($zip_illegal, reason => "Illegal prefix used"); $Test_none -> no_match ($zip_illegal, reason => "Illegal prefix used"); $Test_iso -> no_match ($zip_illegal, reason => "Illegal prefix used"); $Test_cept -> no_match ($zip_illegal, reason => "Illegal prefix used"); } done_testing; Regexp-Common-2017060201/t/zip/121_belgium.t000755 000765 000024 00000021416 13114353631 020601 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use warnings; no warnings 'syntax'; use lib "."; use Regexp::Common; use Test::More; use t::zip::Zip; my $r = eval "require Test::Regexp; 1"; unless ($r) { print "1..0 # SKIP Test::Regexp not found\n"; exit; } test_zips country => "Belgium", name => "Belgian zip codes", prefix => { iso => "BE", cept => "B", invalid => "FR", }, prefix_test_set => [4480, 5555], ; done_testing; sub valid_zip_codes { 1000, 1005 .. 1012, 1020, 1030 .. 1031, 1040 .. 1041, 1043 .. 1045, 1047 .. 1050, 1060, 1070, 1080 .. 1083, 1090, 1100, 1105, 1110, 1120, 1130, 1140, 1150, 1160, 1170, 1180, 1190, 1200 .. 1201, 1210, 1212, 1300 .. 1301, 1310, 1315, 1320, 1325, 1330 .. 1332, 1340 .. 1342, 1348, 1350, 1357, 1360, 1367, 1370, 1380, 1390, 1400 .. 1402, 1404, 1410, 1414, 1420 .. 1421, 1428, 1430, 1435, 1440, 1450, 1457, 1460 .. 1461, 1470 .. 1474, 1476, 1480, 1490, 1495, 1500 .. 1502, 1540 .. 1541, 1547, 1560, 1570, 1600 .. 1602, 1620, 1630, 1640, 1650 .. 1654, 1670 .. 1671, 1673 .. 1674, 1700 .. 1703, 1730 .. 1731, 1740 .. 1742, 1745, 1750, 1755, 1760 .. 1761, 1770, 1780, 1785, 1790, 1800, 1804, 1818, 1820, 1830 .. 1831, 1840, 1850 .. 1853, 1860 .. 1861, 1880, 1910, 1930 .. 1934, 1950, 1970, 1980 .. 1982, 2000, 2018, 2020, 2030, 2040, 2050, 2060, 2070, 2100, 2110, 2140, 2150, 2160, 2170, 2180, 2200, 2220 .. 2223, 2230, 2235, 2240, 2242 .. 2243, 2250, 2260, 2270, 2275, 2280, 2288, 2290, 2300, 2310, 2320 .. 2323, 2328, 2330, 2340, 2350, 2360, 2370, 2380 .. 2382, 2387, 2390, 2400, 2430 .. 2431, 2440, 2450, 2460, 2470, 2480, 2490 .. 2491, 2500, 2520, 2530 .. 2531, 2540, 2547, 2550, 2560, 2570, 2580, 2590, 2600, 2610, 2620, 2627, 2630, 2640, 2650, 2660, 2800 .. 2801, 2811 .. 2812, 2820, 2830, 2840, 2845, 2850, 2860 .. 2861, 2870, 2880, 2890, 2900, 2910, 2920, 2930, 2940, 2950, 2960, 2970, 2980, 2990, 3000 .. 3001, 3010, 3012, 3018, 3020, 3040, 3050 .. 3054, 3060 .. 3061, 3070 .. 3071, 3078, 3080, 3090, 3110 .. 3111, 3118, 3120, 3128, 3130, 3140, 3150, 3190 .. 3191, 3200 .. 3202, 3210 .. 3212, 3220 .. 3221, 3270 .. 3272, 3290, 3293 .. 3294, 3300, 3320 .. 3321, 3350, 3360, 3370, 3380 .. 3381, 3384, 3390 .. 3391, 3400 .. 3401, 3404, 3440, 3450, 3454, 3460 .. 3461, 3470 .. 3473, 3500 .. 3501, 3510 .. 3512, 3520, 3530, 3540, 3545, 3550, 3560, 3570, 3580 .. 3583, 3590, 3600, 3620 .. 3621, 3630 .. 3631, 3640, 3650, 3660, 3665, 3668, 3670, 3680, 3690, 3700, 3717, 3720 .. 3724, 3730, 3732, 3740, 3742, 3746, 3770, 3790 .. 3793, 3798, 3800, 3803, 3806, 3830 .. 3832, 3840, 3850, 3870, 3890 .. 3891, 3900, 3910, 3920, 3930, 3940 .. 3941, 3945, 3950, 3960, 3970 .. 3971, 3980, 3990, 4000, 4020, 4030 .. 4032, 4040 .. 4042, 4050 .. 4053, 4090, 4100 .. 4102, 4120 .. 4122, 4130, 4140 .. 4141, 4151, 4160 .. 4163, 4170 .. 4171, 4180 .. 4181, 4190, 4210, 4217 .. 4219, 4250, 4252 .. 4254, 4257, 4260 .. 4261, 4263, 4280, 4287, 4300, 4317, 4340, 4342, 4347, 4350 .. 4351, 4357, 4360, 4367, 4400, 4420, 4430 .. 4432, 4450 .. 4453, 4458, 4460, 4470, 4480, 4500, 4520, 4530, 4537, 4540, 4550, 4557, 4560, 4570, 4577, 4590, 4600 .. 4602, 4606 .. 4608, 4610, 4620 .. 4621, 4623 .. 4624, 4630 .. 4633, 4650 .. 4654, 4670 .. 4672, 4680 .. 4684, 4690, 4700 .. 4701, 4710 .. 4711, 4720 .. 4721, 4728, 4730 .. 4731, 4750, 4760 .. 4761, 4770 .. 4771, 4780, 4782 .. 4784, 4790 .. 4791, 4800 .. 4802, 4820 .. 4821, 4830 .. 4831, 4834, 4837, 4840 .. 4841, 4845, 4850 .. 4852, 4860 .. 4861, 4870, 4877, 4880, 4890, 4900, 4910, 4920, 4950, 4960, 4970, 4980, 4983, 4987, 4990, 5000 .. 5004, 5020 .. 5022, 5024, 5030 .. 5032, 5060, 5070, 5080 .. 5081, 5100 .. 5101, 5140, 5150, 5170, 5190, 5300, 5310, 5330, 5332 .. 5334, 5336, 5340, 5350 .. 5354, 5360 .. 5364, 5370, 5372, 5374, 5376 .. 5377, 5380, 5500 .. 5504, 5520 .. 5524, 5530, 5537, 5540 .. 5544, 5550, 5555, 5560 .. 5564, 5570 .. 5576, 5580, 5590, 5600, 5620 .. 5621, 5630, 5640 .. 5641, 5644, 5646, 5650 .. 5651, 5660, 5670, 5680, 6000 .. 6001, 6010, 6020, 6030 .. 6032, 6040 .. 6044, 6060 .. 6061, 6110 .. 6111, 6120, 6140 .. 6142, 6150, 6180 .. 6183, 6200, 6210 .. 6211, 6220 .. 6224, 6230, 6238, 6240, 6250, 6280, 6440 .. 6441, 6460 .. 6464, 6470, 6500, 6511, 6530 .. 6534, 6536, 6540, 6542 .. 6543, 6560, 6567, 6590 .. 6594, 6596, 6600, 6630, 6637, 6640, 6642, 6660 .. 6663, 6666, 6670 .. 6674, 6680 .. 6681, 6686 .. 6688, 6690, 6692, 6698, 6700, 6704, 6706, 6717, 6720 .. 6721, 6723 .. 6724, 6730, 6740 .. 6743, 6747, 6750, 6760 .. 6762, 6767, 6769, 6780 .. 6782, 6790 .. 6792, 6800, 6810 .. 6813, 6820 .. 6821, 6823 .. 6824, 6830 .. 6834, 6836, 6838, 6840, 6850 .. 6853, 6856, 6860, 6870, 6880, 6887, 6890, 6900, 6920 .. 6922, 6924, 6927, 6929, 6940 .. 6941, 6950 .. 6953, 6960, 6970 .. 6972, 6980, 6982 .. 6984, 6986 .. 6987, 6990, 6997, 7000, 7010 .. 7012, 7020 .. 7022, 7024, 7030 .. 7034, 7040 .. 7041, 7050, 7060 .. 7063, 7070, 7080, 7090, 7100, 7110, 7120, 7130 .. 7131, 7133 .. 7134, 7140 .. 7141, 7160, 7170, 7180 .. 7181, 7190 .. 7191, 7300 .. 7301, 7320 .. 7322, 7330 .. 7334, 7340, 7350, 7370, 7380, 7382, 7387, 7390, 7500 .. 7504, 7506, 7520 .. 7522, 7530 .. 7534, 7536, 7538, 7540, 7542 .. 7543, 7548, 7600 .. 7604, 7608, 7610 .. 7611, 7618, 7620 .. 7624, 7640 .. 7643, 7700, 7711 .. 7712, 7730, 7740, 7742 .. 7743, 7750, 7760, 7780 .. 7784, 7800 .. 7804, 7810 .. 7812, 7822 .. 7823, 7830, 7850, 7860 .. 7864, 7866, 7870, 7880, 7890, 7900 .. 7901, 7903 .. 7904, 7906, 7910 .. 7912, 7940 .. 7943, 7950 .. 7951, 7970 .. 7973, 8000, 8020, 8200, 8210 .. 8211, 8300 .. 8301, 8310, 8340, 8370, 8377, 8380, 8400, 8420 .. 8421, 8430 .. 8434, 8450, 8460, 8470, 8480, 8490, 8500 .. 8501, 8510 .. 8511, 8520, 8530 .. 8531, 8540, 8550 .. 8554, 8560, 8570, 8572 .. 8573, 8580 .. 8583, 8587, 8600, 8610, 8620, 8630, 8640, 8647, 8650, 8660, 8670, 8680, 8690 .. 8691, 8700, 8710, 8720, 8730, 8740, 8750, 8755, 8760, 8770, 8780, 8790 .. 8793, 8800, 8810, 8820, 8830, 8840, 8850 .. 8851, 8860, 8870, 8880, 8890, 8900, 8902, 8904, 8906, 8908, 8920, 8930, 8940, 8950 .. 8954, 8956 .. 8958, 8970, 8972, 8978, 8980, 9000, 9030 .. 9032, 9040 .. 9042, 9050 .. 9052, 9060, 9070, 9080, 9090, 9100, 9111 .. 9112, 9120, 9130, 9140, 9150, 9160, 9170, 9180, 9185, 9190, 9200, 9220, 9230, 9240, 9250, 9255, 9260, 9270, 9280, 9290, 9300, 9308, 9310, 9320, 9340, 9400 .. 9404, 9406, 9420, 9450 .. 9451, 9470, 9472 .. 9473, 9500, 9506, 9520 .. 9521, 9550 .. 9552, 9570 .. 9572, 9600, 9620, 9630, 9636, 9660 .. 9661, 9667, 9680 .. 9681, 9688, 9690, 9700, 9750, 9770 .. 9772, 9790, 9800, 9810, 9820, 9830 .. 9831, 9840, 9850, 9860, 9870, 9880 .. 9881, 9890, 9900, 9910, 9920 .. 9921, 9930 .. 9932, 9940, 9950, 9960 .. 9961, 9968, 9970 .. 9971, 9980 .. 9982, 9988, 9990 .. 9992, } __END__ Regexp-Common-2017060201/t/zip/131_denmark.t000755 000765 000024 00000014321 13114353631 020574 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use warnings; no warnings 'syntax'; use lib "."; use Regexp::Common; use Test::More; use t::zip::Zip; my $r = eval "require Test::Regexp; 1"; unless ($r) { print "1..0 # SKIP Test::Regexp not found\n"; exit; } test_zips country => "Denmark", name => "Danish zip codes", prefix => { iso => "DK", cept => "DK", invalid => "DE", }, prefix_test_set => [5550, 7100], ; done_testing; sub valid_zip_codes { map {sprintf "%04d" => $_} 800, 900, 917, 960, 999 .. 1000, 1050 .. 1074, 1092 .. 1093, 1095, 1098, 1100 .. 1107, 1110 .. 1131, 1140, 1147 .. 1148, 1150 .. 1162, 1164 .. 1175, 1200 .. 1211, 1213 .. 1221, 1240, 1250 .. 1251, 1253 .. 1257, 1259 .. 1261, 1263 .. 1268, 1270 .. 1271, 1291, 1300 .. 1304, 1306 .. 1329, 1350, 1352 .. 1371, 1400 .. 1403, 1406 .. 1441, 1448, 1450 .. 1460, 1462 .. 1464, 1466 .. 1468, 1470 .. 1472, 1500, 1513, 1532 .. 1533, 1550 .. 1564, 1566 .. 1577, 1592, 1599 .. 1604, 1606 .. 1624, 1630 .. 1635, 1650 .. 1677, 1699 .. 1712, 1714 .. 1739, 1749 .. 1766, 1770 .. 1775, 1777, 1780, 1785 .. 1787, 1790, 1799 .. 1820, 1822 .. 1829, 1850 .. 1857, 1860 .. 1868, 1870 .. 1879, 1900 .. 1906, 1908 .. 1917, 1920 .. 1928, 1950 .. 1967, 1970 .. 1974, 2000, 2100, 2150, 2200, 2300, 2400, 2450, 2500, 2600, 2605, 2610, 2620, 2625, 2630, 2635, 2640, 2650, 2660, 2665, 2670, 2680, 2690, 2700, 2720, 2730, 2740, 2750, 2760, 2765, 2770, 2791, 2800, 2820, 2830, 2840, 2850, 2860, 2870, 2880, 2900, 2920, 2930, 2942, 2950, 2960, 2970, 2980, 2990, 3000, 3050, 3060, 3070, 3080, 3100, 3120, 3140, 3150, 3200, 3210, 3220, 3230, 3250, 3300, 3310, 3320, 3330, 3360, 3370, 3390, 3400, 3450, 3460, 3480, 3490, 3500, 3520, 3540, 3550, 3600, 3630, 3650, 3660, 3670, 3700, 3720, 3730, 3740, 3751, 3760, 3770, 3782, 3790, 4000, 4030, 4040, 4050, 4060, 4070, 4100, 4130, 4140, 4160, 4171, 4173 .. 4174, 4180, 4190, 4200, 4220, 4230, 4241 .. 4243, 4250, 4261 .. 4262, 4270, 4281, 4291, 4293, 4295 .. 4296, 4300, 4320, 4330, 4340, 4350, 4360, 4370, 4390, 4400, 4420, 4440, 4450, 4460, 4470, 4480, 4490, 4500, 4520, 4532, 4534, 4540, 4550, 4560, 4571 .. 4573, 4581, 4583, 4591 .. 4593, 4600, 4621 .. 4623, 4632, 4640, 4652 .. 4654, 4660, 4671 .. 4673, 4681 .. 4684, 4690, 4700, 4720, 4733, 4735 .. 4736, 4750, 4760, 4771 .. 4773, 4780, 4791 .. 4793, 4800, 4840, 4850, 4862 .. 4863, 4871 .. 4874, 4880, 4891 .. 4892, 4894 .. 4895, 4900, 4912 .. 4913, 4920, 4930, 4941, 4943 .. 4944, 4951 .. 4953, 4960, 4970, 4983, 4990, 5000, 5200, 5210, 5220, 5230, 5240, 5250, 5260, 5270, 5290, 5300, 5320, 5330, 5350, 5370, 5380, 5390, 5400, 5450, 5462 .. 5464, 5466, 5471, 5474, 5485, 5491 .. 5492, 5500, 5540, 5550, 5560, 5580, 5591 .. 5592, 5600, 5610, 5620, 5631, 5642, 5672, 5683, 5690, 5700, 5750, 5762, 5771 .. 5772, 5792, 5800, 5853 .. 5854, 5856, 5863, 5871, 5874, 5881 .. 5884, 5892, 5900, 5932, 5935, 5953, 5960, 5970, 5985, 6000, 6040, 6051 .. 6052, 6064, 6070, 6091 .. 6094, 6100, 6200, 6230, 6240, 6261, 6270, 6280, 6300, 6310, 6320, 6330, 6340, 6360, 6372, 6392, 6400, 6430, 6440, 6470, 6500, 6510, 6520, 6534 .. 6535, 6541, 6560, 6580, 6600, 6621 .. 6623, 6630, 6640, 6650, 6660, 6670, 6682 .. 6683, 6690, 6700, 6705, 6710, 6715, 6720, 6731, 6740, 6752 .. 6753, 6760, 6771, 6780, 6792, 6800, 6818, 6823, 6830, 6840, 6851 .. 6855, 6857, 6862, 6870, 6880, 6893, 6900, 6920, 6933, 6940, 6950, 6960, 6971, 6973, 6980, 6990, 7000, 7007, 7080, 7100, 7120, 7130, 7140, 7150, 7160, 7171, 7173, 7182 .. 7184, 7190, 7200, 7250, 7260, 7270, 7280, 7300, 7321, 7323, 7330, 7361 .. 7362, 7400, 7430, 7441 .. 7442, 7451, 7470, 7480, 7490, 7500, 7540, 7550, 7560, 7570, 7600, 7620, 7650, 7660, 7673, 7680, 7700, 7730, 7741 .. 7742, 7752, 7755, 7760, 7770, 7790, 7800, 7830, 7840, 7850, 7860, 7870, 7884, 7900, 7950, 7960, 7970, 7980, 7990, 8000, 8200, 8210, 8220, 8230, 8240, 8245, 8250, 8260, 8270, 8300, 8305, 8310, 8320, 8330, 8340, 8350, 8355, 8361 .. 8362, 8370, 8380 .. 8382, 8400, 8410, 8420, 8444, 8450, 8462, 8464, 8471 .. 8472, 8500, 8520, 8530, 8541, 8543 .. 8544, 8550, 8560, 8570, 8581, 8585 .. 8586, 8592, 8600, 8620, 8632, 8641, 8643, 8653 .. 8654, 8660, 8670, 8680, 8700, 8721 .. 8723, 8732, 8740, 8751 .. 8752, 8762 .. 8763, 8765 .. 8766, 8781, 8783, 8800, 8830 .. 8832, 8840, 8850, 8860, 8870, 8881 .. 8883, 8900, 8920, 8930, 8940, 8950, 8960 .. 8961, 8963, 8970, 8981, 8983, 8990, 9000, 9200, 9210, 9220, 9230, 9240, 9260, 9270, 9280, 9293, 9300, 9310, 9320, 9330, 9340, 9352, 9362, 9370, 9380 .. 9382, 9400, 9430, 9440, 9460, 9480, 9490, 9492 .. 9493, 9500, 9510, 9520, 9530, 9541, 9550, 9560, 9574 .. 9575, 9600, 9610, 9620, 9631 .. 9632, 9640, 9670, 9681, 9690, 9700, 9740, 9750, 9760, 9800, 9830, 9850, 9870, 9881, 9900, 9940, 9970, 9981 .. 9982, 9990, } __END__ Regexp-Common-2017060201/t/zip/141_greenland.t000755 000765 000024 00000001474 13114353631 021120 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use warnings; no warnings 'syntax'; use lib "."; use Regexp::Common; use Test::More; use t::zip::Zip; my $r = eval "require Test::Regexp; 1"; unless ($r) { print "1..0 # SKIP Test::Regexp not found\n"; exit; } test_zips country => "Greenland", name => "Greenlandic zip codes", prefix => { iso => "GL", cept => "GL", invalid => "DE", }, prefix_test_set => [3940, 3955], ; done_testing; sub valid_zip_codes { 2412, 3900, 3905, 3910 .. 3913, 3915, 3919 .. 3924, 3930, 3932, 3940, 3950 .. 3953, 3955, 3961 .. 3962, 3964, 3970 .. 3972, 3980, 3982, 3984 .. 3985, 3992, } __END__ Regexp-Common-2017060201/t/zip/151_norway.t000755 000765 000024 00000047062 13114353631 020504 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use warnings; no warnings 'syntax'; use lib "."; use Regexp::Common; use Test::More; use t::zip::Zip; my $r = eval "require Test::Regexp; 1"; unless ($r) { print "1..0 # SKIP Test::Regexp not found\n"; exit; } test_zips country => "Norway", name => "Norwegian zip codes", prefix => { iso => "NO", cept => "N", invalid => "SE", }, prefix_test_set => [3331, 6996], ; done_testing; sub valid_zip_codes { map {sprintf "%04d" => $_} # Add leading 0s 1, 10, 15, 18, 21, 24 .. 26, 28, 30 .. 34, 37, 40, 45 .. 48, 50 .. 51, 55, 60, 80, 101 .. 107, 109 .. 125, 128 .. 139, 150 .. 155, 157 .. 162, 164 .. 188, 190 .. 196, 198, 201 .. 204, 207 .. 208, 211 .. 218, 230, 240, 244, 247, 250 .. 260, 262 .. 268, 270 .. 284, 286 .. 287, 301 .. 309, 311, 313 .. 319, 323, 330, 340, 349 .. 383, 401 .. 406, 408 .. 413, 415, 421 .. 424, 440 .. 442, 445, 450 .. 452, 454 .. 465, 467 .. 470, 472 .. 496, 501 .. 513, 515 .. 518, 520, 540, 550 .. 598, 601 .. 609, 611 .. 624, 626, 650 .. 694, 701 .. 702, 705, 710, 712, 750 .. 758, 760, 763 .. 768, 770 .. 779, 781 .. 791, 801, 805 .. 807, 840, 850 .. 858, 860 .. 864, 870 .. 877, 880 .. 884, 890 .. 891, 901 .. 905, 907 .. 908, 913 .. 915, 950 .. 960, 962 .. 964, 968 .. 973, 975 .. 988, 1001, 1003, 1005 .. 1009, 1011, 1051 .. 1056, 1061 .. 1065, 1067 .. 1069, 1071, 1081, 1083 .. 1084, 1086 .. 1089, 1101 .. 1102, 1109, 1112, 1150 .. 1158, 1160 .. 1170, 1172, 1176 .. 1179, 1181 .. 1182, 1184 .. 1185, 1187 .. 1189, 1201 .. 1205, 1207, 1214 .. 1215, 1250 .. 1259, 1262 .. 1263, 1266, 1270 .. 1275, 1278 .. 1279, 1281, 1283 .. 1286, 1290 .. 1291, 1294 .. 1295, 1300 .. 1307, 1309, 1311 .. 1314, 1316 .. 1319, 1321 .. 1342, 1344, 1346, 1348 .. 1354, 1356 .. 1369, 1371 .. 1373, 1375 .. 1381, 1383 .. 1397, 1399 .. 1421, 1429 .. 1432, 1440 .. 1451, 1453 .. 1455, 1457 .. 1458, 1468 .. 1488, 1501 .. 1504, 1506, 1508 .. 1526, 1528 .. 1541, 1545, 1550, 1555 .. 1556, 1560, 1570, 1580 .. 1581, 1590 .. 1593, 1596 .. 1599, 1601 .. 1610, 1612 .. 1621, 1624 .. 1626, 1628 .. 1630, 1632 .. 1634, 1636 .. 1642, 1650 .. 1651, 1653 .. 1655, 1657 .. 1659, 1661 .. 1667, 1670 .. 1673, 1675 .. 1676, 1678 .. 1680, 1682 .. 1684, 1690, 1692, 1701 .. 1715, 1718 .. 1727, 1730, 1733 .. 1735, 1738 .. 1740, 1742 .. 1743, 1745 .. 1747, 1751 .. 1754, 1757, 1759 .. 1761, 1763 .. 1769, 1771 .. 1772, 1776 .. 1779, 1781 .. 1794, 1796, 1798 .. 1799, 1801 .. 1809, 1811 .. 1816, 1820, 1823, 1825, 1827, 1830 .. 1833, 1850 .. 1851, 1859 .. 1861, 1866 .. 1867, 1870 .. 1871, 1875, 1878, 1880, 1890 .. 1893, 1900 .. 1901, 1903, 1910 .. 1912, 1914, 1916 .. 1917, 1920 .. 1921, 1923 .. 1931, 1940 .. 1941, 1950, 1954, 1960 .. 1961, 1963, 1970 .. 1971, 2000 .. 2001, 2003 .. 2028, 2030 .. 2036, 2040 .. 2041, 2050 .. 2058, 2060 .. 2062, 2066 .. 2074, 2076, 2080 .. 2081, 2090 .. 2093, 2100 .. 2101, 2110, 2114, 2116, 2120, 2123, 2130, 2133 .. 2134, 2150 .. 2151, 2160 .. 2162, 2164 .. 2166, 2170, 2201 .. 2206, 2208 .. 2214, 2216 .. 2220, 2223 .. 2226, 2230, 2232 .. 2233, 2235, 2240, 2256, 2260 .. 2261, 2264 .. 2266, 2270 .. 2271, 2280, 2283, 2301 .. 2309, 2312, 2315 .. 2326, 2330, 2332, 2334 .. 2338, 2340 .. 2341, 2344 .. 2345, 2350, 2353, 2355, 2360, 2364 .. 2365, 2372, 2380 .. 2391, 2401 .. 2403, 2405 .. 2412, 2415 .. 2416, 2418, 2420 .. 2423, 2425, 2427 .. 2430, 2432, 2435 .. 2438, 2440, 2443, 2446, 2448, 2450 .. 2451, 2460, 2476 .. 2478, 2480 .. 2481, 2485, 2500 .. 2501, 2510, 2512, 2540, 2542, 2544, 2550, 2552, 2555, 2560 .. 2561, 2580 .. 2582, 2584, 2601 .. 2619, 2624 .. 2626, 2629 .. 2637, 2639 .. 2640, 2642 .. 2643, 2645 .. 2649, 2651 .. 2653, 2656 .. 2670, 2672 .. 2677, 2680, 2682 .. 2688, 2690, 2693 .. 2695, 2711 .. 2718, 2720, 2730, 2740, 2742 .. 2743, 2750, 2760, 2770, 2801 .. 2811, 2815 .. 2822, 2825, 2827, 2830 .. 2832, 2836 .. 2840, 2843, 2846 .. 2851, 2853 .. 2854, 2857 .. 2858, 2860 .. 2862, 2864, 2866 .. 2867, 2870, 2879 .. 2882, 2890, 2893, 2900 .. 2901, 2907, 2910, 2917 .. 2918, 2920, 2923, 2929 .. 2930, 2933, 2936 .. 2937, 2939 .. 2940, 2943, 2950, 2952 .. 2954, 2959 .. 2960, 2966 .. 2967, 2973 .. 2975, 2977, 2985, 3001 .. 3009, 3011 .. 3019, 3021 .. 3048, 3050 .. 3051, 3053 .. 3058, 3060 .. 3061, 3070 .. 3071, 3075, 3080 .. 3090, 3092, 3095, 3101, 3103 .. 3128, 3131 .. 3133, 3135, 3137 .. 3145, 3148, 3150 .. 3154, 3157 .. 3189, 3191 .. 3196, 3199, 3201 .. 3246, 3249, 3251 .. 3265, 3267 .. 3271, 3274 .. 3277, 3280 .. 3282, 3284 .. 3285, 3290 .. 3292, 3294 .. 3297, 3300 .. 3301, 3320 .. 3322, 3330 .. 3331, 3340 .. 3342, 3350 .. 3351, 3355, 3358 .. 3361, 3370 .. 3371, 3401 .. 3414, 3420 .. 3421, 3425 .. 3428, 3430 .. 3431, 3440 .. 3442, 3470 .. 3472, 3474 .. 3478, 3480 .. 3484, 3490 .. 3491, 3501 .. 3504, 3507, 3510 .. 3526, 3528 .. 3531, 3533 .. 3541, 3544, 3550 .. 3551, 3560 .. 3561, 3570 .. 3571, 3575 .. 3577, 3579 .. 3581, 3588, 3593, 3595, 3601 .. 3606, 3608 .. 3624, 3626 .. 3632, 3646 .. 3648, 3650, 3652, 3656, 3658, 3660 .. 3661, 3665 .. 3666, 3671 .. 3681, 3683 .. 3684, 3690 .. 3692, 3697, 3701 .. 3705, 3707 .. 3708, 3710 .. 3744, 3746 .. 3750, 3753, 3760, 3766, 3770, 3780 .. 3781, 3783, 3785, 3787 .. 3796, 3798, 3800 .. 3805, 3810 .. 3812, 3820, 3825, 3830 .. 3836, 3840 .. 3841, 3844, 3848 .. 3850, 3853 .. 3855, 3864, 3870, 3880, 3882 .. 3888, 3890 .. 3891, 3893, 3895, 3901 .. 3906, 3910 .. 3922, 3924 .. 3925, 3928 .. 3931, 3933, 3936 .. 3937, 3939 .. 3944, 3946 .. 3950, 3960, 3965 .. 3967, 3970, 3991, 3993 .. 3999, 4001 .. 4029, 4031 .. 4036, 4041 .. 4059, 4064 .. 4070, 4076 .. 4079, 4081 .. 4100, 4102, 4110, 4119 .. 4120, 4123 .. 4124, 4126 .. 4130, 4134, 4137, 4139, 4146, 4148, 4150, 4152 .. 4154, 4156, 4158 .. 4161, 4163 .. 4164, 4167 .. 4170, 4173 .. 4174, 4180, 4182, 4187, 4198, 4200 .. 4201, 4208 .. 4209, 4230, 4233 .. 4235, 4237, 4239 .. 4240, 4244, 4250, 4260, 4262, 4264 .. 4265, 4270, 4272, 4274 .. 4276, 4280, 4291, 4294 .. 4299, 4301 .. 4319, 4321 .. 4330, 4332 .. 4333, 4335, 4339 .. 4349, 4352 .. 4358, 4360, 4362 .. 4365, 4367 .. 4376, 4378 .. 4381, 4387, 4389, 4391 .. 4398, 4400 .. 4403, 4420, 4432, 4434, 4436, 4438, 4440 .. 4441, 4443, 4460, 4462 .. 4463, 4465, 4473, 4480, 4484 .. 4485, 4490 .. 4492, 4501 .. 4506, 4509, 4513 .. 4517, 4519 .. 4525, 4528 .. 4529, 4532, 4534, 4536, 4540, 4544, 4550 .. 4554, 4557 .. 4558, 4560, 4563, 4575 .. 4577, 4579 .. 4580, 4586, 4588, 4590, 4595 .. 4596, 4604 .. 4606, 4608 .. 4626, 4628 .. 4640, 4645 .. 4647, 4651, 4656 .. 4659, 4661 .. 4666, 4670 .. 4679, 4681 .. 4689, 4691, 4693 .. 4703, 4705, 4715, 4720, 4724, 4730, 4733 .. 4735, 4737, 4741 .. 4742, 4745, 4747 .. 4748, 4754 .. 4756, 4760, 4766, 4768, 4770, 4780, 4790 .. 4795, 4801 .. 4804, 4808 .. 4810, 4812, 4815 .. 4818, 4820 .. 4821, 4823 .. 4825, 4827 .. 4828, 4830, 4832, 4834, 4836, 4838 .. 4839, 4841 .. 4844, 4846 .. 4849, 4851 .. 4859, 4861 .. 4865, 4868 .. 4870, 4876 .. 4879, 4884 .. 4889, 4891 .. 4894, 4896, 4898, 4900 .. 4902, 4909 .. 4910, 4912, 4915 .. 4916, 4920, 4934, 4950 .. 4953, 4955, 4971 .. 4974, 4980, 4985, 4990, 4993 .. 4994, 5003 .. 5022, 5031 .. 5039, 5041 .. 5043, 5045, 5052 .. 5059, 5063, 5067 .. 5068, 5072 .. 5073, 5075, 5081 .. 5082, 5089, 5093 .. 5094, 5096 .. 5099, 5101, 5104 .. 5109, 5111, 5113 .. 5119, 5121 .. 5122, 5124, 5130 .. 5132, 5134 .. 5137, 5141 .. 5148, 5151 .. 5155, 5160 .. 5165, 5170 .. 5174, 5176 .. 5179, 5183 .. 5184, 5200 .. 5203, 5206 .. 5212, 5215 .. 5218, 5221 .. 5232, 5235 .. 5239, 5243 .. 5244, 5251 .. 5254, 5257 .. 5265, 5267 .. 5268, 5281 .. 5286, 5291, 5293, 5299 .. 5310, 5314 .. 5315, 5318 .. 5319, 5321 .. 5323, 5325 .. 5327, 5329, 5331, 5333 .. 5337, 5341 .. 5343, 5345 .. 5347, 5350, 5353 .. 5355, 5357 .. 5358, 5360, 5363, 5365 .. 5366, 5371, 5374, 5378 .. 5382, 5384 .. 5385, 5387 .. 5388, 5392 .. 5394, 5396 .. 5399, 5401 .. 5404, 5406 .. 5420, 5423, 5427 .. 5428, 5430, 5437, 5440, 5443 .. 5445, 5447, 5449 .. 5455, 5457 .. 5460, 5462 .. 5465, 5470, 5472 .. 5476, 5480, 5484, 5486, 5498 .. 5499, 5501 .. 5509, 5511 .. 5512, 5514 .. 5519, 5521 .. 5523, 5525, 5527 .. 5529, 5531 .. 5538, 5541 .. 5542, 5544 .. 5551, 5554 .. 5555, 5559 .. 5561, 5563, 5565 .. 5568, 5570, 5574 .. 5576, 5578, 5580, 5582 .. 5586, 5588 .. 5591, 5593 .. 5596, 5598, 5600 .. 5602, 5604 .. 5605, 5610, 5612, 5614, 5620, 5626 .. 5630, 5632, 5635 .. 5637, 5640 .. 5643, 5645 .. 5647, 5649 .. 5650, 5652 .. 5653, 5680, 5683, 5685, 5687, 5690, 5693 .. 5696, 5700 .. 5715, 5718 .. 5719, 5721 .. 5731, 5733 .. 5734, 5736, 5741 .. 5743, 5745 .. 5752, 5760, 5763, 5770, 5773, 5776 .. 5788, 5803 .. 5822, 5824 .. 5825, 5828 .. 5829, 5831, 5835 .. 5836, 5838, 5841, 5845, 5847 .. 5849, 5851 .. 5854, 5857 .. 5859, 5861 .. 5864, 5868 .. 5869, 5871 .. 5873, 5876 .. 5879, 5881 .. 5882, 5884, 5886 .. 5889, 5892 .. 5893, 5895 .. 5896, 5899, 5902 .. 5904, 5906 .. 5908, 5911 .. 5918, 5931, 5936 .. 5939, 5941, 5943, 5947 .. 5948, 5951 .. 5957, 5960 .. 5962, 5966 .. 5967, 5970, 5977 .. 5979, 5981, 5983 .. 5984, 5986 .. 5987, 5991, 5993 .. 5994, 6001 .. 6026, 6028, 6030, 6035 .. 6040, 6043 .. 6048, 6050 .. 6052, 6055, 6057 .. 6060, 6062 .. 6065, 6067 .. 6070, 6076, 6080, 6082 .. 6085, 6087, 6089 .. 6092, 6094 .. 6096, 6098 .. 6106, 6110, 6120, 6133, 6139 .. 6144, 6146, 6149 .. 6156, 6160 .. 6161, 6165 .. 6166, 6170, 6174, 6183 .. 6184, 6190, 6196, 6200 .. 6201, 6210 .. 6216, 6218, 6220, 6222, 6224, 6230, 6238 .. 6240, 6249 .. 6250, 6259 .. 6260, 6263 .. 6265, 6270, 6272, 6280 .. 6283, 6285, 6290, 6292 .. 6294, 6300 .. 6301, 6310, 6315, 6320, 6330, 6339, 6350, 6360, 6363 .. 6364, 6386 .. 6387, 6390 .. 6399, 6401 .. 6405, 6407 .. 6416, 6418 .. 6419, 6421 .. 6423, 6425, 6429 .. 6431, 6433 .. 6436, 6440, 6443 .. 6445, 6447, 6450, 6453 .. 6457, 6460 .. 6462, 6470, 6472, 6475 .. 6476, 6480 .. 6481, 6483 .. 6484, 6486 .. 6488, 6490, 6493 .. 6494, 6499, 6501 .. 6504, 6506 .. 6512, 6514 .. 6518, 6520 .. 6525, 6529 .. 6530, 6538 .. 6539, 6570 .. 6571, 6590, 6600 .. 6601, 6610 .. 6613, 6620, 6622, 6628 .. 6631, 6633, 6636 .. 6640, 6642 .. 6645, 6650, 6652 .. 6653, 6655 .. 6659, 6670, 6674, 6680, 6683, 6686 .. 6690, 6693 .. 6694, 6697 .. 6704, 6707 .. 6708, 6710 .. 6711, 6713 .. 6719, 6721, 6723, 6726 .. 6731, 6734, 6737, 6740 .. 6741, 6750 .. 6751, 6761, 6763, 6770 .. 6772, 6776 .. 6779, 6781 .. 6784, 6788 .. 6789, 6791 .. 6793, 6795 .. 6815, 6817 .. 6819, 6821 .. 6823, 6826 .. 6829, 6841, 6843, 6847 .. 6848, 6851 .. 6856, 6858 .. 6859, 6861, 6863, 6866, 6868 .. 6873, 6875 .. 6879, 6881 .. 6882, 6884 .. 6888, 6891, 6893 .. 6896, 6898 .. 6903, 6909, 6912, 6914 .. 6919, 6921, 6924, 6926 .. 6929, 6940 .. 6942, 6944, 6946 .. 6947, 6951, 6953, 6957 .. 6958, 6961, 6963 .. 6964, 6966 .. 6969, 6971, 6973, 6975, 6977 .. 6978, 6980 .. 6988, 6991, 6993, 6995 .. 6996, 7003 .. 7006, 7010 .. 7016, 7018 .. 7034, 7036 .. 7054, 7056 .. 7059, 7070, 7072, 7074 .. 7075, 7078 .. 7083, 7088 .. 7089, 7091 .. 7092, 7097 .. 7101, 7105, 7110, 7112 .. 7114, 7119 .. 7121, 7125 .. 7127, 7129 .. 7130, 7140, 7142, 7150, 7152 .. 7153, 7156, 7159 .. 7160, 7165 .. 7170, 7176 .. 7178, 7180, 7190, 7194, 7200 .. 7201, 7203, 7206, 7211 .. 7213, 7221, 7223 .. 7224, 7227 .. 7228, 7231 .. 7232, 7234 .. 7236, 7238 .. 7243, 7246 .. 7247, 7250, 7252, 7255 .. 7257, 7259 .. 7261, 7263 .. 7264, 7266, 7268, 7270, 7273, 7280, 7282, 7284 .. 7291, 7295, 7298, 7300 .. 7302, 7310, 7315 .. 7316, 7318 .. 7321, 7327, 7329, 7331 .. 7336, 7338, 7340 .. 7343, 7345, 7350 .. 7351, 7353 .. 7355, 7357 .. 7358, 7361, 7370, 7372, 7374, 7380, 7383 .. 7384, 7386 .. 7387, 7391 .. 7393, 7397 .. 7422, 7424 .. 7459, 7461 .. 7463, 7465 .. 7497, 7500 .. 7510, 7512 .. 7514, 7517, 7519 .. 7520, 7525, 7529 .. 7531, 7533, 7540 .. 7541, 7549 .. 7551, 7560, 7562 .. 7563, 7566, 7570, 7580 .. 7581, 7583 .. 7584, 7590 .. 7591, 7596, 7600 .. 7610, 7619 .. 7620, 7622 .. 7624, 7629 .. 7634, 7650 .. 7658, 7660, 7670 .. 7671, 7690, 7701 .. 7705, 7707 .. 7718, 7724 .. 7726, 7729 .. 7730, 7732, 7734 .. 7740, 7742, 7744 .. 7746, 7748, 7750 .. 7751, 7760 .. 7761, 7770 .. 7771, 7777, 7790 .. 7791, 7796 .. 7797, 7800 .. 7805, 7808, 7810, 7817 .. 7820, 7822, 7856, 7860, 7863 .. 7864, 7869 .. 7871, 7873, 7882, 7884, 7890, 7892 .. 7893, 7896, 7898, 7900 .. 7901, 7940, 7944, 7950, 7960, 7970 .. 7971, 7973, 7976 .. 7977, 7980 .. 7982, 7985, 7990, 7993 .. 7994, 8001 .. 8016, 8019 .. 8023, 8026 .. 8032, 8037 .. 8038, 8041, 8047 .. 8050, 8056, 8058, 8063 .. 8064, 8070 .. 8076, 8079, 8084, 8086 .. 8089, 8091 .. 8098, 8100, 8102 .. 8103, 8108, 8110, 8114, 8118, 8120, 8128, 8130, 8135 .. 8136, 8138, 8140, 8145 .. 8146, 8149 .. 8151, 8157 .. 8161, 8168, 8170, 8178, 8181 .. 8182, 8184 .. 8190, 8193, 8195 .. 8198, 8200 .. 8203, 8205 .. 8211, 8214 .. 8215, 8218 .. 8220, 8226, 8230 .. 8233, 8250 .. 8251, 8255 .. 8256, 8260 .. 8261, 8264, 8266, 8270 .. 8271, 8273 .. 8276, 8278, 8281, 8283, 8285 .. 8286, 8288 .. 8291, 8294, 8297 .. 8298, 8300 .. 8301, 8305, 8309 .. 8317, 8320, 8322 .. 8326, 8328, 8340, 8352, 8357, 8360, 8370, 8372 .. 8373, 8376 .. 8378, 8380, 8382, 8384, 8387 .. 8388, 8390, 8392 .. 8393, 8398, 8400 .. 8416, 8426, 8428, 8430, 8432, 8438 .. 8439, 8445, 8447, 8450, 8455, 8459, 8465, 8469 .. 8470, 8475, 8480 .. 8481, 8483 .. 8485, 8488 .. 8489, 8493, 8501 .. 8510, 8512 .. 8518, 8520, 8522 .. 8523, 8530 .. 8531, 8533 .. 8536, 8539 .. 8540, 8543, 8546, 8590 .. 8591, 8601 .. 8604, 8607 .. 8608, 8610, 8613 .. 8618, 8622, 8624, 8626, 8630, 8634, 8638, 8640 .. 8643, 8646 .. 8648, 8651 .. 8652, 8654 .. 8661, 8663 .. 8666, 8672, 8680 .. 8681, 8690 .. 8691, 8700 .. 8701, 8720, 8723 .. 8725, 8730, 8732 .. 8733, 8735, 8740, 8742 .. 8743, 8750, 8752 .. 8754, 8761 .. 8762, 8764, 8766 .. 8767, 8770, 8800 .. 8805, 8809, 8813, 8820, 8827, 8830, 8842, 8844, 8850 .. 8852, 8854, 8860 .. 8861, 8865, 8870, 8880, 8890 .. 8892, 8897, 8900 .. 8902, 8904 .. 8910, 8920 .. 8922, 8960 .. 8961, 8976, 8980 .. 8981, 8985, 9006 .. 9020, 9022, 9024, 9027, 9029 .. 9030, 9034, 9037 .. 9038, 9040, 9042 .. 9043, 9046, 9049 .. 9050, 9055 .. 9057, 9059 .. 9060, 9062, 9064, 9068 .. 9069, 9100 .. 9108, 9110, 9118 .. 9120, 9128, 9130 .. 9132, 9134 .. 9138, 9140 .. 9144, 9146 .. 9148, 9151 .. 9153, 9156, 9159, 9161 .. 9163, 9169, 9180 .. 9182, 9184 .. 9187, 9189 .. 9190, 9192 .. 9195, 9197, 9240, 9251 .. 9263, 9265 .. 9288, 9290 .. 9294, 9296, 9298 .. 9300, 9302 .. 9306, 9310 .. 9311, 9315 .. 9316, 9321 .. 9322, 9325 .. 9326, 9329, 9334 .. 9336, 9350, 9355, 9357 .. 9358, 9360, 9365, 9370, 9372 .. 9373, 9376, 9379 .. 9382, 9384 .. 9389, 9391 .. 9393, 9395, 9402 .. 9409, 9411, 9414 .. 9415, 9419 .. 9420, 9423 .. 9427, 9430, 9436, 9439 .. 9448, 9450 .. 9451, 9453 .. 9455, 9470 .. 9471, 9475 .. 9476, 9479 .. 9489, 9496 .. 9498, 9501 .. 9521, 9525, 9531 .. 9533, 9536, 9540, 9545, 9550 .. 9551, 9580, 9582 .. 9587, 9590, 9593, 9595, 9600, 9609 .. 9610, 9615 .. 9616, 9620 .. 9621, 9624, 9650, 9657, 9664, 9670, 9672, 9690 .. 9692, 9700, 9709 .. 9717, 9722, 9730, 9735, 9740, 9742, 9750 .. 9751, 9760, 9763 .. 9765, 9768, 9770 .. 9773, 9775, 9782, 9790, 9800, 9802, 9810 .. 9811, 9815, 9820, 9826, 9840, 9845 .. 9846, 9900, 9910, 9912, 9914 .. 9917, 9925, 9930, 9935, 9950 .. 9951, 9960, 9980 .. 9982, 9990 .. 9991, } __END__ Regexp-Common-2017060201/t/zip/161_liechtenstein.t000755 000765 000024 00000001161 13114353631 022012 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use warnings; no warnings 'syntax'; use lib "."; use Regexp::Common; use Test::More; use t::zip::Zip; my $r = eval "require Test::Regexp; 1"; unless ($r) { print "1..0 # SKIP Test::Regexp not found\n"; exit; } test_zips country => "Liechtenstein", name => "Liechtenstein zip codes", prefix => { iso => "LI", cept => "LIE", invalid => "CH", }, prefix_test_set => [9489, 9490], ; done_testing; sub valid_zip_codes { 9485 .. 9498 } __END__ Regexp-Common-2017060201/t/zip/171_switzerland.t000755 000765 000024 00000033372 13114353631 021534 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use warnings; no warnings 'syntax'; use lib "."; use Regexp::Common; use Test::More; use t::zip::Zip; my $r = eval "require Test::Regexp; 1"; unless ($r) { print "1..0 # SKIP Test::Regexp not found\n"; exit; } test_zips country => "Switzerland", name => "Swiss zip codes", prefix => { iso => "CH", cept => "CH", invalid => "LI", }, prefix_test_set => [4444, 6664], ; done_testing; sub valid_zip_codes { 1000 .. 1012, 1014 .. 1015, 1017 .. 1020, 1022 .. 1047, 1052 .. 1055, 1058 .. 1059, 1061 .. 1063, 1066, 1068, 1070 .. 1073, 1076 .. 1078, 1080 .. 1085, 1088, 1090 .. 1098, 1110, 1112 .. 1117, 1121 .. 1128, 1131 .. 1132, 1134 .. 1136, 1141 .. 1149, 1162 .. 1170, 1172 .. 1176, 1180, 1182 .. 1189, 1195 .. 1197, 1200 .. 1209, 1211 .. 1220, 1222 .. 1228, 1231 .. 1234, 1236 .. 1237, 1239 .. 1248, 1251 .. 1258, 1260 .. 1279, 1281, 1283 .. 1300, 1302 .. 1308, 1310 .. 1313, 1315 .. 1318, 1320 .. 1326, 1329 .. 1330, 1337 .. 1338, 1341 .. 1348, 1350, 1352 .. 1358, 1372 .. 1377, 1400 .. 1401, 1404 .. 1410, 1412 .. 1413, 1415 .. 1418, 1420 .. 1443, 1445 .. 1446, 1450, 1452 .. 1454, 1462 .. 1464, 1468, 1470, 1473 .. 1475, 1482 .. 1486, 1489, 1509 .. 1510, 1512 .. 1515, 1521 .. 1530, 1532 .. 1538, 1541 .. 1545, 1551 .. 1555, 1562 .. 1568, 1580, 1582 .. 1589, 1595, 1607 .. 1619, 1623 .. 1628, 1630 .. 1638, 1642 .. 1649, 1651 .. 1654, 1656 .. 1661, 1663, 1665 .. 1667, 1669 .. 1670, 1673 .. 1692, 1694 .. 1697, 1699 .. 1702, 1704 .. 1705, 1707 .. 1709, 1712 .. 1728, 1730 .. 1738, 1740 .. 1742, 1744 .. 1749, 1752 .. 1754, 1756 .. 1757, 1762 .. 1763, 1772 .. 1776, 1782 .. 1789, 1791 .. 1797, 1800 .. 1809, 1811, 1814 .. 1818, 1820, 1822 .. 1824, 1832 .. 1833, 1844 .. 1847, 1852 .. 1854, 1856, 1860, 1862 .. 1875, 1880, 1882, 1884 .. 1885, 1890 .. 1893, 1895 .. 1899, 1902 .. 1908, 1911 .. 1914, 1918 .. 1923, 1925 .. 1929, 1932 .. 1934, 1936 .. 1938, 1941 .. 1948, 1950 .. 1951, 1953, 1955, 1957 .. 1958, 1961 .. 1969, 1971 .. 1978, 1981 .. 1988, 1991 .. 1994, 1996 .. 1997, 2000 .. 2004, 2006 .. 2010, 2012 .. 2017, 2019, 2022 .. 2025, 2027 .. 2028, 2034 .. 2037, 2042 .. 2043, 2046, 2052 .. 2054, 2056 .. 2058, 2063, 2065, 2067 .. 2068, 2072 .. 2075, 2087 .. 2088, 2103, 2105, 2108, 2112 .. 2117, 2123 .. 2124, 2126 .. 2127, 2149, 2206 .. 2208, 2300 .. 2304, 2306, 2314, 2316, 2318, 2322, 2325, 2333, 2336, 2338, 2340, 2345, 2350, 2353 .. 2354, 2360, 2362 .. 2364, 2400, 2405 .. 2406, 2414, 2416, 2500 .. 2505, 2510, 2512 .. 2518, 2520, 2523, 2525, 2532 .. 2538, 2540, 2542 .. 2545, 2552 .. 2558, 2560, 2562 .. 2565, 2572, 2575 .. 2577, 2603 .. 2608, 2610, 2612 .. 2613, 2615 .. 2616, 2710, 2712 .. 2718, 2720, 2722 .. 2723, 2732 .. 2733, 2735 .. 2736, 2738, 2740, 2742 .. 2748, 2762, 2800, 2802 .. 2803, 2805 .. 2807, 2812 .. 2814, 2822 .. 2830, 2832, 2842 .. 2843, 2852 .. 2857, 2863 .. 2864, 2873, 2882 .. 2889, 2900, 2902 .. 2908, 2912, 2914 .. 2916, 2922 .. 2926, 2932 .. 2933, 2935, 2942 .. 2944, 2946 .. 2947, 2950, 2952 .. 2954, 3000 .. 3008, 3010 .. 3015, 3017 .. 3020, 3024, 3027, 3029 .. 3030, 3032 .. 3050, 3052 .. 3054, 3063, 3065 .. 3068, 3070 .. 3078, 3082 .. 3089, 3095 .. 3099, 3110 .. 3116, 3122 .. 3128, 3132, 3144 .. 3145, 3147 .. 3148, 3150, 3152 .. 3159, 3172 .. 3179, 3182 .. 3186, 3202 .. 3208, 3210, 3212 .. 3216, 3225 .. 3226, 3232 .. 3238, 3250 .. 3257, 3262 .. 3264, 3266 .. 3268, 3270 .. 3274, 3280, 3282 .. 3286, 3292 .. 3298, 3302 .. 3303, 3305 .. 3309, 3312 .. 3315, 3317, 3321 .. 3326, 3360, 3362 .. 3363, 3365 .. 3368, 3372 .. 3377, 3380, 3400 .. 3402, 3412 .. 3419, 3421 .. 3429, 3432 .. 3439, 3452 .. 3457, 3462 .. 3465, 3472 .. 3476, 3503 .. 3504, 3506 .. 3508, 3510, 3512 .. 3513, 3531 .. 3538, 3543, 3550 .. 3553, 3555 .. 3557, 3600 .. 3605, 3607 .. 3609, 3612 .. 3619, 3622 .. 3629, 3631 .. 3636, 3638, 3645 .. 3647, 3652 .. 3658, 3661 .. 3665, 3671 .. 3674, 3700, 3702 .. 3707, 3711, 3713 .. 3718, 3722 .. 3725, 3752 .. 3758, 3762 .. 3766, 3770 .. 3773, 3775 .. 3778, 3780 .. 3785, 3792, 3800 .. 3801, 3803 .. 3807, 3812 .. 3816, 3818, 3822 .. 3826, 3852 .. 3858, 3860, 3862 .. 3864, 3900 .. 3908, 3910 .. 3914, 3916 .. 3920, 3922 .. 3935, 3937 .. 3940, 3942 .. 3949, 3951 .. 3957, 3960 .. 3961, 3963, 3965 .. 3968, 3970 .. 3979, 3982 .. 3989, 3991 .. 4005, 4007 .. 4013, 4015 .. 4020, 4023 .. 4025, 4030 .. 4035, 4039 .. 4042, 4051 .. 4059, 4065, 4070, 4075, 4078, 4080 .. 4089, 4091 .. 4096, 4101 .. 4108, 4112, 4114 .. 4118, 4123 .. 4127, 4132 .. 4133, 4142 .. 4148, 4153, 4202 .. 4204, 4206 .. 4208, 4222 .. 4229, 4232 .. 4234, 4242 .. 4247, 4252 .. 4254, 4302 .. 4305, 4310, 4312 .. 4317, 4322 .. 4325, 4332 .. 4334, 4402, 4410 .. 4419, 4421 .. 4426, 4431 .. 4438, 4441 .. 4448, 4450 .. 4453, 4455 .. 4458, 4460 .. 4469, 4492 .. 4497, 4500 .. 4503, 4509, 4512 .. 4515, 4522 .. 4525, 4528, 4532 .. 4539, 4542 .. 4543, 4551 .. 4554, 4556 .. 4558, 4562 .. 4566, 4571, 4573 .. 4574, 4576 .. 4579, 4581 .. 4588, 4600 .. 4601, 4603, 4609, 4611 .. 4618, 4620 .. 4626, 4628 .. 4630, 4632 .. 4634, 4640, 4652 .. 4658, 4663, 4665, 4702 .. 4704, 4710, 4712 .. 4719, 4800 .. 4803, 4805 .. 4809, 4812 .. 4814, 4852 .. 4853, 4856, 4900 .. 4902, 4911 .. 4917, 4919, 4922 .. 4924, 4932 .. 4938, 4942 .. 4944, 4950, 4952 .. 4955, 5000 .. 5001, 5004, 5010, 5012 .. 5015, 5017 .. 5018, 5022 .. 5028, 5032 .. 5037, 5040, 5042 .. 5044, 5046, 5053 .. 5054, 5056 .. 5058, 5062 .. 5064, 5070, 5072 .. 5080, 5082 .. 5085, 5102 .. 5103, 5105 .. 5108, 5112 .. 5113, 5116, 5200 .. 5201, 5210, 5212 .. 5213, 5222 .. 5225, 5232 .. 5237, 5242 .. 5246, 5272 .. 5277, 5300 .. 5301, 5303 .. 5306, 5312 .. 5318, 5322 .. 5326, 5330, 5332 .. 5334, 5400 .. 5402, 5404 .. 5406, 5408, 5412 .. 5413, 5415 .. 5417, 5420, 5423, 5425 .. 5426, 5430 .. 5432, 5436, 5442 .. 5445, 5452 .. 5454, 5462 .. 5467, 5502 .. 5507, 5512, 5522, 5524 .. 5525, 5600 .. 5601, 5603 .. 5608, 5610 .. 5628, 5630, 5632, 5634, 5636 .. 5637, 5642 .. 5647, 5702 .. 5708, 5712, 5722 .. 5728, 5732 .. 5737, 5742, 5745 .. 5746, 6000, 6002 .. 6028, 6030 .. 6039, 6042 .. 6045, 6047 .. 6048, 6052 .. 6053, 6055 .. 6056, 6060 .. 6064, 6066 .. 6068, 6072 .. 6074, 6078, 6083 .. 6086, 6102 .. 6103, 6105 .. 6106, 6110, 6112 .. 6114, 6122 .. 6123, 6125 .. 6126, 6130, 6132 .. 6133, 6142 .. 6147, 6152 .. 6154, 6156, 6160 .. 6163, 6166 .. 6167, 6170, 6173 .. 6174, 6182, 6192, 6196 .. 6197, 6203 .. 6208, 6210 .. 6218, 6221 .. 6222, 6231 .. 6236, 6242 .. 6248, 6252 .. 6253, 6260, 6262 .. 6265, 6274 .. 6277, 6280 .. 6281, 6283 .. 6289, 6294 .. 6295, 6300 .. 6304, 6310, 6312 .. 6315, 6317 .. 6319, 6330 .. 6333, 6340 .. 6346, 6349, 6353 .. 6354, 6356, 6362 .. 6363, 6365, 6370 .. 6377, 6382 .. 6383, 6386 .. 6388, 6390 .. 6391, 6402 .. 6405, 6410, 6414 .. 6418, 6422 .. 6424, 6430 .. 6434, 6436, 6438, 6440 .. 6443, 6452, 6454, 6460 .. 6469, 6472 .. 6476, 6482, 6484 .. 6485, 6487, 6490 .. 6491, 6493, 6500 .. 6501, 6503, 6506, 6511 .. 6518, 6523 .. 6528, 6532 .. 6535, 6537 .. 6538, 6540 .. 6549, 6556 .. 6558, 6562 .. 6563, 6565, 6571 .. 6579, 6582 .. 6584, 6590, 6592 .. 6602, 6604 .. 6605, 6611 .. 6614, 6616, 6618, 6622, 6631 .. 6637, 6644 .. 6648, 6652 .. 6659, 6661 .. 6664, 6670, 6672 .. 6678, 6682 .. 6685, 6690, 6692 .. 6696, 6702 .. 6703, 6705, 6707, 6710, 6713 .. 6724, 6742 .. 6749, 6760, 6763 .. 6764, 6772 .. 6777, 6780 .. 6781, 6802 .. 6810, 6814 .. 6818, 6821 .. 6823, 6825 .. 6828, 6830, 6832 .. 6839, 6850, 6852 .. 6855, 6862 .. 6867, 6872 .. 6875, 6877, 6883, 6900 .. 6908, 6911 .. 6919, 6921 .. 6922, 6924 .. 6930, 6932 .. 6939, 6942 .. 6959, 6962 .. 6968, 6974, 6976 .. 6984, 6986 .. 7004, 7006 .. 7007, 7012 .. 7019, 7023, 7026 .. 7029, 7031 .. 7032, 7050, 7056 .. 7058, 7062 .. 7064, 7074 .. 7078, 7082 .. 7084, 7104, 7106 .. 7107, 7109 .. 7116, 7122, 7126 .. 7128, 7130, 7132 .. 7138, 7141 .. 7149, 7151 .. 7159, 7162 .. 7168, 7172 .. 7176, 7180, 7182 .. 7189, 7201 .. 7206, 7208, 7212 .. 7215, 7220, 7222 .. 7224, 7226, 7228, 7231 .. 7233, 7235, 7240 .. 7247, 7249 .. 7250, 7252, 7260, 7265, 7270, 7272, 7276 .. 7278, 7302 .. 7304, 7306 .. 7307, 7310, 7312 .. 7315, 7317, 7320, 7323 .. 7326, 7402 .. 7405, 7407 .. 7408, 7411 .. 7419, 7421 .. 7428, 7430 .. 7438, 7440, 7442 .. 7448, 7450 .. 7460, 7462 .. 7464, 7472 .. 7473, 7477, 7482, 7484, 7492 .. 7494, 7500, 7502 .. 7505, 7512 .. 7517, 7522 .. 7527, 7530, 7532 .. 7537, 7542 .. 7543, 7545 .. 7546, 7550 .. 7554, 7556 .. 7560, 7562 .. 7563, 7602 .. 7606, 7608, 7610, 7710, 7741 .. 7748, 8000 .. 8006, 8008, 8010 .. 8012, 8015 .. 8016, 8020 .. 8024, 8026 .. 8027, 8030 .. 8034, 8036 .. 8042, 8044 .. 8053, 8055, 8057 .. 8061, 8063 .. 8066, 8068, 8070 .. 8071, 8074 .. 8075, 8080 .. 8081, 8085 .. 8088, 8090 .. 8093, 8096, 8098 .. 8099, 8102 .. 8109, 8112 .. 8115, 8117 .. 8118, 8121 .. 8127, 8130, 8132 .. 8136, 8142 .. 8143, 8152 .. 8158, 8162, 8164 .. 8166, 8172 .. 8175, 8180 .. 8185, 8187, 8192 .. 8197, 8200 .. 8205, 8207 .. 8208, 8210, 8212 .. 8219, 8222 .. 8226, 8228, 8231 .. 8236, 8238 .. 8243, 8245 .. 8248, 8252 .. 8255, 8259 .. 8269, 8272 .. 8274, 8280, 8285, 8301 .. 8312, 8314 .. 8315, 8317, 8320, 8322, 8325, 8330 .. 8332, 8335, 8340, 8342 .. 8345, 8352 .. 8357, 8360, 8362 .. 8363, 8370 .. 8372, 8374, 8376, 8400 .. 8402, 8404 .. 8406, 8408 .. 8416, 8418, 8421 .. 8428, 8442, 8444, 8447, 8450 .. 8455, 8457 .. 8468, 8471 .. 8472, 8474 .. 8479, 8482 .. 8484, 8486 .. 8489, 8492 .. 8503, 8505 .. 8508, 8510, 8512, 8514, 8520, 8522 .. 8526, 8530, 8532, 8535 .. 8537, 8540, 8542 .. 8548, 8552 .. 8556, 8558, 8560 .. 8561, 8564 .. 8566, 8570, 8572 .. 8577, 8580 .. 8590, 8592 .. 8600, 8602 .. 8608, 8610, 8612 .. 8618, 8620 .. 8627, 8630, 8632 .. 8640, 8645 .. 8646, 8700, 8702 .. 8704, 8706 .. 8708, 8712 .. 8718, 8722 .. 8723, 8725 .. 8727, 8730, 8732 .. 8735, 8737 .. 8740, 8750 .. 8759, 8762, 8765 .. 8767, 8772 .. 8775, 8777, 8782 .. 8784, 8800 .. 8808, 8810, 8812 .. 8813, 8815 .. 8816, 8820, 8824 .. 8825, 8832 .. 8836, 8840 .. 8847, 8849, 8852 .. 8858, 8862 .. 8868, 8872 .. 8874, 8877 .. 8890, 8892 .. 8898, 8901 .. 8919, 8925 .. 8926, 8932 .. 8934, 8942, 8951 .. 8957, 8962, 8964 .. 8967, 8970, 9000 .. 9001, 9004, 9006 .. 9016, 9020, 9022 .. 9030, 9032 .. 9038, 9042 .. 9044, 9050, 9052 .. 9058, 9062 .. 9064, 9100 .. 9105, 9107 .. 9108, 9112 .. 9116, 9122 .. 9123, 9125 .. 9127, 9200 .. 9201, 9203 .. 9205, 9212 .. 9217, 9220, 9223, 9225, 9230 .. 9231, 9240, 9242 .. 9249, 9300 .. 9301, 9304 .. 9306, 9308, 9312 .. 9315, 9320, 9322 .. 9323, 9325 .. 9327, 9400 .. 9405, 9410 .. 9411, 9413 .. 9414, 9422 .. 9428, 9430, 9434 .. 9437, 9442 .. 9445, 9450 .. 9453, 9462 .. 9473, 9475 .. 9479, 9500 .. 9504, 9506 .. 9508, 9510, 9512, 9514 .. 9515, 9517, 9523 .. 9527, 9532 .. 9536, 9542 .. 9543, 9545 .. 9548, 9552 .. 9556, 9562, 9565, 9573, 9601 .. 9602, 9604, 9606 .. 9608, 9612 .. 9615, 9620 .. 9622, 9630 .. 9631, 9633, 9642 .. 9643, 9650 .. 9652, 9655 .. 9658, } __END__ Regexp-Common-2017060201/t/zip/181_italy.t000755 000765 000024 00000031326 13114353631 020306 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use warnings; no warnings 'syntax'; use lib "."; use Regexp::Common; use Test::More; use t::zip::Zip; my $r = eval "require Test::Regexp; 1"; unless ($r) { print "1..0 # SKIP Test::Regexp not found\n"; exit; } test_zips country => "Italy", name => "Italian zip codes", prefix => { iso => "IT", cept => "I", invalid => "DE", }, prefix_test_set => [19100, 83020], ; done_testing; sub valid_zip_codes { map {sprintf "%05d" => $_} 10 .. 13, 15, 17 .. 55, 57 .. 63, 65 .. 69, 119 .. 128, 131 .. 139, 141 .. 149, 151 .. 159, 161 .. 169, 171 .. 179, 181 .. 189, 191 .. 199, 1010 .. 1012, 1014 .. 1028, 1030, 1032 .. 1039, 1100, 2010 .. 2016, 2018 .. 2026, 2028, 2030 .. 2035, 2037 .. 2049, 2100, 3010 .. 3014, 3016 .. 3049, 3100, 4010 .. 4029, 4100, 5010 .. 5018, 5020 .. 5026, 5028 .. 5032, 5034 .. 5035, 5039, 5100, 6010, 6012, 6014, 6016, 6018 .. 6031, 6033 .. 6036, 6038 .. 6047, 6049 .. 6051, 6053 .. 6057, 6059 .. 6066, 6068 .. 6070, 6072 .. 6073, 6081, 6083 .. 6084, 6089, 6100, 6121 .. 6129, 6131 .. 6132, 6134, 7010 .. 7041, 7043 .. 7049, 7100, 8010 .. 8013, 8015 .. 8040, 8042 .. 8049, 8100, 9010 .. 9045, 9047 .. 9049, 9070 .. 9086, 9088, 9090 .. 9100, 9121 .. 9129, 9131, 9134, 9170, 10010 .. 10020, 10022 .. 10026, 10028 .. 10032, 10034 .. 10038, 10040 .. 10046, 10048, 10050 .. 10078, 10080 .. 10088, 10090 .. 10095, 10098 .. 10100, 10121 .. 10129, 10131 .. 10139, 10141 .. 10149, 10151 .. 10156, 11010 .. 11018, 11020 .. 11029, 11100, 12010 .. 12056, 12058, 12060 .. 12066, 12068 .. 12084, 12087 .. 12089, 12100, 13010 .. 13012, 13017 .. 13028, 13030 .. 13041, 13043 .. 13049, 13060, 13100, 13811 .. 13812, 13814 .. 13818, 13821 .. 13825, 13831, 13833 .. 13836, 13841, 13843 .. 13845, 13847 .. 13848, 13851 .. 13856, 13861 .. 13868, 13871 .. 13878, 13881 .. 13888, 13891, 13893 .. 13900, 14010 .. 14026, 14030 .. 14037, 14039 .. 14055, 14057 .. 14059, 14100, 15010 .. 15036, 15038 .. 15046, 15048 .. 15079, 15100, 16010 .. 16036, 16038 .. 16049, 16100, 16121 .. 16129, 16131 .. 16139, 16141 .. 16149, 16151 .. 16159, 16161 .. 16167, 17010 .. 17015, 17017, 17019 .. 17028, 17030 .. 17035, 17037 .. 17048, 17051 .. 17058, 17100, 18010 .. 18027, 18030 .. 18039, 18100, 19010 .. 19018, 19020 .. 19021, 19025, 19028, 19030 .. 19034, 19037 .. 19038, 19100, 19121 .. 19126, 19131 .. 19139, 20010 .. 20030, 20032, 20037, 20040, 20056, 20060 .. 20070, 20077 .. 20078, 20080 .. 20099, 20121 .. 20129, 20131 .. 20139, 20141 .. 20149, 20151 .. 20159, 20161 .. 20162, 20811 .. 20816, 20821 .. 20826, 20831 .. 20838, 20841 .. 20847, 20851 .. 20857, 20861 .. 20867, 20871 .. 20877, 20881 .. 20886, 20900, 21010 .. 21059, 21100, 22010 .. 22040, 22044 .. 22046, 22060, 22063, 22066, 22069 .. 22079, 22100, 23010 .. 23027, 23029 .. 23038, 23100, 23801 .. 23802, 23804 .. 23808, 23811, 23813 .. 23819, 23821 .. 23829, 23831 .. 23838, 23841 .. 23849, 23851 .. 23852, 23854 .. 23855, 23857, 23861 .. 23862, 23864 .. 23865, 23867 .. 23868, 23870 .. 23871, 23873 .. 23881, 23883 .. 23900, 24010 .. 24031, 24033 .. 24069, 24100, 24121 .. 24129, 25010 .. 25065, 25068 .. 25089, 25100, 25121 .. 25129, 25131 .. 25136, 26010 .. 26049, 26100, 26811 .. 26818, 26821 .. 26828, 26831 .. 26839, 26841 .. 26849, 26851 .. 26859, 26861 .. 26867, 26900, 27010 .. 27055, 27057 .. 27059, 27100, 28010 .. 28017, 28019, 28021, 28024, 28028, 28040 .. 28041, 28043, 28045 .. 28047, 28050, 28053, 28060 .. 28062, 28064 .. 28066, 28068 .. 28079, 28100, 28801 .. 28805, 28811 .. 28819, 28821 .. 28828, 28831 .. 28833, 28836, 28838, 28841 .. 28845, 28851 .. 28859, 28861 .. 28866, 28868, 28871, 28873, 28875 .. 28877, 28879, 28881, 28883 .. 28887, 28891, 28893 .. 28899, 28922, 29010 .. 29029, 29100, 30010, 30013 .. 30016, 30020 .. 30039, 30100, 30121 .. 30126, 30131 .. 30133, 30135, 30141 .. 30142, 30170 .. 30175, 31010 .. 31018, 31020 .. 31059, 31100, 32010, 32012 .. 32016, 32020 .. 32022, 32026 .. 32028, 32030 .. 32037, 32040 .. 32047, 32100, 33010 .. 33011, 33013, 33015 .. 33059, 33070, 33072, 33074 .. 33087, 33090, 33092, 33094 .. 33095, 33097 .. 33100, 33170, 34010 .. 34012, 34014 .. 34018, 34070 .. 34079, 34100, 34121 .. 34129, 34131 .. 34139, 34141 .. 34149, 34151, 34170, 35010 .. 35032, 35034 .. 35038, 35040 .. 35048, 35100, 35121 .. 35129, 35131 .. 35139, 35141 .. 35143, 36010 .. 36016, 36020 .. 36028, 36030 .. 36036, 36040, 36042 .. 36043, 36045 .. 36047, 36050 .. 36057, 36060 .. 36066, 36070 .. 36073, 36075 .. 36078, 36100, 37010 .. 37024, 37026, 37028 .. 37032, 37035 .. 37036, 37038 .. 37047, 37049 .. 37060, 37062 .. 37064, 37066 .. 37069, 37100, 37121 .. 37129, 37131 .. 37139, 37142, 38010 .. 38013, 38015 .. 38043, 38045 .. 38057, 38059 .. 38083, 38085 .. 38089, 38100, 39010 .. 39058, 39100, 40010 .. 40027, 40030, 40032 .. 40038, 40041 .. 40043, 40045 .. 40046, 40048, 40050 .. 40057, 40059 .. 40069, 40100, 40121 .. 40129, 40131 .. 40139, 40141, 41010 .. 41023, 41025 .. 41040, 41042 .. 41046, 41048 .. 41049, 41051 .. 41059, 41100, 42010 .. 42028, 42030 .. 42035, 42037, 42039 .. 42049, 42100, 43010 .. 43015, 43017 .. 43022, 43024 .. 43025, 43028 .. 43030, 43032, 43035 .. 43045, 43047 .. 43053, 43055 .. 43056, 43058 .. 43059, 43100, 43126, 44010 .. 44012, 44014 .. 44016, 44019 .. 44023, 44025 .. 44030, 44033 .. 44035, 44037, 44039, 44041 .. 44043, 44045, 44047 .. 44049, 44100, 45010 .. 45012, 45014 .. 45015, 45017 .. 45027, 45030 .. 45039, 45100, 46010 .. 46014, 46017 .. 46020, 46022 .. 46033, 46035 .. 46037, 46039 .. 46049, 46100, 47010 .. 47021, 47023, 47025, 47027 .. 47028, 47030, 47032, 47034 .. 47035, 47039, 47042 .. 47043, 47100, 47121 .. 47122, 47814, 47822, 47824 .. 47826, 47832 .. 47838, 47841 .. 47843, 47853 .. 47855, 47861 .. 47867, 47900, 48010 .. 48015, 48017 .. 48018, 48020, 48022, 48024 .. 48027, 48100, 50010, 50012 .. 50014, 50018 .. 50023, 50025 .. 50028, 50031 .. 50039, 50041, 50050 .. 50056, 50058 .. 50068, 50100, 50121 .. 50127, 50129, 50131 .. 50137, 50139, 50141 .. 50145, 51010 .. 51013, 51015 .. 51021, 51024, 51028, 51030 .. 51031, 51034 .. 51037, 51039, 51100, 52010 .. 52011, 52014 .. 52018, 52020 .. 52022, 52024 .. 52033, 52035 .. 52038, 52041, 52043 .. 52048, 52100, 53011 .. 53027, 53030 .. 53031, 53034 .. 53037, 53040 .. 53043, 53045, 53047 .. 53049, 53100, 54010 .. 54016, 54021, 54023, 54026 .. 54029, 54033, 54035, 54038, 54100, 55010 .. 55016, 55018 .. 55020, 55022 .. 55023, 55025, 55027, 55030 .. 55036, 55038, 55040 .. 55042, 55045, 55047, 55049, 55051, 55054, 55060 .. 55062, 55064, 55100, 56010 .. 56012, 56017, 56019 .. 56025, 56028 .. 56038, 56040 .. 56041, 56043 .. 56046, 56048, 56100, 56121 .. 56128, 57014, 57016 .. 57017, 57020 .. 57023, 57025, 57027 .. 57028, 57030 .. 57034, 57036 .. 57039, 57100, 57121 .. 57128, 58010 .. 58012, 58014 .. 58015, 58017 .. 58020, 58022 .. 58027, 58031, 58033 .. 58034, 58036 .. 58038, 58040, 58042 .. 58045, 58051, 58053 .. 58055, 58100, 59011, 59013, 59015 .. 59016, 59021, 59024 .. 59026, 59100, 60010 .. 60011, 60013, 60015, 60018 .. 60022, 60024 .. 60027, 60030 .. 60031, 60033 .. 60041, 60043 .. 60044, 60048, 60100, 60121 .. 60129, 60131, 61010 .. 61014, 61020 .. 61026, 61028 .. 61030, 61032 .. 61034, 61037 .. 61049, 61100, 62010 .. 62012, 62014 .. 62015, 62017 .. 62022, 62024 .. 62029, 62032, 62034 .. 62036, 62038 .. 62039, 62100, 63020, 63031, 63061 .. 63069, 63071 .. 63079, 63081 .. 63088, 63091 .. 63096, 63100, 63811 .. 63816, 63821 .. 63828, 63831 .. 63839, 63841 .. 63848, 63851 .. 63858, 63900, 64010 .. 64016, 64018, 64020 .. 64021, 64023 .. 64028, 64030 .. 64037, 64039 .. 64047, 64049, 64100, 65010 .. 65015, 65017, 65019 .. 65020, 65022 .. 65029, 65100, 65121 .. 65129, 65131 .. 65132, 66010 .. 66012, 66014 .. 66023, 66026, 66030 .. 66034, 66036 .. 66038, 66040 .. 66047, 66050 .. 66052, 66054, 66100, 67010, 67012 .. 67015, 67017, 67019 .. 67041, 67043 .. 67064, 67066 .. 67069, 67100, 70010 .. 70011, 70013 .. 70029, 70032 .. 70033, 70037 .. 70038, 70042 .. 70044, 70054, 70056, 70100, 70121 .. 70129, 70131, 71010 .. 71043, 71045, 71047 .. 71048, 71100, 72010, 72012 .. 72029, 72100, 73010 .. 73059, 73100, 74010 .. 74028, 74100, 75010 .. 75029, 75100, 76011 .. 76017, 76121, 76123, 76125, 80010 .. 80014, 80016 .. 80036, 80038 .. 80042, 80044 .. 80051, 80053 .. 80063, 80065 .. 80067, 80069 .. 80071, 80073 .. 80079, 80100, 80121 .. 80129, 80131 .. 80139, 80141 .. 80147, 81010 .. 81014, 81016 .. 81017, 81020 .. 81025, 81027 .. 81028, 81030 .. 81044, 81046 .. 81047, 81049 .. 81059, 81100, 82010 .. 82011, 82013, 82015 .. 82034, 82036 .. 82038, 82100, 83010 .. 83018, 83020 .. 83032, 83034 .. 83059, 83100, 84010 .. 84040, 84042 .. 84053, 84055 .. 84057, 84059 .. 84062, 84065 .. 84070, 84073 .. 84088, 84090 .. 84092, 84095 .. 84096, 84098 .. 84100, 84121 .. 84129, 84131 .. 84135, 85010 .. 85018, 85020 .. 85040, 85042 .. 85044, 85046 .. 85059, 85100, 86010 .. 86049, 86070 .. 86075, 86077 .. 86097, 86100, 86170, 87010 .. 87024, 87026 .. 87038, 87040 .. 87048, 87050 .. 87058, 87060 .. 87062, 87064, 87066 .. 87067, 87069 .. 87076, 87100, 88020 .. 88022, 88024 .. 88025, 88040 .. 88042, 88044 .. 88047, 88049 .. 88051, 88054 .. 88056, 88060, 88062, 88064 .. 88065, 88067 .. 88070, 88100, 88811 .. 88819, 88821 .. 88825, 88831 .. 88838, 88841 .. 88842, 88900, 89010 .. 89018, 89020 .. 89050, 89052, 89054, 89056 .. 89058, 89060, 89062 .. 89065, 89069, 89100, 89121 .. 89129, 89131 .. 89135, 89812 .. 89819, 89821 .. 89824, 89831 .. 89834, 89841 .. 89844, 89851 .. 89853, 89861 .. 89864, 89866 .. 89868, 89900, 90010 .. 90049, 90100, 90121 .. 90129, 90131 .. 90139, 90141 .. 90149, 90151, 91010 .. 91029, 91100, 92010 .. 92029, 92100, 93010 .. 93019, 93100, 94010 .. 94019, 94100, 95010 .. 95022, 95024 .. 95025, 95027 .. 95049, 95100, 95121 .. 95129, 95131, 96010 .. 96019, 96100, 97010 .. 97019, 97100, 98020 .. 98023, 98025 .. 98051, 98053 .. 98079, 98100, 98121 .. 98129, 98131 .. 98139, 98141 .. 98149, 98151 .. 98159, 98161 .. 98168, } __END__ Regexp-Common-2017060201/t/zip/191_germany.t000755 000765 000024 00000230176 13114353631 020633 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use warnings; no warnings 'syntax'; use lib "."; use Regexp::Common; use Test::More; use t::zip::Zip; my $r = eval "require Test::Regexp; 1"; unless ($r) { print "1..0 # SKIP Test::Regexp not found\n"; exit; } test_zips country => "Germany", name => "German zip codes", prefix => { iso => "DE", cept => "D", invalid => "NL", }, prefix_test_set => [22299, 77776], ; done_testing; sub valid_zip_codes { map {sprintf "%05d" => $_} 1067, 1069, 1097, 1099, 1108 .. 1109, 1127, 1129, 1139, 1156 .. 1157, 1159, 1169, 1187, 1189, 1217, 1219, 1237, 1239, 1257, 1259, 1277, 1279, 1307, 1309, 1314, 1324, 1326, 1328, 1445, 1454, 1458, 1462, 1465, 1468, 1471, 1477 .. 1478, 1558, 1561, 1587, 1589, 1591, 1594, 1609, 1612, 1616, 1619, 1623, 1640, 1662, 1665, 1683, 1689, 1705, 1723, 1728, 1731, 1734, 1737 .. 1738, 1744, 1762, 1768, 1773 .. 1774, 1776, 1778, 1796, 1809, 1814, 1816, 1819, 1824 .. 1825, 1829, 1833, 1844, 1847 .. 1848, 1855, 1877, 1896, 1900, 1904, 1906, 1909, 1917, 1920, 1936, 1945, 1968, 1979, 1983, 1987, 1990, 1993 .. 1994, 1996, 1998, 2625, 2627, 2633, 2640, 2643, 2681, 2689, 2692, 2694, 2699, 2708, 2727, 2730, 2733, 2736, 2739, 2742, 2747 .. 2748, 2763, 2779, 2782, 2785, 2788, 2791, 2794, 2796 .. 2797, 2799, 2826 .. 2829, 2894, 2899, 2906, 2923, 2929, 2943, 2953, 2956 .. 2957, 2959, 2977, 2979, 2991, 2994, 2997, 2999, 3042, 3044, 3046, 3048, 3050 .. 3055, 3058, 3096, 3099, 3103, 3116, 3119, 3130, 3139, 3149, 3159, 3172, 3185, 3197, 3202, 3205, 3222, 3226, 3229, 3238, 3246, 3249, 3253, 4103, 4105, 4107, 4109, 4129, 4155, 4157 .. 4159, 4177 .. 4179, 4205, 4207, 4209, 4229, 4249, 4275, 4277, 4279, 4288 .. 4289, 4299, 4315 .. 4319, 4328 .. 4329, 4347, 4349, 4356 .. 4357, 4416, 4420, 4425, 4435, 4442, 4451, 4460, 4463, 4509, 4519, 4523, 4539, 4552, 4564 .. 4565, 4567, 4571, 4574 .. 4575, 4579, 4600, 4603, 4610, 4613, 4617 .. 4618, 4626, 4639, 4643, 4651, 4654 .. 4655, 4657, 4668, 4680, 4683, 4685, 4687 .. 4688, 4703, 4720, 4736, 4741, 4746, 4749, 4758, 4769, 4774, 4779, 4808, 4821, 4824, 4827 .. 4828, 4838, 4849, 4860, 4862, 4874, 4880, 4886, 4889, 4895, 4910, 4916, 4924, 4928, 4931 .. 4932, 4934, 4936, 4938, 6108, 6110, 6112, 6114, 6116, 6118, 6120, 6122, 6124, 6126, 6128, 6130, 6132, 6179, 6184, 6188, 6193, 6198, 6217, 6231, 6237, 6242, 6246, 6249, 6254 .. 6255, 6258 .. 6259, 6268, 6279, 6295, 6308, 6311, 6313, 6317 .. 6318, 6333, 6343, 6347 .. 6348, 6366, 6369, 6385 .. 6386, 6388, 6406, 6408, 6420, 6425, 6429, 6449, 6456, 6458, 6463 .. 6464, 6466 .. 6467, 6469, 6484, 6493, 6502, 6507, 6526, 6528, 6536 .. 6537, 6542 .. 6543, 6547 .. 6548, 6556, 6567, 6571, 6577 .. 6578, 6618, 6628, 6632, 6636, 6638, 6642, 6647 .. 6648, 6667, 6679, 6682, 6686, 6688, 6712, 6721 .. 6722, 6724 .. 6725, 6727, 6729, 6731, 6749, 6766, 6773 .. 6774, 6779 .. 6780, 6785 .. 6786, 6791 .. 6792, 6794, 6796, 6800, 6803 .. 6804, 6808 .. 6809, 6842, 6844, 6846 .. 6847, 6849, 6861 .. 6862, 6869, 6886, 6888 .. 6889, 6895 .. 6896, 6901, 6905, 6909, 6917 .. 6918, 6922, 6925 .. 6926, 6928, 7318, 7330, 7333 .. 7334, 7336, 7338, 7343, 7349, 7356, 7366, 7368, 7381, 7387, 7389, 7407, 7422, 7426 .. 7427, 7429, 7545 .. 7546, 7548 .. 7549, 7551 .. 7552, 7554, 7557, 7570, 7580, 7586, 7589, 7607, 7613, 7616, 7619, 7629, 7639, 7646, 7743, 7745, 7747, 7749, 7751, 7768, 7774, 7778, 7806, 7819, 7907, 7919, 7922, 7924, 7926 .. 7927, 7929, 7937, 7950, 7952, 7955, 7957 .. 7958, 7973, 7980, 7985, 7987, 7989, 8056, 8058, 8060, 8062, 8064, 8066, 8107, 8112, 8115, 8118, 8132, 8134, 8141, 8144, 8147, 8209, 8223, 8228, 8233, 8236 .. 8237, 8239, 8248, 8258, 8261 .. 8262, 8265, 8267, 8269, 8280, 8289, 8294, 8297, 8301, 8304, 8309, 8312, 8315, 8318, 8321, 8324 .. 8326, 8328, 8340, 8344, 8349, 8352, 8355, 8359, 8371, 8373, 8393, 8396, 8412, 8427 .. 8428, 8432, 8439, 8451, 8459, 8468, 8485, 8491, 8496, 8499, 8523, 8525, 8527, 8529, 8538 .. 8539, 8541, 8543, 8547 .. 8548, 8606, 8626, 8645, 8648, 9028, 9030, 9111 .. 9114, 9116 .. 9117, 9119 .. 9120, 9122 .. 9123, 9125 .. 9128, 9130 .. 9131, 9212, 9217, 9221, 9224, 9227 .. 9228, 9232, 9235 .. 9236, 9241, 9243 .. 9244, 9249, 9306, 9322, 9326, 9328, 9337, 9350, 9353, 9355 .. 9356, 9366, 9376, 9380, 9385, 9387, 9390, 9392, 9394 .. 9395, 9399, 9405, 9419, 9423, 9427, 9429 .. 9430, 9432, 9435, 9437, 9439, 9456, 9465, 9468, 9471, 9474, 9477, 9481, 9484, 9487 .. 9488, 9496, 9509, 9514, 9517 .. 9518, 9526, 9544, 9548, 9557, 9569, 9573, 9575, 9577, 9579, 9599 .. 9600, 9603, 9618 .. 9619, 9623, 9627, 9629, 9633 .. 9634, 9638, 9648, 9661, 9669, 10115, 10117, 10119, 10178 .. 10179, 10243, 10245, 10247, 10249, 10315, 10317 .. 10319, 10365, 10367, 10369, 10405, 10407, 10409, 10435, 10437, 10439, 10551, 10553, 10555, 10557, 10559, 10585, 10587, 10589, 10623, 10625, 10627, 10629, 10707, 10709, 10711, 10713, 10715, 10717, 10719, 10777, 10779, 10781, 10783, 10785, 10787, 10789, 10823, 10825, 10827, 10829, 10961, 10963, 10965, 10967, 10969, 10997, 10999, 11011, 12043, 12045, 12047, 12049, 12051, 12053, 12055, 12057, 12059, 12099, 12101, 12103, 12105, 12107, 12109, 12157, 12159, 12161, 12163, 12165, 12167, 12169, 12203, 12205, 12207, 12209, 12247, 12249, 12277, 12279, 12305, 12307, 12309, 12347, 12349, 12351, 12353, 12355, 12357, 12359, 12435, 12437, 12439, 12459, 12487, 12489, 12524, 12526 .. 12527, 12529, 12555, 12557, 12559, 12587, 12589, 12619, 12621, 12623, 12627, 12629, 12679, 12681, 12683, 12685, 12687, 12689, 13047, 13051, 13053, 13055, 13057, 13059, 13086, 13088 .. 13089, 13125, 13127, 13129, 13156, 13158 .. 13159, 13187, 13189, 13347, 13349, 13351, 13353, 13355, 13357, 13359, 13403, 13405, 13407, 13409, 13435, 13437, 13439, 13465, 13467, 13469, 13503, 13505, 13507, 13509, 13581, 13583, 13585, 13587, 13589, 13591, 13593, 13595, 13597, 13599, 13627, 13629, 14050, 14052 .. 14053, 14055, 14057, 14059, 14089, 14109, 14129, 14131, 14163, 14165, 14167, 14169, 14193, 14195, 14197, 14199, 14461, 14467, 14469, 14471, 14473, 14476, 14478, 14480, 14482, 14513, 14532, 14542, 14547 .. 14548, 14550, 14552, 14554, 14557 .. 14558, 14612, 14621, 14624, 14627, 14641, 14656, 14662, 14669, 14712, 14715, 14727 .. 14728, 14770, 14772, 14774, 14776, 14778, 14789, 14793, 14797 .. 14798, 14806, 14822 .. 14823, 14827 .. 14828, 14913, 14929, 14943, 14947, 14959, 14974, 14979, 15230, 15232, 15234, 15236, 15295, 15299, 15306, 15320, 15324, 15326, 15328, 15344 .. 15345, 15366, 15370, 15372, 15374, 15377 .. 15378, 15517 .. 15518, 15526, 15528, 15537, 15562, 15566, 15569, 15711, 15732, 15738, 15741, 15745 .. 15746, 15748 .. 15749, 15751 .. 15752, 15754 .. 15755, 15757 .. 15758, 15806, 15827, 15831, 15834, 15837 .. 15838, 15848, 15859, 15864, 15868, 15890, 15898, 15907, 15910, 15913, 15926, 15936, 15938, 16225, 16227, 16230, 16244, 16247 .. 16248, 16259, 16269, 16278, 16303, 16306 .. 16307, 16321, 16341, 16348, 16352, 16356, 16359, 16515, 16540, 16547 .. 16548, 16552, 16556, 16559, 16562, 16565, 16567, 16727, 16761, 16766 .. 16767, 16775, 16792, 16798, 16816, 16818, 16827, 16831, 16833, 16835, 16837, 16845, 16866, 16868, 16909, 16918, 16921, 16928, 16945, 16949, 17033 .. 17034, 17036, 17039, 17087, 17089, 17091, 17094, 17098 .. 17099, 17109, 17111, 17121, 17126, 17129, 17139, 17153 .. 17154, 17159, 17166, 17168, 17179, 17192, 17194, 17207, 17209, 17213 .. 17214, 17217, 17219, 17235, 17237, 17248, 17252, 17255, 17258 .. 17259, 17268, 17279, 17291, 17309, 17321 .. 17322, 17326, 17328 .. 17329, 17335, 17337, 17348 .. 17349, 17358, 17367, 17373, 17375, 17379, 17389 .. 17392, 17398, 17406, 17419, 17424, 17429, 17438, 17440, 17449, 17454, 17459, 17489, 17491, 17493, 17495, 17498, 17506, 17509, 18055, 18057, 18059, 18069, 18106 .. 18107, 18109, 18119, 18146 .. 18147, 18181 .. 18182, 18184, 18190, 18195 .. 18196, 18198, 18209, 18211, 18225, 18230 .. 18231, 18233, 18236, 18239, 18246, 18249, 18258, 18273, 18276, 18279, 18292, 18299, 18311, 18314, 18317, 18320, 18334, 18337, 18347, 18356, 18374 .. 18375, 18435, 18437, 18439, 18442, 18445, 18461, 18465, 18469, 18507, 18510, 18513, 18516, 18519, 18528, 18546, 18551, 18556, 18565, 18569, 18573 .. 18574, 18581, 18586, 18609, 19053, 19055, 19057, 19059, 19061, 19063, 19065, 19067, 19069, 19071, 19073, 19075, 19077, 19079, 19086, 19089, 19205, 19209, 19217, 19230, 19243, 19246, 19249, 19258, 19260, 19273, 19288, 19294, 19300, 19303, 19306, 19309, 19322, 19336, 19339, 19348, 19357, 19370, 19372, 19374, 19376, 19386, 19395, 19399, 19406, 19412, 19417, 20038, 20088, 20095, 20097, 20099, 20144, 20146, 20148 .. 20149, 20249, 20251, 20253, 20255, 20257, 20259, 20350, 20354 .. 20355, 20357, 20359, 20457, 20459, 20535, 20537, 20539, 21029, 21031, 21033, 21035, 21037, 21039, 21073, 21075, 21077, 21079, 21107, 21109, 21129, 21147, 21149, 21217 .. 21218, 21220, 21224, 21227 .. 21228, 21244, 21255 .. 21256, 21258 .. 21259, 21261, 21266, 21271 .. 21272, 21274, 21279, 21335, 21337, 21339, 21354, 21357 .. 21358, 21360, 21365, 21368 .. 21369, 21371, 21376, 21379 .. 21380, 21382, 21385 .. 21386, 21388, 21391, 21394 .. 21395, 21397 .. 21398, 21400 .. 21401, 21403, 21406 .. 21407, 21409, 21423, 21435 .. 21436, 21438 .. 21439, 21441 .. 21442, 21444 .. 21445, 21447, 21449, 21465, 21481, 21483, 21493, 21502, 21509, 21514, 21516, 21521 .. 21522, 21524, 21526 .. 21527, 21529, 21614, 21629, 21635, 21640 .. 21641, 21643 .. 21644, 21646 .. 21647, 21649, 21680, 21682 .. 21684, 21698, 21702, 21706, 21709 .. 21710, 21712, 21714, 21717, 21720, 21723, 21726 .. 21727, 21729 .. 21730, 21732, 21734, 21737, 21739, 21745, 21755 .. 21756, 21762 .. 21763, 21765, 21769 .. 21770, 21772, 21775 .. 21776, 21781 .. 21782, 21784 .. 21785, 21787, 21789, 22041, 22043, 22045, 22047, 22049, 22081, 22083, 22085, 22087, 22089, 22111, 22113, 22115, 22117, 22119, 22143, 22145, 22147, 22149, 22159, 22175, 22177, 22179, 22297, 22299, 22301, 22303, 22305, 22307, 22309, 22335, 22337, 22339, 22359, 22391, 22393, 22395, 22397, 22399, 22415, 22417, 22419, 22453, 22455, 22457, 22459, 22523, 22525, 22527, 22529, 22547, 22549, 22559, 22587, 22589, 22605, 22607, 22609, 22761, 22763, 22765, 22767, 22769, 22844, 22846, 22848, 22850 .. 22851, 22869, 22880, 22885, 22889, 22926 .. 22927, 22929, 22941, 22946, 22949, 22952, 22955 .. 22956, 22958 .. 22959, 22962, 22964 .. 22965, 22967, 22969, 23539, 23552, 23554, 23556, 23558, 23560, 23562, 23564, 23566, 23568 .. 23570, 23611, 23617, 23619, 23623, 23626 .. 23629, 23669, 23683 .. 23684, 23689, 23701, 23714 .. 23715, 23717, 23719, 23730, 23738, 23743 .. 23744, 23746 .. 23747, 23749, 23758, 23769, 23774 .. 23775, 23777, 23779, 23795, 23812 .. 23813, 23815 .. 23816, 23818, 23820 .. 23821, 23823 .. 23824, 23826 .. 23827, 23829, 23843, 23845, 23847, 23858, 23860, 23863, 23866 .. 23867, 23869, 23879, 23881, 23883, 23896, 23898 .. 23899, 23909, 23911, 23919, 23923, 23936, 23942, 23944, 23946, 23948, 23952, 23966, 23968, 23970, 23972, 23974, 23992, 23996, 23999, 24103, 24105 .. 24107, 24109, 24111, 24113 .. 24114, 24116, 24118 .. 24119, 24143, 24145 .. 24149, 24159, 24161, 24211, 24214, 24217, 24220, 24222 .. 24223, 24226, 24229, 24232, 24235, 24238 .. 24239, 24241 .. 24242, 24244 .. 24245, 24247 .. 24248, 24250 .. 24251, 24253 .. 24254, 24256 .. 24257, 24259, 24306, 24321, 24326 .. 24327, 24329, 24340, 24351, 24354, 24357 .. 24358, 24360 .. 24361, 24363 .. 24364, 24366 .. 24367, 24369, 24376, 24392, 24395, 24398 .. 24399, 24401 .. 24402, 24404 .. 24405, 24407, 24409, 24534, 24536 .. 24537, 24539, 24558, 24568, 24576, 24582, 24589, 24594, 24598, 24601, 24610, 24613, 24616, 24619 .. 24620, 24622 .. 24623, 24625 .. 24626, 24628 .. 24629, 24631 .. 24632, 24634 .. 24635, 24637 .. 24638, 24640 .. 24641, 24643 .. 24644, 24646 .. 24647, 24649, 24768, 24782 .. 24784, 24787, 24790 .. 24791, 24793 .. 24794, 24796 .. 24797, 24799 .. 24800, 24802 .. 24803, 24805 .. 24806, 24808 .. 24809, 24811, 24813 .. 24814, 24816 .. 24817, 24819, 24837, 24848, 24850, 24852, 24855, 24857, 24860 .. 24861, 24863 .. 24864, 24866 .. 24867, 24869 .. 24870, 24872 .. 24873, 24875 .. 24876, 24878 .. 24879, 24881 .. 24882, 24884 .. 24885, 24887 .. 24888, 24890 .. 24891, 24893 .. 24894, 24896 .. 24897, 24899, 24937, 24939, 24941, 24943 .. 24944, 24955, 24960, 24963, 24966, 24969, 24972, 24975 .. 24977, 24980, 24983, 24986, 24988 .. 24989, 24991 .. 24992, 24994, 24996 .. 24997, 24999, 25335 .. 25337, 25348, 25355, 25358, 25361, 25364 .. 25365, 25368, 25370 .. 25371, 25373, 25376 .. 25377, 25379, 25404, 25421, 25429, 25436 .. 25437, 25451, 25462, 25469, 25474, 25479, 25482, 25485 .. 25486, 25488 .. 25489, 25491 .. 25492, 25494 .. 25495, 25497, 25499, 25524, 25541, 25548, 25551, 25554, 25557, 25560, 25563, 25566, 25569, 25572 .. 25573, 25575 .. 25576, 25578 .. 25579, 25581 .. 25582, 25584 .. 25585, 25587 .. 25588, 25590 .. 25591, 25593 .. 25594, 25596 .. 25597, 25599, 25693, 25704, 25709, 25712, 25715, 25718 .. 25719, 25721, 25724 .. 25725, 25727, 25729, 25746, 25761, 25764, 25767, 25770, 25774, 25776, 25779, 25782, 25785 .. 25786, 25788, 25791 .. 25792, 25794 .. 25795, 25797, 25799, 25813, 25821, 25826, 25832, 25836, 25840, 25842, 25845, 25849 .. 25850, 25852 .. 25853, 25855 .. 25856, 25858 .. 25860, 25862 .. 25864, 25866, 25868 .. 25870, 25872 .. 25873, 25875 .. 25876, 25878 .. 25879, 25881 .. 25882, 25884 .. 25885, 25887, 25889, 25899, 25917, 25920, 25923 .. 25924, 25926 .. 25927, 25938, 25946, 25980, 25992, 25996 .. 25997, 25999, 26121 .. 26123, 26125, 26127, 26129, 26131, 26133, 26135, 26160, 26169, 26180, 26188, 26197, 26203, 26209, 26215, 26219, 26316, 26340, 26345, 26349, 26382, 26384, 26386, 26388 .. 26389, 26409, 26419, 26427, 26434, 26441, 26446, 26452, 26465, 26474, 26486 .. 26487, 26489, 26506, 26524, 26529, 26532, 26548, 26553, 26556, 26571, 26579, 26603, 26605, 26607, 26624, 26629, 26632, 26639, 26655, 26670, 26676, 26683, 26689, 26721, 26723, 26725, 26736, 26757, 26759, 26789, 26802, 26810, 26817, 26826, 26831, 26835, 26842, 26844 .. 26845, 26847, 26849, 26871, 26892, 26897, 26899, 26901, 26903 .. 26904, 26906 .. 26907, 26909, 26919, 26931, 26935 .. 26937, 26939, 26954, 26969, 27211, 27232, 27239, 27243, 27245 .. 27246, 27248 .. 27249, 27251 .. 27252, 27254, 27257, 27259, 27283, 27299, 27305, 27308, 27313, 27318, 27321, 27324, 27327, 27330, 27333, 27336 .. 27337, 27339, 27356, 27367, 27374, 27383, 27386, 27389, 27404, 27412, 27419, 27432, 27442, 27446, 27449, 27472, 27474, 27476, 27478, 27498 .. 27499, 27568, 27570, 27572, 27574, 27576, 27578, 27580, 27607, 27612, 27616, 27619, 27624, 27628, 27632, 27637 .. 27638, 27711, 27721, 27726, 27729, 27749, 27751, 27753, 27755, 27777, 27793, 27798, 27801, 27804, 27809, 28195, 28197, 28199, 28201, 28203, 28205, 28207, 28209, 28211, 28213, 28215, 28217, 28219, 28237, 28239, 28259, 28277, 28279, 28307, 28309, 28325, 28327, 28329, 28335, 28355, 28357, 28359, 28717, 28719, 28755, 28757, 28759, 28777, 28779, 28790, 28816, 28832, 28844, 28857, 28865, 28870, 28876, 28879, 29221, 29223, 29225, 29227, 29229, 29303, 29308, 29313, 29320, 29323, 29328, 29331, 29336, 29339, 29342, 29345, 29348, 29351 .. 29353, 29355 .. 29356, 29358 .. 29359, 29361 .. 29362, 29364 .. 29365, 29367, 29369, 29378 .. 29379, 29386, 29389, 29392 .. 29394, 29396, 29399, 29410, 29413, 29416, 29439, 29451, 29456, 29459, 29462, 29465, 29468, 29471 .. 29473, 29475 .. 29476, 29478 .. 29479, 29481 .. 29482, 29484 .. 29485, 29487 .. 29488, 29490 .. 29491, 29493 .. 29494, 29496 .. 29497, 29499, 29525, 29549, 29553, 29556, 29559, 29562, 29565, 29568, 29571, 29574 .. 29576, 29578 .. 29579, 29581 .. 29582, 29584 .. 29585, 29587 .. 29588, 29590 .. 29591, 29593 .. 29594, 29596 .. 29597, 29599, 29614, 29633, 29640, 29643, 29646, 29649, 29664, 29683, 29690, 29693, 29699, 30159, 30161, 30163, 30165, 30167, 30169, 30171, 30173, 30175, 30177, 30179, 30419, 30449, 30451, 30453, 30455, 30457, 30459, 30519, 30521, 30539, 30559, 30625, 30627, 30629, 30655, 30657, 30659, 30669, 30823, 30826 .. 30827, 30851, 30853, 30855, 30880, 30890, 30900, 30916, 30926, 30938, 30952, 30966, 30974, 30982, 30989, 31008, 31020, 31028 .. 31029, 31032 .. 31033, 31035 .. 31036, 31039, 31061, 31073, 31079, 31084 .. 31085, 31087 .. 31089, 31091, 31093 .. 31094, 31096 .. 31097, 31099, 31134 .. 31135, 31137, 31139, 31141, 31157, 31162, 31167, 31171, 31174, 31177, 31180, 31185, 31188, 31191, 31195 .. 31196, 31199, 31224, 31226, 31228, 31234, 31241, 31246, 31249, 31275, 31303, 31311, 31319, 31515, 31535, 31542, 31547, 31552 .. 31553, 31555 .. 31556, 31558 .. 31559, 31582, 31592, 31595, 31600, 31603 .. 31604, 31606, 31608 .. 31609, 31613, 31618 .. 31619, 31621 .. 31623, 31626 .. 31629, 31632 .. 31634, 31636 .. 31638, 31655, 31675, 31683, 31688, 31691, 31693, 31698 .. 31700, 31702, 31707 .. 31708, 31710 .. 31712, 31714 .. 31715, 31717 .. 31719, 31737, 31749, 31785, 31787, 31789, 31812, 31832, 31840, 31848, 31855, 31860, 31863, 31867 .. 31868, 32049, 32051 .. 32052, 32105, 32107 .. 32108, 32120, 32130, 32139, 32257, 32278, 32289, 32312, 32339, 32351, 32361, 32369, 32423, 32425, 32427, 32429, 32457, 32469, 32479, 32545, 32547, 32549, 32584, 32602, 32609, 32657, 32676, 32683, 32689, 32694, 32699, 32756, 32758, 32760, 32791, 32805, 32816, 32825, 32832, 32839, 33014, 33034, 33039, 33098, 33100, 33102, 33104, 33106, 33129, 33142, 33154, 33161, 33165, 33175, 33178, 33181, 33184, 33189, 33311, 33330, 33332, 33334 .. 33335, 33378, 33397, 33415, 33428, 33442, 33449, 33519, 33602, 33604 .. 33605, 33607, 33609, 33611, 33613, 33615, 33617, 33619, 33647, 33649, 33659, 33689, 33699, 33719, 33729, 33739, 33758, 33775, 33790, 33803, 33813, 33818, 33824, 33829, 34117, 34119, 34121, 34123, 34125, 34127 .. 34128, 34130 .. 34132, 34134, 34212, 34225, 34233, 34246, 34253, 34260, 34266, 34270, 34277, 34281, 34286, 34289, 34292, 34295, 34298, 34302, 34305, 34308, 34311, 34314, 34317, 34320, 34323, 34326 .. 34327, 34329, 34346, 34355, 34359, 34369, 34376, 34379, 34385, 34388, 34393, 34396, 34399, 34414, 34431, 34434, 34439, 34454, 34466, 34471, 34474, 34477, 34479, 34497, 34508, 34513, 34516, 34519, 34537, 34549, 34560, 34576, 34582, 34587, 34590, 34593, 34596, 34599, 34613, 34621, 34626, 34628, 34630, 34632 .. 34633, 34637, 34639, 35037, 35039, 35041, 35043, 35066, 35075, 35080, 35083, 35085, 35088, 35091, 35094, 35096, 35099, 35102, 35104, 35108, 35110, 35112, 35114, 35116 .. 35117, 35119, 35216, 35232, 35236, 35239, 35260, 35274, 35279, 35282, 35285, 35287 .. 35288, 35305, 35315, 35321, 35325, 35327, 35329, 35390, 35392, 35394, 35396, 35398, 35410, 35415, 35418, 35423, 35428, 35435, 35440, 35444, 35447, 35452, 35457, 35460, 35463, 35466, 35469, 35510, 35516, 35519, 35576, 35578 .. 35586, 35606, 35614, 35619, 35625, 35630, 35633, 35638, 35641, 35644, 35647, 35649, 35683 .. 35690, 35708, 35713, 35716, 35719, 35745, 35753, 35756, 35759, 35764, 35767 .. 35768, 35781, 35789, 35792, 35794, 35796, 35799, 36037, 36039, 36041, 36043, 36088, 36093, 36100, 36103, 36110, 36115, 36119, 36124, 36129, 36132, 36137, 36142, 36145, 36148, 36151, 36154, 36157, 36160, 36163, 36166 .. 36167, 36169, 36179, 36199, 36205, 36208, 36211, 36214, 36217, 36219, 36251, 36266, 36269, 36272, 36275, 36277, 36280, 36282, 36284, 36286 .. 36287, 36289, 36304, 36318, 36320, 36323, 36325 .. 36326, 36329, 36341, 36355, 36358, 36364, 36367, 36369, 36381, 36391, 36396, 36399, 36404, 36414, 36419, 36433, 36448, 36452, 36456 .. 36457, 36460, 36466, 36469, 37073, 37075, 37077, 37079, 37081, 37083, 37085, 37115, 37120, 37124, 37127, 37130, 37133, 37136, 37139, 37154, 37170, 37176, 37181, 37186, 37191, 37194, 37197, 37199, 37213 .. 37218, 37235, 37242, 37247, 37249, 37269, 37276, 37281, 37284, 37287, 37290, 37293, 37296 .. 37297, 37299, 37308, 37318, 37327, 37339, 37345, 37351, 37355, 37359, 37412, 37431, 37434, 37441, 37444 .. 37445, 37447, 37449, 37520, 37534, 37539, 37547, 37574, 37581, 37586, 37589, 37603, 37619 .. 37620, 37627, 37632 .. 37633, 37635, 37639 .. 37640, 37642 .. 37643, 37647, 37649, 37671, 37688, 37691, 37696 .. 37697, 37699, 38023, 38100, 38102, 38104, 38106, 38108, 38110, 38112, 38114, 38116, 38118, 38120, 38122, 38124, 38126, 38154, 38159, 38162, 38165, 38170, 38173, 38176, 38179, 38226, 38228 .. 38229, 38239, 38259, 38268, 38271 .. 38272, 38274 .. 38275, 38277, 38279, 38281, 38300, 38302, 38304, 38312, 38315, 38319, 38321 .. 38322, 38324 .. 38325, 38327, 38329, 38350, 38364, 38368, 38372 .. 38373, 38375 .. 38376, 38378 .. 38379, 38381 .. 38382, 38384 .. 38385, 38387 .. 38388, 38440, 38442, 38444, 38446, 38448, 38458 .. 38459, 38461 .. 38462, 38464 .. 38465, 38467 .. 38468, 38470 .. 38471, 38473 .. 38474, 38476 .. 38477, 38479, 38486, 38489, 38518, 38524, 38527 .. 38528, 38530 .. 38531, 38533, 38536, 38539, 38542 .. 38543, 38547, 38550 .. 38551, 38553 .. 38554, 38556 .. 38557, 38559, 38640, 38642, 38644, 38667, 38678, 38685, 38690, 38700, 38704, 38707, 38709, 38723, 38729, 38820, 38822, 38828 .. 38829, 38835 .. 38836, 38838, 38855, 38871, 38875, 38877, 38879, 38889, 38895, 38899, 39014, 39104, 39106, 39108, 39110, 39112, 39114, 39116, 39118, 39120, 39122, 39124, 39126, 39128, 39130, 39164, 39167, 39171, 39175, 39179, 39218, 39221, 39240, 39245, 39249, 39261, 39264, 39279, 39288, 39291, 39307, 39317, 39319, 39326, 39340, 39343, 39345, 39356, 39359, 39365, 39387, 39393, 39397 .. 39398, 39418, 39434 .. 39435, 39439, 39443 .. 39444, 39446, 39448, 39517, 39524, 39539, 39576, 39579, 39590, 39596, 39599, 39606, 39615, 39619, 39624, 39629, 39638, 39646, 39649, 40210 .. 40213, 40215, 40217, 40219, 40221, 40223, 40225, 40227, 40229, 40231, 40233, 40235, 40237, 40239, 40468, 40470, 40472, 40474, 40476 .. 40477, 40479, 40489, 40545, 40547, 40549, 40589, 40591, 40593, 40595, 40597, 40599, 40625, 40627, 40629, 40667 .. 40668, 40670, 40699, 40721, 40723 .. 40724, 40764, 40789, 40822, 40832, 40878, 40880, 40882 .. 40883, 40885, 41061, 41063, 41065 .. 41066, 41068 .. 41069, 41169, 41179, 41189, 41199, 41236, 41238 .. 41239, 41334, 41352, 41363, 41366, 41372, 41379, 41460, 41462, 41464, 41466, 41468 .. 41470, 41472, 41515 .. 41517, 41539 .. 41542, 41564, 41569, 41747 .. 41749, 41751, 41812, 41836, 41844, 41849, 42103, 42105, 42107, 42109, 42111, 42113, 42115, 42117, 42119, 42275, 42277, 42279, 42281, 42283, 42285, 42287, 42289, 42327, 42329, 42349, 42369, 42389, 42399, 42477, 42489, 42499, 42549, 42551, 42553, 42555, 42579, 42651, 42653, 42655, 42657, 42659, 42697, 42699, 42719, 42781, 42799, 42853, 42855, 42857, 42859, 42897, 42899, 42929, 44135, 44137, 44139, 44141, 44143, 44145, 44147, 44149, 44225, 44227, 44229, 44263, 44265, 44267, 44269, 44287, 44289, 44309, 44319, 44328 .. 44329, 44339, 44357, 44359, 44369, 44379, 44388, 44532, 44534, 44536, 44575, 44577, 44579, 44581, 44623, 44625, 44627 .. 44629, 44649, 44651 .. 44653, 44787, 44789, 44791, 44793, 44795, 44797, 44799, 44801, 44803, 44805, 44807, 44809, 44866 .. 44867, 44869, 44879, 44892, 44894, 45127 .. 45128, 45130 .. 45131, 45133 .. 45134, 45136, 45138 .. 45139, 45141, 45143 .. 45145, 45147, 45149, 45219, 45239, 45257, 45259, 45276 .. 45277, 45279, 45289, 45307, 45309, 45326 .. 45327, 45329, 45355 .. 45357, 45359, 45403, 45468, 45470, 45472 .. 45473, 45475 .. 45476, 45478 .. 45479, 45481, 45525, 45527, 45529, 45549, 45657, 45659, 45661, 45663, 45665, 45699, 45701, 45711, 45721, 45731, 45739, 45768, 45770, 45772, 45879, 45881, 45883 .. 45884, 45886, 45888 .. 45889, 45891 .. 45892, 45894, 45896 .. 45897, 45899, 45964, 45966, 45968, 46045, 46047, 46049, 46117, 46119, 46145, 46147, 46149, 46236, 46238, 46240, 46242, 46244, 46282, 46284, 46286, 46325, 46342, 46348, 46354, 46359, 46395, 46397, 46399, 46414, 46419, 46446, 46459, 46483, 46485, 46487, 46499, 46509, 46514, 46519, 46535, 46537, 46539, 46562, 46569, 47051, 47053, 47055, 47057 .. 47059, 47119, 47137 .. 47139, 47166 .. 47167, 47169, 47178 .. 47179, 47198 .. 47199, 47226, 47228 .. 47229, 47239, 47249, 47259, 47269, 47279, 47441, 47443, 47445, 47447, 47475, 47495, 47506, 47509, 47533, 47546, 47551, 47559, 47574, 47589, 47608, 47623 .. 47627, 47638, 47647, 47652, 47661, 47665, 47669, 47798 .. 47800, 47802 .. 47805, 47807, 47809, 47829, 47839, 47877, 47906, 47918, 47929, 48079, 48143, 48145, 48147, 48149, 48151, 48153, 48155, 48157, 48159, 48161, 48163, 48165, 48167, 48231, 48249, 48268, 48282, 48291, 48301, 48308, 48317, 48324, 48329, 48336, 48341, 48346, 48351, 48356, 48361, 48366, 48369, 48429, 48431 .. 48432, 48455, 48465, 48477, 48480, 48485, 48488, 48493, 48496, 48499, 48527, 48529, 48531, 48565, 48599, 48607, 48612, 48619, 48624, 48629, 48653, 48683, 48691, 48703, 48712, 48720, 48727, 48734, 48739, 49074, 49076, 49078, 49080, 49082, 49084, 49086, 49088, 49090, 49124, 49134, 49143, 49152, 49163, 49170, 49176, 49179, 49186, 49191, 49196, 49201, 49205, 49214, 49219, 49324, 49326, 49328, 49356, 49377, 49393, 49401, 49406, 49413, 49419, 49424, 49429, 49434, 49439, 49448, 49451, 49453, 49456 .. 49457, 49459, 49477, 49479, 49492, 49497, 49504, 49509, 49525, 49536, 49545, 49549, 49565, 49577, 49584, 49586, 49593 .. 49594, 49596 .. 49597, 49599, 49610, 49624, 49626, 49632, 49635, 49637 .. 49638, 49661, 49681, 49685, 49688, 49692, 49696, 49699, 49716, 49733, 49740, 49744, 49751, 49757, 49762, 49767, 49770, 49774, 49777, 49779, 49808 .. 49809, 49811, 49824, 49828, 49832, 49835, 49838, 49843 .. 49844, 49846 .. 49847, 49849, 50126 .. 50127, 50129, 50169 .. 50171, 50181, 50189, 50226, 50259, 50321, 50354, 50374, 50389, 50667 .. 50668, 50670, 50672, 50674, 50676 .. 50679, 50733, 50735, 50737, 50739, 50765, 50767, 50769, 50823, 50825, 50827, 50829, 50858 .. 50859, 50931, 50933, 50935, 50937, 50939, 50968 .. 50969, 50996 .. 50997, 50999, 51061, 51063, 51065, 51067, 51069, 51103, 51105, 51107, 51109, 51143, 51145, 51147, 51149, 51371, 51373, 51375, 51377, 51379, 51381, 51399, 51427, 51429, 51465, 51467, 51469, 51491, 51503, 51515, 51519, 51545, 51570, 51580, 51588, 51597 .. 51598, 51643, 51645, 51647, 51674, 51688, 51702, 51709, 51766, 51789, 52062, 52064, 52066, 52068, 52070, 52072, 52074, 52076, 52078, 52080, 52134, 52146, 52152, 52156, 52159, 52222 .. 52224, 52249, 52349, 52351, 52353, 52355, 52372, 52379, 52382, 52385, 52388, 52391, 52393, 52396, 52399, 52428, 52441, 52445, 52457, 52459, 52477, 52499, 52511, 52525, 52531, 52538, 53111, 53113, 53115, 53117, 53119, 53121, 53123, 53125, 53127, 53129, 53173, 53175, 53177, 53179, 53225, 53227, 53229, 53332, 53340, 53343, 53347, 53359, 53424, 53426, 53474, 53489, 53498, 53501, 53505 .. 53508, 53518, 53520, 53533 .. 53534, 53539, 53545, 53547, 53557, 53560, 53562, 53567, 53572, 53577 .. 53579, 53604, 53619, 53639, 53721, 53757, 53773, 53783, 53797, 53804, 53809, 53819, 53840, 53842, 53844, 53859, 53879, 53881, 53894, 53902, 53909, 53913, 53919, 53925, 53937, 53940, 53945, 53947, 53949, 54290, 54292 .. 54296, 54298, 54306, 54308 .. 54311, 54313 .. 54314, 54316 .. 54318, 54320, 54329, 54331 .. 54332, 54338, 54340 .. 54341, 54343 .. 54344, 54346 .. 54347, 54349, 54411, 54413, 54421 .. 54422, 54424, 54426 .. 54427, 54429, 54439, 54441, 54450 .. 54451, 54453, 54455 .. 54457, 54459, 54470, 54472, 54483 .. 54484, 54486 .. 54487, 54492, 54497 .. 54498, 54516, 54518, 54523 .. 54524, 54526, 54528 .. 54529, 54531, 54533 .. 54534, 54536, 54538 .. 54539, 54550, 54552, 54558, 54568, 54570, 54574, 54576, 54578 .. 54579, 54584 .. 54587, 54589, 54595, 54597, 54608, 54610 .. 54612, 54614, 54616 .. 54617, 54619, 54634, 54636, 54646 .. 54647, 54649, 54655, 54657, 54662, 54664, 54666, 54668 .. 54669, 54673, 54675, 54687, 54689, 55116, 55118, 55120, 55122, 55124, 55126 .. 55131, 55218, 55232, 55234, 55237, 55239, 55246, 55252, 55257, 55262 .. 55263, 55268, 55270 .. 55271, 55276, 55278, 55283, 55286, 55288, 55291, 55294, 55296, 55299, 55411, 55413, 55422, 55424 .. 55425, 55430, 55432, 55435, 55437, 55442, 55444, 55450, 55452, 55457, 55459, 55469, 55471, 55481, 55483, 55487, 55490 .. 55491, 55494, 55496 .. 55497, 55499, 55543, 55545 .. 55546, 55559, 55566, 55568 .. 55569, 55571, 55576, 55578, 55583, 55585, 55590, 55592 .. 55593, 55595 .. 55597, 55599, 55606, 55608, 55618 .. 55619, 55621, 55624, 55626 .. 55627, 55629, 55743, 55756, 55758, 55765, 55767 .. 55768, 55774, 55776 .. 55777, 55779, 56068, 56070, 56072 .. 56073, 56075 .. 56077, 56112, 56130, 56132 .. 56133, 56154, 56170, 56179, 56182, 56191, 56203 .. 56204, 56206, 56218, 56220, 56235, 56237, 56242, 56244, 56249, 56253 .. 56254, 56269, 56271, 56276, 56281, 56283, 56288, 56290 .. 56291, 56294 .. 56295, 56299, 56305, 56307, 56316 .. 56317, 56321 .. 56323, 56329 .. 56330, 56332 .. 56333, 56335, 56337 .. 56338, 56340 .. 56341, 56346, 56348 .. 56349, 56355, 56357, 56368, 56370, 56377, 56379, 56410, 56412, 56414, 56422, 56424, 56427 .. 56428, 56457, 56459, 56462, 56470, 56472, 56477, 56479, 56564, 56566 .. 56567, 56575, 56579, 56581, 56584, 56587 .. 56589, 56593 .. 56594, 56598 .. 56599, 56626, 56630, 56637, 56642, 56645, 56648, 56651, 56653, 56656, 56659, 56727, 56729, 56736, 56743, 56745 .. 56746, 56751, 56753 .. 56754, 56759, 56761, 56766 .. 56767, 56769, 56812, 56814, 56818, 56820 .. 56821, 56823, 56825 .. 56826, 56828 .. 56829, 56841, 56843, 56850, 56856, 56858 .. 56859, 56861 .. 56862, 56864 .. 56865, 56867, 56869, 57072, 57074, 57076, 57078, 57080, 57223, 57234, 57250, 57258, 57271, 57290, 57299, 57319, 57334, 57339, 57368, 57392, 57399, 57413, 57439, 57462, 57482, 57489, 57518, 57520, 57537, 57539, 57548, 57555, 57562, 57567, 57572, 57577 .. 57578, 57580 .. 57581, 57583 .. 57584, 57586 .. 57587, 57589, 57610, 57612, 57614, 57627, 57629, 57632, 57635 .. 57636, 57638 .. 57639, 57641 .. 57642, 57644 .. 57645, 57647 .. 57648, 58089, 58091, 58093, 58095, 58097, 58099, 58119, 58135, 58239, 58256, 58285, 58300, 58313, 58332, 58339, 58452 .. 58456, 58507, 58509, 58511, 58513, 58515, 58540, 58553, 58566, 58579, 58636, 58638, 58640, 58642, 58644, 58675, 58706, 58708, 58710, 58730, 58739, 58762, 58769, 58791, 58802, 58809, 58840, 58849, 59063, 59065, 59067, 59069, 59071, 59073, 59075, 59077, 59174, 59192, 59199, 59227, 59229, 59269, 59302, 59320, 59329, 59348, 59368, 59379, 59387, 59394, 59399, 59423, 59425, 59427, 59439, 59457, 59469, 59494, 59505, 59510, 59514, 59519, 59555 .. 59558, 59581, 59590, 59597, 59602, 59609, 59755, 59757, 59759, 59821, 59823, 59846, 59872, 59889, 59909, 59929, 59939, 59955, 59964, 59969, 60308, 60311, 60313 .. 60314, 60316, 60318, 60320, 60322 .. 60323, 60325 .. 60327, 60329, 60385 .. 60386, 60388 .. 60389, 60431, 60433, 60435, 60437 .. 60439, 60486 .. 60489, 60528 .. 60529, 60549, 60594, 60596, 60598 .. 60599, 61118, 61130, 61137 .. 61138, 61169, 61184, 61191, 61194, 61197, 61200, 61203, 61206, 61209, 61231, 61239, 61250, 61267, 61273, 61276, 61279, 61348, 61350, 61352, 61381, 61389, 61440, 61449, 61462, 61476, 61479, 63065, 63067, 63069, 63071, 63073, 63075, 63110, 63128, 63150, 63165, 63179, 63225, 63263, 63303, 63322, 63329, 63405, 63450, 63452, 63454, 63456 .. 63457, 63477, 63486, 63500, 63505, 63512, 63517, 63526, 63533, 63538, 63543, 63546, 63549, 63571, 63579, 63584, 63589, 63594, 63599, 63607, 63619, 63628, 63633, 63636 .. 63637, 63639, 63654, 63667, 63674, 63679, 63683, 63688, 63691, 63694 .. 63695, 63697, 63699, 63739, 63741, 63743, 63755, 63762, 63768, 63773, 63776, 63785, 63791, 63796, 63801, 63808, 63811, 63814, 63820, 63825 .. 63826, 63828 .. 63829, 63831, 63834, 63839 .. 63840, 63843, 63846, 63849, 63853, 63856 .. 63857, 63860, 63863 .. 63864, 63867 .. 63869, 63871 .. 63872, 63874 .. 63875, 63877, 63879, 63897, 63906, 63911, 63916, 63920, 63924 .. 63925, 63927 .. 63928, 63930 .. 63931, 63933 .. 63934, 63936 .. 63937, 63939, 64283, 64285, 64287, 64289, 64291, 64293, 64295, 64297, 64319, 64331, 64342, 64347, 64354, 64367, 64372, 64380, 64385, 64390, 64395, 64397, 64401, 64404 .. 64405, 64407, 64409, 64521, 64546, 64560, 64569, 64572, 64579, 64584, 64589, 64625, 64646, 64653, 64658, 64665, 64668, 64673, 64678, 64683, 64686, 64689, 64711, 64720, 64732, 64739, 64743, 64747, 64750, 64753 .. 64754, 64756 .. 64757, 64759, 64807, 64823, 64832, 64839, 64846, 64850, 64853, 64859, 65183, 65185, 65187, 65189, 65191, 65193, 65195, 65197, 65199, 65201, 65203, 65205, 65207, 65219 .. 65224, 65232, 65239, 65307, 65321, 65326, 65329, 65343 .. 65347, 65366, 65375, 65385, 65388, 65391, 65396, 65399, 65428, 65439, 65451, 65462, 65468, 65474, 65479, 65510, 65520, 65527, 65529, 65549 .. 65556, 65558, 65582, 65589, 65594, 65597, 65599, 65604, 65606, 65611, 65614, 65618, 65620, 65623 .. 65624, 65626 .. 65627, 65629, 65719, 65760, 65779, 65795, 65812, 65817, 65824, 65830, 65835, 65843, 65929, 65931, 65933 .. 65934, 65936, 66111, 66113, 66115, 66117, 66119, 66121, 66123, 66125 .. 66133, 66265, 66271, 66280, 66287, 66292, 66299, 66333, 66346, 66352, 66359, 66386, 66399, 66424, 66440, 66450, 66453, 66459, 66482, 66484, 66497, 66500 .. 66501, 66503 .. 66504, 66506 .. 66507, 66509, 66538 .. 66540, 66557, 66564, 66571, 66578, 66583, 66589, 66606, 66620, 66625, 66629, 66636, 66640, 66646, 66649, 66663, 66679, 66687, 66693, 66701, 66706, 66709, 66740, 66763, 66773, 66780, 66787, 66793, 66798, 66802, 66806, 66809, 66822, 66839, 66849, 66851, 66862, 66869, 66871, 66877, 66879, 66882, 66885, 66887, 66892, 66894, 66901, 66903 .. 66904, 66907, 66909, 66914, 66916 .. 66917, 66919, 66953 .. 66955, 66957, 66969, 66976, 66978, 66981, 66987, 66989, 66994, 66996, 66999, 67059, 67061, 67063, 67065, 67067, 67069, 67071, 67098, 67105, 67112, 67117, 67122, 67125 .. 67127, 67133 .. 67134, 67136, 67141, 67146 .. 67147, 67149 .. 67150, 67152, 67157 .. 67159, 67161, 67165 .. 67167, 67169, 67227, 67229, 67240, 67245 .. 67246, 67251, 67256, 67258 .. 67259, 67269, 67271, 67273, 67278, 67280 .. 67281, 67283, 67292, 67294 .. 67295, 67297, 67304 .. 67305, 67307 .. 67308, 67310 .. 67311, 67316 .. 67317, 67319, 67346, 67354, 67360 .. 67361, 67363, 67365 .. 67366, 67368, 67373 .. 67374, 67376 .. 67378, 67433 .. 67435, 67454, 67459, 67466, 67468, 67471 .. 67473, 67475, 67480, 67482 .. 67483, 67487, 67489, 67547, 67549 .. 67551, 67574 .. 67575, 67577 .. 67578, 67580, 67582 .. 67583, 67585 .. 67587, 67590 .. 67593, 67595 .. 67596, 67598 .. 67599, 67653, 67655, 67657, 67659, 67661, 67663, 67677 .. 67678, 67680 .. 67681, 67685 .. 67686, 67688, 67691, 67693, 67697, 67699 .. 67701, 67705 .. 67707, 67714 .. 67716, 67718, 67722, 67724 .. 67725, 67727 .. 67729, 67731 .. 67732, 67734 .. 67735, 67737, 67742, 67744 .. 67746, 67748 .. 67749, 67752 .. 67754, 67756 .. 67757, 67759, 67806, 67808, 67811, 67813 .. 67814, 67816 .. 67817, 67819, 67821 .. 67824, 67826 .. 67827, 67829, 68159, 68161, 68163, 68165, 68167, 68169, 68199, 68219, 68229, 68239, 68259, 68305, 68307, 68309, 68519, 68526, 68535, 68542, 68549, 68623, 68642, 68647, 68649, 68723, 68753, 68766, 68775, 68782, 68789, 68794, 68799, 68804, 68809, 69115, 69117 .. 69118, 69120 .. 69121, 69123 .. 69124, 69126, 69151, 69168, 69181, 69190, 69198, 69207, 69214, 69221, 69226, 69231, 69234, 69239, 69242, 69245, 69250 .. 69251, 69253 .. 69254, 69256 .. 69257, 69259, 69412, 69427, 69429, 69434, 69436 .. 69437, 69439, 69469, 69483, 69488, 69493, 69502, 69509, 69514, 69517 .. 69518, 70173 .. 70174, 70176, 70178, 70180, 70182, 70184, 70186, 70188, 70190 .. 70193, 70195, 70197, 70199, 70327, 70329, 70372, 70374, 70376, 70378, 70435, 70437, 70439, 70469, 70499, 70563, 70565, 70567, 70569, 70597, 70599, 70619, 70629, 70734, 70736, 70771, 70794, 70806, 70825, 70839, 71032, 71034, 71063, 71065, 71067, 71069, 71083, 71088, 71093, 71101, 71106, 71111, 71116, 71120, 71126, 71131, 71134, 71139, 71144, 71149, 71154 .. 71155, 71157, 71159, 71229, 71254, 71263, 71272, 71277, 71282, 71287, 71292, 71296 .. 71297, 71299, 71332, 71334, 71336, 71364, 71384, 71394, 71397, 71404, 71409, 71522, 71540, 71543, 71546, 71549, 71554, 71560, 71563, 71566, 71570, 71573, 71576 .. 71577, 71579, 71634, 71636, 71638, 71640, 71642, 71665, 71672, 71679, 71686, 71691, 71696, 71701, 71706, 71711, 71717 .. 71718, 71720, 71723, 71726, 71729, 71732, 71735, 71737, 71739, 72070, 72072, 72074, 72076, 72108, 72116, 72119, 72124, 72127, 72131, 72135, 72138, 72141, 72144 .. 72145, 72147, 72149, 72160, 72172, 72175, 72178, 72181, 72184, 72186, 72189, 72202, 72213, 72218, 72221, 72224, 72226 .. 72227, 72229, 72250, 72270, 72275, 72280, 72285, 72290 .. 72291, 72293 .. 72294, 72296 .. 72297, 72299, 72336, 72348, 72351, 72355 .. 72356, 72358 .. 72359, 72361 .. 72362, 72364 .. 72365, 72367, 72369, 72379, 72393, 72401, 72406, 72411, 72414 .. 72415, 72417, 72419, 72458 .. 72459, 72461, 72469, 72474 .. 72475, 72477, 72479, 72488, 72501, 72505, 72510 .. 72511, 72513 .. 72514, 72516 .. 72517, 72519, 72525, 72531 .. 72532, 72534 .. 72535, 72537, 72539, 72555, 72574, 72581 .. 72582, 72584 .. 72585, 72587, 72589, 72622, 72631, 72636, 72639, 72644, 72649, 72654 .. 72655, 72657 .. 72658, 72660 .. 72661, 72663 .. 72664, 72666 .. 72667, 72669, 72760, 72762, 72764, 72766, 72768, 72770, 72793, 72800, 72805, 72810, 72813, 72818, 72820, 72827, 72829, 73033, 73035, 73037, 73054, 73061, 73066, 73072, 73079, 73084, 73087, 73092, 73095, 73098 .. 73099, 73101 .. 73102, 73104 .. 73105, 73107 .. 73108, 73110 .. 73111, 73113 .. 73114, 73116 .. 73117, 73119, 73207, 73230, 73235, 73240, 73249, 73252, 73257, 73262, 73265 .. 73266, 73268 .. 73269, 73271 .. 73272, 73274 .. 73275, 73277 .. 73278, 73312, 73326, 73329, 73333, 73337, 73340, 73342, 73344 .. 73345, 73347, 73349, 73430 .. 73434, 73441, 73447, 73450, 73453, 73457, 73460, 73463, 73466 .. 73467, 73469, 73479, 73485 .. 73486, 73488 .. 73489, 73491 .. 73492, 73494 .. 73495, 73497, 73499, 73525, 73527, 73529, 73540, 73547, 73550, 73553, 73557, 73560, 73563, 73565 .. 73566, 73568 .. 73569, 73571 .. 73572, 73574 .. 73575, 73577, 73579, 73614, 73630, 73635, 73642, 73650, 73655, 73660, 73663, 73666 .. 73667, 73669, 73728, 73730, 73732 .. 73734, 73760, 73765, 73770, 73773, 73776, 73779, 74072, 74074, 74076, 74078, 74080 .. 74081, 74172, 74177, 74182, 74189, 74193, 74196, 74199, 74206, 74211, 74214, 74219, 74223, 74226, 74229, 74232, 74235, 74238 .. 74239, 74243, 74245 .. 74246, 74248 .. 74249, 74251 .. 74252, 74254 .. 74255, 74257, 74259, 74321, 74336 .. 74337, 74343, 74348, 74354, 74357, 74360, 74363, 74366, 74369, 74372, 74374, 74376, 74379, 74382, 74385, 74388 .. 74389, 74391 .. 74392, 74394 .. 74395, 74397, 74399, 74405, 74417, 74420, 74423 .. 74424, 74426 .. 74427, 74429, 74523, 74532, 74535, 74538, 74541 .. 74542, 74544 .. 74545, 74547, 74549, 74564, 74572, 74575, 74579, 74582, 74585 .. 74586, 74589, 74592, 74594 .. 74595, 74597, 74599, 74613, 74626, 74629, 74632, 74635, 74638 .. 74639, 74653, 74670, 74673, 74676 .. 74677, 74679, 74706, 74722, 74731, 74736, 74740, 74743 .. 74744, 74746 .. 74747, 74749, 74821, 74831 .. 74832, 74834, 74838, 74842, 74847, 74850, 74855, 74858, 74861 .. 74862, 74864 .. 74865, 74867, 74869, 74889, 74906, 74909, 74912, 74915, 74918, 74921, 74924 .. 74925, 74927 .. 74928, 74930 .. 74931, 74933 .. 74934, 74936 .. 74937, 74939, 75015, 75031, 75038, 75045, 75050, 75053, 75056 .. 75057, 75059, 75172 .. 75173, 75175, 75177, 75179 .. 75181, 75196, 75203, 75210, 75217, 75223, 75228, 75233, 75236, 75239, 75242, 75245, 75248 .. 75249, 75305, 75323, 75328, 75331, 75334 .. 75335, 75337, 75339, 75365, 75378, 75382, 75385, 75387, 75389, 75391 .. 75392, 75394 .. 75395, 75397, 75399, 75417, 75428, 75433, 75438, 75443, 75446 .. 75447, 75449, 76006, 76131, 76133, 76135, 76137, 76139, 76149, 76185, 76187, 76189, 76199, 76227 .. 76229, 76275, 76287, 76297, 76307, 76316, 76327, 76332, 76337, 76344, 76351, 76356, 76359, 76437, 76448, 76456, 76461, 76467, 76470, 76473 .. 76474, 76476 .. 76477, 76479, 76530, 76532, 76534, 76547, 76549, 76571, 76593, 76596 .. 76597, 76599, 76646, 76661, 76669, 76676, 76684, 76689, 76694, 76698, 76703, 76706 .. 76707, 76709, 76726, 76744, 76751, 76756, 76761, 76764, 76767 .. 76768, 76770 .. 76771, 76773 .. 76774, 76776 .. 76777, 76779, 76829, 76831, 76833, 76835, 76846, 76848, 76855, 76857, 76863, 76865, 76870, 76872, 76877, 76879, 76887, 76889, 76891, 77652, 77654, 77656, 77694, 77704, 77709, 77716, 77723, 77728, 77731, 77736, 77740, 77743, 77746, 77749, 77756, 77761, 77767, 77770, 77773, 77776, 77781, 77784, 77787, 77790 .. 77791, 77793 .. 77794, 77796 .. 77797, 77799, 77815, 77830, 77833, 77836, 77839, 77855, 77866, 77871, 77876, 77880, 77883, 77886 .. 77887, 77889, 77933, 77944, 77948, 77955, 77960, 77963, 77966, 77971 .. 77972, 77974 .. 77975, 77977 .. 77978, 78048, 78050, 78052, 78054, 78056, 78073, 78078, 78083, 78086 .. 78087, 78089, 78098, 78112, 78120, 78126, 78132, 78136, 78141, 78144, 78147 .. 78148, 78166, 78176, 78183, 78187, 78194, 78199, 78224, 78234, 78239, 78244, 78247, 78250, 78253, 78256, 78259, 78262, 78266 .. 78267, 78269, 78315, 78333, 78337, 78343, 78345, 78351, 78354 .. 78355, 78357, 78359, 78462, 78464 .. 78465, 78467, 78476, 78479, 78532, 78549, 78554, 78559, 78564, 78567, 78570, 78573, 78576, 78579 .. 78580, 78582 .. 78583, 78585 .. 78586, 78588 .. 78589, 78591 .. 78592, 78594 .. 78595, 78597 .. 78598, 78600 .. 78601, 78603 .. 78604, 78606 .. 78607, 78609, 78628, 78647, 78652, 78655, 78658, 78661 .. 78662, 78664 .. 78665, 78667, 78669, 78713, 78727, 78730, 78733, 78736 .. 78737, 78739, 79098, 79100, 79102, 79104, 79106, 79108, 79110 .. 79112, 79114 .. 79115, 79117, 79183, 79189, 79194, 79199, 79206, 79211, 79215, 79219, 79224, 79227, 79232, 79235, 79238, 79241, 79244, 79249, 79252, 79254, 79256, 79258, 79261, 79263, 79268, 79271, 79274, 79276, 79279 .. 79280, 79282 .. 79283, 79285 .. 79286, 79288 .. 79289, 79291 .. 79292, 79294 .. 79295, 79297, 79299, 79312, 79331, 79336, 79341, 79346, 79348, 79350, 79353, 79356, 79359, 79361 .. 79362, 79364 .. 79365, 79367, 79369, 79379, 79395, 79400, 79410, 79415, 79418, 79423 .. 79424, 79426 .. 79427, 79429, 79513, 79539 .. 79541, 79576, 79578, 79585, 79588 .. 79589, 79591 .. 79592, 79594 .. 79595, 79597, 79599, 79618, 79639, 79650, 79664, 79669, 79674, 79677, 79682 .. 79683, 79685 .. 79686, 79688 .. 79689, 79691 .. 79692, 79694 .. 79695, 79697, 79699, 79713, 79725, 79730, 79733, 79736 .. 79737, 79739, 79761, 79771, 79774, 79777, 79780, 79787, 79790, 79793, 79798, 79801 .. 79802, 79804 .. 79805, 79807, 79809, 79822, 79837, 79843, 79848, 79853, 79856, 79859, 79862, 79865, 79868, 79871 .. 79872, 79874 .. 79875, 79877, 79879, 80331, 80333, 80335 .. 80337, 80339, 80469, 80538 .. 80539, 80634, 80636 .. 80639, 80686 .. 80687, 80689, 80796 .. 80799, 80801 .. 80805, 80807, 80809, 80933, 80935, 80937, 80939, 80992 .. 80993, 80995, 80997, 80999, 81241, 81243, 81245, 81247, 81249, 81369, 81371, 81373, 81375, 81377, 81379, 81475 .. 81477, 81479, 81539, 81541, 81543, 81545, 81547, 81549, 81667, 81669, 81671, 81673, 81675, 81677, 81679, 81735, 81737, 81739, 81825, 81827, 81829, 81925, 81927, 81929, 82008, 82024, 82031 .. 82032, 82041, 82049, 82054, 82057, 82061, 82064 .. 82065, 82067, 82069, 82110, 82131, 82140, 82152, 82166, 82178, 82194, 82205, 82211, 82216, 82223, 82229, 82234, 82237, 82239, 82256, 82266, 82269, 82272, 82275 .. 82276, 82278 .. 82279, 82281 .. 82282, 82284 .. 82285, 82287 .. 82288, 82290 .. 82291, 82293 .. 82294, 82296 .. 82297, 82299, 82319, 82327, 82335, 82340, 82343, 82346 .. 82347, 82349, 82362, 82377, 82380, 82383, 82386 .. 82387, 82389 .. 82390, 82392 .. 82393, 82395 .. 82396, 82398 .. 82399, 82401 .. 82402, 82404 .. 82405, 82407, 82409, 82418, 82431 .. 82433, 82435 .. 82436, 82438 .. 82439, 82441 .. 82442, 82444 .. 82445, 82447, 82449, 82467, 82481, 82487 .. 82488, 82490 .. 82491, 82493 .. 82494, 82496 .. 82497, 82499, 82515, 82538, 82541, 82544, 82547, 82549, 83022, 83024, 83026, 83043, 83052, 83059, 83064, 83071, 83075, 83080, 83083, 83088, 83093, 83098, 83101, 83104, 83109, 83112, 83115, 83119, 83122 .. 83123, 83125 .. 83126, 83128 .. 83129, 83131 .. 83132, 83134 .. 83135, 83137, 83139, 83209, 83224, 83229, 83233, 83236, 83242, 83246, 83250, 83253 .. 83254, 83256 .. 83257, 83259, 83278, 83301, 83308, 83313, 83317, 83324, 83329, 83334, 83339, 83342, 83344, 83346, 83349, 83352, 83355, 83358 .. 83359, 83361 .. 83362, 83364 .. 83365, 83367 .. 83368, 83370 .. 83371, 83373 .. 83374, 83376 .. 83377, 83379, 83395, 83404, 83410, 83413, 83416 .. 83417, 83435, 83451, 83454, 83457 .. 83458, 83471, 83483, 83486 .. 83487, 83489, 83512, 83527, 83530, 83533, 83536, 83539, 83543 .. 83544, 83546 .. 83547, 83549 .. 83550, 83552 .. 83553, 83555 .. 83556, 83558 .. 83559, 83561 .. 83562, 83564 .. 83565, 83567, 83569, 83607, 83620, 83623 .. 83624, 83626 .. 83627, 83629, 83646, 83661, 83666, 83670 .. 83671, 83673 .. 83674, 83676 .. 83677, 83679, 83684, 83700, 83703, 83707 .. 83708, 83714, 83727, 83730, 83734 .. 83735, 83737, 83739, 84028, 84030, 84032, 84034, 84036, 84048, 84051, 84056, 84061, 84066, 84069, 84072, 84076, 84079, 84082, 84085, 84088 .. 84089, 84091 .. 84092, 84094 .. 84095, 84097 .. 84098, 84100 .. 84101, 84103 .. 84104, 84106 .. 84107, 84109, 84130, 84137, 84140, 84144, 84149, 84152, 84155, 84160, 84163 .. 84164, 84166, 84168 .. 84169, 84171 .. 84172, 84174 .. 84175, 84177 .. 84178, 84180 .. 84181, 84183 .. 84184, 84186 .. 84187, 84189, 84307, 84323, 84326, 84329, 84332 .. 84333, 84335, 84337, 84339, 84347, 84359, 84364, 84367, 84371, 84375, 84378, 84381, 84384 .. 84385, 84387, 84389, 84405, 84416, 84419, 84424, 84427 .. 84428, 84431 .. 84432, 84434 .. 84435, 84437, 84439, 84453, 84478, 84489, 84494, 84503, 84508, 84513, 84518, 84524, 84529, 84533, 84539, 84543 .. 84544, 84546 .. 84547, 84549 .. 84550, 84552 .. 84553, 84555 .. 84556, 84558 .. 84559, 84561 .. 84562, 84564 .. 84565, 84567 .. 84568, 84570 .. 84571, 84573 .. 84574, 84576 .. 84577, 84579, 85049, 85051, 85053, 85055, 85057, 85072, 85077, 85080, 85084, 85088, 85092, 85095, 85098, 85101, 85104, 85107, 85110 .. 85111, 85113 .. 85114, 85116 .. 85117, 85119 .. 85120, 85122 .. 85123, 85125 .. 85126, 85128 .. 85129, 85131 .. 85132, 85134 .. 85135, 85137, 85139, 85221, 85229, 85232, 85235, 85238, 85241, 85244, 85247, 85250, 85253 .. 85254, 85256, 85258 .. 85259, 85276, 85283, 85290, 85293, 85296, 85298, 85301 .. 85302, 85304 .. 85305, 85307, 85309, 85354, 85356, 85368, 85375 .. 85376, 85386, 85391, 85395, 85399, 85402, 85405 .. 85406, 85408, 85410 .. 85411, 85413 .. 85414, 85416 .. 85417, 85419, 85435, 85445, 85447, 85452, 85456 .. 85457, 85459, 85461 .. 85462, 85464 .. 85465, 85467, 85469, 85521, 85540, 85551, 85560, 85567, 85570, 85579, 85586, 85591, 85598 .. 85599, 85604, 85609, 85614, 85617, 85622, 85625, 85630, 85635, 85640, 85643, 85646, 85649, 85652 .. 85653, 85655 .. 85656, 85658 .. 85659, 85661 .. 85662, 85664 .. 85665, 85667, 85669, 85716, 85737, 85748, 85757, 85764, 85774, 85777 .. 85778, 86150, 86152 .. 86154, 86156 .. 86157, 86159, 86161, 86163, 86165, 86167, 86169, 86179, 86199, 86316, 86343, 86356, 86368, 86381, 86391, 86399, 86405, 86415, 86420, 86424, 86438, 86441, 86444, 86447, 86450, 86453, 86456, 86459, 86462, 86465, 86470, 86473, 86476 .. 86477, 86479 .. 86480, 86482 .. 86483, 86485 .. 86486, 86488 .. 86489, 86491 .. 86492, 86494 .. 86495, 86497 .. 86498, 86500, 86502, 86504 .. 86505, 86507 .. 86508, 86510 .. 86511, 86513 .. 86514, 86517, 86519, 86529, 86551, 86554, 86556, 86558 .. 86559, 86561 .. 86562, 86564 .. 86565, 86567 .. 86568, 86570 .. 86571, 86573 .. 86574, 86576 .. 86577, 86579, 86609, 86633, 86637, 86641, 86643, 86647, 86650, 86653, 86655, 86657, 86660, 86663, 86666, 86668 .. 86669, 86672 .. 86676, 86678 .. 86679, 86681 .. 86682, 86684 .. 86685, 86687 .. 86688, 86690, 86692, 86694 .. 86695, 86697 .. 86698, 86700 .. 86701, 86703 .. 86704, 86706 .. 86707, 86709, 86720, 86732 .. 86733, 86735 .. 86736, 86738 .. 86739, 86741 .. 86742, 86744 .. 86745, 86747 .. 86748, 86750 .. 86751, 86753 .. 86754, 86756 .. 86757, 86759, 86807, 86825, 86830, 86833, 86836, 86842, 86845, 86850, 86853 .. 86854, 86856 .. 86857, 86859 .. 86860, 86862 .. 86863, 86865 .. 86866, 86868 .. 86869, 86871 .. 86872, 86874 .. 86875, 86877, 86879, 86899, 86911, 86916, 86919 .. 86920, 86922 .. 86923, 86925 .. 86926, 86928 .. 86929, 86931 .. 86932, 86934 .. 86935, 86937 .. 86938, 86940 .. 86941, 86943 .. 86944, 86946 .. 86947, 86949, 86956, 86971 .. 86972, 86974 .. 86975, 86977 .. 86978, 86980 .. 86981, 86983 .. 86984, 86986 .. 86987, 86989, 87435, 87437, 87439, 87448, 87452, 87459, 87463, 87466, 87471, 87474, 87477, 87480, 87484, 87487 .. 87488, 87490, 87493 .. 87494, 87496 .. 87497, 87499, 87509, 87527, 87534, 87538, 87541, 87544 .. 87545, 87547, 87549, 87561, 87600, 87616, 87629, 87634, 87637, 87640, 87642, 87645, 87647 .. 87648, 87650 .. 87651, 87653 .. 87654, 87656 .. 87657, 87659 .. 87660, 87662 .. 87663, 87665 .. 87666, 87668 .. 87669, 87671 .. 87672, 87674 .. 87675, 87677, 87679, 87700, 87719, 87724, 87727, 87730, 87733 .. 87734, 87736 .. 87737, 87739 .. 87740, 87742 .. 87743, 87745 .. 87746, 87748 .. 87749, 87751 .. 87752, 87754 .. 87755, 87757 .. 87758, 87760 .. 87761, 87763 .. 87764, 87766 .. 87767, 87769 .. 87770, 87772 .. 87773, 87775 .. 87776, 87778 .. 87779, 87781 .. 87782, 87784 .. 87785, 87787, 87789, 88045 .. 88046, 88048, 88069, 88074, 88079, 88085 .. 88086, 88090, 88094, 88097, 88099, 88131, 88138, 88142, 88145, 88147, 88149, 88161, 88167, 88171, 88175, 88178 .. 88179, 88212 .. 88214, 88239, 88250, 88255, 88260, 88263, 88267, 88271, 88273, 88276, 88279, 88281, 88284 .. 88285, 88287, 88289, 88299, 88316 .. 88317, 88319, 88326, 88339, 88348, 88353, 88356, 88361, 88364, 88367 .. 88368, 88370 .. 88371, 88373 .. 88374, 88376 .. 88377, 88379, 88400, 88410, 88416, 88422, 88427, 88430, 88433, 88436 .. 88437, 88441, 88444, 88447 .. 88448, 88450 .. 88451, 88453 .. 88454, 88456 .. 88457, 88459, 88471, 88477, 88480 .. 88481, 88483 .. 88484, 88486 .. 88487, 88489, 88499, 88512, 88515, 88518, 88521, 88524 .. 88525, 88527, 88529, 88605, 88630 .. 88631, 88633 .. 88634, 88636 .. 88637, 88639, 88662, 88677, 88682, 88690, 88693, 88696 .. 88697, 88699, 88709, 88718 .. 88719, 89040, 89073, 89075, 89077, 89079, 89081, 89129, 89134, 89143, 89150, 89155, 89160, 89165, 89168, 89171, 89173 .. 89174, 89176 .. 89177, 89179 .. 89180, 89182 .. 89183, 89185 .. 89186, 89188 .. 89189, 89191 .. 89192, 89194 .. 89195, 89197 .. 89198, 89231, 89233, 89250, 89257, 89264, 89269, 89275, 89278, 89281, 89284, 89287, 89290 .. 89291, 89293 .. 89294, 89296 .. 89297, 89299, 89312, 89331, 89335, 89340, 89343 .. 89344, 89346 .. 89347, 89349 .. 89350, 89352 .. 89353, 89355 .. 89356, 89358 .. 89359, 89361 .. 89362, 89364 .. 89365, 89367 .. 89368, 89407, 89415, 89420, 89423, 89426, 89428 .. 89429, 89431 .. 89432, 89434 .. 89435, 89437 .. 89438, 89440 .. 89441, 89443 .. 89444, 89446 .. 89447, 89449, 89518, 89520, 89522, 89537, 89542, 89547, 89551, 89555, 89558, 89561, 89564, 89567 .. 89568, 89584, 89597, 89601, 89604 .. 89605, 89607 .. 89608, 89610 .. 89611, 89613 .. 89614, 89616 .. 89617, 89619, 90402 .. 90403, 90408 .. 90409, 90411, 90419, 90425, 90427, 90429, 90431, 90439, 90441, 90443, 90449, 90451, 90453, 90455, 90457, 90459, 90461, 90469, 90471, 90473, 90475, 90478, 90480, 90482, 90489, 90491, 90513, 90518, 90522, 90530, 90537, 90542, 90547, 90552, 90556, 90559, 90562, 90571, 90574, 90579, 90584, 90587, 90592, 90596, 90599, 90602, 90607, 90610, 90613 .. 90614, 90616 .. 90617, 90619, 90762 .. 90763, 90765 .. 90766, 90768, 91052, 91054, 91056, 91058, 91074, 91077, 91080, 91083, 91085 .. 91086, 91088, 91090 .. 91091, 91093 .. 91094, 91096 .. 91097, 91099, 91126, 91154, 91161, 91166, 91171, 91174, 91177, 91180, 91183, 91186 .. 91187, 91189, 91207, 91217, 91220, 91224, 91227, 91230, 91233, 91235 .. 91236, 91238 .. 91239, 91241 .. 91242, 91244 .. 91245, 91247, 91249, 91257, 91275, 91278, 91281 .. 91282, 91284, 91286 .. 91287, 91289, 91301, 91315, 91320, 91322, 91325, 91327, 91330, 91332, 91334, 91336, 91338, 91341, 91344, 91346 .. 91347, 91349 .. 91350, 91352 .. 91353, 91355 .. 91356, 91358 .. 91359, 91361 .. 91362, 91364 .. 91365, 91367, 91369, 91413, 91438, 91443, 91448, 91452, 91456, 91459 .. 91460, 91462 .. 91463, 91465 .. 91466, 91468 .. 91469, 91471 .. 91472, 91474 .. 91475, 91477 .. 91478, 91480 .. 91481, 91483 .. 91484, 91486 .. 91487, 91489, 91522, 91541, 91550, 91555, 91560, 91564, 91567, 91572, 91575, 91578, 91580, 91583, 91586 .. 91587, 91589 .. 91590, 91592 .. 91593, 91595 .. 91596, 91598 .. 91599, 91601 .. 91602, 91604 .. 91605, 91607 .. 91608, 91610 .. 91611, 91613 .. 91614, 91616 .. 91617, 91619 .. 91620, 91622 .. 91623, 91625 .. 91626, 91628 .. 91629, 91631 .. 91632, 91634 .. 91635, 91637, 91639, 91710, 91717, 91719 .. 91720, 91722 .. 91723, 91725 .. 91726, 91728 .. 91729, 91731 .. 91732, 91734 .. 91735, 91737 .. 91738, 91740 .. 91741, 91743 .. 91744, 91746 .. 91747, 91749, 91757, 91781, 91785, 91788, 91790, 91792 .. 91793, 91795 .. 91796, 91798 .. 91799, 91801 .. 91802, 91804 .. 91805, 91807, 91809, 92224, 92237, 92242, 92245, 92249, 92253, 92256, 92259 .. 92260, 92262 .. 92263, 92265 .. 92266, 92268 .. 92269, 92271 .. 92272, 92274 .. 92275, 92277 .. 92278, 92280 .. 92281, 92283 .. 92284, 92286 .. 92287, 92289, 92318, 92331, 92334, 92339, 92342, 92345, 92348, 92353, 92355, 92358, 92360 .. 92361, 92363 .. 92364, 92366 .. 92367, 92369, 92421, 92431, 92436, 92439, 92442, 92444 .. 92445, 92447, 92449, 92507, 92521, 92526, 92533, 92536, 92539 .. 92540, 92542 .. 92543, 92545 .. 92546, 92548 .. 92549, 92551 .. 92552, 92554 .. 92555, 92557, 92559, 92637, 92648, 92655, 92660, 92665, 92670, 92676, 92681, 92685, 92690, 92693 .. 92694, 92696 .. 92697, 92699 .. 92700, 92702 .. 92703, 92705 .. 92706, 92708 .. 92709, 92711 .. 92712, 92714 .. 92715, 92717 .. 92718, 92720 .. 92721, 92723 .. 92724, 92726 .. 92727, 92729, 93047, 93049, 93051, 93053, 93055, 93057, 93059, 93073, 93077, 93080, 93083, 93086 .. 93087, 93089 .. 93090, 93092 .. 93093, 93095 .. 93096, 93098 .. 93099, 93101 .. 93102, 93104 .. 93105, 93107, 93109, 93128, 93133, 93138, 93142, 93149, 93152, 93155, 93158, 93161, 93164, 93167, 93170, 93173, 93176 .. 93177, 93179 .. 93180, 93182 .. 93183, 93185 .. 93186, 93188 .. 93189, 93191 .. 93192, 93194 .. 93195, 93197, 93199, 93309, 93326, 93333, 93336, 93339, 93342 .. 93343, 93345 .. 93346, 93348 .. 93349, 93351 .. 93352, 93354, 93356, 93358 .. 93359, 93413, 93426, 93437, 93444, 93449, 93453, 93455, 93458, 93462, 93464, 93466, 93468, 93470 .. 93471, 93473 .. 93474, 93476 .. 93477, 93479 .. 93480, 93482 .. 93483, 93485 .. 93486, 93488 .. 93489, 93491 .. 93492, 93494 .. 93495, 93497, 93499, 94032, 94034, 94036, 94051, 94060, 94065, 94072, 94078, 94081, 94086, 94089, 94094, 94099, 94104, 94107, 94110, 94113, 94116, 94118, 94121, 94124, 94127, 94130, 94133, 94136 .. 94137, 94139 .. 94140, 94142 .. 94143, 94145 .. 94146, 94148 .. 94149, 94151 .. 94152, 94154 .. 94155, 94157 .. 94158, 94160 .. 94161, 94163 .. 94164, 94166 .. 94167, 94169, 94209, 94227, 94234, 94239, 94244, 94249 .. 94250, 94252 .. 94253, 94255 .. 94256, 94258 .. 94259, 94261 .. 94262, 94264 .. 94265, 94267, 94269, 94315, 94327, 94330, 94333, 94336, 94339, 94342, 94344 .. 94345, 94347 .. 94348, 94350 .. 94351, 94353 .. 94354, 94356 .. 94357, 94359 .. 94360, 94362 .. 94363, 94365 .. 94366, 94368 .. 94369, 94371 .. 94372, 94374 .. 94375, 94377, 94379, 94405, 94419, 94424, 94428, 94431, 94436 .. 94437, 94439, 94447, 94469, 94474, 94481, 94486, 94491, 94496, 94501, 94505, 94508, 94513, 94518, 94522, 94526 .. 94527, 94529 .. 94530, 94532 .. 94533, 94535 .. 94536, 94538 .. 94539, 94541 .. 94542, 94544 .. 94545, 94547 .. 94548, 94550 .. 94551, 94553 .. 94554, 94556 .. 94557, 94559 .. 94560, 94562 .. 94563, 94565 .. 94566, 94568 .. 94569, 94571 .. 94572, 94574 .. 94575, 94577, 94579, 95028, 95030, 95032, 95100, 95111, 95119, 95126, 95131, 95138, 95145, 95152, 95158, 95163, 95168, 95173, 95176, 95179 .. 95180, 95182 .. 95183, 95185 .. 95186, 95188 .. 95189, 95191 .. 95192, 95194 .. 95195, 95197, 95199, 95213, 95233 .. 95234, 95236 .. 95237, 95239, 95326, 95336, 95339, 95346, 95349, 95352, 95355 .. 95356, 95358 .. 95359, 95361 .. 95362, 95364 .. 95365, 95367, 95369, 95444 .. 95445, 95447 .. 95448, 95460, 95463, 95466, 95469, 95473, 95478, 95482, 95485, 95488, 95490 .. 95491, 95493 .. 95494, 95496 .. 95497, 95499 .. 95500, 95502 .. 95503, 95505 .. 95506, 95508 .. 95509, 95511 .. 95512, 95514 .. 95515, 95517, 95519, 95615, 95632, 95643, 95652, 95659, 95666, 95671, 95676, 95679 .. 95680, 95682 .. 95683, 95685 .. 95686, 95688 .. 95689, 95691 .. 95692, 95694 .. 95695, 95697 .. 95698, 95700 .. 95701, 95703 .. 95704, 95706 .. 95707, 95709, 96047, 96049 .. 96050, 96052, 96103, 96106, 96110, 96114, 96117, 96120, 96123, 96126, 96129, 96132, 96135, 96138, 96142, 96145 .. 96146, 96148 .. 96149, 96151 .. 96152, 96154 .. 96155, 96157 .. 96158, 96160 .. 96161, 96163 .. 96164, 96166 .. 96167, 96169 .. 96170, 96172 .. 96173, 96175 .. 96176, 96178 .. 96179, 96181 .. 96182, 96184 .. 96185, 96187 .. 96188, 96190 .. 96191, 96193 .. 96194, 96196 .. 96197, 96199, 96215, 96224, 96231, 96237, 96242, 96247, 96250, 96253, 96257, 96260, 96264, 96268 .. 96269, 96271 .. 96272, 96274 .. 96275, 96277, 96279, 96317, 96328, 96332, 96337, 96342, 96346, 96349, 96352, 96355, 96358, 96361, 96364 .. 96365, 96367, 96369, 96450, 96465, 96472, 96476, 96479, 96482, 96484, 96486 .. 96487, 96489, 96515, 96523 .. 96524, 96528, 97070, 97072, 97074, 97076, 97078, 97080, 97082, 97084, 97199, 97204, 97209, 97215, 97218, 97222, 97225, 97228, 97230, 97232, 97234, 97236 .. 97237, 97239, 97241, 97243 .. 97244, 97246 .. 97247, 97249 .. 97250, 97252 .. 97253, 97255 .. 97256, 97258 .. 97259, 97261 .. 97262, 97264 .. 97265, 97267 .. 97268, 97270 .. 97271, 97273 .. 97274, 97276 .. 97277, 97279 .. 97280, 97282 .. 97283, 97285 .. 97286, 97288 .. 97289, 97291 .. 97292, 97294 .. 97295, 97297, 97299, 97318, 97320, 97332, 97334, 97337, 97340, 97342, 97346, 97348, 97350, 97353, 97355, 97357, 97359, 97412, 97421 .. 97422, 97424, 97437, 97440, 97447, 97450, 97453, 97456, 97461, 97464, 97469, 97475, 97478, 97483, 97486, 97488, 97490 .. 97491, 97493 .. 97494, 97496 .. 97497, 97499 .. 97500, 97502 .. 97503, 97505 .. 97506, 97508 .. 97509, 97511, 97513 .. 97514, 97516 .. 97517, 97519 .. 97520, 97522 .. 97523, 97525 .. 97526, 97528 .. 97529, 97531 .. 97532, 97534 .. 97535, 97537, 97539, 97616, 97618, 97631, 97633, 97638, 97640, 97645, 97647, 97650, 97653 .. 97654, 97656 .. 97657, 97659, 97688, 97702, 97705, 97708, 97711, 97714, 97717, 97720, 97723 .. 97725, 97727, 97729, 97737, 97753, 97762, 97769, 97772 .. 97773, 97775 .. 97776, 97778 .. 97780, 97782 .. 97783, 97785 .. 97786, 97788 .. 97789, 97791 .. 97792, 97794 .. 97795, 97797, 97799, 97816, 97828, 97833 .. 97834, 97836 .. 97837, 97839 .. 97840, 97842 .. 97843, 97845 .. 97846, 97848 .. 97849, 97851 .. 97852, 97854 .. 97855, 97857, 97859, 97877, 97892, 97896, 97900 .. 97901, 97903 .. 97904, 97906 .. 97907, 97909, 97922, 97941, 97944, 97947, 97950, 97953, 97956 .. 97957, 97959, 97980, 97990, 97993, 97996, 97999, 98527 .. 98530, 98544, 98547, 98553 .. 98554, 98559, 98574, 98587, 98590, 98593, 98596 .. 98597, 98599, 98617, 98631, 98634, 98639, 98646, 98660, 98663, 98666 .. 98667, 98669, 98673, 98678, 98693, 98701, 98704, 98708, 98711, 98714, 98716, 98724, 98739, 98743 .. 98744, 98746, 98749, 99084 .. 99087, 99089, 99091 .. 99092, 99094, 99096 .. 99100, 99102, 99130, 99189, 99192, 99195, 99198, 99310, 99326, 99330, 99334, 99338, 99423, 99425, 99427 .. 99428, 99438 .. 99439, 99441, 99444, 99448, 99510, 99518, 99610, 99625, 99628, 99631, 99634, 99636, 99638, 99706, 99713, 99718, 99734 .. 99735, 99752, 99755, 99759, 99762, 99765, 99768, 99817, 99819, 99826, 99830 .. 99831, 99834, 99837, 99842, 99846, 99848, 99867, 99869, 99880, 99885, 99887, 99891, 99894, 99897 .. 99898, 99947, 99955, 99958, 99974, 99976, 99986, 99988, 99991, 99994, 99996, 99998, } __END__ Regexp-Common-2017060201/t/zip/201_luxembourg.t000755 000765 000024 00000023341 13114353631 021344 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use warnings; no warnings 'syntax'; use lib "."; use Regexp::Common; use Test::More; use t::zip::Zip; my $r = eval "require Test::Regexp; 1"; unless ($r) { print "1..0 # SKIP Test::Regexp not found\n"; exit; } test_zips country => "Luxembourg", name => "Luxembourg zip codes", prefix => { iso => "LU", cept => "L", invalid => "DE", }, prefix_test_set => [2968, 8701], ; done_testing; sub valid_zip_codes { map {sprintf "%04d" => $_} 101, 121, 123 .. 125, 131 .. 132, 141 .. 143, 161, 171, 173, 181 .. 183, 191 .. 192, 202, 211, 231, 241, 251, 262 .. 263, 291, 321 .. 325, 332, 342, 361 .. 362, 372, 381 .. 383, 391, 401 .. 403, 411 .. 412, 421 .. 422, 441 .. 443, 445 .. 446, 451, 453, 462 .. 464, 471 .. 472, 481 .. 482, 491 .. 497, 521, 531 .. 532, 551 .. 554, 561 .. 562, 581 .. 584, 611 .. 612, 641 .. 644, 661 .. 664, 671 .. 672, 691 .. 692, 721 .. 723, 751 .. 754, 761, 763, 771 .. 772, 801 .. 809, 811 .. 814, 821 .. 823, 831 .. 834, 841, 852 .. 855, 861, 881, 901, 903 .. 904, 911 .. 914, 921 .. 922, 942 .. 944, 951 .. 954, 961 .. 963, 971 .. 973, 981 .. 983, 991 .. 995, 1009 .. 1030, 1050, 1060, 1090, 1110 .. 1153, 1159 .. 1161, 1208 .. 1283, 1309 .. 1376, 1409, 1411 .. 1434, 1445, 1448 .. 1484, 1490, 1499, 1508 .. 1552, 1610 .. 1611, 1613 .. 1656, 1660 .. 1661, 1670, 1709 .. 1753, 1811 .. 1818, 1820 .. 1822, 1831 .. 1843, 1845 .. 1846, 1850 .. 1868, 1870 .. 1873, 1880 .. 1882, 1896 .. 1899, 1910 .. 1954, 2010 .. 2020, 2080, 2082, 2084 .. 2091, 2093 .. 2099, 2111 .. 2125, 2127 .. 2135, 2137 .. 2184, 2210 .. 2215, 2220 .. 2234, 2240 .. 2243, 2261 .. 2263, 2265 .. 2273, 2308 .. 2320, 2322 .. 2324, 2326 .. 2361, 2370, 2380 .. 2381, 2409 .. 2420, 2422 .. 2436, 2440 .. 2454, 2510 .. 2567, 2609 .. 2617, 2619 .. 2637, 2651 .. 2654, 2661 .. 2674, 2680 .. 2681, 2711 .. 2734, 2736 .. 2741, 2761 .. 2764, 2850, 2860, 2880, 2887 .. 2889, 2900, 2910 .. 2916, 2918 .. 2922, 2925 .. 2926, 2928 .. 2942, 2946, 2949 .. 2958, 2960 .. 2961, 2964 .. 2966, 2968, 2971, 2974 .. 2988, 2990 .. 2992, 2994 .. 2999, 3201, 3205 .. 3206, 3208 .. 3225, 3229 .. 3243, 3249 .. 3261, 3265 .. 3267, 3269 .. 3288, 3290, 3311, 3313 .. 3318, 3320 .. 3330, 3332 .. 3337, 3340 .. 3341, 3345 .. 3378, 3380, 3382 .. 3386, 3389 .. 3398, 3401 .. 3403, 3409 .. 3433, 3435 .. 3436, 3439 .. 3454, 3460 .. 3476, 3480 .. 3493, 3501 .. 3517, 3520 .. 3526, 3529 .. 3532, 3539 .. 3555, 3560 .. 3576, 3582 .. 3585, 3588 .. 3598, 3601, 3611 .. 3617, 3620 .. 3622, 3630 .. 3631, 3635 .. 3638, 3640 .. 3644, 3650 .. 3658, 3660, 3670 .. 3682, 3701, 3705, 3710 .. 3731, 3733 .. 3744, 3750 .. 3755, 3761 .. 3768, 3770 .. 3776, 3780 .. 3782, 3784, 3786 .. 3790, 3801, 3810 .. 3826, 3830 .. 3844, 3850 .. 3864, 3870 .. 3884, 3895 .. 3899, 3901, 3909 .. 3941, 3943 .. 3945, 3960 .. 3961, 3980, 3985, 4001 .. 4074, 4080 .. 4086, 4088, 4100 .. 4103, 4105 .. 4116, 4118 .. 4123, 4125 .. 4126, 4130 .. 4143, 4149 .. 4156, 4164 .. 4180, 4201 .. 4211, 4213 .. 4214, 4216 .. 4217, 4220 .. 4222, 4230 .. 4256, 4260 .. 4268, 4270 .. 4272, 4275 .. 4283, 4289, 4301 .. 4310, 4314 .. 4328, 4330 .. 4337, 4340 .. 4355, 4360 .. 4373, 4380 .. 4385, 4390 .. 4398, 4401 .. 4402, 4405 .. 4423, 4429 .. 4451, 4459 .. 4470, 4475 .. 4494, 4499, 4501 .. 4565, 4569 .. 4583, 4590 .. 4599, 4601 .. 4613, 4620 .. 4636, 4638 .. 4651, 4653, 4656 .. 4658, 4660 .. 4672, 4676 .. 4693, 4696 .. 4698, 4701 .. 4702, 4706 .. 4722, 4730 .. 4745, 4750 .. 4763, 4770 .. 4786, 4795 .. 4798, 4801 .. 4802, 4804 .. 4815, 4818 .. 4820, 4822 .. 4826, 4829 .. 4834, 4837 .. 4840, 4842 .. 4850, 4853, 4870 .. 4895, 4901 .. 4902, 4906 .. 4956, 4958 .. 4982, 4984 .. 4999, 5201, 5211 .. 5222, 5230 .. 5241, 5243 .. 5244, 5250 .. 5256, 5280, 5290, 5299, 5310, 5312, 5314 .. 5318, 5320, 5322, 5324, 5326, 5328, 5330 .. 5337, 5339 .. 5342, 5351 .. 5353, 5355, 5359 .. 5378, 5380, 5401 .. 5405, 5407 .. 5408, 5410 .. 5419, 5421 .. 5427, 5429 .. 5435, 5439 .. 5447, 5450 .. 5451, 5460, 5465 .. 5466, 5470 .. 5471, 5480 .. 5483, 5485, 5488 .. 5489, 5495, 5499, 5501, 5505 .. 5507, 5511 .. 5523, 5530 .. 5540, 5544, 5548 .. 5561, 5570 .. 5577, 5601 .. 5602, 5605, 5610 .. 5620, 5626 .. 5640, 5650 .. 5659, 5670 .. 5671, 5675, 5680 .. 5687, 5690 .. 5693, 5695, 5698, 5701, 5710 .. 5714, 5716 .. 5723, 5730, 5740 .. 5741, 5750 .. 5756, 5760 .. 5762, 5770 .. 5776, 5801, 5808 .. 5826, 5828 .. 5844, 5846, 5850, 5852 .. 5856, 5859 .. 5876, 5878, 5880, 5884 .. 5893, 5898 .. 5899, 5940 .. 5943, 5950 .. 5964, 5969 .. 5978, 6101, 6111 .. 6125, 6129 .. 6150, 6155, 6160 .. 6163, 6165 .. 6166, 6169 .. 6171, 6175, 6180 .. 6190, 6195 .. 6197, 6201, 6210 .. 6215, 6225, 6230 .. 6231, 6235, 6238 .. 6240, 6243, 6245 .. 6246, 6250 .. 6252, 6255, 6301, 6310 .. 6315, 6340, 6350, 6360, 6370, 6380, 6401 .. 6402, 6406, 6408 .. 6423, 6430 .. 6443, 6445 .. 6455, 6460 .. 6488, 6490 .. 6497, 6499, 6550 .. 6553, 6555, 6557 .. 6560, 6562, 6570 .. 6572, 6579 .. 6583, 6585 .. 6587, 6590, 6601, 6610 .. 6623, 6630 .. 6638, 6645 .. 6651, 6660 .. 6661, 6663, 6665 .. 6666, 6669 .. 6678, 6680 .. 6693, 6695, 6701, 6711 .. 6726, 6730 .. 6745, 6750 .. 6765, 6770 .. 6786, 6790 .. 6796, 6815, 6830 .. 6842, 6850 .. 6852, 6858, 6868 .. 6871, 6880, 6901, 6905 .. 6906, 6910 .. 6919, 6921 .. 6923, 6925 .. 6926, 6930 .. 6931, 6933 .. 6934, 6939 .. 6948, 6950 .. 6951, 6955 .. 6956, 6960 .. 6962, 6969 .. 6982, 6985 .. 6992, 6995 .. 6999, 7201 .. 7202, 7209 .. 7264, 7268 .. 7270, 7274, 7302 .. 7364, 7370 .. 7384, 7390 .. 7392, 7395 .. 7397, 7409 .. 7412, 7415 .. 7418, 7420 .. 7421, 7423 .. 7425, 7430 .. 7433, 7435, 7440 .. 7458, 7460 .. 7465, 7470 .. 7471, 7473, 7475, 7480 .. 7482, 7501 .. 7502, 7505 .. 7508, 7511 .. 7526, 7531 .. 7547, 7553 .. 7572, 7590 .. 7599, 7601, 7610, 7612 .. 7613, 7615, 7618 .. 7627, 7633 .. 7636, 7639 .. 7641, 7649 .. 7653, 7660 .. 7664, 7670, 7673, 7680 .. 7681, 7701, 7703, 7710 .. 7716, 7720 .. 7724, 7726 .. 7727, 7730 .. 7735, 7737 .. 7741, 7750, 7758 .. 7774, 7777 .. 7795, 8001 .. 8002, 8005 .. 8099, 8110 .. 8112, 8115 .. 8121, 8123 .. 8135, 8137 .. 8142, 8145 .. 8147, 8149 .. 8154, 8156 .. 8160, 8165 .. 8167, 8179 .. 8191, 8201, 8205, 8209 .. 8255, 8258 .. 8274, 8277 .. 8295, 8301 .. 8303, 8306, 8308 .. 8345, 8350 .. 8376, 8378 .. 8381, 8383 .. 8388, 8390 .. 8396, 8398 .. 8399, 8401, 8410 .. 8415, 8420 .. 8424, 8435 .. 8438, 8440 .. 8445, 8447 .. 8453, 8460 .. 8480, 8501 .. 8502, 8506 .. 8511, 8521 .. 8523, 8525 .. 8531, 8533, 8537 .. 8546, 8550 .. 8552, 8557 .. 8558, 8560 .. 8562, 8606, 8609 .. 8615, 8620, 8701, 8705 .. 8708, 8710 .. 8711, 8715, 8720, 8801 .. 8802, 8805 .. 8806, 8808 .. 8809, 8811 .. 8814, 8816 .. 8826, 8831 .. 8835, 8838, 9001 .. 9004, 9006, 9010 .. 9033, 9040 .. 9048, 9050 .. 9056, 9060 .. 9072, 9080 .. 9094, 9098 .. 9099, 9115 .. 9137, 9140, 9142, 9144 .. 9147, 9150 .. 9151, 9153 .. 9158, 9160 .. 9161, 9163 .. 9173, 9175 .. 9177, 9179 .. 9184, 9186, 9188 .. 9191, 9201 .. 9218, 9220 .. 9221, 9224 .. 9245, 9249 .. 9268, 9273, 9275 .. 9294, 9330, 9340, 9350 .. 9357, 9359 .. 9361, 9364 .. 9366, 9368 .. 9373, 9375 .. 9378, 9380 .. 9382, 9390 .. 9392, 9395, 9401, 9405 .. 9412, 9414 .. 9426, 9440, 9451 .. 9459, 9461 .. 9466, 9501 .. 9502, 9506, 9510 .. 9523, 9530 .. 9545, 9550 .. 9560, 9570 .. 9579, 9631 .. 9633, 9635 .. 9641, 9643 .. 9645, 9647 .. 9648, 9650 .. 9651, 9653 .. 9657, 9659 .. 9660, 9662 .. 9663, 9665 .. 9666, 9668 .. 9674, 9676, 9678, 9681 .. 9682, 9684, 9687, 9689 .. 9690, 9696, 9701, 9706 .. 9715, 9737 .. 9738, 9740 .. 9749, 9751 .. 9776, 9779 .. 9780, 9801, 9805 .. 9809, 9830 .. 9831, 9833 .. 9841, 9901 .. 9903, 9905 .. 9913, 9940, 9942 .. 9944, 9946, 9948, 9950, 9952, 9954, 9956, 9960, 9962, 9964, 9966, 9968, 9970, 9972, 9974, 9976, 9980, 9982, 9990 .. 9993, 9999, } __END__ Regexp-Common-2017060201/t/zip/211_france.t000755 000765 000024 00000273237 13114353631 020425 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use warnings; no warnings 'syntax'; use lib "."; use Regexp::Common; use Test::More; use t::zip::Zip; my $r = eval "require Test::Regexp; 1"; unless ($r) { print "1..0 # SKIP Test::Regexp not found\n"; exit; } test_zips country => "France", name => "French zip codes", prefix => { iso => "FR", cept => "F", invalid => "ES", }, prefix_test_set => [19000, 57480], ; done_testing; sub valid_zip_codes { map {sprintf "%05d" => $_} 1000 .. 1020, 1059 .. 1061, 1069, 1090, 1100 .. 1112, 1115 .. 1117, 1120 .. 1130, 1140, 1150 .. 1155, 1158, 1160, 1170 .. 1174, 1190, 1200 .. 1204, 1206, 1208, 1210 .. 1213, 1216 .. 1217, 1220, 1230, 1240, 1250, 1260, 1270, 1280, 1290, 1300 .. 1303, 1306, 1310, 1320, 1330, 1340, 1350, 1360, 1365 .. 1366, 1369 .. 1370, 1380, 1390, 1400, 1410, 1420, 1430, 1440 .. 1443, 1450, 1460, 1470, 1480, 1500 .. 1506, 1508, 1510, 1540, 1550, 1560, 1570, 1580, 1590, 1600 .. 1604, 1606, 1630, 1632 .. 1633, 1637 .. 1638, 1640, 1660, 1680, 1700 .. 1708, 1710, 1750, 1800, 1851, 1921, 1960, 1990, 2000 .. 2020, 2025, 2100 .. 2110, 2120, 2130, 2140, 2150 .. 2151, 2160, 2170, 2190, 2200 .. 2210, 2220, 2230, 2240, 2250, 2260, 2270, 2290, 2300 .. 2303, 2309 .. 2310, 2314 .. 2315, 2320 .. 2327, 2329 .. 2331, 2340, 2350, 2360, 2370, 2380, 2390, 2400 .. 2407, 2409 .. 2410, 2420, 2430, 2440, 2450, 2460, 2470, 2480, 2490, 2500, 2510, 2520, 2540, 2550, 2570, 2580, 2590, 2600 .. 2604, 2609 .. 2610, 2620, 2630, 2640, 2650, 2670, 2680, 2690, 2700, 2720, 2760, 2790, 2800, 2810, 2820, 2830, 2840, 2850, 2860, 2870, 2880, 2930, 2939, 3000, 3003 .. 3008, 3010 .. 3019, 3021, 3100 .. 3110, 3120, 3130, 3140, 3150, 3160, 3170, 3190, 3200 .. 3210, 3220, 3230, 3240, 3250, 3260, 3270, 3290, 3300 .. 3307, 3309 .. 3311, 3314 .. 3315, 3319 .. 3321, 3329 .. 3330, 3340, 3350, 3360, 3370, 3380, 3390, 3400 .. 3403, 3405 .. 3406, 3409 .. 3410, 3420, 3430, 3440, 3450, 3452, 3460, 3470, 3500, 3510, 3600, 3630, 3700, 3800, 4000 .. 4006, 4009 .. 4019, 4029, 4100 .. 4107, 4110, 4119 .. 4120, 4130, 4140, 4150, 4160, 4170, 4180, 4190, 4200 .. 4203, 4209 .. 4210, 4220, 4230, 4240, 4250, 4260, 4270, 4280, 4290, 4300 .. 4301, 4310, 4320, 4330, 4340, 4350, 4360, 4370, 4380, 4400, 4410, 4420, 4500, 4510, 4530, 4600, 4660, 4700, 4800, 4850, 4860, 4870, 4990, 4995, 5000 .. 5008, 5010 .. 5012, 5014 .. 5016, 5019, 5100 .. 5105, 5107, 5110, 5120, 5130, 5140, 5150, 5160, 5170, 5190, 5200 .. 5202, 5208 .. 5209, 5220, 5230, 5240, 5250, 5260, 5290, 5300, 5310, 5320, 5330, 5340, 5350, 5380, 5400, 5460, 5470, 5480, 5500, 5560, 5600, 5700, 5800, 6000 .. 6013, 6016, 6032 .. 6036, 6044 .. 6050, 6053, 6071, 6073, 6078 .. 6079, 6082 .. 6085, 6099 .. 6103, 6105 .. 6110, 6113 .. 6117, 6119, 6121, 6125 .. 6126, 6130 .. 6133, 6135 .. 6137, 6139 .. 6143, 6150 .. 6157, 6160 .. 6162, 6164, 6167, 6170 .. 6173, 6175, 6177, 6180 .. 6187, 6189 .. 6190, 6200 .. 6206, 6209 .. 6212, 6220 .. 6242, 6250 .. 6255, 6257, 6259 .. 6260, 6270 .. 6272, 6281 .. 6284, 6286 .. 6290, 6292 .. 6295, 6299 .. 6306, 6309 .. 6310, 6320, 6330, 6340 .. 6345, 6348 .. 6349, 6352 .. 6354, 6357 .. 6360, 6364, 6369 .. 6373, 6376, 6379 .. 6380, 6390 .. 6392, 6400 .. 6408, 6410, 6414, 6420, 6430, 6440, 6450, 6460, 6470, 6480, 6500 .. 6508, 6510 .. 6511, 6513 .. 6518, 6520, 6530 .. 6532, 6534 .. 6535, 6540, 6550, 6560, 6570, 6580, 6590, 6600 .. 6607, 6609 .. 6610, 6620, 6631 .. 6634, 6640, 6650, 6660, 6666, 6670, 6690, 6700 .. 6706, 6708 .. 6710, 6721, 6723, 6730, 6740, 6750, 6790, 6800 .. 6806, 6808, 6810, 6825 .. 6826, 6829 .. 6831, 6833, 6850, 6891, 6901 .. 6906, 6909 .. 6910, 6912 .. 6915, 6921 .. 6922, 6925, 6928 .. 6929, 6950, 6999 .. 7007, 7100 .. 7110, 7120, 7130 .. 7140, 7150, 7160, 7170, 7190, 7200 .. 7210, 7220, 7230, 7240, 7250, 7260, 7270, 7290, 7300 .. 7310, 7320, 7330, 7340, 7350, 7360, 7370, 7380, 7400 .. 7410, 7430, 7440, 7450, 7460, 7470, 7500 .. 7510, 7520, 7530, 7560, 7570, 7580, 7590, 7600, 7610, 7630, 7660, 7690, 7700, 7790, 7800, 8000 .. 8006, 8010 .. 8011, 8013 .. 8014, 8090, 8098 .. 8099, 8101 .. 8107, 8109 .. 8110, 8120, 8130, 8140, 8150, 8160, 8170, 8190, 8200 .. 8210, 8220, 8230, 8240, 8250, 8260, 8270, 8290, 8300, 8302 .. 8305, 8310, 8320, 8330, 8350, 8360, 8370, 8380, 8390, 8400, 8410, 8430, 8440, 8450, 8460, 8500, 8600, 8700, 8800, 9000 .. 9004, 9007 .. 9009, 9014 .. 9017, 9100 .. 9105, 9109 .. 9110, 9120, 9130, 9140, 9160, 9190, 9200 .. 9201, 9209 .. 9210, 9220, 9230, 9240, 9250, 9270, 9290, 9300 .. 9301, 9310, 9320, 9330, 9340, 9350, 9390, 9400 .. 9401, 9420, 9460, 9500, 9600, 9700, 9800, 10000 .. 10015, 10018, 10025 .. 10026, 10030 .. 10032, 10042, 10080 .. 10081, 10088 .. 10089, 10091 .. 10092, 10096, 10100 .. 10105, 10110, 10120 .. 10122, 10128, 10130, 10140, 10150 .. 10154, 10160, 10170, 10180, 10190, 10200 .. 10202, 10208, 10210, 10220, 10230, 10240, 10250, 10260, 10270, 10280, 10290, 10300, 10310, 10320, 10330, 10340, 10350 .. 10353, 10355, 10360, 10370 .. 10371, 10380, 10390, 10400 .. 10404, 10410, 10420, 10430 .. 10433, 10440, 10450, 10500, 10510, 10600 .. 10603, 10605 .. 10606, 10700, 10800, 10901 .. 10902, 10910, 11000 .. 11005, 11007, 11009 .. 11012, 11015 .. 11017, 11020 .. 11022, 11029, 11100 .. 11110, 11120, 11130, 11140, 11150, 11160, 11170, 11190, 11200 .. 11205, 11208 .. 11210, 11220, 11230, 11240, 11250, 11260, 11270, 11290, 11300 .. 11301, 11303 .. 11304, 11310, 11320, 11330, 11340, 11350, 11360, 11370, 11380, 11390, 11400 .. 11402, 11409 .. 11410, 11420, 11430, 11440, 11451 .. 11453, 11480, 11490 .. 11494, 11500, 11510, 11540, 11560, 11570, 11580, 11590, 11600, 11610, 11620, 11700, 11781 .. 11782, 11784 .. 11785, 11789 .. 11790, 11800, 11802 .. 11803, 11805 .. 11808, 11810, 11816, 11823, 11833, 11835 .. 11836, 11838, 11848, 11850, 11855, 11860, 11870, 11875 .. 11878, 11880, 11885, 11890, 11898, 12000 .. 12003, 12005, 12007 .. 12009, 12019 .. 12035, 12039 .. 12040, 12100 .. 12104, 12106, 12108 .. 12110, 12120, 12130, 12140, 12150, 12160, 12170, 12190, 12200 .. 12204, 12210, 12220, 12230, 12240, 12250, 12260, 12270, 12290, 12300, 12310, 12320, 12330, 12340, 12350, 12360, 12370, 12380, 12390, 12400 .. 12402, 12410, 12420, 12430, 12440, 12450, 12460, 12470, 12480, 12490, 12500, 12510, 12520, 12540, 12550, 12560, 12580, 12600, 12620, 12630, 12640, 12700, 12720, 12740, 12780, 12800, 12850, 13000 .. 13016, 13020, 13066 .. 13067, 13080, 13085, 13088 .. 13124, 13126 .. 13133, 13138 .. 13142, 13148 .. 13153, 13155 .. 13161, 13163 .. 13165, 13168 .. 13170, 13177 .. 13178, 13180 .. 13182, 13190 .. 13192, 13196, 13200 .. 13203, 13205, 13207, 13209 .. 13211, 13213 .. 13228, 13230 .. 13236, 13239 .. 13245, 13248 .. 13282, 13284 .. 13304, 13306 .. 13328, 13330 .. 13335, 13338 .. 13340, 13342 .. 13348, 13350 .. 13352, 13354 .. 13357, 13359 .. 13364, 13366 .. 13372, 13374 .. 13397, 13399 .. 13404, 13406, 13410 .. 13417, 13420 .. 13421, 13424 .. 13426, 13428, 13430 .. 13432, 13434 .. 13435, 13440 .. 13448, 13450 .. 13458, 13460, 13462 .. 13464, 13467, 13470 .. 13474, 13478, 13480 .. 13484, 13489 .. 13490, 13493, 13500 .. 13503, 13510 .. 13514, 13516, 13518 .. 13525, 13528 .. 13533, 13538 .. 13543, 13545 .. 13552, 13558 .. 13560, 13566 .. 13568, 13570, 13572, 13580 .. 13581, 13583, 13590 .. 13594, 13599 .. 13612, 13614 .. 13617, 13619 .. 13621, 13625 .. 13633, 13635, 13637, 13640 .. 13643, 13646, 13649 .. 13656, 13658 .. 13678, 13680 .. 13681, 13683 .. 13685, 13687 .. 13705, 13708 .. 13710, 13712 .. 13733, 13740 .. 13747, 13749 .. 13752, 13755, 13757 .. 13760, 13764, 13766, 13770 .. 13785, 13789 .. 13810, 13812 .. 13815, 13820 .. 13825, 13828 .. 13836, 13838 .. 13842, 13844 .. 13847, 13850 .. 13864, 13867 .. 13868, 13870, 13880 .. 13881, 13883, 13887, 13889 .. 13890, 13895, 13900, 13902, 13904 .. 13908, 13910 .. 13911, 13920 .. 13924, 13930 .. 13933, 13937, 13940 .. 13942, 13950, 13960, 13980, 13990, 14000, 14005 .. 14020, 14023 .. 14040, 14045 .. 14048, 14050 .. 14054, 14058 .. 14059, 14061 .. 14067, 14070, 14074 .. 14079, 14081 .. 14086, 14089 .. 14114, 14117, 14120 .. 14121, 14123, 14125 .. 14128, 14130, 14140, 14150, 14160 .. 14162, 14165, 14168, 14170, 14190, 14200 .. 14205, 14207 .. 14210, 14220, 14230, 14240, 14250, 14260, 14270, 14280, 14290, 14310, 14320, 14330, 14340, 14350, 14360, 14370, 14380, 14390, 14400 .. 14410, 14420, 14430, 14440, 14450, 14460 .. 14462, 14469 .. 14470, 14480, 14490, 14500 .. 14505, 14508 .. 14510, 14520, 14530, 14540, 14550, 14570, 14590, 14600 .. 14603, 14610, 14620, 14630, 14640, 14650 .. 14654, 14659, 14670, 14680, 14690, 14700, 14710, 14730, 14740, 14750, 14760, 14770, 14780, 14790 .. 14791, 14800 .. 14810, 14830, 14840, 14850, 14860, 14880, 14901 .. 14916, 14919 .. 14926, 14930 .. 14934, 14940, 14949 .. 14950, 14960, 14970, 14980, 14990, 15000 .. 15008, 15010 .. 15015, 15017 .. 15019, 15100 .. 15107, 15109 .. 15110, 15120, 15130, 15140, 15150, 15160, 15170, 15190, 15200, 15210, 15220, 15229 .. 15230, 15240, 15250, 15260, 15270, 15290, 15300, 15310, 15320, 15340, 15350, 15380, 15400, 15430, 15500, 15590, 15600, 15700, 15800, 16000 .. 16008, 16010 .. 16026, 16100 .. 16113, 16120 .. 16121, 16130, 16140, 16150, 16160, 16170, 16190, 16200, 16210, 16220, 16230, 16240, 16250, 16260, 16270, 16290, 16300, 16310, 16320, 16330, 16340, 16350, 16360, 16370, 16380, 16390, 16400, 16410, 16420, 16430, 16440, 16450, 16460, 16470, 16480, 16490, 16500, 16510, 16560, 16570, 16590, 16600, 16620, 16700, 16710, 16720, 16730, 16800, 16901 .. 16920, 16929, 16950 .. 16955, 16959, 16999 .. 17045, 17051 .. 17056, 17071 .. 17076, 17078 .. 17079, 17086 .. 17089, 17100 .. 17121, 17123, 17130, 17132 .. 17133, 17136 .. 17140, 17150, 17160, 17170, 17180 .. 17190, 17200 .. 17211, 17214 .. 17215, 17220, 17230, 17240, 17250, 17260, 17270, 17281, 17284 .. 17285, 17289 .. 17290, 17300 .. 17314, 17320, 17330, 17340, 17350, 17360, 17370, 17380, 17390, 17400, 17410 .. 17416, 17419 .. 17420, 17430, 17440 .. 17446, 17449 .. 17450, 17460, 17470, 17480, 17490, 17500 .. 17504, 17509 .. 17510, 17520, 17530, 17540, 17550, 17560, 17570, 17580, 17590, 17600, 17610, 17620, 17630, 17640, 17650, 17670, 17690, 17700, 17730, 17740, 17750, 17770, 17780, 17800, 17810, 17840, 17870, 17880, 17890, 17920, 17940, 18000 .. 18007, 18012 .. 18016, 18019 .. 18037, 18039, 18100 .. 18110, 18120, 18130, 18140, 18150, 18160, 18170, 18190, 18200 .. 18207, 18210, 18220, 18230, 18240, 18250, 18260, 18270, 18290, 18300, 18310, 18320, 18330, 18340, 18350, 18360, 18370, 18380, 18390, 18400, 18410, 18500, 18510, 18520, 18570, 18600, 18700, 18800, 18910 .. 18911, 18920, 18922 .. 18924, 18934 .. 18935, 18939 .. 18941, 18945, 18998, 19000 .. 19007, 19009, 19011 .. 19012, 19015, 19017 .. 19019, 19033, 19100 .. 19111, 19113 .. 19114, 19116 .. 19120, 19130, 19140, 19150, 19160, 19170, 19190, 19200 .. 19204, 19208 .. 19210, 19220, 19230 .. 19232, 19240, 19250, 19260, 19270, 19290, 19300, 19310 .. 19320, 19330, 19340, 19350, 19360 .. 19361, 19370, 19380, 19390, 19400, 19410, 19430, 19450, 19460, 19470, 19490, 19500, 19510, 19520, 19550, 19560, 19600, 19700, 19800, 20000, 20090, 20100, 20110 .. 20119, 20121 .. 20148, 20150 .. 20153, 20157, 20160, 20162 .. 20195, 20197 .. 20200, 20212 .. 20215, 20217 .. 20240, 20242 .. 20248, 20250 .. 20253, 20256, 20259 .. 20260, 20270, 20272, 20275 .. 20276, 20279, 20287 .. 20299, 20302 .. 20306, 20309, 20311, 20401 .. 20403, 20405 .. 20414, 20416 .. 20419, 20501 .. 20504, 20537 .. 20538, 20600 .. 20601, 20604, 20611, 20620, 20700 .. 20703, 20900, 21000 .. 21019, 21021 .. 21049, 21051 .. 21063, 21065 .. 21081, 21083 .. 21086, 21088 .. 21089, 21092 .. 21093, 21097 .. 21098, 21110, 21120 .. 21121, 21130, 21140, 21150, 21160, 21170, 21190, 21200 .. 21210, 21219 .. 21220, 21230, 21240, 21250, 21260 .. 21262, 21270, 21290, 21300 .. 21305, 21309 .. 21310, 21320, 21330, 21340, 21350, 21360, 21370, 21380, 21390, 21400 .. 21403, 21409 .. 21410, 21420, 21430, 21440, 21450, 21460, 21470, 21490, 21500 .. 21502, 21506, 21509 .. 21510, 21520, 21530, 21540, 21550, 21560, 21570, 21580, 21590, 21600 .. 21604, 21609 .. 21610, 21630, 21640, 21690, 21700 .. 21705, 21709, 21719, 21760, 21800 .. 21803, 21806, 21809, 21820, 21850, 21900, 21910, 21998, 22000 .. 22005, 22014 .. 22017, 22021 .. 22027, 22029, 22031 .. 22035, 22041 .. 22046, 22049, 22070, 22079 .. 22080, 22089, 22091 .. 22093, 22095 .. 22096, 22098 .. 22111, 22120, 22130, 22140, 22150, 22160, 22170, 22190 .. 22196, 22199 .. 22206, 22209 .. 22210, 22220, 22230, 22240, 22250, 22260, 22270, 22290, 22300 .. 22310, 22320, 22330, 22340, 22350, 22360, 22370, 22380, 22390, 22400, 22402 .. 22405, 22409 .. 22410, 22420, 22430, 22440, 22450, 22460, 22470, 22480, 22490, 22500 .. 22505, 22509 .. 22510, 22520, 22530, 22540, 22550, 22560, 22570, 22580, 22590, 22600, 22602 .. 22607, 22609 .. 22610, 22620, 22630, 22640, 22650, 22660, 22680, 22690, 22700, 22710, 22720, 22730, 22740, 22750, 22770, 22780, 22800, 22810, 22820, 22830, 22860, 22870, 22930, 22940, 22950, 22960, 22970, 22980, 23000 .. 23009, 23011, 23013 .. 23016, 23020, 23100, 23110, 23120, 23130, 23140, 23150, 23160, 23170, 23190, 23200, 23210, 23220, 23230, 23240, 23250, 23260, 23270, 23290, 23300, 23320, 23340, 23350, 23360, 23380, 23400, 23420, 23430, 23450, 23460, 23480, 23500, 23600, 23700, 23800, 24000 .. 24005, 24007, 24009 .. 24017, 24019 .. 24020, 24022, 24024, 24029, 24050 .. 24053, 24055, 24059 .. 24060, 24100 .. 24102, 24104 .. 24114, 24120 .. 24122, 24130, 24140, 24150, 24160, 24170, 24190, 24200 .. 24206, 24208 .. 24210, 24212, 24220, 24230, 24240, 24250, 24260, 24270, 24290, 24300, 24310, 24320, 24330, 24340, 24350, 24360, 24370, 24380, 24390, 24400, 24410, 24420, 24430, 24440, 24450, 24460, 24470, 24480, 24490, 24500, 24510, 24520, 24530, 24540, 24550, 24560, 24570, 24580, 24590, 24600, 24610, 24620, 24630, 24640, 24650, 24660, 24680, 24700, 24750 .. 24752, 24755, 24758 .. 24759, 24800, 24910, 24912 .. 24913, 24915, 24926, 25000 .. 25027, 25029 .. 25052, 25054, 25056 .. 25063, 25068 .. 25073, 25075, 25079 .. 25080, 25082 .. 25087, 25089 .. 25090, 25098 .. 25099, 25110 .. 25120, 25130, 25140, 25150, 25160, 25170, 25190, 25200 .. 25220, 25230, 25240, 25250, 25260, 25270, 25290, 25300 .. 25304, 25309 .. 25310, 25320, 25330, 25340, 25350, 25360, 25370, 25380, 25390, 25400 .. 25406, 25409 .. 25410, 25420, 25430, 25440, 25450, 25460 .. 25462, 25469 .. 25470, 25479 .. 25480, 25490, 25500 .. 25504, 25508 .. 25510, 25520, 25530, 25550, 25560, 25570, 25580, 25600 .. 25610, 25620, 25630, 25640, 25650, 25660, 25680, 25690, 25700 .. 25702, 25706 .. 25709, 25720, 25750, 25770, 25790, 25800, 25820, 25840, 25870, 25909, 25920, 25930 .. 25933, 25960, 26000 .. 26015, 26021 .. 26032, 26100 .. 26111, 26119 .. 26120, 26130 .. 26131, 26140, 26150, 26160, 26170, 26190, 26199 .. 26210, 26215 .. 26216, 26220, 26230, 26240 .. 26244, 26249 .. 26250, 26260, 26270, 26290, 26300 .. 26304, 26309 .. 26310, 26320, 26330, 26340, 26350, 26380, 26390, 26400 .. 26402, 26409 .. 26410, 26420, 26450, 26460, 26470, 26500 .. 26504, 26509 .. 26510, 26530, 26540, 26560, 26570, 26600 .. 26603, 26609, 26620, 26700 .. 26702, 26709, 26730, 26740, 26750, 26760 .. 26761, 26770, 26780, 26790, 26800 .. 26802, 26809, 26901 .. 26907, 26909, 26950 .. 26956, 26958, 27000 .. 27010, 27012 .. 27013, 27015 .. 27019, 27021 .. 27023, 27025 .. 27026, 27030 .. 27040, 27090 .. 27110, 27120 .. 27122, 27127, 27130 .. 27138, 27140, 27150, 27160, 27170, 27180, 27190, 27200 .. 27210, 27220, 27230, 27240, 27250, 27260, 27270, 27290, 27300 .. 27310, 27320, 27330, 27340, 27350, 27360, 27370, 27380, 27390, 27400 .. 27407, 27409 .. 27410, 27420, 27430, 27440, 27450, 27460, 27470, 27480, 27490, 27500 .. 27510, 27520, 27530, 27540, 27550, 27560, 27570, 27580, 27590, 27600, 27607, 27610, 27620, 27630, 27640, 27650, 27660, 27670, 27680, 27690, 27700 .. 27703, 27705, 27710, 27720, 27730, 27740, 27750, 27760, 27770, 27780, 27790, 27800, 27810, 27820, 27830, 27850, 27860, 27870, 27890, 27909 .. 27911, 27914, 27920, 27924, 27928 .. 27933, 27936, 27939 .. 27940, 27949 .. 27950, 28000 .. 28009, 28011, 28018 .. 28019, 28023 .. 28026, 28029, 28033 .. 28040, 28044, 28080, 28088, 28100 .. 28106, 28108 .. 28114, 28119 .. 28120, 28130 .. 28133, 28140, 28150, 28160, 28170, 28190, 28200 .. 28203, 28205, 28207, 28209 .. 28211, 28220, 28230 .. 28232, 28234, 28240, 28250, 28260, 28270, 28290, 28300 .. 28305, 28309 .. 28310, 28320, 28330, 28340, 28350, 28360, 28380, 28400 .. 28404, 28409 .. 28410, 28480 .. 28481, 28489, 28500 .. 28501, 28600, 28630 .. 28633, 28636 .. 28637, 28639, 28700 .. 28703, 28707, 28709, 28800, 28901, 28910, 28920, 28930 .. 28933, 28935, 28944, 28950, 29000, 29018, 29080, 29100 .. 29109, 29120 .. 29125, 29129, 29140, 29150, 29160, 29170 .. 29174, 29176 .. 29177, 29179 .. 29187, 29189 .. 29193, 29196, 29199 .. 29200, 29206 .. 29213, 29217 .. 29225, 29227 .. 29229, 29231, 29233, 29238, 29240 .. 29242, 29246, 29250, 29252 .. 29253, 29259 .. 29260, 29270, 29280, 29282, 29289 .. 29290, 29299 .. 29300, 29310, 29320 .. 29328, 29330 .. 29337, 29340, 29350, 29360, 29370, 29380, 29390 .. 29404, 29406 .. 29407, 29409 .. 29414, 29419 .. 29420, 29430, 29440, 29450, 29455, 29460, 29470, 29480, 29490, 29500, 29510, 29520, 29530, 29540, 29550 .. 29561, 29563, 29570, 29590, 29600, 29602, 29606, 29609 .. 29610, 29620, 29630, 29640, 29650, 29660, 29670 .. 29674, 29678 .. 29682, 29684, 29688 .. 29690, 29700, 29710, 29720, 29730, 29740, 29750, 29760, 29770, 29780, 29790, 29800 .. 29804, 29806 .. 29810, 29820, 29824 .. 29825, 29827, 29830, 29833 .. 29837, 29839 .. 29840, 29850, 29860, 29870, 29880, 29890, 29900, 29910, 29920, 29930, 29940, 29950, 29970, 29980, 29990, 30000 .. 30003, 30006 .. 30025, 30028 .. 30029, 30031 .. 30036, 30039 .. 30040, 30044 .. 30045, 30048 .. 30051, 30055, 30100 .. 30107, 30109 .. 30112, 30114 .. 30115, 30119 .. 30134, 30139 .. 30140, 30150, 30160, 30170, 30190, 30200 .. 30207, 30209 .. 30210, 30220, 30230, 30240, 30250 .. 30253, 30255, 30260, 30270, 30290, 30300 .. 30302, 30310 .. 30311, 30313, 30318 .. 30320, 30330, 30340, 30350, 30360, 30380, 30390, 30400 .. 30406, 30409 .. 30410, 30420, 30430, 30440, 30450, 30460, 30470, 30480, 30490, 30500, 30510, 30520, 30530, 30540, 30560, 30570, 30580, 30600, 30610, 30620, 30630, 30640, 30650, 30660, 30670, 30700 .. 30703, 30720, 30730, 30740, 30750, 30760, 30770, 30800, 30820, 30840, 30870, 30900 .. 30901, 30903 .. 30908, 30910 .. 30914, 30918, 30920 .. 30925, 30929, 30931 .. 30932, 30934 .. 30937, 30939 .. 30943, 30947, 30960, 30969, 30971 .. 30972, 30975, 30980, 31000 .. 31082, 31084 .. 31086, 31088 .. 31104, 31106 .. 31107, 31109 .. 31110, 31112, 31120 .. 31142, 31149 .. 31152, 31155, 31159 .. 31160, 31170, 31180, 31189 .. 31190, 31200 .. 31201, 31203 .. 31205, 31210, 31220, 31230, 31240 .. 31245, 31249 .. 31250, 31260, 31270, 31280, 31289 .. 31290, 31300, 31310, 31312 .. 31315, 31317, 31319 .. 31322, 31325 .. 31326, 31329 .. 31330, 31340, 31350, 31360, 31370, 31380, 31389 .. 31390, 31400 .. 31406, 31410, 31420, 31430, 31432, 31440, 31450, 31460, 31470, 31480, 31489 .. 31490, 31500, 31503 .. 31507, 31510, 31512, 31520 .. 31522, 31524, 31529 .. 31530, 31540, 31550, 31560, 31570, 31580, 31589 .. 31590, 31600 .. 31606, 31608 .. 31609, 31620 .. 31621, 31629, 31650, 31660, 31670 .. 31679, 31681 .. 31683, 31685, 31689, 31692, 31700 .. 31709, 31711 .. 31712, 31715 .. 31716, 31750, 31770 .. 31774, 31776 .. 31777, 31779 .. 31780, 31790, 31800 .. 31807, 31809 .. 31810, 31820, 31830 .. 31832, 31839 .. 31840, 31850, 31860, 31870, 31880, 31900 .. 31903, 31931, 31945, 31947, 31950, 31957 .. 31958, 31960, 31962, 31998 .. 32005, 32007 .. 32014, 32016 .. 32022, 32100, 32110, 32120, 32129 .. 32130, 32140, 32150, 32160, 32170, 32190, 32200 .. 32201, 32209, 32220, 32230, 32240, 32250, 32260, 32270, 32290, 32300, 32310, 32320, 32330, 32340, 32350, 32360, 32370, 32380, 32390, 32400, 32410, 32420, 32430, 32440, 32450, 32460, 32480, 32490, 32500 .. 32502, 32505, 32509, 32550, 32600, 32700, 32720, 32730, 32800, 32810, 33000 .. 33002, 33004 .. 33012, 33015, 33019 .. 33021, 33023 .. 33038, 33040 .. 33043, 33047 .. 33100, 33110, 33112 .. 33116, 33120 .. 33121, 33123 .. 33127, 33130, 33133, 33138, 33140 .. 33141, 33148, 33150 .. 33153, 33155, 33160, 33164 .. 33167, 33169 .. 33175, 33180, 33185 .. 33187, 33190 .. 33193, 33200, 33210 .. 33214, 33219 .. 33220, 33230, 33240, 33250, 33260, 33270 .. 33274, 33278 .. 33279, 33290 .. 33295, 33300, 33305 .. 33306, 33309 .. 33314, 33319 .. 33324, 33326 .. 33327, 33329 .. 33330, 33335, 33340 .. 33341, 33350, 33360, 33370, 33380, 33390 .. 33395, 33400 .. 33405, 33409 .. 33410, 33420, 33430, 33440, 33450 .. 33452, 33460 .. 33461, 33469 .. 33470, 33480, 33490 .. 33492, 33495, 33500 .. 33507, 33509 .. 33510, 33515, 33520 .. 33527, 33529 .. 33530, 33540, 33550, 33560 .. 33565, 33570, 33580, 33590, 33600 .. 33615, 33620 .. 33621, 33625 .. 33627, 33629, 33640, 33650, 33652, 33660, 33670, 33680, 33688 .. 33710, 33720, 33730 .. 33741, 33747, 33750, 33760, 33770, 33780, 33790, 33800 .. 33801, 33810, 33820, 33830, 33840, 33850, 33860, 33870, 33880 .. 33887, 33890, 33900 .. 33907, 33909 .. 33915, 33918 .. 33920, 33930, 33950, 33970, 33980, 33990, 33998, 34000 .. 34004, 34006 .. 34012, 34023 .. 34028, 34030, 34032 .. 34035, 34037 .. 34043, 34045 .. 34046, 34048 .. 34049, 34051, 34053 .. 34056, 34058, 34060 .. 34068, 34070 .. 34080, 34082 .. 34083, 34085 .. 34087, 34089 .. 34099, 34110 .. 34120, 34130 .. 34132, 34137 .. 34140, 34150, 34160, 34170 .. 34174, 34178 .. 34179, 34181, 34183 .. 34184, 34186 .. 34187, 34190 .. 34204, 34207, 34209 .. 34210, 34220, 34230, 34240, 34250, 34260 .. 34267, 34270, 34274, 34280, 34290, 34293 .. 34305, 34307, 34309 .. 34310, 34320, 34330, 34340, 34350, 34360, 34370, 34380, 34390 .. 34394, 34396 .. 34404, 34409 .. 34410, 34420, 34430 .. 34431, 34433 .. 34435, 34438 .. 34440, 34450, 34460, 34470, 34473, 34477, 34480, 34490, 34500 .. 34508, 34510, 34513 .. 34518, 34520 .. 34526, 34529 .. 34530, 34534 .. 34537, 34539 .. 34540, 34543 .. 34545, 34550, 34560, 34564, 34570, 34590, 34600, 34610, 34620, 34630, 34650, 34660, 34670 .. 34671, 34680, 34690, 34700 .. 34702, 34710, 34720, 34725, 34730, 34740 .. 34742, 34747 .. 34751, 34753, 34760, 34770, 34790, 34800, 34810, 34820, 34830, 34850, 34871 .. 34875, 34880, 34900, 34920, 34923, 34925 .. 34926, 34932 .. 34935, 34937 .. 34940, 34942 .. 34944, 34948 .. 34949, 34954 .. 34962, 34964 .. 34965, 34967, 34970, 34972 .. 34975, 34977, 34980 .. 34987, 34989 .. 34990, 35000 .. 35012, 35014 .. 35016, 35018, 35020 .. 35024, 35026 .. 35035, 35039 .. 35040, 35042 .. 35047, 35049 .. 35055, 35057 .. 35059, 35063 .. 35067, 35069 .. 35071, 35073, 35076, 35078 .. 35094, 35099, 35101 .. 35106, 35108 .. 35109, 35111, 35113 .. 35114, 35120, 35130 .. 35137, 35140, 35150, 35160 .. 35164, 35166, 35169 .. 35172, 35174 .. 35177, 35190, 35200 .. 35205, 35207 .. 35210, 35220 .. 35221, 35230, 35235 .. 35236, 35240, 35250, 35260, 35270, 35290, 35300 .. 35306, 35309 .. 35310, 35320, 35330, 35340 .. 35342, 35345, 35349 .. 35350, 35360, 35370, 35380, 35390, 35400 .. 35420, 35430 .. 35433, 35435, 35439 .. 35440, 35450, 35460, 35470, 35480, 35490, 35500 .. 35507, 35509 .. 35521, 35530 .. 35533, 35538 .. 35540, 35550, 35560, 35571 .. 35574, 35576 .. 35580, 35590, 35600 .. 35603, 35605 .. 35606, 35610, 35620, 35630, 35640, 35650 .. 35653, 35659 .. 35660, 35680, 35690, 35700 .. 35709, 35711, 35720, 35730, 35740 .. 35744, 35746, 35750, 35760 .. 35772, 35780, 35800 .. 35803, 35830 .. 35833, 35850, 35870, 35890, 35900 .. 35909, 35911 .. 35921, 35960, 35998, 36000 .. 36029, 36032 .. 36033, 36100 .. 36105, 36107, 36109 .. 36110, 36120, 36130 .. 36131, 36140, 36150, 36160, 36170, 36180, 36190, 36200, 36210, 36220, 36230, 36240, 36250, 36255, 36260, 36270, 36290, 36300 .. 36301, 36310, 36320, 36330, 36340, 36350, 36360, 36370, 36400, 36500 .. 36501, 36505, 36600, 36700, 36800, 36910, 36915, 37000, 37008 .. 37020, 37025 .. 37029, 37032 .. 37035, 37038 .. 37045, 37047 .. 37049, 37058 .. 37061, 37071 .. 37082, 37089, 37095 .. 37100, 37110, 37120, 37130, 37140, 37150, 37152, 37160, 37170 .. 37175, 37179, 37190, 37200, 37204 .. 37206, 37209 .. 37210, 37220, 37230, 37240, 37250, 37260, 37270, 37290, 37300 .. 37306, 37309 .. 37310, 37320 .. 37321, 37330, 37340, 37350, 37360, 37370, 37380, 37390, 37400 .. 37404, 37409, 37420, 37460, 37500 .. 37502, 37509 .. 37510, 37520 .. 37521, 37530, 37540 .. 37542, 37549 .. 37556, 37600 .. 37602, 37609, 37700 .. 37703, 37705, 37709, 37800, 37910 .. 37913, 37915, 37917, 37921 .. 37922, 37924 .. 37929, 37931 .. 37932, 37941 .. 37942, 38000 .. 38019, 38021 .. 38037, 38039 .. 38054, 38056, 38058 .. 38059, 38061, 38063, 38065 .. 38067, 38069 .. 38070, 38074, 38077, 38080 .. 38081, 38089 .. 38093, 38096 .. 38100, 38110, 38112 .. 38114, 38118 .. 38122, 38130, 38134, 38138, 38140, 38142, 38144, 38146 .. 38148, 38150, 38152 .. 38154, 38159 .. 38165, 38169 .. 38174, 38176, 38179 .. 38180, 38190 .. 38191, 38196 .. 38197, 38200 .. 38211, 38216 .. 38220, 38230 .. 38232, 38236, 38240 .. 38244, 38246, 38249 .. 38250, 38256, 38260 .. 38261, 38269 .. 38270, 38280, 38290 .. 38293, 38295 .. 38297, 38299 .. 38305, 38307, 38309, 38311 .. 38315, 38317, 38319 .. 38322, 38326 .. 38327, 38329 .. 38334, 38340 .. 38343, 38345 .. 38347, 38349 .. 38354, 38356 .. 38361, 38370, 38380, 38390, 38400 .. 38410, 38420, 38430 .. 38437, 38439 .. 38440, 38450, 38460, 38470, 38480, 38490, 38500 .. 38511, 38516, 38519 .. 38524, 38526, 38529 .. 38530, 38540, 38550 .. 38557, 38559 .. 38560, 38570, 38580, 38590 .. 38591, 38600 .. 38603, 38609 .. 38610, 38620, 38630, 38640, 38650, 38660, 38670, 38680, 38690, 38700 .. 38702, 38706 .. 38710, 38730 .. 38731, 38740, 38750, 38760 .. 38761, 38763, 38767, 38769 .. 38770, 38780 .. 38782, 38784, 38789 .. 38790, 38800 .. 38803, 38816 .. 38817, 38821, 38830, 38840, 38850, 38860, 38870, 38880, 38890, 38900, 38913, 38920 .. 38921, 38926 .. 38927, 38930, 38940 .. 38941, 38943 .. 38944, 38950, 38960, 38970, 38980, 39000 .. 39010, 39015 .. 39016, 39021, 39029 .. 39039, 39100 .. 39110, 39120, 39130, 39140, 39150, 39160, 39170 .. 39171, 39180 .. 39181, 39189 .. 39190, 39200 .. 39211, 39219 .. 39220, 39230, 39240, 39250, 39260 .. 39261, 39270, 39290, 39300 .. 39310, 39320, 39330, 39350, 39360, 39370, 39380, 39400 .. 39410, 39460, 39500 .. 39502, 39520, 39570, 39600 .. 39603, 39605, 39609, 39700, 39800 .. 39809, 40000 .. 40006, 40011 .. 40013, 40015 .. 40019, 40021 .. 40027, 40090, 40100 .. 40108, 40110, 40115, 40118, 40120, 40130, 40140 .. 40141, 40150, 40160 .. 40161, 40170, 40180, 40190, 40200 .. 40202, 40210, 40220, 40230 .. 40232, 40235, 40239 .. 40240, 40250, 40260, 40270, 40280 .. 40282, 40286, 40290, 40300 .. 40301, 40305, 40309 .. 40310, 40320, 40330, 40350, 40360, 40370, 40380, 40390, 40400, 40410, 40420, 40430, 40440, 40460, 40465, 40480, 40500 .. 40502, 40510, 40530, 40550, 40560, 40600 .. 40602, 40630, 40660, 40700 .. 40701, 40705, 40800 .. 40801, 40805, 40990 .. 40994, 41000 .. 41013, 41015 .. 41016, 41018 .. 41020, 41022 .. 41023, 41025 .. 41026, 41028 .. 41029, 41033 .. 41035, 41042 .. 41043, 41100 .. 41103, 41105 .. 41106, 41109 .. 41110, 41120 .. 41122, 41130, 41140, 41150 .. 41151, 41160, 41170, 41190, 41200 .. 41207, 41210, 41220, 41230, 41240, 41250, 41260 .. 41261, 41270, 41290, 41300, 41310, 41320, 41330, 41350, 41353 .. 41355, 41357, 41360, 41370, 41400 .. 41402, 41406, 41500, 41600, 41700, 41800, 41901, 41903 .. 41906, 41908 .. 41910, 41913 .. 41915, 41918 .. 41919, 41921, 41924 .. 41925, 41930 .. 41933, 41936, 41941 .. 41943, 41945, 41948 .. 41951, 41958, 41960, 41963 .. 41968, 41970 .. 41976, 42000 .. 42018, 42021 .. 42031, 42033, 42041 .. 42043, 42045, 42047 .. 42050, 42055, 42058 .. 42059, 42100, 42110 .. 42111, 42114, 42120, 42122 .. 42127, 42129 .. 42131, 42140, 42150, 42152 .. 42153, 42155, 42160 .. 42170, 42173 .. 42174, 42176, 42179, 42190, 42210, 42220, 42230, 42240, 42260, 42270 .. 42273, 42275 .. 42277, 42279, 42290, 42300 .. 42304, 42308, 42310 .. 42315, 42318, 42320 .. 42323, 42328, 42330, 42332 .. 42335, 42339 .. 42340, 42350 .. 42351, 42353 .. 42356, 42359 .. 42360, 42370, 42380, 42390, 42400 .. 42412, 42420, 42430, 42440, 42450, 42460, 42470, 42480, 42484, 42486, 42489 .. 42490, 42500 .. 42503, 42505, 42509 .. 42510, 42520, 42530, 42540, 42550, 42560, 42570, 42580, 42590, 42600 .. 42610, 42620, 42630, 42640, 42650 .. 42651, 42653, 42660, 42670, 42680, 42700 .. 42705, 42707, 42709, 42720, 42740, 42750, 42780, 42800 .. 42810, 42820, 42830, 42840, 42890, 42920, 42940, 42950 .. 42955, 42958 .. 42959, 42961 .. 42969, 42990, 43000 .. 43006, 43008 .. 43014, 43017, 43019, 43100 .. 43103, 43110, 43120, 43130, 43140, 43150, 43160, 43170, 43190, 43200 .. 43203, 43210, 43220, 43230, 43240, 43250, 43260, 43270, 43290, 43300, 43320, 43330, 43340, 43350, 43360, 43370, 43380, 43390, 43400, 43410, 43420, 43430, 43440, 43450, 43490, 43500, 43510, 43520, 43530, 43550, 43580, 43590, 43600, 43620, 43700, 43750, 43770, 43800, 43810, 44000 .. 44024, 44032 .. 44036, 44038, 44040 .. 44042, 44046 .. 44047, 44090, 44092 .. 44095, 44097, 44099 .. 44107, 44109 .. 44110, 44115 .. 44124, 44126, 44129 .. 44130, 44140 .. 44146, 44149 .. 44160, 44170, 44176, 44179, 44184 .. 44188, 44190 .. 44196, 44198 .. 44205, 44209 .. 44217, 44219 .. 44220, 44230 .. 44236, 44239 .. 44245, 44249 .. 44250, 44260 .. 44263, 44265, 44268, 44270, 44272 .. 44277, 44290, 44300 .. 44346, 44349 .. 44353, 44356 .. 44360, 44370 .. 44373, 44379 .. 44380, 44390, 44400 .. 44410, 44412, 44420, 44430, 44440, 44450, 44460, 44470 .. 44484, 44490, 44500 .. 44506, 44509 .. 44510, 44520 .. 44522, 44530, 44540, 44550, 44560, 44570, 44580, 44590, 44600 .. 44606, 44609 .. 44618, 44620, 44630, 44640, 44650, 44660, 44670, 44680, 44690, 44700 .. 44703, 44706 .. 44710, 44720, 44730, 44740, 44750, 44760, 44770, 44780, 44800 .. 44819, 44821 .. 44824, 44829 .. 44830, 44840, 44850, 44860, 44880, 44900, 44911 .. 44919, 44921 .. 44929, 44931 .. 44939, 44941 .. 44942, 44944 .. 44945, 44947, 44949, 44951 .. 44959, 44963 .. 44969, 44971 .. 44978, 44980 .. 44986, 44989, 45000 .. 45012, 45015 .. 45017, 45019, 45021, 45023, 45025, 45028 .. 45035, 45038, 45040 .. 45046, 45052 .. 45053, 45056 .. 45058, 45060 .. 45065, 45067 .. 45069, 45071 .. 45075, 45077 .. 45079, 45081 .. 45082, 45087 .. 45088, 45100, 45110, 45120 .. 45122, 45125, 45129 .. 45130, 45140 .. 45147, 45149 .. 45150, 45160 .. 45166, 45168 .. 45170, 45190, 45200 .. 45214, 45220, 45230, 45240, 45250, 45260, 45270, 45290, 45300, 45302 .. 45308, 45310, 45312, 45320, 45330 .. 45331, 45340, 45360, 45370, 45380, 45390, 45400 .. 45404, 45406, 45409 .. 45410, 45420, 45430 .. 45433, 45450, 45460, 45470, 45480, 45490, 45500 .. 45504, 45510, 45520, 45530, 45550, 45560, 45570, 45590, 45600, 45620, 45630, 45640, 45650 .. 45651, 45655 .. 45656, 45680, 45700 .. 45702, 45709, 45720, 45730, 45740, 45750, 45760, 45770 .. 45771, 45774 .. 45775, 45777, 45800 .. 45809, 45811, 45900, 45910 .. 45913, 45915 .. 45927, 45929 .. 45938, 45943 .. 45957, 45960 .. 45980, 46000 .. 46005, 46008 .. 46010, 46014 .. 46023, 46090 .. 46091, 46100 .. 46103, 46106, 46110, 46120, 46130, 46140, 46150, 46160, 46170, 46190, 46200, 46210, 46220, 46230, 46240, 46250, 46260, 46270, 46300, 46310, 46320, 46330, 46340, 46350, 46360, 46400, 46500, 46600, 46700, 46800, 47000, 47002 .. 47008, 47013, 47020, 47023, 47030 .. 47032, 47039, 47110, 47120, 47130, 47140, 47150, 47160, 47170, 47180, 47190, 47200 .. 47205, 47207 .. 47211, 47213, 47220, 47230, 47240, 47250, 47260, 47270, 47290, 47300 .. 47305, 47307 .. 47310, 47320, 47330, 47340, 47350, 47360, 47370, 47380, 47390, 47400, 47410, 47420, 47430, 47440, 47450, 47470, 47480, 47500 .. 47502, 47510, 47520, 47550 .. 47553, 47555, 47559, 47600, 47700, 47800, 47901, 47909 .. 47918, 47920 .. 47925, 47929, 47931, 48000 .. 48003, 48005 .. 48009, 48100, 48110, 48120, 48130, 48140, 48150, 48160, 48170, 48190, 48200, 48210, 48220, 48230, 48240, 48250, 48260, 48270, 48300, 48310, 48320, 48330, 48340, 48370, 48400, 48500, 48600, 48700, 48800, 49000 .. 49004, 49006 .. 49011, 49014 .. 49018, 49020 .. 49024, 49026, 49028, 49032 .. 49033, 49035 .. 49036, 49041, 49043 .. 49047, 49049, 49051 .. 49053, 49055, 49059, 49066, 49070 .. 49072, 49079 .. 49080, 49100 .. 49107, 49109 .. 49112, 49115 .. 49117, 49119 .. 49120, 49122 .. 49125, 49130, 49135 .. 49137, 49139 .. 49140, 49150, 49160, 49170, 49180 .. 49184, 49190, 49220, 49230, 49240 .. 49245, 49249 .. 49250, 49260, 49270, 49280, 49290, 49300 .. 49312, 49314, 49319 .. 49321, 49325, 49327 .. 49330, 49340, 49350, 49360, 49370, 49380, 49390, 49400 .. 49406, 49408 .. 49415, 49417 .. 49418, 49420 .. 49421, 49425 .. 49428, 49430, 49440, 49450, 49456, 49458, 49460, 49480 .. 49481, 49484, 49486, 49490, 49500 .. 49505, 49509 .. 49510, 49520, 49530, 49540, 49560, 49570, 49590, 49600 .. 49602, 49609 .. 49610, 49620, 49630, 49640, 49650, 49660, 49670, 49680, 49690, 49700, 49710, 49730, 49740, 49750, 49770, 49800 .. 49805, 49809, 49905 .. 49906, 49911 .. 49913, 49919, 49925, 49927, 49933 .. 49934, 49937 .. 49939, 49941, 49949, 50000 .. 50016, 50050, 50100 .. 50110, 50113 .. 50115, 50120, 50130 .. 50131, 50140, 50150, 50160, 50170, 50180, 50190, 50200 .. 50211, 50220, 50230, 50240, 50250, 50260, 50270, 50290, 50300 .. 50310, 50320, 50330, 50340, 50350, 50360, 50370, 50380, 50390, 50400 .. 50407, 50409 .. 50410, 50420, 50430, 50440 .. 50442, 50444 .. 50450, 50460, 50470, 50480, 50490, 50500, 50510, 50520, 50530, 50540, 50550, 50560, 50570, 50580, 50590, 50600, 50610, 50620, 50630, 50640, 50651 .. 50652, 50660, 50670, 50680, 50690, 50700, 50710, 50720, 50730, 50740, 50750, 50760, 50770, 50800, 50810, 50840, 50850, 50860, 50870, 50880, 50890, 50950 .. 50951, 50958, 51000 .. 51001, 51005 .. 51013, 51016 .. 51017, 51021 .. 51022, 51035 .. 51039, 51041 .. 51043, 51051 .. 51077, 51079 .. 51084, 51086 .. 51090, 51092, 51095 .. 51097, 51099 .. 51100, 51110, 51120 .. 51122, 51130, 51140, 51150, 51160, 51170, 51190, 51200 .. 51210, 51220, 51230, 51240, 51250, 51260, 51270, 51290, 51300 .. 51306, 51308 .. 51310, 51318 .. 51320, 51330 .. 51334, 51340, 51349 .. 51350, 51360 .. 51361, 51370, 51380, 51390, 51400 .. 51401, 51420, 51430 .. 51435, 51450, 51460, 51470, 51480, 51490, 51500, 51510, 51520, 51530, 51571 .. 51573, 51600 .. 51601, 51662 .. 51664, 51673, 51675, 51677 .. 51679, 51682 .. 51689, 51700, 51713, 51715, 51721 .. 51723, 51726, 51800 .. 51801, 51871, 51873, 51884, 51886, 51900, 51902, 51904, 52000 .. 52008, 52011 .. 52012, 52014, 52016, 52100 .. 52113, 52115, 52120, 52130, 52140, 52150, 52160, 52170, 52190, 52200 .. 52210, 52220, 52230, 52240, 52250, 52260, 52270, 52290, 52300 .. 52301, 52310, 52320, 52330, 52340, 52360, 52370, 52400, 52410, 52500 .. 52502, 52600, 52700, 52800, 52901 .. 52906, 52915, 52917, 52919 .. 52920, 53000 .. 53010, 53012 .. 53016, 53019 .. 53022, 53030 .. 53032, 53060 .. 53063, 53069, 53073, 53080 .. 53091, 53093 .. 53095, 53098 .. 53105, 53109 .. 53110, 53120, 53140, 53150, 53160, 53170, 53190, 53200 .. 53205, 53210, 53220, 53230, 53240, 53250, 53260, 53270, 53290, 53300, 53320, 53340, 53350, 53360, 53370, 53380, 53390, 53400, 53410, 53420, 53440, 53470, 53480, 53500, 53540, 53600 .. 53602, 53640, 53700, 53800, 53810 .. 53811, 53940 .. 53942, 53950 .. 53951, 53960, 53970 .. 53971, 54000 .. 54017, 54020 .. 54023, 54029, 54031 .. 54032, 54035 .. 54039, 54041 .. 54043, 54045 .. 54049, 54052 .. 54054, 54056, 54062 .. 54064, 54071 .. 54074, 54076, 54082, 54096 .. 54098, 54100, 54110 .. 54116, 54118 .. 54123, 54129 .. 54136, 54138 .. 54140, 54150 .. 54154, 54159 .. 54160, 54170, 54180 .. 54186, 54189 .. 54190, 54200 .. 54206, 54209 .. 54211, 54220, 54230, 54240, 54250, 54260 .. 54263, 54270 .. 54273, 54279 .. 54280, 54290, 54300 .. 54305, 54309 .. 54312, 54319 .. 54320, 54330, 54340, 54350, 54360, 54370, 54380, 54385, 54390, 54400 .. 54406, 54409 .. 54414, 54420, 54425, 54430, 54440, 54450, 54460, 54470, 54480, 54490, 54500 .. 54507, 54509 .. 54517, 54519 .. 54530, 54540, 54550, 54560, 54570, 54580, 54590, 54600 .. 54603, 54608 .. 54610, 54620, 54630, 54640, 54650, 54660, 54670, 54680, 54690, 54700 .. 54706, 54708 .. 54716, 54719 .. 54720, 54730, 54740, 54750, 54760, 54770, 54780, 54790, 54800 .. 54803, 54810, 54820, 54830, 54840, 54850, 54860, 54870, 54880, 54890, 54900, 54910, 54920, 54930 .. 54931, 54933 .. 54934, 54939 .. 54941, 54950, 54960, 54970, 54980, 54990, 55000 .. 55003, 55005 .. 55008, 55012 .. 55015, 55020 .. 55021, 55100 .. 55110, 55112 .. 55113, 55119 .. 55120, 55130, 55140, 55150, 55160, 55170, 55190, 55200 .. 55203, 55205, 55210, 55220 .. 55221, 55230, 55240, 55250, 55260, 55270 .. 55271, 55290, 55300, 55310, 55320, 55400, 55430, 55500, 55600, 55700, 55800, 55840, 56000 .. 56010, 56016 .. 56020, 56029, 56034, 56036 .. 56039, 56100 .. 56110, 56120, 56130, 56140, 56150, 56160, 56170 .. 56175, 56178 .. 56179, 56190, 56200 .. 56201, 56204, 56207, 56209, 56219 .. 56220, 56230 .. 56231, 56239 .. 56240, 56250, 56260, 56270 .. 56277, 56279, 56290, 56300 .. 56312, 56317, 56319 .. 56330, 56340 .. 56343, 56349 .. 56350, 56360, 56370, 56380 .. 56383, 56390, 56400 .. 56407, 56409 .. 56411, 56413, 56419 .. 56420, 56430, 56440, 56450, 56460, 56470, 56480, 56490, 56500 .. 56504, 56506, 56509 .. 56510, 56520, 56530 .. 56532, 56535 .. 56536, 56539 .. 56540, 56550, 56560, 56570, 56580, 56590, 56600 .. 56603, 56607, 56609 .. 56610, 56620, 56630, 56640, 56650, 56660, 56670, 56680, 56690, 56700 .. 56705, 56709, 56730, 56740, 56750, 56760, 56770, 56780, 56800 .. 56805, 56809, 56840, 56850, 56854 .. 56855, 56860, 56870, 56880, 56890 .. 56893, 56896, 56899 .. 56903, 56909 .. 56910, 56920, 56930, 56950 .. 56951, 56954, 56956 .. 56957, 56959, 56970, 56973, 56977, 56979, 56998, 57000, 57003 .. 57021, 57023, 57028, 57030 .. 57038, 57040 .. 57041, 57044 .. 57046, 57049 .. 57054, 57056 .. 57057, 57059, 57061 .. 57063, 57070 .. 57079, 57081 .. 57084, 57100 .. 57106, 57108 .. 57109, 57119 .. 57120, 57125 .. 57133, 57140 .. 57141, 57144, 57146 .. 57155, 57157, 57159 .. 57164, 57169 .. 57170, 57175, 57180 .. 57181, 57185, 57190 .. 57193, 57199 .. 57209, 57211 .. 57212, 57214 .. 57220, 57230 .. 57234, 57240, 57245, 57250, 57255, 57260, 57270, 57280 .. 57283, 57289 .. 57292, 57299 .. 57304, 57309 .. 57310, 57320, 57330, 57340, 57350 .. 57352, 57354, 57359 .. 57363, 57365, 57369 .. 57373, 57379 .. 57383, 57385, 57390, 57400 .. 57405, 57409 .. 57410, 57412, 57415, 57420, 57430, 57440, 57445, 57450, 57455, 57460, 57470, 57480, 57490, 57500 .. 57510, 57515, 57520, 57525, 57530, 57535, 57540, 57550, 57560, 57565, 57570, 57580, 57590, 57600 .. 57610, 57619 .. 57620, 57630, 57635, 57640, 57645, 57650, 57655, 57660, 57670, 57680, 57685, 57690, 57700 .. 57705, 57709 .. 57710, 57720, 57730 .. 57731, 57739 .. 57740, 57747 .. 57748, 57751, 57756 .. 57757, 57770, 57772, 57774, 57777 .. 57778, 57780, 57790, 57800 .. 57801, 57803 .. 57805, 57809 .. 57810, 57815, 57820, 57830, 57840, 57850, 57855, 57860, 57865, 57870, 57880, 57890, 57905, 57910 .. 57913, 57915 .. 57916, 57919 .. 57920, 57925, 57930, 57935, 57940, 57950 .. 57955, 57957 .. 57960, 57970 .. 57974, 57978 .. 57980, 57990, 58000 .. 58009, 58013 .. 58020, 58022 .. 58029, 58033 .. 58034, 58036, 58039, 58110, 58120, 58130, 58140, 58150, 58160, 58170, 58180, 58190, 58200 .. 58210, 58220, 58230, 58240, 58250, 58260, 58270, 58290, 58300 .. 58302, 58310, 58320, 58330, 58340, 58350, 58360, 58370, 58380, 58390, 58400 .. 58405, 58410, 58420, 58430, 58440, 58450, 58460, 58470, 58490, 58500 .. 58503, 58508, 58530, 58600, 58640 .. 58643, 58649, 58660, 58700, 58800, 59000 .. 59049, 59051 .. 59063, 59065 .. 59066, 59069 .. 59074, 59078 .. 59084, 59086 .. 59088, 59091 .. 59092, 59097, 59100, 59108, 59110 .. 59182, 59184 .. 59195, 59198 .. 59200, 59202 .. 59203, 59207 .. 59227, 59229 .. 59247, 59249 .. 59255, 59258 .. 59275, 59277 .. 59288, 59290, 59292 .. 59297, 59299 .. 59322, 59326, 59328 .. 59339, 59341, 59345 .. 59346, 59349 .. 59351, 59358 .. 59365, 59370, 59373 .. 59383, 59385 .. 59386, 59389 .. 59393, 59399 .. 59413, 59416, 59419 .. 59422, 59424 .. 59433, 59435 .. 59437, 59440 .. 59453, 59455 .. 59458, 59460 .. 59468, 59470 .. 59476, 59478 .. 59483, 59485 .. 59487, 59490 .. 59497, 59500 .. 59510, 59520, 59522 .. 59524, 59529 .. 59532, 59535 .. 59537, 59540 .. 59544, 59550 .. 59555, 59557 .. 59564, 59567 .. 59573, 59580 .. 59584, 59586 .. 59590, 59600 .. 59608, 59610 .. 59613, 59618, 59620, 59630, 59635, 59637, 59639 .. 59640, 59650 .. 59667, 59669 .. 59673, 59677, 59680 .. 59683, 59685 .. 59687, 59689 .. 59690, 59700 .. 59723, 59726 .. 59727, 59730 .. 59735, 59740, 59750, 59760, 59770, 59777, 59779 .. 59785, 59787 .. 59792, 59800, 59810 .. 59818, 59820, 59830 .. 59832, 59838 .. 59840, 59845, 59847 .. 59853, 59859 .. 59878, 59880 .. 59885, 59887, 59889 .. 59900, 59910, 59920, 59930 .. 59933, 59940 .. 59944, 59948, 59950 .. 59952, 59960 .. 59965, 59967, 59970 .. 59972, 59975 .. 59976, 59979 .. 59981, 59984, 59990, 59998, 60000, 60002, 60004 .. 60019, 60021 .. 60029, 60031, 60035, 60100 .. 60123, 60126 .. 60132, 60134, 60138, 60140 .. 60141, 60149 .. 60150, 60153, 60155, 60157, 60160, 60162, 60170, 60173, 60175, 60180 .. 60181, 60183 .. 60185, 60190, 60200 .. 60210, 60220, 60230, 60240, 60250 .. 60252, 60260, 60270 .. 60271, 60280 .. 60281, 60290 .. 60293, 60299 .. 60321, 60323, 60329 .. 60330, 60332, 60340, 60350, 60360, 60370, 60380, 60390, 60400 .. 60403, 60406, 60409 .. 60410, 60420, 60430 .. 60437, 60440, 60451, 60460, 60476 .. 60477, 60480, 60490, 60500 .. 60501, 60503 .. 60504, 60506, 60508 .. 60510, 60520, 60530, 60540 .. 60544, 60550 .. 60552, 60560, 60570, 60580, 60590, 60600, 60602 .. 60603, 60607 .. 60612, 60617 .. 60620, 60631 .. 60635, 60637 .. 60640, 60643, 60646 .. 60650, 60660, 60671 .. 60672, 60674, 60677, 60680, 60690, 60700, 60710 .. 60711, 60721 .. 60723, 60729 .. 60732, 60734, 60740 .. 60745, 60749 .. 60751, 60761 .. 60762, 60765, 60771 .. 60772, 60776 .. 60777, 60779, 60790, 60800 .. 60805, 60810, 60820, 60831 .. 60833, 60840, 60850, 60860, 60870 .. 60872, 60880, 60890, 60902 .. 60903, 60908 .. 60909, 60911 .. 60912, 60921 .. 60924, 60930 .. 60932, 60940, 60950, 60960, 60981, 61000 .. 61009, 61011 .. 61019, 61021 .. 61024, 61041 .. 61042, 61051, 61100 .. 61107, 61109 .. 61110, 61120, 61130, 61140, 61150, 61160, 61170, 61190, 61200 .. 61206, 61208 .. 61210, 61220, 61230, 61240, 61250, 61260, 61270, 61290, 61300 .. 61306, 61310, 61320, 61330, 61340, 61350, 61360, 61370, 61380, 61390, 61400, 61410, 61420, 61430, 61438, 61440, 61448, 61450, 61458, 61470, 61490, 61500, 61550, 61560, 61570, 61600, 61700, 61790, 61800, 61891, 61961, 61984, 61992, 61994, 62000 .. 62005, 62007 .. 62034, 62036, 62051 .. 62055, 62059 .. 62067, 62069 .. 62072, 62079 .. 62081, 62089 .. 62092, 62100 .. 62114, 62116 .. 62124, 62126 .. 62132, 62134, 62136 .. 62145, 62147, 62149 .. 62153, 62155 .. 62162, 62164 .. 62166, 62169 .. 62170, 62172 .. 62173, 62175 .. 62176, 62179 .. 62180, 62182, 62185, 62187, 62189 .. 62194, 62196, 62199 .. 62207, 62209 .. 62213, 62215, 62217 .. 62226, 62228, 62230 .. 62232, 62240, 62242, 62245 .. 62260, 62270, 62280, 62290, 62300 .. 62311, 62320 .. 62322, 62325, 62327, 62330 .. 62336, 62340, 62350, 62360 .. 62361, 62370, 62380, 62390, 62400 .. 62408, 62410 .. 62412, 62418 .. 62420, 62430, 62440, 62450 .. 62453, 62459 .. 62460, 62470, 62480, 62490, 62500 .. 62510, 62520, 62530, 62540, 62550, 62560, 62570, 62575, 62580, 62590, 62600 .. 62604, 62606, 62608 .. 62610, 62620, 62630, 62640, 62650, 62660, 62670, 62680, 62690, 62700 .. 62702, 62709 .. 62710, 62720, 62730, 62740, 62750, 62760, 62770, 62780, 62790, 62800 .. 62806, 62809 .. 62810, 62820, 62830, 62840, 62850, 62860, 62870, 62880 .. 62882, 62889 .. 62890, 62901 .. 62910, 62920 .. 62923, 62929 .. 62930, 62940, 62950 .. 62955, 62960, 62965 .. 62978, 62980, 62990, 63000 .. 63024, 63028 .. 63040, 63042 .. 63046, 63049 .. 63051, 63054 .. 63058, 63063 .. 63064, 63100, 63110 .. 63120, 63122, 63130, 63140, 63150, 63160, 63170 .. 63175, 63177 .. 63178, 63190, 63200 .. 63206, 63210, 63220, 63230, 63240, 63250, 63260, 63270, 63290, 63300 .. 63308, 63310, 63320, 63330, 63340, 63350, 63360, 63370, 63380, 63390, 63400 .. 63410, 63420, 63430, 63440, 63450, 63460, 63470, 63480, 63490, 63500 .. 63506, 63510, 63520, 63530, 63540, 63550, 63560, 63570, 63580, 63590, 63600, 63610, 63620, 63630, 63640, 63650, 63660, 63670, 63680, 63690, 63700, 63710, 63720, 63730, 63740, 63750, 63760, 63770, 63780, 63790, 63800 .. 63804, 63808, 63810, 63820, 63830, 63840, 63850, 63870, 63880, 63890, 63900, 63910, 63920, 63930, 63940, 63950, 63959 .. 63970, 63972, 63980, 63990, 64000 .. 64004, 64006 .. 64008, 64010 .. 64013, 64015 .. 64024, 64027 .. 64044, 64046, 64050 .. 64062, 64064, 64071, 64075, 64078 .. 64082, 64086 .. 64087, 64089 .. 64090, 64100 .. 64113, 64115 .. 64116, 64120 .. 64122, 64130, 64140 .. 64143, 64145 .. 64148, 64150, 64160, 64170, 64181 .. 64185, 64187, 64190, 64200 .. 64206, 64208, 64210, 64220, 64230 .. 64238, 64240, 64250, 64260, 64270, 64290, 64300 .. 64304, 64307, 64310, 64320, 64330, 64340, 64350, 64360, 64370, 64390, 64400 .. 64404, 64410, 64420, 64430, 64440, 64450, 64460, 64470, 64480, 64490, 64500 .. 64506, 64510 .. 64511, 64520, 64530, 64560, 64570, 64600 .. 64605, 64640, 64660, 64680, 64700 .. 64705, 64780, 64800, 64811, 64870, 64990, 65000 .. 65010, 65013 .. 65018, 65020 .. 65025, 65100 .. 65108, 65110 .. 65112, 65116 .. 65117, 65120, 65130, 65140, 65150, 65170 .. 65171, 65190, 65200 .. 65204, 65220, 65230, 65240, 65250, 65260, 65270, 65290, 65300 .. 65303, 65307 .. 65312, 65320 .. 65321, 65330, 65350, 65360, 65370, 65380, 65390, 65400 .. 65402, 65410, 65420 .. 65421, 65429 .. 65430, 65440, 65460, 65490, 65500 .. 65503, 65510, 65560, 65590, 65600 .. 65601, 65660, 65670, 65690, 65700 .. 65701, 65706, 65710, 65800 .. 65801, 65901 .. 65905, 65907, 65911 .. 65912, 65914 .. 65915, 65917 .. 65918, 65920 .. 65921, 65930, 65950 .. 65951, 66000 .. 66006, 66011 .. 66015, 66017 .. 66021, 66025 .. 66034, 66039, 66046, 66050, 66070, 66100 .. 66103, 66110 .. 66113, 66120 .. 66123, 66130, 66140 .. 66141, 66144 .. 66145, 66150, 66160 .. 66162, 66165, 66170, 66180, 66190, 66200 .. 66202, 66210, 66220, 66230, 66240, 66250, 66260, 66270, 66280, 66290, 66300 .. 66302, 66310, 66320, 66330 .. 66331, 66334 .. 66335, 66339 .. 66340, 66350, 66360, 66370, 66380, 66390, 66400 .. 66403, 66410, 66420 .. 66423, 66430, 66440, 66450, 66460, 66470, 66480, 66490, 66500 .. 66502, 66509 .. 66510, 66530, 66540, 66550, 66560, 66570, 66600 .. 66602, 66604 .. 66606, 66609 .. 66610, 66620, 66650 .. 66652, 66659 .. 66660, 66664, 66670, 66680, 66690, 66700 .. 66704, 66720, 66730, 66740, 66750 .. 66751, 66755, 66760, 66800, 66820, 66830 .. 66832, 66836, 66845, 66850, 66853 .. 66854, 66856, 66860, 66863, 66866, 66870, 66906, 66921, 66931, 66933, 66940 .. 66941, 66945, 66950 .. 66951, 66959 .. 66968, 66987, 67000 .. 67039, 67043 .. 67046, 67059 .. 67061, 67064 .. 67065, 67067 .. 67071, 67073 .. 67077, 67080 .. 67093, 67096, 67098 .. 67100, 67102, 67109 .. 67110, 67112 .. 67118, 67120 .. 67126, 67129 .. 67133, 67137 .. 67138, 67140 .. 67146, 67150 .. 67152, 67155, 67158, 67160 .. 67163, 67165 .. 67167, 67169 .. 67173, 67190, 67200 .. 67207, 67209 .. 67220, 67230 .. 67232, 67234 .. 67235, 67239 .. 67243, 67249 .. 67250, 67260 .. 67262, 67269 .. 67270, 67280, 67290, 67300 .. 67308, 67310 .. 67312, 67318 .. 67320, 67330, 67340, 67350, 67360, 67370, 67380 .. 67382, 67390, 67400 .. 67405, 67407 .. 67412, 67420, 67430, 67440 .. 67441, 67450 .. 67460, 67470, 67480, 67490, 67500 .. 67507, 67509 .. 67510, 67520 .. 67521, 67530, 67540 .. 67542, 67550, 67560, 67570, 67580, 67590, 67600 .. 67610, 67620, 67630, 67640, 67650, 67660, 67670, 67680, 67690, 67700 .. 67710, 67720 .. 67728, 67730, 67750, 67760, 67770, 67790, 67800 .. 67804, 67807, 67809 .. 67810, 67820, 67831 .. 67834, 67836, 67838 .. 67843, 67850, 67860, 67870, 67880, 67891 .. 67892, 67900, 67905 .. 67907, 67909, 67911, 67913, 67920 .. 67923, 67925 .. 67928, 67930 .. 67933, 67942 .. 67944, 67948 .. 67949, 67952 .. 67953, 67955, 67957 .. 67967, 67969 .. 67970, 67972, 67974 .. 67986, 67990, 67999 .. 68010, 68012 .. 68027, 68029, 68040, 68050 .. 68074, 68076 .. 68077, 68082 .. 68086, 68090 .. 68093, 68097, 68099 .. 68100, 68110, 68116, 68118, 68120 .. 68121, 68124 .. 68128, 68130 .. 68134, 68139 .. 68140, 68150 .. 68153, 68159 .. 68160, 68170 .. 68173, 68180, 68190, 68200, 68210, 68220 .. 68221, 68230, 68240, 68250, 68260 .. 68265, 68270 .. 68274, 68280, 68290, 68300 .. 68317, 68320, 68330 .. 68333, 68340, 68350, 68360, 68370, 68380, 68390 .. 68393, 68399 .. 68400, 68410, 68420, 68440, 68460, 68470, 68480, 68490, 68500 .. 68504, 68509 .. 68510, 68520, 68530, 68540, 68550, 68560, 68570, 68580, 68590, 68600, 68610, 68620, 68630, 68640, 68650, 68660, 68680, 68690, 68700 .. 68705, 68720, 68730, 68740, 68750, 68760, 68770, 68780, 68790, 68800 .. 68802, 68804, 68806, 68809, 68820, 68830, 68840, 68850, 68870, 68890, 68910, 68920 .. 68921, 68923, 68925, 68927, 68929, 68941, 68943 .. 68945, 68947 .. 68950, 68960, 68968, 68970, 68980, 68990, 69001 .. 69009, 69061 .. 69062, 69064, 69100, 69110, 69115, 69120, 69124 .. 69126, 69129 .. 69132, 69134, 69136, 69139 .. 69145, 69147 .. 69148, 69150 .. 69154, 69159 .. 69161, 69170 .. 69173, 69190 .. 69192, 69195, 69199 .. 69220, 69225 .. 69230, 69232, 69237, 69239 .. 69247, 69250 .. 69253, 69255 .. 69272, 69275 .. 69276, 69279 .. 69294, 69300 .. 69303, 69307, 69309 .. 69310, 69316 .. 69317, 69319 .. 69322, 69326 .. 69330, 69336 .. 69367, 69369 .. 69373, 69376 .. 69377, 69379 .. 69380, 69384 .. 69385, 69389 .. 69406, 69408 .. 69461, 69463 .. 69470, 69472, 69474 .. 69493, 69495, 69500 .. 69503, 69505, 69509 .. 69520, 69530 .. 69531, 69540 .. 69544, 69550 .. 69553, 69560 .. 69561, 69563 .. 69565, 69569 .. 69574, 69576, 69578 .. 69583, 69590 .. 69595, 69600 .. 69613, 69615 .. 69616, 69619 .. 69661, 69664 .. 69665, 69667, 69669 .. 69677, 69679 .. 69680, 69682, 69684 .. 69687, 69689 .. 69694, 69696, 69700 .. 69702, 69709, 69714, 69720, 69726 .. 69727, 69729 .. 69732, 69735, 69740 .. 69747, 69749, 69751, 69755, 69760, 69770 .. 69771, 69780, 69790 .. 69795, 69800 .. 69806, 69808 .. 69809, 69811 .. 69814, 69816 .. 69817, 69819 .. 69820, 69822 .. 69824, 69829 .. 69833, 69836, 69840 .. 69841, 69850, 69860, 69870, 69881 .. 69883, 69889 .. 69891, 69900 .. 69908, 69910, 69921 .. 69926, 69930 .. 69939, 69942, 69945 .. 69949, 69951 .. 69955, 69957, 69960 .. 69964, 69968 .. 69970, 69998, 70000 .. 70007, 70013 .. 70014, 70019 .. 70022, 70030, 70100 .. 70104, 70110, 70120, 70130, 70140, 70150, 70160, 70170, 70180, 70190, 70200 .. 70204, 70210, 70220, 70230, 70240, 70250, 70270, 70280, 70290, 70300 .. 70304, 70306, 70310, 70320, 70360, 70400, 70440, 70500, 70600, 70700, 70800, 70807, 71000 .. 71012, 71017 .. 71029, 71031, 71040, 71049, 71100 .. 71110, 71118, 71120, 71130, 71140, 71150, 71160, 71170, 71190, 71200 .. 71206, 71209 .. 71210, 71220, 71230, 71240, 71250, 71260, 71270, 71290, 71300 .. 71310, 71320 .. 71328, 71330 .. 71337, 71339 .. 71340, 71350, 71360, 71370, 71380, 71390, 71400 .. 71405, 71407 .. 71410, 71420, 71430, 71440, 71450, 71460, 71470, 71480, 71490, 71500 .. 71503, 71509 .. 71510, 71520, 71530, 71540, 71550, 71570, 71580, 71590, 71600 .. 71604, 71609, 71620, 71640, 71670, 71680, 71700, 71710, 71740, 71760, 71800, 71850, 71870, 71880, 71960, 71990, 72000 .. 72011, 72013 .. 72016, 72018 .. 72019, 72021, 72024 .. 72030, 72032 .. 72045, 72047 .. 72049, 72051 .. 72052, 72055, 72058 .. 72059, 72070 .. 72073, 72075, 72079 .. 72089, 72091 .. 72093, 72095 .. 72096, 72100, 72109 .. 72110, 72120, 72130, 72140, 72150, 72160, 72170, 72190, 72200 .. 72203, 72205 .. 72206, 72208, 72210, 72220, 72230 .. 72234, 72236 .. 72237, 72239 .. 72240, 72250, 72260, 72270, 72290, 72300 .. 72305, 72308 .. 72310, 72320, 72330, 72340, 72350, 72360, 72370, 72380, 72390, 72400 .. 72407, 72409, 72430, 72440, 72450, 72460, 72470, 72500, 72510, 72530, 72540, 72550, 72560, 72600, 72610, 72650, 72700, 72702 .. 72705, 72800, 72902, 72908, 73000 .. 73011, 73014 .. 73022, 73024 .. 73026, 73031, 73065, 73073, 73079, 73089, 73091, 73094, 73100 .. 73110, 73120 .. 73124, 73127, 73129 .. 73130, 73140, 73150 .. 73155, 73157, 73159 .. 73160, 73170, 73190 .. 73193, 73199 .. 73212, 73214, 73216, 73219 .. 73221, 73223 .. 73225, 73229 .. 73232, 73235, 73239 .. 73240, 73250, 73260 .. 73261, 73264 .. 73265, 73269 .. 73270, 73276 .. 73277, 73290 .. 73292, 73294 .. 73295, 73299 .. 73303, 73309 .. 73310, 73320 .. 73322, 73329 .. 73330, 73340, 73350, 73360, 73370 .. 73379, 73381 .. 73382, 73390, 73400 .. 73403, 73409 .. 73410, 73420, 73440, 73450, 73460, 73470, 73480, 73490 .. 73494, 73499 .. 73500, 73520, 73530, 73540, 73550, 73570 .. 73573, 73579, 73590, 73600 .. 73604, 73609 .. 73610, 73620, 73630, 73640, 73660, 73670, 73700 .. 73705, 73708 .. 73710, 73720, 73730, 73790, 73800 .. 73802, 73804 .. 73809, 73870, 74000 .. 74016, 74020 .. 74021, 74024 .. 74025, 74034, 74036, 74040 .. 74041, 74054 .. 74055, 74059, 74100 .. 74113, 74120, 74130 .. 74137, 74139 .. 74140, 74150 .. 74166, 74169 .. 74170, 74190, 74200 .. 74210, 74220, 74230, 74240, 74250, 74260, 74270, 74290, 74300 .. 74305, 74307 .. 74311, 74314, 74320, 74330 .. 74334, 74337 .. 74340, 74350, 74360, 74370 .. 74374, 74380, 74390, 74400 .. 74405, 74409 .. 74410, 74420, 74430, 74440, 74450, 74460, 74470, 74480, 74490, 74500 .. 74503, 74509, 74520, 74540, 74550, 74560, 74570, 74580, 74600 .. 74607, 74609, 74650, 74660, 74700 .. 74704, 74706, 74709, 74740, 74800 .. 74809, 74890, 74910, 74920, 74930, 74940 .. 74946, 74949 .. 74954, 74960 .. 74964, 74966, 74969 .. 74970, 74981 .. 74982, 74984 .. 74991, 74993 .. 75021, 75023 .. 75024, 75026, 75028 .. 75036, 75038 .. 75049, 75051 .. 75056, 75058 .. 75069, 75072 .. 75090, 75092 .. 75097, 75100 .. 75116, 75118 .. 75120, 75122 .. 75131, 75134, 75138 .. 75142, 75144, 75150 .. 75159, 75161 .. 75172, 75174, 75176 .. 75177, 75179 .. 75182, 75184, 75186, 75188 .. 75189, 75191 .. 75192, 75194 .. 75198, 75201 .. 75224, 75226 .. 75241, 75243 .. 75244, 75248, 75250, 75252 .. 75253, 75256, 75260 .. 75266, 75269 .. 75270, 75272, 75275, 75278 .. 75284, 75288, 75290 .. 75292, 75294 .. 75295, 75298 .. 75299, 75302 .. 75315, 75317 .. 75330, 75333, 75335, 75337 .. 75345, 75348 .. 75350, 75352 .. 75353, 75355 .. 75367, 75370 .. 75376, 75378 .. 75392, 75394 .. 75403, 75405 .. 75408, 75410 .. 75413, 75415 .. 75432, 75434 .. 75447, 75449 .. 75460, 75462 .. 75468, 75470 .. 75488, 75490 .. 75493, 75495 .. 75499, 75502 .. 75512, 75521 .. 75528, 75533 .. 75538, 75540 .. 75548, 75550 .. 75558, 75560 .. 75589, 75591 .. 75614, 75616 .. 75644, 75646 .. 75665, 75667 .. 75671, 75673 .. 75675, 75677 .. 75683, 75685, 75687 .. 75694, 75696 .. 75703, 75705 .. 75710, 75712 .. 75727, 75729 .. 75732, 75734, 75737 .. 75743, 75745, 75747 .. 75750, 75753 .. 75757, 75759, 75761 .. 75773, 75775, 75778, 75780 .. 75786, 75789 .. 75790, 75794, 75796, 75798 .. 75800, 75802 .. 75809, 75812 .. 75813, 75815, 75817 .. 75841, 75843 .. 75855, 75857 .. 75858, 75860 .. 75872, 75874 .. 75887, 75889 .. 75895, 75897 .. 75905, 75907 .. 75909, 75911, 75913 .. 75962, 75965 .. 75967, 75969 .. 75981, 75983 .. 75991, 75993 .. 75998, 76000 .. 76008, 76011 .. 76012, 76017 .. 76022, 76024 .. 76026, 76028 .. 76033, 76035 .. 76047, 76049 .. 76072, 76074, 76079 .. 76080, 76083 .. 76087, 76092 .. 76101, 76107 .. 76111, 76113, 76116 .. 76117, 76119 .. 76125, 76127, 76129 .. 76144, 76150 .. 76153, 76155, 76159 .. 76161, 76164, 76170 .. 76179, 76181, 76183, 76185 .. 76197, 76200 .. 76210, 76220, 76230 .. 76233, 76235 .. 76240, 76250, 76260, 76270, 76280, 76290, 76300 .. 76306, 76308, 76310, 76320, 76330, 76340, 76350, 76360, 76370, 76379 .. 76380, 76390, 76400 .. 76405, 76409 .. 76410, 76418 .. 76420, 76430, 76440, 76450, 76460, 76470, 76480, 76490, 76500 .. 76504, 76509 .. 76510, 76520, 76530, 76540, 76550, 76560, 76570, 76580, 76590, 76600, 76610, 76620, 76630, 76640, 76650, 76660, 76680, 76690, 76700, 76710, 76720 .. 76721, 76723, 76730, 76740, 76750, 76760, 76770, 76780, 76790, 76800 .. 76810, 76821, 76823 .. 76825, 76840, 76850, 76860, 76870, 76880 .. 76885, 76887, 76890, 76900, 76902, 76910, 76914 .. 76915, 76917, 76920, 76925 .. 76927, 76929 .. 76930, 76934 .. 76935, 76940, 76945, 76950, 76960, 76970, 76980, 77000 .. 77021, 77023 .. 77028, 77039 .. 77043, 77050 .. 77052, 77090, 77100 .. 77115, 77118, 77120, 77122 .. 77124, 77126 .. 77127, 77130 .. 77131, 77133 .. 77135, 77138 .. 77141, 77144 .. 77145, 77148, 77150 .. 77151, 77154, 77157, 77160, 77163 .. 77167, 77169 .. 77171, 77173 .. 77174, 77176 .. 77178, 77181, 77183 .. 77187, 77190 .. 77225, 77229 .. 77232, 77234, 77239 .. 77243, 77246 .. 77255, 77257, 77259 .. 77264, 77266, 77270 .. 77272, 77280 .. 77282, 77290 .. 77305, 77307 .. 77316, 77318 .. 77320, 77327, 77330 .. 77335, 77337, 77340 .. 77344, 77346 .. 77353, 77360, 77370, 77380 .. 77382, 77384 .. 77385, 77388 .. 77390, 77400 .. 77405, 77407, 77409 .. 77417, 77419 .. 77427, 77429 .. 77437, 77439 .. 77448, 77450 .. 77455, 77458, 77460, 77462 .. 77465, 77467 .. 77470, 77480 .. 77484, 77486 .. 77489, 77500 .. 77510, 77515, 77520 .. 77529, 77540 .. 77570, 77580 .. 77583, 77585, 77590, 77600 .. 77612, 77614 .. 77617, 77620, 77630, 77640 .. 77641, 77645 .. 77646, 77649 .. 77650, 77660, 77670, 77680, 77690, 77700 .. 77706, 77708 .. 77711, 77714 .. 77717, 77720 .. 77723, 77730, 77750, 77760, 77771 .. 77772, 77776 .. 77780, 77791 .. 77796, 77798 .. 77799, 77810 .. 77811, 77813 .. 77820, 77830 .. 77835, 77837 .. 77840, 77850, 77860, 77870 .. 77873, 77875 .. 77876, 77879 .. 77880, 77890, 77910, 77920, 77923, 77930 .. 77933, 77939 .. 77940, 77950 .. 77951, 77961, 77970, 77981 .. 77983, 77986, 77989 .. 77990, 78000 .. 78015, 78017 .. 78022, 78024, 78026 .. 78030, 78032 .. 78035, 78041 .. 78049, 78051 .. 78057, 78059 .. 78062, 78064 .. 78067, 78071, 78078 .. 78079, 78081 .. 78089, 78091 .. 78096, 78099 .. 78102, 78104 .. 78106, 78108 .. 78122, 78124 .. 78126, 78129 .. 78135, 78139 .. 78143, 78145 .. 78155, 78157 .. 78160, 78162 .. 78167, 78169 .. 78174, 78177, 78179 .. 78186, 78188 .. 78210, 78212, 78214, 78219 .. 78223, 78229 .. 78234, 78239 .. 78244, 78249 .. 78250, 78260, 78270, 78280 .. 78294, 78299 .. 78304, 78306 .. 78317, 78319 .. 78322, 78330 .. 78331, 78339 .. 78342, 78344 .. 78346, 78349 .. 78356, 78359 .. 78364, 78368, 78370 .. 78380, 78390 .. 78391, 78395, 78400 .. 78404, 78409 .. 78413, 78415 .. 78417, 78419 .. 78424, 78429 .. 78431, 78439 .. 78440, 78450 .. 78451, 78457 .. 78458, 78460, 78470 .. 78472, 78479 .. 78480, 78490, 78500 .. 78507, 78509 .. 78515, 78519 .. 78520, 78530 .. 78536, 78539 .. 78540, 78550, 78560, 78570, 78580, 78590 .. 78592, 78599 .. 78606, 78609 .. 78610, 78612, 78619 .. 78620, 78630, 78640, 78650, 78660, 78670, 78680, 78690, 78700 .. 78703, 78705, 78709 .. 78715, 78718, 78720, 78730, 78740, 78750, 78760, 78770 .. 78771, 78778 .. 78780, 78790, 78800 .. 78806, 78809 .. 78810, 78820, 78830, 78840, 78850 .. 78852, 78854, 78859 .. 78860, 78870, 78881 .. 78886, 78890, 78897, 78910, 78915, 78920 .. 78931, 78940 .. 78946, 78948 .. 78950, 78955, 78960, 78970, 78980, 78990, 78995 .. 78997, 79000 .. 79018, 79021 .. 79039, 79041 .. 79046, 79049 .. 79056, 79059 .. 79061, 79068 .. 79077, 79079 .. 79088, 79091 .. 79093, 79098 .. 79106, 79109 .. 79110, 79120, 79130, 79140 .. 79145, 79150, 79160, 79170, 79180 .. 79182, 79184 .. 79185, 79189 .. 79190, 79200 .. 79206, 79208 .. 79210, 79220, 79230 .. 79234, 79240, 79250, 79260, 79270, 79290, 79300 .. 79310, 79320, 79330, 79340, 79350, 79360, 79370, 79380, 79390, 79400 .. 79404, 79409 .. 79410, 79420, 79430, 79440, 79450, 79460, 79500, 79510, 79600, 79700, 79800, 79939, 79950, 79953, 80000 .. 80017, 80019 .. 80023, 80025 .. 80034, 80036 .. 80044, 80046 .. 80051, 80054 .. 80057, 80060 .. 80064, 80068 .. 80069, 80075, 80080 .. 80097, 80099 .. 80110, 80115, 80118, 80120, 80122, 80130 .. 80132, 80134 .. 80136, 80140, 80142 .. 80146, 80150, 80160, 80170, 80190, 80200 .. 80206, 80208 .. 80210, 80220, 80230, 80240, 80250, 80260, 80270, 80290, 80300 .. 80303, 80309 .. 80310, 80320, 80330 .. 80336, 80339 .. 80340, 80350, 80360, 80370, 80390, 80400, 80410, 80420, 80430, 80440, 80450, 80460, 80470, 80480, 80490, 80500, 80510, 80520, 80531 .. 80535, 80539 .. 80540, 80550, 80560, 80570, 80580, 80600, 80610, 80620, 80630, 80640, 80650, 80670, 80680, 80690, 80700, 80710, 80740, 80750, 80770, 80780, 80800, 80820, 80830, 80850, 80860, 80870, 80880, 80890 .. 80891, 80910, 80919, 80960, 80970, 80980, 81000 .. 81007, 81011 .. 81023, 81025 .. 81028, 81030 .. 81031, 81034 .. 81039, 81090, 81100 .. 81110, 81115 .. 81116, 81120, 81130, 81140, 81150, 81160, 81170, 81190, 81200 .. 81210, 81215, 81220, 81230, 81240, 81250, 81260, 81270, 81290, 81300 .. 81305, 81310, 81320, 81330, 81340, 81350, 81360, 81370, 81380, 81390, 81400, 81430, 81440, 81450, 81470, 81490, 81500 .. 81503, 81506, 81509, 81530, 81540, 81570, 81580, 81600 .. 81605, 81609, 81630, 81640, 81660, 81700, 81710, 81800, 81990, 82000 .. 82006, 82008 .. 82009, 82013 .. 82015, 82017, 82019, 82024, 82027, 82030, 82032 .. 82033, 82037, 82040, 82047 .. 82048, 82053 .. 82054, 82057, 82060, 82065, 82067, 82070, 82077, 82080, 82087, 82100 .. 82104, 82109 .. 82110, 82120, 82130, 82140, 82150, 82160, 82170, 82190, 82200 .. 82202, 82208, 82210, 82220, 82230, 82240, 82250, 82270, 82290, 82300 .. 82303, 82330, 82340, 82350, 82360, 82370, 82390, 82400 .. 82403, 82410, 82440, 82500, 82600, 82700, 82710, 82800, 83000 .. 83008, 83012 .. 83016, 83019, 83030, 83036, 83038, 83040 .. 83042, 83048 .. 83065, 83069 .. 83071, 83076 .. 83095, 83097 .. 83100, 83107 .. 83108, 83110 .. 83111, 83119 .. 83120, 83130 .. 83131, 83136, 83140, 83143, 83149 .. 83150, 83160 .. 83164, 83166 .. 83167, 83170 .. 83177, 83179 .. 83181, 83183 .. 83185, 83187 .. 83192, 83196, 83199 .. 83200, 83210, 83220, 83230 .. 83231, 83236 .. 83238, 83240, 83250, 83260, 83270, 83300, 83310 .. 83317, 83320, 83330, 83340, 83350, 83370 .. 83372, 83379 .. 83380, 83390, 83400 .. 83409, 83411 .. 83412, 83418, 83420, 83430, 83440, 83460, 83470, 83480 .. 83490, 83500 .. 83504, 83507, 83509 .. 83512, 83514, 83518, 83520, 83530, 83550, 83560, 83570, 83580, 83590, 83600 .. 83604, 83606, 83608 .. 83610, 83613 .. 83616, 83618, 83630, 83640, 83660, 83670, 83680, 83690, 83700 .. 83705, 83707, 83720, 83740, 83780, 83790, 83800, 83820, 83830, 83840, 83860, 83870, 83890, 83910, 83920, 83951 .. 83954, 83957, 83980, 83990 .. 83998, 84000, 84004 .. 84011, 84013 .. 84016, 84018 .. 84019, 84021 .. 84025, 84027, 84029, 84031 .. 84036, 84041 .. 84051, 84054, 84056, 84058 .. 84059, 84071 .. 84072, 84077 .. 84078, 84081 .. 84085, 84090 .. 84110, 84120 .. 84124, 84130 .. 84135, 84139 .. 84144, 84147, 84149 .. 84150, 84160, 84170, 84190, 84200 .. 84210, 84220, 84230 .. 84232, 84240, 84250, 84260, 84270 .. 84279, 84290, 84300 .. 84310, 84320, 84330, 84340, 84350, 84360, 84370, 84380, 84390, 84400 .. 84405, 84410, 84420, 84430, 84440, 84450, 84460, 84470, 84480, 84490, 84500 .. 84505, 84507, 84510, 84530, 84550, 84560, 84570, 84580, 84600 .. 84603, 84609, 84660, 84700 .. 84706, 84740, 84750, 84760, 84800 .. 84805, 84808, 84810, 84820, 84830, 84840, 84850, 84860, 84870 .. 84874, 84878, 84901 .. 84902, 84905, 84909, 84911 .. 84919, 84951 .. 84954, 84956, 84961, 84963 .. 84965, 84967 .. 84969, 84971 .. 84973, 84976 .. 84977, 85000 .. 85010, 85012 .. 85013, 85015 .. 85021, 85023 .. 85024, 85026, 85033, 85035 .. 85036, 85100 .. 85111, 85113 .. 85114, 85118 .. 85120, 85130 .. 85133, 85139 .. 85140, 85150, 85160 .. 85165, 85167, 85169 .. 85170, 85180, 85190, 85200 .. 85206, 85208 .. 85210, 85220, 85230, 85240, 85250, 85260, 85270, 85280, 85290 .. 85292, 85299 .. 85307, 85309 .. 85310, 85320, 85330, 85340 .. 85342, 85350, 85360, 85370, 85390, 85400 .. 85404, 85406 .. 85407, 85409 .. 85410, 85420, 85430, 85440, 85450, 85460, 85470, 85480, 85490, 85500 .. 85506, 85509 .. 85510, 85520, 85530, 85540, 85550, 85560, 85570, 85580, 85590, 85600 .. 85604, 85607, 85609 .. 85610, 85612 .. 85616, 85620, 85630, 85640, 85660, 85670, 85680, 85690, 85700, 85702 .. 85703, 85707 .. 85710, 85740, 85750, 85770, 85800, 85803 .. 85806, 85809, 85919, 85921 .. 85928, 85930 .. 85934, 86000 .. 86013, 86020 .. 86023, 86029 .. 86030, 86034 .. 86036, 86038, 86042 .. 86047, 86050 .. 86056, 86060 .. 86063, 86065 .. 86069, 86071 .. 86074, 86076, 86080 .. 86098, 86100 .. 86110, 86117, 86120, 86130 .. 86135, 86137 .. 86140, 86150, 86160, 86170, 86180, 86190, 86200 .. 86202, 86204, 86206, 86209 .. 86210, 86220, 86230, 86240, 86250, 86260, 86270, 86280 .. 86282, 86289 .. 86290, 86300, 86310, 86320, 86330, 86340, 86350, 86360 .. 86362, 86369 .. 86370, 86380, 86390, 86400, 86410, 86420, 86430, 86440, 86450, 86460, 86470, 86480, 86490, 86500 .. 86502, 86508 .. 86510, 86530, 86540, 86550, 86580, 86600, 86610, 86700, 86800, 86905, 86910, 86960 .. 86964, 86969, 86980 .. 86984, 87000 .. 87013, 87015 .. 87018, 87020 .. 87023, 87025 .. 87026, 87030 .. 87034, 87036 .. 87055, 87058 .. 87061, 87065 .. 87071, 87073 .. 87085, 87089 .. 87090, 87100, 87110, 87120, 87130, 87140, 87150, 87160, 87170, 87190, 87200 .. 87203, 87205 .. 87206, 87210, 87220 .. 87223, 87230, 87240, 87250, 87260, 87270, 87280, 87290, 87300, 87310, 87320, 87330, 87340, 87350, 87360, 87370, 87380, 87400, 87410, 87420, 87430, 87440, 87460, 87470, 87480, 87500, 87510, 87520, 87570, 87590, 87600, 87620, 87640, 87700, 87720, 87800, 87890, 87900, 87919 .. 87920, 87930, 87950, 88000 .. 88018, 88020 .. 88021, 88025 .. 88027, 88029, 88033, 88050 .. 88051, 88060, 88084 .. 88086, 88088 .. 88089, 88099 .. 88110, 88120 .. 88123, 88125, 88127, 88129 .. 88133, 88139 .. 88143, 88149 .. 88156, 88160 .. 88162, 88165, 88169 .. 88170, 88187, 88190 .. 88195, 88198 .. 88207, 88209 .. 88214, 88220, 88230, 88240, 88250, 88260, 88270, 88290, 88300 .. 88307, 88310, 88320, 88330, 88340, 88350, 88360, 88370, 88380, 88390, 88400 .. 88403, 88405 .. 88410, 88420, 88430, 88440, 88450, 88460, 88470, 88480, 88490, 88500 .. 88504, 88507, 88509 .. 88510, 88520, 88530, 88540, 88550, 88560, 88580, 88600, 88630, 88640, 88650, 88700, 88800 .. 88805, 88809, 89000 .. 89007, 89009 .. 89012, 89015 .. 89016, 89019 .. 89030, 89089 .. 89095, 89099 .. 89110, 89113, 89116, 89120, 89130, 89140, 89144, 89150, 89160, 89170, 89190, 89200 .. 89207, 89209 .. 89210, 89220, 89230, 89240, 89250, 89260, 89270, 89290, 89300 .. 89307, 89309 .. 89310, 89320, 89330 .. 89331, 89340, 89350, 89360, 89380, 89390, 89400, 89410, 89420, 89430, 89440, 89450, 89460, 89470, 89480, 89500, 89510, 89515, 89520, 89525, 89530, 89550, 89560, 89570, 89580, 89600, 89630, 89660, 89690, 89700, 89710, 89740, 89770 .. 89772, 89800, 90000 .. 90016, 90018 .. 90023, 90025, 90040, 90100 .. 90101, 90110, 90120, 90130, 90140, 90150, 90160, 90170, 90200, 90300, 90330, 90340, 90350, 90360, 90370, 90380, 90400, 90500, 90600, 90700, 90800, 90850, 91000 .. 91059, 91070 .. 91072, 91074, 91077 .. 91080, 91090, 91097, 91100 .. 91109, 91120 .. 91133, 91135 .. 91137, 91140 .. 91142, 91146, 91149 .. 91154, 91156 .. 91174, 91177 .. 91180, 91190 .. 91201, 91204 .. 91205, 91207, 91209 .. 91211, 91213 .. 91214, 91220 .. 91230, 91240 .. 91241, 91250, 91260 .. 91263, 91265 .. 91270, 91280, 91290 .. 91292, 91294 .. 91312, 91314 .. 91315, 91320 .. 91325, 91328 .. 91335, 91339 .. 91351, 91353 .. 91355, 91359 .. 91360, 91370 .. 91371, 91374, 91380 .. 91390, 91400 .. 91407, 91409 .. 91410, 91412, 91414 .. 91418, 91420 .. 91430, 91440, 91450, 91460 .. 91463, 91470, 91480, 91490, 91510, 91520, 91530, 91540 .. 91542, 91549 .. 91551, 91560, 91570 .. 91574, 91578 .. 91580, 91590, 91600 .. 91603, 91605, 91609 .. 91610, 91612 .. 91613, 91619 .. 91620, 91625, 91630, 91640, 91650, 91660, 91670, 91680, 91690 .. 91713, 91720, 91730, 91740 .. 91750, 91760 .. 91764, 91767, 91770, 91780 .. 91781, 91783, 91790 .. 91792, 91800 .. 91807, 91809 .. 91815, 91820 .. 91821, 91830, 91840 .. 91841, 91849 .. 91852, 91855, 91860 .. 91861, 91870 .. 91887, 91889 .. 91896, 91898 .. 91899, 91910 .. 91917, 91919, 91921 .. 91924, 91930, 91940 .. 91949, 91951 .. 91959, 91961 .. 91969, 91971 .. 91979, 91981 .. 91986, 91988, 92000 .. 92029, 92033 .. 92061, 92063 .. 92079, 92081 .. 92089, 92092 .. 92093, 92095 .. 92106, 92108 .. 92179, 92181 .. 92186, 92188 .. 92191, 92193 .. 92196, 92199 .. 92206, 92208 .. 92216, 92219 .. 92235, 92237 .. 92247, 92249 .. 92254, 92256 .. 92263, 92266, 92269 .. 92275, 92279 .. 92282, 92284, 92286 .. 92288, 92290 .. 92293, 92295 .. 92298, 92300 .. 92314, 92316 .. 92333, 92337, 92339 .. 92342, 92350 .. 92357, 92359 .. 92366, 92369 .. 92370, 92372, 92379 .. 92380, 92388, 92390 .. 92420, 92423, 92430, 92438, 92441 .. 92445, 92447 .. 92448, 92454, 92499 .. 92509, 92511, 92513 .. 92514, 92516 .. 92519, 92521 .. 92525, 92527 .. 92529, 92531 .. 92538, 92541 .. 92546, 92552 .. 92553, 92555, 92561 .. 92567, 92569, 92571, 92573 .. 92578, 92581 .. 92588, 92591 .. 92607, 92609, 92611, 92613 .. 92616, 92622, 92624, 92631 .. 92638, 92641 .. 92643, 92645, 92649 .. 92651, 92653 .. 92656, 92658 .. 92660, 92665, 92671 .. 92672, 92675, 92677, 92679, 92682 .. 92686, 92688 .. 92689, 92691, 92693, 92695, 92698, 92700 .. 92709, 92711 .. 92715, 92721 .. 92722, 92725 .. 92730, 92735 .. 92739, 92741 .. 92745, 92747 .. 92748, 92751 .. 92752, 92755 .. 92756, 92758, 92761 .. 92764, 92766 .. 92768, 92772 .. 92774, 92776, 92779, 92781 .. 92789, 92791 .. 92809, 92811, 92813, 92815 .. 92824, 92842 .. 92848, 92851 .. 92856, 92859, 92861 .. 92867, 92881 .. 92887, 92889, 92891 .. 92898, 92901 .. 92904, 92906 .. 92909, 92911 .. 92939, 92959, 92970 .. 92975, 92977 .. 92981, 92983 .. 92989, 92999 .. 93003, 93005 .. 93009, 93011 .. 93014, 93016 .. 93018, 93021 .. 93022, 93024, 93100 .. 93108, 93110 .. 93112, 93114 .. 93118, 93120 .. 93123, 93126 .. 93127, 93130 .. 93131, 93133 .. 93136, 93140 .. 93158, 93160 .. 93172, 93174 .. 93177, 93181 .. 93184, 93186 .. 93197, 93199 .. 93214, 93216 .. 93222, 93230 .. 93231, 93233, 93235, 93240 .. 93241, 93245, 93250, 93260 .. 93261, 93270 .. 93271, 93274 .. 93275, 93282 .. 93286, 93290, 93294, 93297, 93300 .. 93308, 93310 .. 93311, 93315, 93320 .. 93325, 93330 .. 93332, 93334 .. 93337, 93340 .. 93346, 93348 .. 93352, 93360 .. 93366, 93370, 93380 .. 93382, 93390, 93400 .. 93408, 93410 .. 93412, 93420 .. 93424, 93430 .. 93431, 93436 .. 93437, 93440 .. 93441, 93450 .. 93451, 93453 .. 93458, 93460 .. 93465, 93470, 93472 .. 93473, 93479, 93481 .. 93487, 93489, 93493, 93500 .. 93508, 93511 .. 93517, 93521 .. 93524, 93526 .. 93528, 93531 .. 93539, 93541, 93544 .. 93545, 93547, 93554 .. 93556, 93558, 93561 .. 93564, 93571, 93574 .. 93578, 93581 .. 93589, 93591, 93593, 93600 .. 93606, 93608 .. 93609, 93611 .. 93619, 93621 .. 93623, 93627, 93631, 93691 .. 93701, 93705, 93711 .. 93712, 93719, 93731, 93733 .. 93734, 93736 .. 93738, 93761, 93800 .. 93802, 93806 .. 93807, 93812 .. 93816, 93881, 93883 .. 93885, 93887, 93891, 93899, 93901, 93907 .. 93909, 94000 .. 94049, 94051 .. 94055, 94094, 94100 .. 94166, 94169 .. 94175, 94190 .. 94197, 94199 .. 94211, 94214, 94219 .. 94244, 94246 .. 94247, 94249 .. 94279, 94281, 94290, 94300 .. 94312, 94319 .. 94322, 94324, 94327, 94340 .. 94345, 94349 .. 94351, 94353 .. 94357, 94359 .. 94366, 94368 .. 94396, 94398 .. 94415, 94417, 94419 .. 94420, 94430 .. 94440, 94450 .. 94457, 94459 .. 94460, 94470 .. 94480, 94490, 94500 .. 94528, 94531 .. 94539, 94541 .. 94544, 94546 .. 94553, 94561 .. 94569, 94571 .. 94579, 94581 .. 94589, 94591 .. 94604, 94606 .. 94607, 94609, 94611 .. 94614, 94616 .. 94619, 94621 .. 94623, 94626 .. 94628, 94631 .. 94639, 94641 .. 94645, 94647 .. 94648, 94651, 94653 .. 94654, 94656 .. 94659, 94661, 94663 .. 94664, 94667, 94669, 94671 .. 94679, 94681 .. 94688, 94700 .. 94704, 94706 .. 94707, 94709 .. 94715, 94719, 94721 .. 94729, 94731 .. 94739, 94741 .. 94745, 94748 .. 94749, 94761 .. 94768, 94781 .. 94785, 94789, 94800 .. 94809, 94811 .. 94819, 94831 .. 94833, 94839, 94851 .. 94859, 94861 .. 94867, 94869, 94880, 94891 .. 94894, 94941 .. 94942, 94945 .. 94949, 94951 .. 94956, 94958 .. 94959, 94961 .. 94966, 94968, 94971 .. 94978, 95000 .. 95008, 95010 .. 95025, 95027 .. 95038, 95040 .. 95042, 95046, 95050 .. 95056, 95059 .. 95067, 95069 .. 95079, 95090 .. 95098, 95100 .. 95112, 95117 .. 95127, 95129 .. 95135, 95137, 95139 .. 95146, 95150 .. 95155, 95157 .. 95162, 95165, 95169 .. 95170, 95180, 95190 .. 95207, 95209 .. 95224, 95226, 95228 .. 95234, 95239 .. 95240, 95250 .. 95252, 95259 .. 95260, 95270, 95280, 95290, 95300 .. 95304, 95306, 95309 .. 95316, 95318 .. 95324, 95328 .. 95335, 95340, 95350 .. 95351, 95355, 95360, 95370, 95379 .. 95380, 95390, 95400, 95410 .. 95412, 95419 .. 95420, 95430, 95440 .. 95441, 95445, 95450, 95460 .. 95461, 95470 .. 95480, 95490, 95500 .. 95510, 95520 .. 95530, 95540, 95550 .. 95551, 95559 .. 95560, 95570 .. 95571, 95573, 95580, 95590, 95600 .. 95605, 95609 .. 95620, 95630, 95640, 95650 .. 95652, 95659 .. 95660, 95670, 95680, 95690 .. 95693, 95696 .. 95697, 95700 .. 95713, 95715 .. 95716, 95719 .. 95727, 95731 .. 95734, 95740 .. 95742, 95747, 95750, 95760 .. 95761, 95769 .. 95770, 95780, 95800 .. 95816, 95820, 95830, 95840, 95842 .. 95844, 95850, 95861 .. 95866, 95868, 95870 .. 95877, 95879 .. 95880, 95891 .. 95892, 95897, 95901 .. 95902, 95905, 95907 .. 95908, 95911 .. 95913, 95915 .. 95916, 95919 .. 95928, 95930 .. 95934, 95940 .. 95954, 95956 .. 95959, 95970 .. 95978, 98799, } __END__ Regexp-Common-2017060201/t/zip/221_monaco.t000755 000765 000024 00000001147 13114353631 020431 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use warnings; no warnings 'syntax'; use lib "."; use Regexp::Common; use Test::More; use t::zip::Zip; my $r = eval "require Test::Regexp; 1"; unless ($r) { print "1..0 # SKIP Test::Regexp not found\n"; exit; } test_zips country => "Monaco", name => "Monaco zip codes", prefix => { iso => "MC", cept => "MC", invalid => "FR", }, prefix_test_set => [98010, 98088], ; done_testing; sub valid_zip_codes { 98000 .. 98099, } __END__ Regexp-Common-2017060201/t/zip/231_san-marino.t000755 000765 000024 00000001156 13114353631 021222 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use warnings; no warnings 'syntax'; use lib "."; use Regexp::Common; use Test::More; use t::zip::Zip; my $r = eval "require Test::Regexp; 1"; unless ($r) { print "1..0 # SKIP Test::Regexp not found\n"; exit; } test_zips country => "San Marino", name => "San Marino zip codes", prefix => { iso => "SM", cept => "SM", invalid => "IT", }, prefix_test_set => [47892, 47897], ; done_testing; sub valid_zip_codes { 47890 .. 47899 } __END__ Regexp-Common-2017060201/t/zip/241_vatican-city.t000755 000765 000024 00000001140 13114353631 021543 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use warnings; no warnings 'syntax'; use lib "."; use Regexp::Common; use Test::More; use t::zip::Zip; my $r = eval "require Test::Regexp; 1"; unless ($r) { print "1..0 # SKIP Test::Regexp not found\n"; exit; } test_zips country => "Vatican City", name => "Vatican City zip codes", prefix => { iso => "VA", cept => "VA", invalid => "CH", }, prefix_test_set => [], ; done_testing; sub valid_zip_codes { "00120", } __END__ Regexp-Common-2017060201/t/zip/netherlands.t000755 000765 000024 00000020070 12116413566 021101 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use lib qw {blib/lib}; use Regexp::Common; use warnings; sub failures; use constant PASSES => 20; use constant FAIL => 10; my $count; my $normal = $RE {zip} {Netherlands}; my $no_space = $RE {zip} {Dutch} {-sep => ""}; my $dash = $RE {zip} {Netherlands} {-sep => "-"}; my $prefix = $RE {zip} {Dutch} {-prefix => "yes"}; my $no_prefix = $RE {zip} {Netherlands} {-prefix => "no"}; my $iso = $RE {zip} {Dutch} {-country => "iso"}; my $cept = $RE {zip} {Netherlands} {-country => "cept"}; my $country = $RE {zip} {Dutch} {-country => "NLD"}; my $dash_prefix = $dash -> {-prefix => "yes"}; my $dash_no_prefix = $dash -> {-prefix => "no"}; my @tests = ( [ normal => $normal => [qw /1 1 0 0 0 0 0/]], [ no_space => $no_space => [qw /0 0 1 1 0 0 0/]], [ dash => $dash => [qw /0 0 0 0 1 1 0/]], [ prefix => $prefix => [qw /0 1 0 0 0 0 0/]], ['no prefix' => $no_prefix => [qw /1 0 0 0 0 0 0/]], [ iso => $iso => [qw /1 1 0 0 0 0 0/]], [ cept => $cept => [qw /1 1 0 0 0 0 0/]], [ country => $country => [qw /1 0 0 0 0 0 1/]], ['dash & prefix' => $dash_prefix => [qw /0 0 0 0 0 1 0/]], ['dash & no prefix' => $dash_no_prefix => [qw /0 0 0 0 1 0 0/]], ); my @failures = failures; sub mess {print ++ $count, " - $_ (@_)\n"} sub pass {print "ok "; &mess} sub fail {print "not ok "; &mess} my $max = 1 + 2 * @tests * @{$tests [0] -> [2]} * PASSES + @failures * @tests; print "1..$max\n"; print "ok ", ++ $count, "\n"; sub run_test { my ($name, $re, $should_match) = @_; my $match = /^$re$/; my $line = $match ? "match" : "no match"; $line .= "; $name"; ($match xor $should_match) ? fail $line : pass $line } sub __ {map {defined () ? $_ : "UNDEF"} @_} sub run_keep { my ($name, $re, $should_match) = splice @_ => 0, 3; unless ($should_match) { if (/^$re$/) {fail "match; keep - $name"} else {pass "no match; keep - $name"} return; } my @exp = ($_, $_ [0], join ("" => grep {defined} @_ [1 .. 3]), @_ [1 .. 3]); if (my @args = /^$re$/) { unshift @_ => $_; unless (@exp == @args) { fail "match; keep - $name [@{[__ @args]}]"; } foreach my $n (0 .. $#_) { unless (!defined $exp [$n] && !defined $args [$n] || defined $exp [$n] && defined $args [$n] && $exp [$n] eq $args [$n]) { fail "match; keep - $name [@{[__ @args]}]"; return; } } pass "match; keep - $name"; return; } fail "no match; keep - $name"; } sub _n { my $min = $_ [0]; my $max = @_ > 1 ? $_ [1] : $_ [0]; my $x = 1 + int rand 9; $x .= int rand 10 for 2 .. $_ [0] + int rand (1 + $max - $min); $x; } sub _l { my $min = $_ [0]; my $max = @_ > 1 ? $_ [1] : $_ [0]; my @l = ('A' .. 'Z'); my $x = ""; $x .= $l [int rand @l] for 1 .. $_ [0] + int rand (1 + $max - $min); $x; } my %cache; foreach my $d (1 .. PASSES) { my $n = _n 4; my $l = _l 2; $l = _l 2 while $l =~ /[FIOQUY]/ || $l =~ /S[ADS]/; redo if $cache {"$n $l"}; my @t = ([undef, $n, " ", $l], ["NL", $n, " ", $l], [undef, $n, "", $l], ["NL", $n, "", $l], [undef, $n, "-", $l], ["NL", $n, "-", $l], ["NLD", $n, " ", $l]); my $c = 0; foreach my $t (@t) { local $_ = defined $t -> [0] ? $t -> [0] . "-" : ""; $_ .= join "" => grep {defined} @{$t} [1 .. 3]; foreach my $test (@tests) { my ($name, $re, $matches) = @$test; run_test $name, $re, $matches -> [$c]; run_keep $name, $re -> {-keep}, $matches -> [$c], @$t; } $c ++; } } foreach (@failures) { foreach my $test (@tests) { my ($name, $re) = @$test; /^$re$/ ? fail "match; $name" : pass "no match; $name"; } } sub failures { my @failures = ("", " "); # Zip starting with '0'. foreach (1 .. FAIL) { my $x = _n 4; $x =~ s/^./0/; my $y .= _l 2; $y = _l 2 while $y =~ /[FIOQUY]/ || $y =~ /S[ADS]/; redo if $cache {"$x $y"} ++; push @failures => "$x $y"; } # Too few numbers. foreach (1 .. FAIL) { my $x = _n 1, 3; my $y .= _l 2; $y = _l 2 while $y =~ /[FIOQUY]/ || $y =~ /S[ADS]/; redo if $cache {"$x $y"} ++; push @failures => "$x $y"; } # Too many numbers. foreach (1 .. FAIL) { my $x = _n 5, 10; my $y .= _l 2; $y = _l 2 while $y =~ /[FIOQUY]/ || $y =~ /S[ADS]/; redo if $cache {"$x $y"} ++; push @failures => "$x $y"; } # Too few letters. foreach (1 .. FAIL) { my $x = _n 4; my $y .= _l 1; $y = _l 1 while $y =~ /[FIOQUY]/ || $y =~ /S[ADS]/; redo if $cache {"$x $y"} ++; push @failures => "$x $y"; } # Too many letters. foreach (1 .. FAIL) { my $x = _n 4; my $y .= _l 3, 6; $y = _l 3, 6 while $y =~ /[FIOQUY]/ || $y =~ /S[ADS]/; redo if $cache {"$x $y"} ++; push @failures => "$x $y"; } # Wrong letters. foreach (1 .. FAIL) { my $x = _n 4; my $y .= _l 2; $y = _l 2 until $y =~ /[FIOQUY]/; redo if $cache {"$x $y"} ++; push @failures => "$x $y"; } # Wrong letter combos. foreach (1 .. FAIL) { my $x = _n 4; my $y .= ('SA', 'SD', 'SS') [rand 3]; redo if $cache {"$x $y"} ++; push @failures => "$x $y"; } # Wrong separator. foreach (1 .. FAIL) { my $x = _n 4; my $y .= _l 2; $y = _l 2 while $y =~ /[FIOQUY]/ || $y =~ /S[ADS]/; my $s = int rand 256; redo if +($s & 0x7F) < 0x20; $s = chr $s; redo if $s eq ' ' || $s eq '-'; redo if $cache {"$x$s$y"} ++; push @failures => "$x$s$y"; } # Lowercase letters. foreach (1 .. FAIL) { my $x = _n 4; my $y .= _l 1; $y = _l 1 while $y =~ /[FIOQUY]/ || $y =~ /S[ADS]/; $y = lc $y; redo if $cache {"$x $y"} ++; push @failures => "$x $y"; } # Letters, then numbers. foreach (1 .. FAIL) { my $x = _n 4; my $y .= _l 2; $y = _l 2 while $y =~ /[FIOQUY]/ || $y =~ /S[ADS]/; redo if $cache {"$y $x"} ++; push @failures => "$y $x"; } # Leading/trailing garbage. foreach (1 .. FAIL) { my $x = _n 4; my $y .= _l 2; $y = _l 2 while $y =~ /[FIOQUY]/ || $y =~ /S[ADS]/; redo if $cache {" $x $y"} ++ or $cache {"$x $y "} ++; push @failures => " $x $y", "$x $y "; } push @failures => map {"NL-$_"} @failures; # Wrong countries. foreach (1 .. FAIL) { my $x = _n 4; my $y .= _l 2; $y = _l 2 while $y =~ /[FIOQUY]/ || $y =~ /S[ADS]/; my $c = _l 2; $c = _l 2 while $c eq "NL"; redo if $cache {"$c-$x $y"} ++; push @failures => "$c-$x $y"; } # Lowercase countries. foreach (1 .. FAIL) { my $x = _n 4; my $y .= _l 2; $y = _l 2 while $y =~ /[FIOQUY]/ || $y =~ /S[ADS]/; redo if $cache {"nl-$x $y"} ++; push @failures => "nl-$x $y"; } # Too many letters in country. foreach (1 .. FAIL) { my $x = _n 4; my $y .= _l 2; $y = _l 2 while $y =~ /[FIOQUY]/ || $y =~ /S[ADS]/; my $c = _l 1; $c = _l 1 while $c eq "D"; redo if $cache {"${c}NL-$x $y"} ++ || $cache {"NL$c-$x $y"} ++; push @failures => "${c}NL-$x $y"; push @failures => "NL$c-$x $y"; } @failures; }; __END__ Regexp-Common-2017060201/t/zip/spain.t000755 000765 000024 00000012112 12116413566 017702 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use lib qw {blib/lib}; use Regexp::Common; use warnings; sub passes; sub failures; use constant PASSES => 20; use constant FAIL => 5; my $normal = $RE {zip} {Spain}; my $prefix = $RE {zip} {Spain} {-prefix => 'yes'}; my $no_prefix = $RE {zip} {Spain} {-prefix => 'no'}; my $iso = $RE {zip} {Spain} {-country => "iso"}; my $cept = $RE {zip} {Spain} {-country => "cept"}; my $country = $RE {zip} {Spain} {-country => "ES"}; my $iso_prefix = $iso -> {-prefix => 'yes'}; my $cept_prefix = $cept -> {-prefix => 'yes'}; my @tests = ( [ normal => $normal => [qw /1 1 1/]], [ prefix => $prefix => [qw /0 1 1/]], ['no prefix' => $no_prefix => [qw /1 0 0/]], [ iso => $iso => [qw /1 0 1/]], [ cept => $cept => [qw /1 1 0/]], [ country => $country => [qw /1 0 1/]], ['iso prefix' => $iso_prefix => [qw /0 0 1/]], ['cept prefix' => $cept_prefix => [qw /0 1 0/]], ); my @failures = failures; my $count; sub mess {print ++ $count, " - $_ (@_)\n"} sub pass {print "ok "; &mess} sub fail {print "not ok "; &mess} my $m = 0; my $k = 0; foreach my $test (@tests) { $m ++ foreach @{$test -> [2]}; $k ++ foreach grep {$_} @{$test -> [2]}; } my $max = 1; $max += PASSES * $m; $max += PASSES * $k; $max += @failures * @tests; print "1..$max\n"; print "ok ", ++ $count, "\n"; sub run_test { my ($name, $re, $should_match) = @_; my $match = "<<$_>>" =~ /$re/; my $good = $match && $_ eq $&; my $line = $good ? "match" : $match ? "wrong match (got: $&)" : "no match"; $line .= "; $name"; if ($should_match) {$good ? pass $line : fail $line} else {$good ? fail $line : pass $line} } sub array_cmp { my ($a1, $a2) = @_; return 0 unless @$a1 eq @$a2; foreach my $i (0 .. $#$a1) { !defined $$a1 [$i] && !defined $$a2 [$i] || defined $$a1 [$i] && defined $$a2 [$i] && $$a1 [$i] eq $$a2 [$i] or return 0; } return 1; } sub __ {map {defined () ? $_ : "UNDEF"} @_} sub run_keep { my ($name, $re, $parts) = @_; my @chunks = /^$re->{-keep}$/; unless (@chunks) {fail "no match; $name - keep"; return} array_cmp (\@chunks, [$_ => @$parts]) ? pass "match; $name - keep" : fail "wrong match [@{[__ @chunks]}]; $name - keep" } sub _ { my $min = $_ [0]; my $max = @_ > 1 ? $_ [1] : $_ [0]; my $x = ""; $x .= int rand 10 for 1 .. $_ [0] + int rand (1 + $max - $min); $x; } my %cache; foreach my $d (1 .. PASSES) { my ($x, $y, $z) = qw /01 0 00/; while ($cache {"$x$y$z"} ++) { $x = _ 2; redo unless 00 < $x && $x <= 52; $y = _ 1; $z = _ 2; } my @t = ([undef, "$x$y$z", $x, $y, $z], ["E", "$x$y$z", $x, $y, $z], ["ES", "$x$y$z", $x, $y, $z]); my $c = 0; foreach my $t (@t) { local $_ = defined $t -> [0] ? $t -> [0] . "-" : ""; $_ .= join "" => @$t [2 .. 4]; foreach my $test (@tests) { my ($name, $re, $matches) = @$test; run_test $name, $re, $matches -> [$c]; run_keep $name, $re -> {-keep}, $t if $matches -> [$c]; } $c ++; } } foreach (@failures) { foreach my $test (@tests) { my ($name, $re) = @$test; /^$re$/ ? fail "match; $name" : pass "no match; $name"; } } sub failures { my @failures = ("", " "); # Too short. push @failures => 0 .. 9; for (1 .. FAIL) { my $x = _ 2, 4; redo if $cache {$x} ++; push @failures => $x; } # Too long. for (1 .. FAIL) { my $x = _ 6, 10; redo if $cache {$x} ++; push @failures => $x; } for my $c ('.', ';', '-', ' ', '+') { for (1 .. FAIL) { my $x = _ 4; $x .= $c; redo if $cache {$x} ++; push @failures => $x; } for (1 .. FAIL) { my $x = _ 4; $x = "$c$x"; redo if $cache {$x} ++; push @failures => $x; } } # Wrong provinces. for (1 .. FAIL) { my $x = _ 2; redo if $x <= 52; my $y = _ 3; redo if $cache {"$x$y"}; push @failures => "$x$y"; } push @failures => "00" . _ 3; # Same failures, with country in front of it as well. push @failures => map {("ES-$_", "E-$_")} @failures; # Wrong countries. for (1 .. FAIL) { my $c = join "" => map {('A' .. 'Z') [rand 26]} 1 .. 2; redo if $c eq "ES" || $c eq "E" || $cache {$c} ++; my $x = _ 5; push @failures => "$c-$x"; } for (1 .. FAIL) { my $c = ('A' .. 'Z') [rand 26]; redo if $cache {$c} ++; my $x = _ 5; push @failures => "${c}ES-$x"; push @failures => "ES$c-$x"; } for (1 .. FAIL) { my $x = _ 5; redo if $cache {"es-$x"} ++; push @failures => "es-$x", "e-$x"; } @failures; } __END__ Regexp-Common-2017060201/t/zip/us.t000755 000765 000024 00000025441 13070654573 017235 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use lib qw {blib/lib}, "."; use Regexp::Common qw /RE_zip_US/; use t::Common qw /run_new_tests cross gimme sample pdd/; use warnings; my $basic = $RE {zip} {US}; my $ext_yes = $RE {zip} {US} {-extended => 'yes'}; my $ext_no = $RE {zip} {US} {-extended => 'no'}; my $prf_yes = $RE {zip} {US} {-prefix => 'yes'}; my $prf_no = $RE {zip} {US} {-prefix => 'no'}; my $sep_sp = $basic -> {-sep => " "}; my $sep_dsh = $basic -> {-sep => "--"}; my $sep_rg = $basic -> {-sep => "[- ]"}; my $iso = $RE {zip} {US} {-country => 'iso'}; my $cept = $RE {zip} {US} {-country => 'cept'}; my $usa = $RE {zip} {US} {-country => 'usa'}; my $iso_py = $iso -> {-prefix => 'yes'}; my $iso_pn = $iso -> {-prefix => 'no'}; my $cept_py = $cept -> {-prefix => 'yes'}; my $cept_pn = $cept -> {-prefix => 'no'}; my $all = $RE {zip} {US} {-country => 'iso'} {-prefix => 'yes'} {-extended => 'yes'} {-sep => '[- ]'}; my @zips = ("00000", gimme 10, sub {pdd 5}); my @ext = ("0000", gimme 5, sub {pdd 4}); my @zip_ext = (["00000", "0000"], cross (["00000"], [gimme 2 => sub {pdd 4}]), cross ([gimme 2 => sub {pdd 5}], ["0000"]), sample 10 => cross [gimme 5 => sub {pdd 5}], [gimme 5 => sub {pdd 4}]); my @bad_zip = ("0000", "000000", gimme (10 => sub {pdd 2, 4}), # Too short. gimme (10 => sub {pdd 6, 8})); # Too long. my @bad_ext = ("000", "0000", gimme (10 => sub {pdd 1, 3}), # Too short. gimme (10 => sub {pdd 5, 8})); # Too long. my @baddies = @bad_zip; # Basic bad zips. push @baddies => map {join "-" => @_} sample 10 => cross \@zips, \@bad_ext; # Bad extensions. push @baddies => map {join ["\n", qw {_ ! & ---}] -> [rand 5] => @_} sample 10 => cross \@zips, \@ext; # Bad separator. push @baddies => map {"USS-$_"} @zips; # Bad countries. my (@tests, %targets); $targets {simple} = { list => \@zips, wanted => sub {$_, undef, join ("-" => @_), $_ [0], substr ($_ [0], 0, 3), substr ($_ [0], 3, 2), undef, undef, undef, undef,}, }; $targets {simple_USA} = { list => [@zips [0 .. 4]], query => sub {join "-" => "USA", $_ [0]}, wanted => sub {$_, "USA", join ("-" => @_), $_ [0], substr ($_ [0], 0, 3), substr ($_ [0], 3, 2), undef, undef, undef, undef,}, }; $targets {simple_US} = { list => [@zips [0 .. 4]], query => sub {join "-" => "US", $_ [0]}, wanted => sub {$_, "US", join ("-" => @_), $_ [0], substr ($_ [0], 0, 3), substr ($_ [0], 3, 2), undef, undef, undef, undef,}, }; $targets {simple_usa} = { list => [@zips [0 .. 4]], query => sub {join "-" => "usa", $_ [0]}, wanted => sub {$_, "usa", join ("-" => @_), $_ [0], substr ($_ [0], 0, 3), substr ($_ [0], 3, 2), undef, undef, undef, undef,}, }; $targets {extended} = { list => \@zip_ext, query => sub {join "-" => @_}, wanted => sub {$_, undef, join ("-" => @_), $_ [0], substr ($_ [0], 0, 3), substr ($_ [0], 3, 2), "-", $_ [1], substr ($_ [1], 0, 2), substr ($_ [1], 2, 2)}, }; $targets {extended_USA} = { list => \@zip_ext, query => sub {join "-" => "USA", @_}, wanted => sub {$_, "USA", join ("-" => @_), $_ [0], substr ($_ [0], 0, 3), substr ($_ [0], 3, 2), "-", $_ [1], substr ($_ [1], 0, 2), substr ($_ [1], 2, 2)}, }; $targets {extended_US} = { list => \@zip_ext, query => sub {join "-" => "US", @_}, wanted => sub {$_, "US", join ("-" => @_), $_ [0], substr ($_ [0], 0, 3), substr ($_ [0], 3, 2), "-", $_ [1], substr ($_ [1], 0, 2), substr ($_ [1], 2, 2)}, }; $targets {extended_US_sp} = { list => \@zip_ext, query => sub {"US-" . $_ [0] . " " . $_ [1]}, wanted => sub {$_, "US", join (" " => @_), $_ [0], substr ($_ [0], 0, 3), substr ($_ [0], 3, 2), " ", $_ [1], substr ($_ [1], 0, 2), substr ($_ [1], 2, 2)}, }; $targets {sep_sp} = { list => \@zip_ext, query => sub {join " " => @_}, wanted => sub {$_, undef, join (" " => @_), $_ [0], substr ($_ [0], 0, 3), substr ($_ [0], 3, 2), " ", $_ [1], substr ($_ [1], 0, 2), substr ($_ [1], 2, 2)}, }; $targets {sep_dashes} = { list => \@zip_ext, query => sub {join "--" => @_}, wanted => sub {$_, undef, join ("--" => @_), $_ [0], substr ($_ [0], 0, 3), substr ($_ [0], 3, 2), "--", $_ [1], substr ($_ [1], 0, 2), substr ($_ [1], 2, 2)}, }; $targets {bad_zip} = { list => \@baddies, }; push @tests => { name => 'basic', regex => $basic, sub => \&RE_zip_US, pass => [qw /simple simple_USA simple_US extended extended_USA extended_US/], fail => [qw /bad_zip sep_sp sep_dashes simple_usa extended_US_sp/], }; push @tests => { name => 'usa', regex => $usa, sub => \&RE_zip_US, sub_args => [-country => 'usa'], pass => [qw /simple simple_usa extended/], fail => [qw /bad_zip sep_sp sep_dashes simple_USA extended_USA simple_US extended_US extended_US_sp/], }; push @tests => { name => 'iso', regex => $iso, sub => \&RE_zip_US, sub_args => [-country => 'iso'], pass => [qw /simple simple_US extended extended_US/], fail => [qw /bad_zip sep_sp sep_dashes simple_USA extended_USA simple_usa extended_US_sp/], }; push @tests => { name => 'iso_py', regex => $iso_py, sub => \&RE_zip_US, sub_args => [-country => 'iso', -prefix => 'yes'], pass => [qw /simple_US extended_US/], fail => [qw /bad_zip sep_sp sep_dashes simple_USA extended_USA extended_US_sp simple extended simple_usa/], }; push @tests => { name => 'iso_pn', regex => $iso_pn, sub => \&RE_zip_US, sub_args => [-country => 'iso', -prefix => 'no'], pass => [qw /simple extended/], fail => [qw /bad_zip sep_sp sep_dashes simple_USA extended_USA extended_US extended_US_sp simple_US simple_usa/], }; push @tests => { name => 'cept_py', regex => $cept_py, sub => \&RE_zip_US, sub_args => [-country => 'cept', -prefix => 'yes'], pass => [qw /simple_USA extended_USA/], fail => [qw /bad_zip sep_sp sep_dashes simple_US simple extended extended_US extended_US_sp simple_usa/], }; push @tests => { name => 'cept_pn', regex => $cept_pn, sub => \&RE_zip_US, sub_args => [-country => 'cept', -prefix => 'no'], pass => [qw /simple extended/], fail => [qw /bad_zip sep_sp sep_dashes simple_USA extended_USA extended_US extended_US_sp simple_US simple_usa/], }; push @tests => { name => 'cept', regex => $cept, sub => \&RE_zip_US, sub_args => [-country => 'cept'], pass => [qw /simple simple_USA extended extended_USA/], fail => [qw /bad_zip sep_sp sep_dashes simple_US simple_usa extended_US extended_US_sp/], }; push @tests => { name => 'ext_yes', regex => $ext_yes, sub => \&RE_zip_US, sub_args => [-extended => 'yes'], pass => [qw /extended extended_USA extended_US/], fail => [qw /simple simple_USA simple_US bad_zip sep_sp sep_dashes simple_usa extended_USA_sp/], }; push @tests => { name => 'ext_no', regex => $ext_no, sub => \&RE_zip_US, sub_args => [-extended => 'no'], pass => [qw /simple simple_USA simple_US/], fail => [qw /extended extended_USA bad_zip sep_sp sep_dashes simple_usa extended_US_sp extended_US/], }; push @tests => { name => 'prf_yes', regex => $prf_yes, sub => \&RE_zip_US, sub_args => [-prefix => 'yes'], pass => [qw /simple_USA simple_US extended_USA extended_US/], fail => [qw /simple extended bad_zip sep_sp sep_dashes simple_usa extended_US_sp/], }; push @tests => { name => 'prf_no', regex => $prf_no, sub => \&RE_zip_US, sub_args => [-prefix => 'no'], pass => [qw /simple extended/], fail => [qw /simple_USA simple_US extended_USA bad_zip sep_sp extended_US extended_US_sp sep_dashes simple_usa/], }; push @tests => { name => 'sep space', regex => $sep_sp, sub => \&RE_zip_US, sub_args => [-sep => ' '], pass => [qw /simple simple_USA simple_US sep_sp extended_US_sp/], fail => [qw /bad_zip sep_dashes extended extended_USA extended_US simple_usa/], }; push @tests => { name => 'sep dashes', regex => $sep_dsh, sub => \&RE_zip_US, sub_args => [-sep => '--'], pass => [qw /simple simple_USA simple_US sep_dashes/], fail => [qw /bad_zip sep_sp extended extended_USA simple_usa extended_US extended_US_sp/], }; push @tests => { name => 'sep regex', regex => $sep_rg, sub => \&RE_zip_US, sub_args => [-sep => '[- ]'], pass => [qw /simple simple_USA simple_US sep_sp extended extended_USA extended_US extended_US_sp/], fail => [qw /bad_zip sep_dashes simple_usa/], }; push @tests => { name => 'all', regex => $all, sub => \&RE_zip_US, sub_args => [-country => 'iso', -prefix => 'yes', -extended => 'yes', -sep => '[- ]'], pass => [qw /extended_US extended_US_sp/], fail => [qw /simple simple_USA simple_US bad_zip sep_sp sep_dashes simple_usa extended extended_USA/], }; run_new_tests tests => \@tests, targets => \%targets, version_from => 'Regexp::Common::zip', version => 5.00503, ; __END__ Regexp-Common-2017060201/t/zip/Zip.pm000644 000765 000024 00000011273 12724401535 017505 0ustar00abigailstaff000000 000000 package t::zip::Zip; use 5.010; use strict; use warnings; no warnings 'syntax'; use Exporter (); our @EXPORT = qw [test_zips]; our @ISA = qw [Exporter]; use Regexp::Common; # # A method to test a common situation for zip codes # sub test_zips { my (%args) = @_; my ($call_pkg) = caller; # # Fetch the valid zip codes # my @valid = $call_pkg -> valid_zip_codes; my %valid = map {$_ => 1} @valid; my $length = length $valid [0]; my $from = "0" x $length; my $to = "9" x $length; my $country = $args {country}; my $name = $args {name}; my $Test = Test::Regexp:: -> new -> init ( pattern => $RE {zip} {$country}, keep_pattern => $RE {zip} {$country} {-keep}, name => $name, ); # # Test whether zip codes are valid or not # foreach my $zip ($from .. $to) { if ($valid {$zip}) { $Test -> match ($zip, [$zip, undef, $zip], test => "Postal code $zip"); } else { $Test -> no_match ($zip, reason => "Invalid zip code $zip"); } } my @test_set = ($valid [0], @{$args {prefix_test_set} || []}, $valid [-1]); # # Test illegal things # $Test -> no_match ("", reason => "Empty string should not match"); foreach my $zip (@test_set) { $Test -> no_match (" $zip", reason => "Leading garbage not allowed"); $Test -> no_match ("$zip ", reason => "Trailing garbage not allowed"); } # # Test prefixes # my $prefix_iso = $args {prefix} {iso}; my $prefix_cept = $args {prefix} {cept}; my $prefix_invalid = $args {prefix} {invalid}; my $Test_none = Test::Regexp:: -> new -> init ( pattern => $RE {zip} {$country} {-prefix => 'no'}, keep_pattern => $RE {zip} {$country} {-prefix => 'no'} {-keep}, name => "$name (no prefix allowed)", ); my $Test_iso = Test::Regexp:: -> new -> init ( pattern => $RE {zip} {$country} {-prefix => 'yes'} {-country => 'iso'}, keep_pattern => $RE {zip} {$country} {-prefix => 'yes'} {-country => 'iso'} {-keep}, name => "$name (ISO prefix required)", ); my $Test_cept = Test::Regexp:: -> new -> init ( pattern => $RE {zip} {$country} {-prefix => 'yes'} {-country => 'cept'}, keep_pattern => $RE {zip} {$country} {-prefix => 'yes'} {-country => 'cept'} {-keep}, name => "$name (CEPT prefix required)", ); foreach my $zip (@test_set) { # # No prefix # $Test_none -> match ($zip, [$zip, undef, $zip], test => "No prefix used"); $Test_iso -> no_match ($zip, reason => "No prefix used"); $Test_cept -> no_match ($zip, reason => "No prefix used"); # # ISO prefix # my $iso_zip = "$prefix_iso-$zip"; $Test -> match ($iso_zip, [$iso_zip, $prefix_iso, $zip], test => "Use ISO prefix"); $Test_none -> no_match ($iso_zip, reason => "Prefix not allowed"); $Test_iso -> match ($iso_zip, [$iso_zip, $prefix_iso, $zip], test => "Use ISO prefix"); if ($prefix_iso ne $prefix_cept) { $Test_none -> no_match ($iso_zip, reason => "ISO prefix not allowed"); } # # CEPT prefix # my $cept_zip = "$prefix_cept-$zip"; $Test -> match ($cept_zip, [$cept_zip, $prefix_cept, $zip], test => "Use CEPT prefix"); $Test_none -> no_match ($cept_zip, reason => "Prefix not allowed"); if ($prefix_iso ne $prefix_cept) { $Test_iso -> no_match ($cept_zip, reason => "CEPT prefix not allowed"); } $Test_cept -> match ($cept_zip, [$cept_zip, $prefix_cept, $zip], test => "Use CEPT prefix"); my $invalid_zip = "$prefix_invalid-$zip"; foreach my $test ($Test, $Test_none, $Test_iso, $Test_cept) { $test -> no_match ("$prefix_invalid-$zip", reason => "Invalid prefix"); } } } 1; __END__ Regexp-Common-2017060201/t/zip/zip.t000755 000765 000024 00000004410 12724355563 017403 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use lib qw {blib/lib}; use Regexp::Common; use warnings; my @tests__ = ("", "\n", "hello, world"); my %tests_t = ( "{1,1}" => [qw [y yes Y YES YeLLow]], "{0,0}" => [qw [n no N NO Nano]], "{0,1}" => [qw [R blue maroon], "\n", "", " ", undef, "\nn"], ); # # Cut and paste from Regexp::Common::zip # my %code = ( Austria => [qw /AU?T AT AUT/], Australia => [qw /AUS? AU AUS/], Belgium => [qw /BE? BE B/], Denmark => [qw /DK DK DK/], France => [qw /FR? FR F/], Germany => [qw /DE? DE D/], Greenland => [qw /GL GL GL/], Italy => [qw /IT? IT I/], Netherlands => [qw /NL NL NL/], Norway => [qw /NO? NO N/], Spain => [qw /ES? ES E/], USA => [qw /USA? US USA/], ); my $tests = @tests__ + 2; $tests += @$_ for values %tests_t; $tests += 1; $tests += keys %code; print "1..$tests\n"; my $count = 0; # # Test the __ subroutine. # foreach my $test (@tests__) { my $ret = Regexp::Common::zip::__ $test; printf "%s %d\n" => defined $ret && $ret eq $test ? "ok" : "not ok", ++ $count; } my $ret1 = Regexp::Common::zip::__ undef; my $ret2 = Regexp::Common::zip::__; printf "%s %d\n" => defined $ret1 && $ret1 eq "" ? "ok" : "not ok", ++ $count; printf "%s %d\n" => defined $ret2 && $ret2 eq "" ? "ok" : "not ok", ++ $count; # # Test the _t subroutine # while (my ($ret, $tests) = each %tests_t) { foreach my $test (@$tests) { my $r = Regexp::Common::zip::_t $test; printf "%s %d\n" => defined $r && $r eq $ret ? "ok" : "not ok", ++ $count; } } my $r = Regexp::Common::zip::_t; printf "%s %d\n" => defined $r && $r eq "{0,1}" ? "ok" : "not ok", ++ $count; # # Test the _c subroutine - we don't have to test all the possible # returned values - that's already done from the various country # specific tests. In fact, all we need to test is giving an # undefined second parameter. # while (my ($name, $codes) = each %code) { my $r = Regexp::Common::zip::_c $name; printf "%s %d\n" => defined $r && $r eq $$codes [0] ? "ok" : "not ok", ++ $count; } __END__ Regexp-Common-2017060201/t/URI/any.t000755 000765 000024 00000012167 12116413566 017226 0ustar00abigailstaff000000 000000 # VOODOO LINE-NOISE my($C,$M,$P,$N,$S);END{print"1..$C\n$M";print"\nfailed: $N\n"if$N} sub ok{$C++; $M.= ($_[0]||!@_)?"ok $C\n":($N++,"not ok $C (". ((caller 1)[1]||(caller 0)[1]).":".((caller 1)[2]||(caller 0)[2]).")\n")} sub try{$P=qr/^$_[0]$/}sub fail{ok($S=$_[0]!~$P)}sub pass{ok($S=$_[0]=~$P)} # LOAD use Regexp::Common; ok; # TEST URIs try $RE{URI}; for my $scheme (qw [http https]) { pass "$scheme://www.example.com"; pass "$scheme://www.example.com/"; pass "$scheme://www.example.com/some/file/some/where"; pass "$scheme://www.example.com/some/directory/some/where"; pass "$scheme://www.example.com:80/some/file"; pass "$scheme://127.0.0.1"; pass "$scheme://127.0.0.1/"; pass "$scheme://127.0.0.1:12345/some/file"; pass "$scheme://www.example.com:80/some/path?query"; pass "$scheme://www.example.com/%7Eabigail/"; # Test "safe" chars. pass "$scheme://www.example.com/--_\$.+++"; pass "$scheme://www.example.com/."; # Test "extra" chars. pass "$scheme://www.example.com/**!(),,''"; # Test HTTP additional chars. pass "$scheme://www.example.com/:;\@=&=;"; pass "$scheme://www.example.com/some/path?query"; pass "$scheme://www.example.com/some/path?funny**!(),,:;\@=&="; pass "$scheme://www.example.com/some/?"; pass "$scheme://www.example.com/?"; pass "$scheme://www.example.com//////////////"; # Usernames/passwords are NOT allowed in http URIs. fail "$scheme://abigail\@www.example.com"; fail "$scheme://abigail\@www.example.com:80/some/file"; fail "$scheme://abigail:secret\@www.example.com:80/some/file"; fail "$scheme://abigail:secret\@127.0.0.1:80/some/file"; # ~ was NOT allowed by RFC 1738, but currently is. pass "$scheme://www.example.com/~abigail/"; # Fail on "national" characters. fail "$scheme://www.example.com/nope|nope"; fail "$scheme://www.example.com/`"; # Fail on "punctation" characters. fail "$scheme://www.example.com/some/file#target"; # Two question marks used to be failure, but is now allowed. pass "$scheme://www.example.com/some/path?query1?query2"; pass "$scheme://www.example.com/some/??"; # Can have slashes in query. pass "$scheme://www.example.com/some/path?query/path"; } # Scheme must be lower case, and correct. fail 'HTTP://www.example.com/'; fail 'HTTPS://www.example.com/'; pass 'ftp://ftp.example.com'; pass 'ftp://ftp.example.com/'; pass 'ftp://ftp.example.com/some/file/some/where'; pass 'ftp://ftp.example.com/some/directory/some/where/'; pass 'ftp://ftp.example.com:21/some/file'; pass 'ftp://127.0.0.1'; pass 'ftp://127.0.0.1/'; pass 'ftp://127.0.0.1:12345/some/file'; pass 'ftp://ftp.example.com/%7Eabigail/'; fail 'ftp://ftp.example.com:21/some/path?query'; # Test "safe" chars. pass 'ftp://ftp.example.com/--_$.+++'; pass 'ftp://ftp.example.com/.'; # Test "extra" chars. pass "ftp://ftp.example.com/**!(),,''"; # Test URI additional chars. pass 'ftp://www.example.com/:@=&='; pass 'ftp://www.example.com//////////////'; # Should fail on ';'. fail 'ftp://www.example.com/some/path;here'; # Usernames/passwords are allowed in ftp URIs. pass 'ftp://abigail@ftp.example.com'; pass 'ftp://abigail@ftp.example.com:21/some/file'; pass 'ftp://abigail:secret@ftp.example.com:21/some/file'; pass 'ftp://abigail:secret@127.0.0.1:21/some/file'; pass 'ftp://abigail:secret:here@127.0.0.1:21/some/file'; # ~ was NOT allowed by RFC 1738, but currently is. pass 'ftp://ftp.example.com/~abigail/'; # Fail on "national" characters. fail 'ftp://ftp.example.com/nope|nope'; fail 'ftp://ftp.example.com/`'; # Fail on "punctation" characters. fail 'ftp://www.example.com/some/file#target'; # Cannot have queries. fail 'ftp://ftp.example.com/some/path?query1?query2'; fail 'ftp://ftp.example.com/some/??'; fail 'ftp://ftp.example.com/some/path?query/path'; # Test type. pass 'ftp://ftp.example.com/some/path;type=A'; pass 'ftp://ftp.example.com/some/path;type=i'; pass 'ftp://abigail@ftp.example.com/some/path/somewhere;type=a', fail 'ftp://ftp.example.com/some/path;type=Q'; fail 'ftp://ftp.example.com/some/path;type=AI'; pass 'ftp://ftp.example.com/;type=I'; # Scheme must be lower case, and correct. fail 'HTTP://ftp.example.com/'; fail 'FTP://ftp.example.com/'; fail 'feeble://ftp.example.com/'; pass 'tel:+12345'; pass 'tel:+358-555-1234567'; pass 'tel:456-7890;phone-context=213'; pass 'tel:456-7890;phone-context=X-COMPANY-NET'; pass 'tel:+1-212-555-1234;tsp=terrifictelecom.com'; pass 'tel:+1-212-555-1234;tsp=terrifictelecom.com;phone-context=X-COMPANY-NET'; pass 'tel:+358-555-1234567;postd=pp22'; pass 'tel:0w003585551234567;phone-context=+3585551234'; pass 'tel:+1234567890;phone-context=+1234;vnd.company.option=foo'; pass 'tel:+1234567890;phone-context=+1234;vnd.company.option=%22foo%22'; pass 'tel:+1234;option=%22!%22'; pass 'tel:+1234;option=%22%5C%22%22'; pass 'tel:+1234;option=%22%5C!%22'; pass 'tel:+1234;option=%22bar%22'; pass 'tel:+456-7890;phone-context=213;phone-context=213'; pass 'tel:456-7890;phone-context=213;phone-context=213'; fail 'tel:456-7890'; fail 'tel:+1-800-RUN-PERL'; fail 'tel:+1234;option=%22%22%22'; fail 'tel:+1234;option=%22%5C%22'; pass 'tel:+123-456-789;isub=123(456)'; pass 'tel:+123456;postd=***'; # RT 52309 This 'hangs' pass 'news:comp.infosystems.www.servers.unix'; Regexp-Common-2017060201/t/URI/fax.t000755 000765 000024 00000006645 12116413566 017221 0ustar00abigailstaff000000 000000 # VOODOO LINE-NOISE my($C,$M,$P,$N,$S);END{print"1..$C\n$M";print"\nfailed: $N\n"if$N} sub ok{$C++; $M.= ($_[0]||!@_)?"ok $C\n":($N++,"not ok $C (". ((caller 1)[1]||(caller 0)[1]).":".((caller 1)[2]||(caller 0)[2]).")\n")} sub try{$P=qr/^$_[0]$/}sub fail{ok($S=$_[0]!~$P)}sub pass{ok($S=$_[0]=~$P)} # LOAD use Regexp::Common; ok; # TEST URIs try $RE{URI}{fax}; pass 'fax:+12345'; pass 'fax:+358-555-1234567'; pass 'fax:456-7890;phone-context=213'; pass 'fax:456-7890;phone-context=X-COMPANY-NET'; pass 'fax:+1-212-555-1234;tsp=terrifictelecom.com'; pass 'fax:+1-212-555-1234;tsp=terrifictelecom.com;phone-context=X-COMPANY-NET'; pass 'fax:+358-555-1234567;postd=pp22'; pass 'fax:0w003585551234567;phone-context=+3585551234'; pass 'fax:+1234567890;phone-context=+1234;vnd.company.option=foo'; pass 'fax:+1234567890;phone-context=+1234;vnd.company.option=%22foo%22'; pass 'fax:+1234;option=%22!%22'; pass 'fax:+1234;option=%22%5C%22%22'; pass 'fax:+1234;option=%22%5C!%22'; pass 'fax:+1234;option=%22bar%22'; pass 'fax:+456-7890;phone-context=213;phone-context=213'; pass 'fax:456-7890;phone-context=213;phone-context=213'; pass 'fax:+12345;tsub=0123456789-.()'; pass 'fax:+358-555-123456;tsub=0123456789-.()7'; pass 'fax:456-7890;tsub=0123456789-.();phone-context=213'; pass 'fax:456-7890;tsub=0123456789-.();phone-context=X-COMPANY-NET'; pass 'fax:+1-212-555-1234;tsub=0123456789-.();tsp=terrifictelecom.com;phone-context=X-COMPANY-NET'; fail 'fax:456-7890'; fail 'fax:+1-800-RUN-PERL'; fail 'fax:+1234;option=%22%22%22'; fail 'fax:+1234;option=%22%5C%22'; pass 'fax:+123-456-789;isub=123(456)'; pass 'fax:+123456;postd=***'; fail 'fax:456-7890;phone-context=213;tsub=0123456789-.()'; fail 'fax:456-7890;tsub=213;tsub=456'; fail 'fax:456-7890;tsub=213;'; try $RE{URI}{fax}{nofuture}; pass 'fax:+12345'; pass 'fax:+358-555-1234567'; pass 'fax:456-7890;phone-context=213'; pass 'fax:456-7890;phone-context=X-COMPANY-NET'; pass 'fax:+1-212-555-1234;tsp=terrifictelecom.com'; pass 'fax:+1-212-555-1234;tsp=terrifictelecom.com;phone-context=X-COMPANY-NET'; pass 'fax:+358-555-1234567;postd=pp22'; pass 'fax:0w003585551234567;phone-context=+3585551234'; fail 'fax:+1234567890;phone-context=+1234;vnd.company.option=foo'; fail 'fax:+1234567890;phone-context=+1234;vnd.company.option=%22foo%22'; fail 'fax:+1234;option=%22!%22'; fail 'fax:+1234;option=%22%5C%22%22'; fail 'fax:+1234;option=%22%5C!%22'; fail 'fax:+1234;option=%22bar%22'; pass 'fax:+456-7890;phone-context=213;phone-context=213'; pass 'fax:456-7890;phone-context=213;phone-context=213'; fail 'fax:456-7890'; fail 'fax:+1-800-RUN-PERL'; fail 'fax:+1234;option=%22%22%22'; fail 'fax:+1234;option=%22%5C%22'; fail 'fax:+358-555-1234567;phone-context=+1234;postd=pp22'; pass 'fax:+123-456-789;isub=123(456)'; fail 'fax:+123-456-789;isub=123(456);isub=123(456)'; fail 'fax:+123-456-789;isub=A23(456)'; pass 'fax:+123456;postd=***'; fail 'fax:1234567890;phone-context=+1234;vnd.company.option=foo'; fail 'fax:1234567890;phone-context=+1234;vnd.company.option=%22foo%22'; fail 'fax:1234;option=%22!%22'; fail 'fax:1234;option=%22%5C%22%22'; fail 'fax:1234;option=%22%5C!%22'; fail 'fax:1234;option=%22bar%22'; fail 'fax:+12345;tsub=foo'; fail 'fax:456-7890;tsub=213;tsub=456'; fail 'fax:456-7890;tsub=213;'; pass 'fax:456-7890;tsub=0123456789-.();phone-context=213'; pass 'fax:456-7890;tsub=0123456789-.();phone-context=X-COMPANY-NET'; pass 'fax:+1-212-555-1234;tsub=0123456789-.();tsp=terrifictelecom.com;phone-context=X-COMPANY-NET'; Regexp-Common-2017060201/t/URI/file.t000755 000765 000024 00000003277 13070654573 017365 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use lib qw {blib/lib}, "."; use Regexp::Common; use t::Common; $^W = 1; sub create_parts; my $file = $RE {URI} {file}; my @tests = ( [file => $file => {file => NORMAL_PASS | FAIL}], ); my ($good, $bad) = create_parts; run_tests version => "Regexp::Common::URI::file", tests => \@tests, good => $good, bad => $bad, query => \&file, wanted => \&wanted; sub file { my ($tag, $host, $path) = ($_ [0], @{$_ [1]}); my $file = "file://"; $file .= $host if defined $host; $file .= "/$path" if defined $path; $file; } sub wanted { my ($tag, $parts) = @_; my @wanted; $wanted [0] = $_; $wanted [1] = "file"; $wanted [2] = $$parts [0]; $wanted [2] .= "/" . $$parts [1] if defined $$parts [1]; $wanted [3] = $$parts [0]; $wanted [4] = "/" . $$parts [1] if defined $$parts [1]; $wanted [5] = $$parts [1]; \@wanted; } sub create_parts { my (@good, @bad); # Hosts. $good [0] = ["", qw /www.abigail.be www.PERL.com a.b.c.d.e.f.g.h.i.j.k.x 127.0.0.1 w--w--w.abigail.be w3.abigail.be/]; $bad [0] = [qw /www.example..com w+w.example.com w--.example.com 127.0.1 127.0.0.0.1 -w.example.com www.example.1com/]; # Paths. $good [1] = ["", qw {foo foo/bar/baz/bingo foo%00bar foo%EFbar %12%34%E6%7B %12%34/%E6%7B %12%34%E6%7B/foo ()() fnurd&.!@}]; $bad [1] = [undef, qw {foo<> foo<>bar ~abigail %GGfoo foo%F %FOfoo}, '#hubba']; return (\@good, \@bad); } __END__ Regexp-Common-2017060201/t/URI/ftp.t000755 000765 000024 00000014034 12116413566 017223 0ustar00abigailstaff000000 000000 # VOODOO LINE-NOISE my($C,$M,$P,$N,$S);END{print"1..$C\n$M";print"\nfailed: $N\n"if$N} sub ok{$C++; $M.= ($_[0]||!@_)?"ok $C\n":($N++,"not ok $C (". ((caller 1)[1]||(caller 0)[1]).":".((caller 1)[2]||(caller 0)[2]).")\n")} sub try{$P=qr/^$_[0]$/}sub fail{ok($S=$_[0]!~$P)}sub pass{ok($S=$_[0]=~$P)} # LOAD use Regexp::Common; ok; # TEST URIs try $RE{URI}{FTP}; pass 'ftp://ftp.example.com'; pass 'ftp://ftp.example.com/'; pass 'ftp://ftp.example.com/some/file/some/where'; pass 'ftp://ftp.example.com/some/directory/some/where/'; pass 'ftp://ftp.example.com:21/some/file'; pass 'ftp://127.0.0.1'; pass 'ftp://127.0.0.1/'; pass 'ftp://127.0.0.1:12345/some/file'; pass 'ftp://ftp.example.com/%7Eabigail/'; fail 'ftp://ftp.example.com:21/some/path?query'; # Test "safe" chars. pass 'ftp://ftp.example.com/--_$.+++'; pass 'ftp://ftp.example.com/.'; # Test "extra" chars. pass "ftp://ftp.example.com/**!(),,''"; # Test URI additional chars. pass 'ftp://www.example.com/:@=&='; pass 'ftp://www.example.com//////////////'; # Should fail on ';'. fail 'ftp://www.example.com/some/path;here'; # Usernames/passwords are allowed in ftp URIs. pass 'ftp://abigail@ftp.example.com'; pass 'ftp://abigail@ftp.example.com:21/some/file'; pass 'ftp://abigail:secret@ftp.example.com:21/some/file'; pass 'ftp://abigail:secret@127.0.0.1:21/some/file'; pass 'ftp://abigail:secret:here@127.0.0.1:21/some/file'; # ~ was NOT allowed by RFC 1738, but currently is. pass 'ftp://ftp.example.com/~abigail/'; # Fail on "national" characters. fail 'ftp://ftp.example.com/nope|nope'; fail 'ftp://ftp.example.com/`'; # Fail on "punctation" characters. fail 'ftp://www.example.com/some/file#target'; # Cannot have queries. fail 'ftp://ftp.example.com/some/path?query1?query2'; fail 'ftp://ftp.example.com/some/??'; fail 'ftp://ftp.example.com/some/path?query/path'; # Test type. pass 'ftp://ftp.example.com/some/path;type=A'; pass 'ftp://ftp.example.com/some/path;type=i'; pass 'ftp://abigail@ftp.example.com/some/path/somewhere;type=a', fail 'ftp://ftp.example.com/some/path;type=Q'; fail 'ftp://ftp.example.com/some/path;type=AI'; pass 'ftp://ftp.example.com/;type=I'; # Scheme must be lower case, and correct. fail 'HTTP://ftp.example.com/'; fail 'FTP://ftp.example.com/'; fail 'http://ftp.example.com/'; try $RE{URI}{FTP}{-password}; pass 'ftp://ftp.example.com'; pass 'ftp://ftp.example.com/'; pass 'ftp://ftp.example.com/some/file/some/where'; pass 'ftp://ftp.example.com/some/directory/some/where/'; pass 'ftp://ftp.example.com:21/some/file'; pass 'ftp://127.0.0.1'; pass 'ftp://127.0.0.1/'; pass 'ftp://127.0.0.1:12345/some/file'; pass 'ftp://ftp.example.com/%7Eabigail/'; fail 'ftp://ftp.example.com:21/some/path?query'; # Test "safe" chars. pass 'ftp://ftp.example.com/--_$.+++'; pass 'ftp://ftp.example.com/.'; # Test "extra" chars. pass "ftp://ftp.example.com/**!(),,''"; # Test URI additional chars. pass 'ftp://www.example.com/:@=&='; pass 'ftp://www.example.com//////////////'; # Should fail on ';'. fail 'ftp://www.example.com/some/path;here'; # Usernames/passwords are allowed in ftp URIs. pass 'ftp://abigail@ftp.example.com'; pass 'ftp://abigail@ftp.example.com:21/some/file'; pass 'ftp://abigail:secret@ftp.example.com:21/some/file'; pass 'ftp://abigail:secret@127.0.0.1:21/some/file'; fail 'ftp://abigail:secret:here@127.0.0.1:21/some/file'; # ~ was NOT allowed by RFC 1738, but currently is. pass 'ftp://ftp.example.com/~abigail/'; # Fail on "national" characters. fail 'ftp://ftp.example.com/nope|nope'; fail 'ftp://ftp.example.com/`'; # Fail on "punctation" characters. fail 'ftp://www.example.com/some/file#target'; # Cannot have queries. fail 'ftp://ftp.example.com/some/path?query1?query2'; fail 'ftp://ftp.example.com/some/??'; fail 'ftp://ftp.example.com/some/path?query/path'; # Test type. pass 'ftp://ftp.example.com/some/path;type=A'; pass 'ftp://ftp.example.com/some/path;type=i'; pass 'ftp://abigail@ftp.example.com/some/path/somewhere;type=a', fail 'ftp://ftp.example.com/some/path;type=Q'; fail 'ftp://ftp.example.com/some/path;type=AI'; pass 'ftp://ftp.example.com/;type=I'; # Scheme must be lower case, and correct. fail 'HTTP://ftp.example.com/'; fail 'FTP://ftp.example.com/'; fail 'http://ftp.example.com/'; try $RE{URI}{FTP}{"-type" => "[AIDaid]"}; pass 'ftp://ftp.example.com'; pass 'ftp://ftp.example.com/'; pass 'ftp://ftp.example.com/some/file/some/where'; pass 'ftp://ftp.example.com/some/directory/some/where/'; pass 'ftp://ftp.example.com:21/some/file'; pass 'ftp://127.0.0.1'; pass 'ftp://127.0.0.1/'; pass 'ftp://127.0.0.1:12345/some/file'; pass 'ftp://ftp.example.com/%7Eabigail/'; fail 'ftp://ftp.example.com:21/some/path?query'; # Test "safe" chars. pass 'ftp://ftp.example.com/--_$.+++'; pass 'ftp://ftp.example.com/.'; # Test "extra" chars. pass "ftp://ftp.example.com/**!(),,''"; # Test URI additional chars. pass 'ftp://www.example.com/:@=&='; pass 'ftp://www.example.com//////////////'; # Should fail on ';'. fail 'ftp://www.example.com/some/path;here'; # Usernames/passwords are allowed in ftp URIs. pass 'ftp://abigail@ftp.example.com'; pass 'ftp://abigail@ftp.example.com:21/some/file'; pass 'ftp://abigail:secret@ftp.example.com:21/some/file'; pass 'ftp://abigail:secret@127.0.0.1:21/some/file'; pass 'ftp://abigail:secret:here@127.0.0.1:21/some/file'; # ~ was NOT allowed by RFC 1738, but currently is. pass 'ftp://ftp.example.com/~abigail/'; # Fail on "national" characters. fail 'ftp://ftp.example.com/nope|nope'; fail 'ftp://ftp.example.com/`'; # Fail on "punctation" characters. fail 'ftp://www.example.com/some/file#target'; # Cannot have queries. fail 'ftp://ftp.example.com/some/path?query1?query2'; fail 'ftp://ftp.example.com/some/??'; fail 'ftp://ftp.example.com/some/path?query/path'; # Test type. pass 'ftp://ftp.example.com/some/path;type=A'; pass 'ftp://ftp.example.com/some/path;type=i'; pass 'ftp://abigail@ftp.example.com/some/path/somewhere;type=a', pass 'ftp://ftp.example.com/some/path;type=D'; fail 'ftp://ftp.example.com/some/path;type=AI'; pass 'ftp://ftp.example.com/;type=I'; # Scheme must be lower case, and correct. fail 'HTTP://ftp.example.com/'; fail 'FTP://ftp.example.com/'; fail 'http://ftp.example.com/'; Regexp-Common-2017060201/t/URI/gopher.t000755 000765 000024 00000006737 13070654573 017736 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use lib qw {blib/lib}, "."; use Regexp::Common; use t::Common; $^W = 1; sub create_parts; my $gopher = $RE {URI} {gopher}; my $gopher_notab = $RE {URI} {gopher} {-notab}; # No point in crosschecking, URI creation is tag independent. my @tests = ( [gopher => $gopher => {gopher => NORMAL_PASS | FAIL}], [gopher_notab => $gopher_notab => {gopher_notab => NORMAL_PASS | FAIL}], ); my ($good, $bad) = create_parts; run_tests version => "Regexp::Common::URI::gopher", tests => \@tests, good => $good, bad => $bad, query => \&gopher, wanted => \&wanted, filter => \&filter, ; sub gopher { my ($tag, $host, $port, $gtype, $selector, $search, $gopherplus_string) = ($_ [0], @{$_ [1]}); my $gopher = "gopher://"; $gopher .= $host if defined $host; $gopher .= ":$port" if defined $port; $gopher .= "/$gtype" if defined $gtype; $gopher .= $selector if defined $selector; $gopher .= "%09$search" if defined $search; $gopher .= "%09$gopherplus_string" if defined $gopherplus_string; $gopher; } sub wanted { my ($tag, $parts) = @_; my @wanted; $wanted [0] = $_; $wanted [1] = "gopher"; $wanted [2] = $$parts [0]; # host. $wanted [3] = $$parts [1]; # port. $wanted [4] = join "" => grep {defined} @$parts [2, 3]; $wanted [4] .= "%09" . $$parts [4] if defined $$parts [4]; $wanted [4] .= "%09" . $$parts [5] if defined $$parts [5]; $wanted [5] = $$parts [2]; # gtype. if ($tag eq 'gopher_notab') { $wanted [6] = $$parts [3]; # selector. $wanted [7] = $$parts [4]; # search. $wanted [8] = $$parts [5]; # gopherplus_string. } else { $wanted [6] = join "%09" => grep {defined} @$parts [3, 4, 5]; } \@wanted; } sub create_parts { my (@good, @bad); local $^W = 0; # Hosts. # Host/ports are tested with other URIs as well, we're not using # all the combinations here. $good [0] = [qw /www.abigail.be 127.0.0.1 w--w--w3.ABIGAIL.nl/]; $bad [0] = [qw /www.example..com w+w.example.com 127.0.0.0.1/]; # Ports. $good [1] = [undef, 70]; $bad [1] = ["", qw /: port/]; # Gtype # No need for both "" and 'undef' in the bad part here - they will # result in the same URI. $good [2] = [qw /0 + T/]; $bad [2] = ["", qw /~/]; # Selector # Don't use an 'undef' here. It will create the same URI as for # the empty string, but {-keep} will return "". $good [3] = ["", qw {FNURD 0}, q {$_.+!*'(),:@&=%FF}]; $bad [3] = [qw {/ []}]; # Search $good [4] = [undef, "", qw {FNORD 0}, q {$_.+!*'(),:@&=%FF}]; $bad [4] = [qw {/ []}]; # Gopherplus string $good [5] = [undef, "", qw {fnord 0}, q {$_.+%09!*'(),:@&=%FF}]; $bad [5] = [qw {/ []}]; return (\@good, \@bad); } sub filter { # Disallow defined gopherplus strings if search is undefined. return 0 if defined $_ [0] -> [5] && !defined $_ [0] -> [4]; # If the gtype is "", but the selector starts with a char that's # a valid gtype, we'll see a match where we'd expect a failure. return 0 if $_ [0] -> [2] eq "" && defined $_ [0] -> [3] && $_ [0] -> [3] =~ /^[0-9+IgT]/; return 1; } __END__ Regexp-Common-2017060201/t/URI/http.t000755 000765 000024 00000005034 13070654573 017416 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use lib qw {blib/lib}, "."; use Regexp::Common; use t::Common; $^W = 1; sub create_parts; my $http = $RE {URI} {HTTP}; my $https = $http -> {-scheme => 'https'}; my $any = $http -> {-scheme => 'https?'}; my @tests = ( [http => $http => {http => NORMAL_PASS | FAIL, https => NORMAL_FAIL}], [https => $https => {http => NORMAL_FAIL, https => NORMAL_PASS | FAIL}], [any => $any => {http => NORMAL_PASS, https => NORMAL_PASS}], ); my ($good, $bad) = create_parts; run_tests version => "Regexp::Common::URI", tests => \@tests, good => $good, bad => $bad, query => \&uri, wanted => \&wanted, filter => \&filter; sub uri { my ($scheme, $host, $port, $path, $query) = ($_ [0], @{$_ [1]}); my $uri = "$scheme://$host"; $uri .= ":$port" if defined $port; $uri .= "/$path" if defined $path; $uri .= "?$query" if defined $query && defined $path; $uri; } sub wanted { my ($scheme, $parts) = @_; my $abs = $parts -> [2]; $abs .= "?$parts->[3]" if defined $abs && defined $parts -> [3]; my @wanted; $wanted [0] = $_; $wanted [1] = $scheme; $wanted [2] = $parts -> [0]; $wanted [3] = $parts -> [1]; $wanted [4] = "/$abs" if defined $abs; $wanted [5] = $abs if defined $abs; $wanted [6] = $parts -> [2]; $wanted [7] = undef; $wanted [7] = $parts -> [3] if defined $parts -> [2]; \@wanted; } sub create_parts { my (@good, @bad); # Hosts. $good [0] = [qw /www.abigail.be www.PERL.com a.b.c.d.e.f.g.h.i.j.k.x 127.0.0.1 w--w--w.abigail.be w3.abigail.be/]; $bad [0] = ["", qw /www.example..com w+w.example.com w--.example.com 127.0.1 127.0.0.0.1 -w.example.com www.example.1com/]; # Ports. $good [1] = [undef, "", 80]; $bad [1] = [qw /-19 : port/]; # Paths. $good [2] = [undef, "", qw {foo foo/bar/baz/bingo foo%00bar foo%EFbar %12%34%E6%7B %12%34/%E6%7B %12%34%E6%7B/foo ()() fnurd&.!~@}]; $bad [2] = [qw {foo<> foo<>bar %GGfoo foo%F %FOfoo}, '#hubba']; # Queries. $good [3] = [undef, "", qw {hubba fnurd=many&woozle=yes %3E%FF barra?femmy??dopey}]; $bad [3] = ['query#', '#query', 'qu#ry']; return (\@good, \@bad); } sub filter { return !defined $_ [0] -> [2] && defined $_ [0] -> [3] ? 0 : 1 } __END__ Regexp-Common-2017060201/t/URI/news.t000755 000765 000024 00000003762 13070654573 017421 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use lib qw {blib/lib}, "."; use Regexp::Common; use t::Common; $^W = 1; sub create_parts; my $news = $RE {URI} {news}; my @tests = ( [news => $news => {news => NORMAL_PASS | FAIL}], ); my ($good, $bad) = create_parts; run_tests version => "Regexp::Common::URI::news", tests => \@tests, good => $good, bad => $bad, query => \&news, wanted => \&wanted; sub news { my ($tag, $grouppart) = ($_ [0], @{$_ [1]}); my $news = "news:"; $news .= $grouppart if defined $grouppart; $news; } sub wanted { my ($tag, $parts) = @_; my @wanted; $wanted [0] = $_; $wanted [1] = "news"; $wanted [2] = $$parts [0]; \@wanted; } sub create_parts { my (@good, @bad); my @good_arts = qw {fnord banzai123 4567 000 (!!make-$$$-fast**) %00%FF%12''' really? ?/?/?/&=:;}; my @good_hosts = qw /www.abigail.be www.PERL.com a.b.c.d.e.f.g.h.i.j.k.x 127.0.0.1 w--w--w.abigail.be w3.abigail.be/; my @bad_arts = ("", qw /%GG %F %7- %% {} <> ~abigail []/); my @bad_hosts = ("", qw /www.example..com w+w.example.com w--.example.com 127.0.1 127.0.0.0.1 -w.example.com www.example.1com/); # Groupparts. $good [0] = ["*", qw /a comp.lang.perl.misc comp.lang.c++ hello_kitty_ foo-1234567890/, map {join '@' => @$_} t::Common::cross (\@good_arts, \@good_hosts)]; $bad [0] = ["", qw /1234567890 ** really? (!!make-$$$-fast**) _hello_kitty_/, (map {join '@' => @$_} t::Common::cross (\@good_arts, \@bad_hosts)), (map {join '@' => @$_} t::Common::cross (\@bad_arts, \@good_hosts))]; return (\@good, \@bad); } __END__ Regexp-Common-2017060201/t/URI/nntp.t000755 000765 000024 00000004135 13070654573 017417 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use lib qw {blib/lib}, "."; use Regexp::Common; use t::Common; $^W = 1; sub create_parts; my $nntp = $RE {URI} {NNTP}; my @tests = ( [nntp => $nntp => {nntp => NORMAL_PASS | FAIL}], ); my ($good, $bad) = create_parts; run_tests version => "Regexp::Common::URI::news", tests => \@tests, good => $good, bad => $bad, query => \&nntp, wanted => \&wanted; sub nntp { my ($tag, $host, $port, $group, $digits) = ($_ [0], @{$_ [1]}); my $nntp = "nntp://"; $nntp .= $host if defined $host; $nntp .= ":$port" if defined $port; $nntp .= "/$group" if defined $group; $nntp .= "/$digits" if defined $digits; $nntp; } sub wanted { my ($tag, $parts) = @_; my @wanted; $wanted [0] = $_; $wanted [1] = "nntp"; $wanted [2] = join "/" => grep {defined} join (":" => grep {defined} @$parts [0, 1]), @$parts [2, 3]; $wanted [3] = join ":" => grep {defined} @$parts [0, 1]; $wanted [4] = $$parts [0]; $wanted [5] = $$parts [1]; $wanted [6] = $$parts [2]; $wanted [7] = $$parts [3]; \@wanted; } sub create_parts { my (@good, @bad); # Hosts. $good [0] = [qw /www.abigail.be www.PERL.com a.b.c.d.e.f.g.h.i.j.k.x 127.0.0.1 w--w--w.abigail.be w3.abigail.be/]; $bad [0] = [qw /www.example..com w+w.example.com w--.example.com 127.0.0.0.1 -w.example.com www.example.1com/]; # Ports. $good [1] = [undef, 119]; $bad [2] = ["", qw /-19 : port/]; # Group. $good [2] = [qw /a comp.lang.perl.misc comp.lang.c++ hello_kitty_ foo-1234567890/]; $bad [2] = [undef, "", qw /1234567890 ** really? (!!make-$$$-fast**) _hello_kitty_/]; # Digits. $good [3] = [undef, qw /0 0000 12345/]; $bad [3] = ["", qw /fnurd -19 */, "1234/", "/12", "/"]; return (\@good, \@bad); } __END__ Regexp-Common-2017060201/t/URI/pop.t000755 000765 000024 00000003751 13070654573 017241 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use lib qw {blib/lib}, "."; use Regexp::Common; use t::Common; $^W = 1; $DEBUG = 1; sub create_parts; my $scheme = 'pop'; my $pop = $RE {URI} {uc $scheme}; # No point in crosschecking, URI creation is tag independent. my @tests = ( [pop => $pop => {pop => NORMAL_PASS | FAIL}], ); my ($good, $bad) = create_parts; run_tests version => "Regexp::Common::URI::$scheme", tests => \@tests, good => $good, bad => $bad, query => \&query, wanted => \&wanted, filter => \&filter, ; sub query { my ($tag, $user, $auth_type, $host, $port) = ($_ [0], @{$_ [1]}); my $url = "$scheme://"; if (defined $user) { $url .= $user; $url .= ";AUTH=$auth_type" if defined $auth_type; $url .= '@'; } $url .= $host if defined $host; $url .= ":$port" if defined $port; $url; } sub wanted { my ($tag, $parts) = @_; my @wanted; $wanted [0] = $_; $wanted [1] = "$scheme"; $wanted [2] = $$parts [0]; # user. $wanted [3] = $$parts [1]; # auth. $wanted [4] = $$parts [2]; # host. $wanted [5] = $$parts [3]; # port. \@wanted; } sub create_parts { my (@good, @bad); # Users $good [0] = [undef, qw /abigail/]; $bad [0] = ["", qw /abigail%GG [abigail]/]; # Auth_type $good [1] = [undef, qw /* password &~=~& +APOP +password +/]; $bad [1] = ["", qw /"password" camel-][/]; # Hosts. $good [2] = [qw /pop3.abigail.be pop3.PERL.com 127.0.0.1/]; $bad [2] = [qw /www.example..com w+w.example.com 127.0.0.0.1 w--.example.com -w.example.com www.example.1com/]; # Ports. $good [3] = [undef, 110]; $bad [3] = ["", qw /: port/]; return (\@good, \@bad); } sub filter { return 0 if defined ${$_ [0]} [1] && !defined ${$_ [0]} [0]; return 1; } __END__ Regexp-Common-2017060201/t/URI/prospero.t000755 000765 000024 00000005574 13070654573 020321 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use lib qw {blib/lib}, "."; use Regexp::Common; use t::Common; $^W = 1; $DEBUG = 1; sub create_parts; my $prospero = $RE {URI} {prospero}; # No point in crosschecking, URI creation is tag independent. my @tests = ( [prospero => $prospero => {prospero => NORMAL_PASS | FAIL}], ); my ($good, $bad) = create_parts; run_tests version => "Regexp::Common::URI::prospero", tests => \@tests, good => $good, bad => $bad, query => \&prospero, wanted => \&wanted, filter => \&filter, ; sub prospero { my ($tag, $host, $port, $ppath, $fieldnames, $fieldvalues) = ($_ [0], @{$_ [1]}); my $prospero = "prospero://"; $prospero .= $host if defined $host; $prospero .= ":$port" if defined $port; $prospero .= "/$ppath" if defined $ppath; if (defined $fieldnames) { foreach my $i (0 .. $#$fieldnames) { $prospero .= ";$fieldnames->[$i]"; $prospero .= "=$fieldvalues->[$i]" if defined $fieldvalues -> [$i]; } } $prospero; } sub wanted { my ($tag, $parts) = @_; my @wanted; $wanted [0] = $_; $wanted [1] = "prospero"; $wanted [2] = $$parts [0]; # host. $wanted [3] = $$parts [1]; # port. $wanted [4] = $$parts [2]; # ppart. $wanted [5] = ""; if (defined $$parts [3]) { foreach my $i (0 .. $#{$$parts [3]}) { $wanted [5] .= ";${$$parts [3]}[$i]=${$$parts [4]}[$i]"; } } \@wanted; } sub create_parts { my (@good, @bad); # Hosts. $good [0] = [qw /www.abigail.be www.PERL.com a.b.c.d.e.f.g.h.i.j.k.x 127.0.0.1 w--w--w.abigail.be w3.abigail.be/]; $bad [0] = [qw /www.example..com w+w.example.com w--.example.com 127.0.0.0.1 -w.example.com www.example.1com/]; # Ports. $good [1] = [undef, 1525]; $bad [1] = ["", qw /: port/]; # Ppart $good [2] = ["", qw {part foo/bar fnord:&=?%FF}]; $bad [2] = [undef, qw {~}, ' ']; # Fieldname $good [3] = [undef, [qw /name/], [qw /name1 name2/], [""], ["", ""], ["", qw /name/], [qw /fnord:&?%FF/]]; $bad [3] = [[qw /name==/], ['~']]; # Fieldvalue $good [4] = [undef, [qw /value/], [qw /value1 value2/], [""], ["", ""], ["", qw /value/], [qw /fnord:&?%FF/]]; $bad [4] = [[qw /value==/], ['~'], [undef], [undef, undef]]; return (\@good, \@bad); } sub filter { return 1 if !defined ${$_ [0]} [3] && !defined ${$_ [0]} [4]; return 0 if defined ${$_ [0]} [3] && !defined ${$_ [0]} [4] || !defined ${$_ [0]} [3] && defined ${$_ [0]} [4]; return 0 if @{${$_ [0]} [3]} != @{${$_ [0]} [4]}; return 1; } __END__ Regexp-Common-2017060201/t/URI/tel.t000755 000765 000024 00000005242 12116413566 017217 0ustar00abigailstaff000000 000000 # VOODOO LINE-NOISE my($C,$M,$P,$N,$S);END{print"1..$C\n$M";print"\nfailed: $N\n"if$N} sub ok{$C++; $M.= ($_[0]||!@_)?"ok $C\n":($N++,"not ok $C (". ((caller 1)[1]||(caller 0)[1]).":".((caller 1)[2]||(caller 0)[2]).")\n")} sub try{$P=qr/^$_[0]$/}sub fail{ok($S=$_[0]!~$P)}sub pass{ok($S=$_[0]=~$P)} # LOAD use Regexp::Common; ok; # TEST URIs try $RE{URI}{tel}; pass 'tel:+12345'; pass 'tel:+358-555-1234567'; pass 'tel:456-7890;phone-context=213'; pass 'tel:456-7890;phone-context=X-COMPANY-NET'; pass 'tel:+1-212-555-1234;tsp=terrifictelecom.com'; pass 'tel:+1-212-555-1234;tsp=terrifictelecom.com;phone-context=X-COMPANY-NET'; pass 'tel:+358-555-1234567;postd=pp22'; pass 'tel:0w003585551234567;phone-context=+3585551234'; pass 'tel:+1234567890;phone-context=+1234;vnd.company.option=foo'; pass 'tel:+1234567890;phone-context=+1234;vnd.company.option=%22foo%22'; pass 'tel:+1234;option=%22!%22'; pass 'tel:+1234;option=%22%5C%22%22'; pass 'tel:+1234;option=%22%5C!%22'; pass 'tel:+1234;option=%22bar%22'; pass 'tel:+456-7890;phone-context=213;phone-context=213'; pass 'tel:456-7890;phone-context=213;phone-context=213'; fail 'tel:456-7890'; fail 'tel:+1-800-RUN-PERL'; fail 'tel:+1234;option=%22%22%22'; fail 'tel:+1234;option=%22%5C%22'; pass 'tel:+123-456-789;isub=123(456)'; pass 'tel:+123456;postd=***'; try $RE{URI}{tel}{nofuture}; pass 'tel:+12345'; pass 'tel:+358-555-1234567'; pass 'tel:456-7890;phone-context=213'; pass 'tel:456-7890;phone-context=X-COMPANY-NET'; pass 'tel:+1-212-555-1234;tsp=terrifictelecom.com'; pass 'tel:+1-212-555-1234;tsp=terrifictelecom.com;phone-context=X-COMPANY-NET'; pass 'tel:+358-555-1234567;postd=pp22'; pass 'tel:0w003585551234567;phone-context=+3585551234'; fail 'tel:+1234567890;phone-context=+1234;vnd.company.option=foo'; fail 'tel:+1234567890;phone-context=+1234;vnd.company.option=%22foo%22'; fail 'tel:+1234;option=%22!%22'; fail 'tel:+1234;option=%22%5C%22%22'; fail 'tel:+1234;option=%22%5C!%22'; fail 'tel:+1234;option=%22bar%22'; pass 'tel:+456-7890;phone-context=213;phone-context=213'; pass 'tel:456-7890;phone-context=213;phone-context=213'; fail 'tel:456-7890'; fail 'tel:+1-800-RUN-PERL'; fail 'tel:+1234;option=%22%22%22'; fail 'tel:+1234;option=%22%5C%22'; fail 'tel:+358-555-1234567;phone-context=+1234;postd=pp22'; pass 'tel:+123-456-789;isub=123(456)'; fail 'tel:+123-456-789;isub=123(456);isub=123(456)'; fail 'tel:+123-456-789;isub=A23(456)'; pass 'tel:+123456;postd=***'; fail 'tel:1234567890;phone-context=+1234;vnd.company.option=foo'; fail 'tel:1234567890;phone-context=+1234;vnd.company.option=%22foo%22'; fail 'tel:1234;option=%22!%22'; fail 'tel:1234;option=%22%5C%22%22'; fail 'tel:1234;option=%22%5C!%22'; fail 'tel:1234;option=%22bar%22'; Regexp-Common-2017060201/t/URI/telnet.t000755 000765 000024 00000004465 13070654573 017741 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use lib qw {blib/lib}, "."; use Regexp::Common; use t::Common; $^W = 1; sub create_parts; my $telnet = $RE {URI} {telnet}; my @tests = ( [telnet => $telnet => {telnet => NORMAL_PASS | FAIL}] ); my ($good, $bad) = create_parts; run_tests version => "Regexp::Common::URI", tests => \@tests, good => $good, bad => $bad, query => \&uri, wanted => \&wanted, filter => \&filter; sub uri { my ($scheme, $user, $password, $host, $port, $slash) = ($_ [0], @{$_ [1]}); my $uri = "$scheme://"; $uri .= $user if defined $user; $uri .= ":$password" if defined $user && defined $password; $uri .= '@' if defined $user; $uri .= $host; $uri .= ":$port" if defined $port; $uri .= $slash if defined $slash; $uri; } sub wanted { my ($scheme, $parts) = @_; my @wanted; $wanted [0] = $_; $wanted [1] = $scheme; if (defined $$parts [0]) { $wanted [2] = $$parts [0]; $wanted [3] = $$parts [0]; if (defined $$parts [1]) { $wanted [2] .= ":$$parts[1]"; $wanted [4] = $$parts [1]; } } $wanted [5] = $$parts [2]; $wanted [6] = $$parts [2]; if (defined $$parts [3]) { $wanted [5] .= ":$$parts[3]"; $wanted [7] = $$parts [3]; } $wanted [8] = undef; $wanted [8] = "/" if $$parts [4]; \@wanted; } sub create_parts { my (@good, @bad); # Users. $good [0] = [undef, "", qw /abigail ab?ga?l; abi%67ai%6C/]; $bad [0] = [qw /abigail-][/]; # Passwords. $good [1] = [undef, "", qw /secret se??et se%FFret/]; $bad [1] = [qw /se{}cret/]; # Hosts. $good [2] = [qw /www.abigail.be www.PERL.com 127.0.0.1 w3.abigail.be/]; $bad [2] = [qw /www.example..com w+w.example.com w--.example.com 127.0.0.0.1 -w.example.com www.example.1com/]; # Ports. $good [3] = [undef, 123]; $bad [3] = ["", qw /-19 : port/]; # Trailing /. $good [4] = [undef, '/']; $bad [4] = ['//', '/foo', '@']; (\@good, \@bad); } sub filter { return !defined $_ [0] -> [0] && defined $_ [0] -> [1] ? 0 : 1 } __END__ Regexp-Common-2017060201/t/URI/tv.t000755 000765 000024 00000002245 12116413566 017064 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use lib qw {blib/lib}; use Regexp::Common; $^W = 1; my $count; my $tv = qr /^$RE{URI}{tv}$/; my $keep = qr /^$RE{URI}{tv}{-keep}$/; sub mess {print ++ $count, " - $_ (@_)\n"} sub pass {print "ok "; &mess} sub fail {print "not ok "; &mess} my (@hosts, @failures); while () { chomp; last unless /\S/; push @hosts => $_; } push @hosts => ""; while () { chomp; last unless /\S/; push @failures => $_; } my $max = 1 + 2 * @hosts + @failures; print "1..$max\n"; print "ok ", ++ $count, "\n"; # print "$fail\n"; exit; foreach my $host (@hosts) { local $_ = "tv:$host"; /$tv/ ? pass "match" : fail "no match"; /$keep/ ? $1 eq $_ && $2 eq "tv" && (length $host ? $3 eq $host : !defined $3) ? pass "match; keep" : fail "match ($1, $2, $3); keep" : fail "no match; keep" } foreach (@failures) { /$tv/ ? fail "match" : pass "no match"; } __DATA__ wqed.com nbc.com abc.com abc.co.au east.hbo.com west.hbo.com bbc.co.uk TV:abc.com abc.com http:abc.com tv://abc.com tv:abc..com tv:.abc.com tv:abc-.com tv:-abc.com Regexp-Common-2017060201/t/URI/wais.t000755 000765 000024 00000006404 13070654573 017404 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use lib qw {blib/lib}, "."; use Regexp::Common; use t::Common; $^W = 1; sub create_parts; my $wais = $RE {URI} {WAIS}; # No point in crosschecking, URI creation is tag independent. my @tests = ( [wais => $wais => {wais => NORMAL_PASS | FAIL}], ); my ($good, $bad) = create_parts; run_tests version => "Regexp::Common::URI::wais", tests => \@tests, good => $good, bad => $bad, query => \&wais, wanted => \&wanted, filter => \&filter, filter_passes => \&filter_passes, ; sub wais { my ($tag, $host, $port, $database, $search, $wtype, $wpath) = ($_ [0], @{$_ [1]}); my $wais = "wais://"; $wais .= $host if defined $host; $wais .= ":$port" if defined $port; $wais .= "/$database" if defined $database; $wais .= "?$search" if defined $search; $wais .= "/$wtype" if defined $wtype; $wais .= "/$wpath" if defined $wpath; $wais; } sub wanted { my ($tag, $parts) = @_; my @wanted; $wanted [0] = $_; $wanted [1] = "wais"; $wanted [2] = $$parts [0]; # host. $wanted [3] = $$parts [1]; # port. $wanted [4] = $$parts [2]; # database. $wanted [4] .= "?" . $$parts [3] if defined $$parts [3]; $wanted [4] .= "/" . $$parts [4] if defined $$parts [4]; $wanted [4] .= "/" . $$parts [5] if defined $$parts [5]; $wanted [5] = $$parts [2]; # database. $wanted [6] = undef; $wanted [6] .= "?" . $$parts [3] if defined $$parts [3]; $wanted [6] .= "/" . $$parts [4] if defined $$parts [4]; $wanted [6] .= "/" . $$parts [5] if defined $$parts [5]; $wanted [7] = $$parts [3]; # search. $wanted [8] = $$parts [4]; # wtype. $wanted [9] = $$parts [5]; # wpath. \@wanted; } sub create_parts { my (@good, @bad); # Hosts. # Host/ports are tested with other URIs as well, we're not using # all the combinations here. $good [0] = [qw /www.abigail.be 127.0.0.1 w--w--w3.ABIGAIL.nl/]; $bad [0] = [qw /www.example..com w+w.example.com 127.0.0.0.1/]; # Ports. $good [1] = [undef, 210]; $bad [1] = ["", qw /: port/]; # Database $good [2] = ["", qw /database 0/, '%00%FF-!*,']; $bad [2] = [undef, qw /~/]; # Search $good [3] = [undef, "", qw /database 0/, '%00%FF-!*,']; $bad [3] = [qw {~ []}]; # Wtype $good [4] = [undef, "", qw /wtype 0/, '%00%FF-!*,']; $bad [4] = [qw {~ []}]; # Wpath $good [5] = [undef, "", qw /wpath 0/, '%00%FF-!*,']; $bad [5] = [qw {~ []}]; return (\@good, \@bad); } sub filter_passes { # Good URIs have either both a wtype and a wpath, or none at all. return 0 if defined $_ [0] -> [4] xor defined $_ [0] -> [5]; return 1; } sub filter { # At most one of 'search' and 'wtype/wpath' should be defined. return 0 if defined $_ [0] -> [3] && (defined $_ [0] -> [4] || defined $_ [0] -> [5]); return 0 if !defined $_ [0] -> [2] && grep {defined} @{$_ [0]} [3 .. 5]; return 1; } __END__ Regexp-Common-2017060201/t/SEN/usa_ssn.t000755 000765 000024 00000004131 13070654573 020075 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use lib qw {blib/lib}, "."; use Regexp::Common; use t::Common qw /run_new_tests cross criss_cross dd pdd/; $^W = 1; my $ssn = $RE {SEN} {USA} {SSN}; my $space = $ssn -> {-sep => ' '}; my $empty = $ssn -> {-sep => ''}; use constant PASS => 4; use constant FAIL => 3; my $areas = [ "001", map {pdd 3} 1 .. PASS]; my $groups = [ "01", map {pdd 2} 1 .. PASS]; my $serials = ["0001", map {pdd 4} 1 .. PASS]; my $bad_a = [ "000", "", dd (1), dd (2), dd (4), dd (5, 10)]; my $bad_g = [ "00", "", dd (1), dd (3), dd (4), dd (5, 10)]; my $bad_s = ["0000", "", dd (1), dd (2), dd (3), dd (5, 10)]; my $ssns = [cross $areas, $groups, $serials]; my $wrong = [criss_cross [[@$areas [0 .. FAIL - 1]], [@$groups [0 .. FAIL - 1]], [@$serials [0 .. FAIL - 1]]], [$bad_a, $bad_g, $bad_s]]; my %targets = ( ssn => { list => $ssns, query => sub {join "-" => @_}, wanted => sub {$_ => @_}, }, space => { list => $ssns, query => sub {join " " => @_}, wanted => sub {$_ => @_}, }, empty => { list => $ssns, query => sub {join "" => @_}, wanted => sub {$_ => @_}, }, wrong1 => { list => $wrong, query => sub {join "-" => @_}, }, wrong2 => { list => $wrong, query => sub {join " " => @_}, }, ); my @wrongs = qw /wrong1 wrong2/; my @tests = ( { name => 'basic', regex => $ssn, pass => [qw /ssn/], fail => [qw /empty space/, @wrongs], }, { name => 'space', regex => $space, pass => [qw /space/], fail => [qw /empty ssn/, @wrongs], }, { name => 'empty', regex => $empty, pass => [qw /empty/], fail => [qw /ssn space/, @wrongs], }, ); run_new_tests tests => \@tests, targets => \%targets, version_from => 'Regexp::Common::SEN', ; __END__ Regexp-Common-2017060201/t/number/101_integer.t000755 000765 000024 00000014256 12643716764 021322 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use warnings; no warnings 'syntax'; use Regexp::Common; use Test::More; my $r = eval "require Test::Regexp; 1"; unless ($r) { print "1..0 # SKIP Test::Regexp not found\n"; exit; } sub make_test { my ($name, $base, @options) = @_; my $pat = $base; while (@options) { my $opt = shift @options; if (@options && $options [0] !~ /^-/) { my $val = shift @options; $pat = $$pat {$opt => $val}; $name .= ", $opt => $val"; } else { $pat = $$pat {$opt}; $name .= ", $opt"; } } my $keep = $$pat {-keep}; Test::Regexp:: -> new -> init ( pattern => $pat, keep_pattern => $keep, name => $name, ); } # # Some basic patterns: plain integers, signed integers, unsigned integers. # my $integer = make_test "Integer pattern" => $RE {num} {int}; my $signed_integer = make_test "Integer pattern" => $RE {num} {int}, -sign => '[-+]'; my $unsigned_integer = make_test "Integer pattern" => $RE {num} {int}, -sign => ''; foreach my $digit (0 .. 9) { $integer -> match ( $digit, [ $digit, "", $digit], test => "Single digit"); $integer -> match ("-$digit", ["-$digit", "-", $digit], test => "Single digit, with minus sign"); $integer -> match ("+$digit", ["+$digit", "+", $digit], test => "Single digit, with plus sign"); $signed_integer -> no_match ($digit, reason => "No sign"); $signed_integer -> match ("-$digit", ["-$digit", "-", $digit], test => "Single digit, with minus sign"); $signed_integer -> match ("+$digit", ["+$digit", "+", $digit], test => "Single digit, with plus sign"); $unsigned_integer -> match ( $digit, [ $digit, "", $digit], test => "Single digit"); $unsigned_integer -> no_match ("-$digit", reason => "Number has - sign"); $unsigned_integer -> no_match ("+$digit", reason => "Number has + sign"); } foreach my $letter ('A' .. 'Z') { my $reason = "Cannot match letters"; $integer -> no_match ( $letter, reason => $reason); $integer -> no_match ("-$letter", reason => $reason); $integer -> no_match ("+$letter", reason => $reason); $signed_integer -> no_match ( $letter, reason => $reason); $signed_integer -> no_match ("-$letter", reason => $reason); $signed_integer -> no_match ("+$letter", reason => $reason); $unsigned_integer -> no_match ( $letter, reason => $reason); $unsigned_integer -> no_match ("-$letter", reason => $reason); $unsigned_integer -> no_match ("+$letter", reason => $reason); } my @numbers = qw [ 123456789 987654321 00 00000 918710985710984523480938457287510917634178356017501984571273461782346 2109381270129857102931405984051817410923193913810985 123981098509850493582357010910371947524594785923602871749187249504395 000000000000000000000000000000000000000000000000000000000000000000000001 12890991823457 09857109247120 0000000090000000000000009000000000000000 ]; my @big_numbers = ( '123456789' x 100, '0' x 10_000, ); my @failures = ( [" 12345" => "Leading space"], ["123 " => "Trailing space"], ["-+1234" => "Double sign"], ["--54311" => "Double sign"], ["- 897" => "Space after sign"], ["" => "Empty string"], ["-" => "Sign only"], ["1234 678" => "Space in number"], ["1234+678" => "Sign in number"], ["678A90" => "Letter in number"], ["0x1234" => "Hex number"], ["0b1234" => "Octal number"], ["Bla bla" => "Garbage"], ); foreach my $number (@numbers) { $integer -> match ( $number , [ $number , "", $number], test => "Unsigned number"); $integer -> match ("-$number", ["-$number", "-", $number], test => "Number with minus sign"); $integer -> match ("+$number", ["+$number", "+", $number], test => "Number with plus sign"); $signed_integer -> no_match ($number, reason => "Number is unsigned"); $signed_integer -> match ("-$number", ["-$number", "-", $number], test => "Number with minus sign"); $signed_integer -> match ("+$number", ["+$number", "+", $number], test => "Number with plus sign"); $unsigned_integer -> match ( $number , [ $number , "", $number], test => "Unsigned number"); $unsigned_integer -> no_match ("-$number", reason => "Number has - sign"); $unsigned_integer -> no_match ("+$number", reason => "Number has + sign"); } foreach my $number (@big_numbers) { $integer -> match ( $number , [ $number , "", $number], test => "Unsigned big number"); $integer -> match ("-$number", ["-$number", "-", $number], test => "Big number with minus sign"); $integer -> match ("+$number", ["+$number", "+", $number], test => "Big number with plus sign"); $signed_integer -> no_match ($number, reason => "Number is unsigned"); $signed_integer -> match ("-$number", ["-$number", "-", $number], test => "Big number with minus sign"); $signed_integer -> match ("+$number", ["+$number", "+", $number], test => "Big number with plus sign"); $unsigned_integer -> match ( $number , [ $number , "", $number], test => "Unsigned big number"); $unsigned_integer -> no_match ("-$number", reason => "Number has - sign"); $unsigned_integer -> no_match ("+$number", reason => "Number has + sign"); } foreach my $failure (@failures) { my ($subject, $reason) = @$failure; $integer -> no_match ($subject, reason => $reason); $signed_integer -> no_match ($subject, reason => $reason); } done_testing (); __END__ Regexp-Common-2017060201/t/number/111_integer_base.t000755 000765 000024 00000012501 12643716764 022304 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use warnings; no warnings 'syntax'; use Regexp::Common; use Test::More; my $r = eval "require Test::Regexp; 1"; unless ($r) { print "1..0 # SKIP Test::Regexp not found\n"; exit; } sub make_test { my ($name, $base, @options) = @_; my $pat = $base; while (@options) { my $opt = shift @options; if (@options && $options [0] !~ /^-/) { my $val = shift @options; $pat = $$pat {$opt => $val}; $name .= ", $opt => $val"; } else { $pat = $$pat {$opt}; $name .= ", $opt"; } } my $keep = $$pat {-keep}; Test::Regexp:: -> new -> init ( pattern => $pat, keep_pattern => $keep, name => $name, ); } # # Play with -base. # my @bases = (2, 5, 8, 16, 23, 36); my %patterns; my $PLAIN = 0; my $SIGNED = 1; foreach my $base (@bases) { my $plain = make_test "Base $base integer pattern", $RE {num} {int}, -base => $base; my $signed = make_test "Base $base integer pattern", $RE {num} {int}, -base => $base, -sign => '[-+]'; $patterns {$base} = [$plain, $signed]; } my @chars = (0 .. 9, 'A' .. 'Z'); for (my $i = 0; $i < @chars; $i ++) { my $char = $chars [$i]; foreach my $base (@bases) { if ($i < $base) { my $subj = $char; $patterns {$base} [$PLAIN] -> match ( $subj, [$subj, "", $char], test => "Single character in base" ); $patterns {$base} [$SIGNED] -> no_match ( $subj, reason => "Not signed" ); $subj = "-$char"; $patterns {$base} [$PLAIN] -> match ( $subj, [$subj, "-", $char], test => "Signed (-) single character in base", ); $patterns {$base} [$SIGNED] -> match ( $subj, [$subj, "-", $char], test => "Signed (-) single character in base", ); $subj = "+$char"; $patterns {$base} [$PLAIN] -> match ( $subj, [$subj, "+", $char], test => "Signed (+) single character in base", ); $patterns {$base} [$SIGNED] -> match ( $subj, [$subj, "+", $char], test => "Signed (+) single character in base", ); } else { for my $subj ($char, "-$char", "+$char") { $patterns {$base} [$PLAIN] -> no_match ( $subj, reason => "Character '$char' out of base $base" ) } } } } my $numbers = [ '00', '00000000000000000000', '0' x 100_000, '11', '10101010101010101010', '11010100110100100111', '12234', '4321', '1234' x 10_000, '00000000000000000000000000000000000000000030000000000000', '444444444444444444444444444444444444', '1234567', '7654321', '12435147126123471234651263154211451235', '412377132477712347716234512374712341541', '2378AB21394CFF9932841EFFA9234', 'DEADBEEF', 'BABEFACE', '87134F13241', 'FEDCBA9876543210' x 1_000, 'ASTORYWELLTOLD', 'BETTERL8THENNEVER', '4SALE', 'AS08142H5A87SDFYOUY4YR09TWRE7YGUASDFA99Q0ASHNR1KF98QERTOQ2C871C123R', 'AL0NGSTR1NGR3P34T3DM4NYT1M3S' x 3_000 ]; my %numbers_by_base; NUMBER: foreach my $number (@$numbers) { my %buckets; $buckets {$_} ++ for split // => $number; for (my $i = @chars - 1; $i >= 0; $i --) { if ($buckets {$chars [$i]}) { push @{$numbers_by_base {$i + 1}} => $number; next NUMBER; } } } my @base_numbers = sort {$a <=> $b} keys %numbers_by_base; foreach my $base (@bases) { my ($pattern, $signed_pattern) = @{$patterns {$base}}; foreach my $base_number (@base_numbers) { foreach my $number (@{$numbers_by_base {$base_number}}) { my $is_big = length ($number) > 100; my $desc_number = $is_big ? "big number" : "number"; if ($base >= $base_number) { my $subj = $number; $pattern -> match ($subj, [$subj, "", $number], test => "Unsigned $desc_number"); $signed_pattern -> no_match ($subj, reason => "No sign for $desc_number"); $subj = "-$number"; $pattern -> match ($subj, [$subj, "-", $number], test => "Signed (-) $desc_number"); $signed_pattern -> match ($subj, [$subj, "-", $number], test => "Signed (-) $desc_number"); $subj = "+$number"; $pattern -> match ($subj, [$subj, "+", $number], test => "Signed (+) $desc_number"); $signed_pattern -> match ($subj, [$subj, "+", $number], test => "Signed (+) $desc_number"); } else { foreach my $subj ($number, "-$number", "+$number") { $pattern -> no_match ($subj, reason => "Out of base characters"); $signed_pattern -> no_match ($subj, reason => "Out of base characters"); } } } } } done_testing (); __END__ Regexp-Common-2017060201/t/number/121_integer_places.t000755 000765 000024 00000006430 12643716764 022646 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use warnings; no warnings 'syntax'; use Regexp::Common; use Test::More; my $r = eval "require Test::Regexp; 1"; unless ($r) { print "1..0 # SKIP Test::Regexp not found\n"; exit; } sub make_test { my ($name, $base, @options) = @_; my $pat = $base; while (@options) { my $opt = shift @options; if (@options && $options [0] !~ /^-/) { my $val = shift @options; $pat = $$pat {$opt => $val}; $name .= ", $opt => $val"; } else { $pat = $$pat {$opt}; $name .= ", $opt"; } } my $keep = $$pat {-keep}; Test::Regexp:: -> new -> init ( pattern => $pat, keep_pattern => $keep, name => $name, ); } # # Patterns with fixed places. # my @places = (1, 2, 3, 5, 8, 13, 21, 34); my %patterns; foreach my $places (@places) { my $places_pattern = make_test "Integer pattern", $RE {num} {int}, -places => $places; my $places_pattern_signed = make_test "Integer pattern", $RE {num} {int}, -places => $places, -sign => '[-+]'; $patterns {$places} = [$places_pattern, $places_pattern_signed]; } my @numbers; push @numbers => map {"0" x $_} 1 .. ($places [-1] + 1); push @numbers => qw [ 921092 1230981409 1239801 12034009123 120381409 12 098213470 289341728912098510298571873824712384 129834701 1098240 12349 3475 897465121 992342199123499195 999999999 12481 598134 23418 98214510814580 891274102981829570918 981243 1928411 912834 ]; foreach my $number (@numbers) { my $length = length $number; foreach my $places (@places) { my ($pattern, $signed_pattern) = @{$patterns {$places}}; if ($length < $places) { my $reason = "Number too short"; foreach my $subj ($number, "-$number") { $pattern -> no_match ($subj, reason => $reason); $signed_pattern -> no_match ($subj, reason => $reason); } } elsif ($length > $places) { my $reason = "Number too long"; foreach my $subj ($number, "+$number") { $pattern -> no_match ($subj, reason => $reason); $signed_pattern -> no_match ($subj, reason => $reason); } } else { $pattern -> match ($number, [$number, "", $number], test => "Exact length"); $signed_pattern -> no_match ($number, reason => "Number not signed"); $pattern -> match ("-$number", ["-$number", "-", $number], test => "Exact length, signed (-)"); $signed_pattern -> match ("-$number", ["-$number", "-", $number], test => "Exact length, signed (-)"); $pattern -> match ("+$number", ["+$number", "+", $number], test => "Exact length, signed (+)"); $signed_pattern -> match ("+$number", ["+$number", "+", $number], test => "Exact length, signed (+)"); } } } done_testing (); __END__ Regexp-Common-2017060201/t/number/122_integer_places.t000755 000765 000024 00000007241 12643716764 022650 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use warnings; no warnings 'syntax'; use Regexp::Common; use Test::More; my $r = eval "require Test::Regexp; 1"; unless ($r) { print "1..0 # SKIP Test::Regexp not found\n"; exit; } sub make_test { my ($name, $base, @options) = @_; my $pat = $base; while (@options) { my $opt = shift @options; if (@options && $options [0] !~ /^-/) { my $val = shift @options; $pat = $$pat {$opt => $val}; $name .= ", $opt => $val"; } else { $pat = $$pat {$opt}; $name .= ", $opt"; } } my $keep = $$pat {-keep}; Test::Regexp:: -> new -> init ( pattern => $pat, keep_pattern => $keep, name => $name, ); } # # Patterns with variable places. # my @places = (1, 3, 8, 21, 34); my %patterns; for (my $i = 0; $i < @places; $i ++) { my $places1 = $places [$i]; for (my $j = $i + 1; $j < @places; $j ++) { my $places2 = $places [$j]; my $places = "$places1,$places2"; my $places_pattern = make_test "Integer pattern" => $RE {num} {int}, -places => $places; my $places_pattern_signed = make_test "Integer pattern" => $RE {num} {int}, -places => $places, -sign => '[-+]'; $patterns {$places1} {$places2} = [$places_pattern, $places_pattern_signed]; } } my @numbers; push @numbers => map {"0" x $_} 1 .. ($places [-1] + 1); push @numbers => qw [ 921092 1230981409 1239801 12034009123 120381409 12 098213470 289341728912098510298571873824712384 129834701 1098240 12349 3475 897465121 992342199123499195 999999999 12481 598134 23418 98214510814580 891274102981829570918 981243 1928411 912834 ]; foreach my $number (@numbers) { my $length = length $number; for (my $i = 0; $i < @places; $i ++) { my $places1 = $places [$i]; for (my $j = $i + 1; $j < @places; $j ++) { my $places2 = $places [$j]; my ($pattern, $signed_pattern) = @{$patterns {$places1} {$places2}}; if ($length < $places1) { my $reason = "Number too short"; foreach my $subj ($number, "-$number") { $pattern -> no_match ($subj, reason => $reason); $signed_pattern -> no_match ($subj, reason => $reason); } } elsif ($length > $places2) { my $reason = "Number too long"; foreach my $subj ($number, "+$number") { $pattern -> no_match ($subj, reason => $reason); $signed_pattern -> no_match ($subj, reason => $reason); } } else { my $reason = "Length within bounds"; $pattern -> match ($number, [$number, "", $number], test => $reason); $signed_pattern -> no_match ($number, reason => "Number not signed"); $pattern -> match ("+$number", ["+$number", "+", $number], test => "$reason, signed (+)"); $signed_pattern -> match ("+$number", ["+$number", "+", $number], test => "$reason, signed (+)"); } } } } done_testing (); __END__ Regexp-Common-2017060201/t/number/123_integer_places.t000755 000765 000024 00000006413 12643716764 022651 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use warnings; no warnings 'syntax'; use Regexp::Common; use Test::More; my $r = eval "require Test::Regexp; 1"; unless ($r) { print "1..0 # SKIP Test::Regexp not found\n"; exit; } sub make_test { my ($name, $base, @options) = @_; my $pat = $base; while (@options) { my $opt = shift @options; if (@options && $options [0] !~ /^-/) { my $val = shift @options; $pat = $$pat {$opt => $val}; $name .= ", $opt => $val"; } else { $pat = $$pat {$opt}; $name .= ", $opt"; } } my $keep = $$pat {-keep}; Test::Regexp:: -> new -> init ( pattern => $pat, keep_pattern => $keep, name => $name, ); } # # Combine places and bases # my $min = 3; my $max = 6; my $pattern = make_test "Integer pattern" => $RE {num} {int}, -base => 4, -places => "$min,$max"; my $pattern_neg = make_test "Integer pattern" => $RE {num} {int}, -base => 4, -places => "$min,$max", -sign => '[-]'; my @numbers; push @numbers => map {"0" x $_} 1 .. 7; push @numbers => qw [ 1201201 21013 120 123100 3210310 1231231013 2130130 2130 31230 13012302 13130 ]; foreach my $number (@numbers) { my $length = length $number; if ($length < $min) { foreach my $subj ($number, "-$number", "+$number") { $pattern -> no_match ($number, reason => "Number too short"); $pattern_neg -> no_match ($number, reason => "Number too short"); } } elsif ($length > $max) { foreach my $subj ($number, "-$number", "+$number") { $pattern -> no_match ($number, reason => "Number too long"); $pattern_neg -> no_match ($number, reason => "Number too long"); } } else { $pattern -> match ($number, [$number, "", $number], test => "Number of correct length"); $pattern_neg -> no_match ($number, reason => "Number not signed"); $pattern -> match ("-$number", ["-$number", "-", $number], test => "Signed number of correct length"); $pattern_neg -> match ("-$number", ["-$number", "-", $number], test => "Signed number of correct length"); $pattern -> match ("+$number", ["+$number", "+", $number], test => "Signed number of correct length"); $pattern_neg -> no_match ($number, reason => "Number incorrectly signed"); } } my @bad_characters = ( ["Number contains space", "12 12", "111 1"], ["Digit exceeds base", "1234", "4", "121212124", "9123123123"], ["Letter in number", "123A", "Q", "202O20", "123Z21"], ); foreach my $entry (@bad_characters) { my ($reason, @subjs) = @$entry; foreach my $subj (@subjs) { $pattern -> no_match ($subj, reason => $reason); $pattern_neg -> no_match ($subj, reason => $reason); } } done_testing (); __END__ Regexp-Common-2017060201/t/number/131_integer_sep.t000755 000765 000024 00000006760 12643716764 022175 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use warnings; no warnings 'syntax'; use Regexp::Common; use Test::More; my $r = eval "require Test::Regexp; 1"; unless ($r) { print "1..0 # SKIP Test::Regexp not found\n"; exit; } sub make_test { my ($name, $base, @options) = @_; my $pat = $base; while (@options) { my $opt = shift @options; if (@options && $options [0] !~ /^-/) { my $val = shift @options; $pat = $$pat {$opt => $val}; $name .= ", $opt => $val"; } else { $pat = $$pat {$opt}; $name .= ", $opt"; } } my $keep = $$pat {-keep}; Test::Regexp:: -> new -> init ( pattern => $pat, keep_pattern => $keep, name => $name, ); } my $pattern_c = make_test "Integer pattern" => $RE {num} {int}, -sep => ","; my $pattern_u = make_test "Integer pattern" => $RE {num} {int}, -sep => "_"; my @pass_numbers = qw [ 0 00 000 123 45 6 123,456 78,901 2,345 0,000,000,000,000,000,000,000,000,000,000,000,000 00,000,000,000,000,000,000,000,000,000,000,000,000 000,000,000,000,000,000,000,000,000,000,000,000,000 5,098,145,984,398,345 2,831,471,982 38,247,113,284,912 7,312,834 8,732,123,847,132 45,884,573 99,234,759,141 27,348,134,581 214,357,191 ]; foreach my $number (@pass_numbers) { my $sep_c = $number =~ y/,/,/; my $test = $sep_c == 0 ? "No separator" : $sep_c == 1 ? "Single separator" : "Multiple separators"; $pattern_c -> match ( $number => [ $number, "", $number], test => $test); $pattern_c -> match ("-$number" => ["-$number", "-", $number], test => "$test, signed (-)"); $pattern_c -> match ("+$number" => ["+$number", "+", $number], test => "$test, signed (+)"); $number =~ s/,/_/g; $pattern_u -> match ( $number => [ $number, "", $number], test => $test); $pattern_u -> match ("-$number" => ["-$number", "-", $number], test => "$test, signed (-)"); $pattern_u -> match ("+$number" => ["+$number", "+", $number], test => "$test, signed (+)"); } my @failures = ( ["Wrong separator" => qw [0.000 1,234_456,789], "100 123"], ["Leading separator" => qw [,123 ,456,789]], ["Trailing separator" => qw [123, 456,789,]], ["Double separator" => qw [0,,000 123,456,,789]], ["No digits" => qw [, ,,]], ["Wrong number of digits in group" => qw [1,23,456 1,2345,678 489,1234,345,169,000]], ["Wrong number of digits in last group" => qw [123,4567 456,78]], ["Too many leading digits" => qw [1234,567 0000,000,000 8129132412341,000]], ["Trailing garbage" => qw [123,456,789foo 000,bar], "123,456 ", "987,543,611\n"], ["Leading garbage" => qw [baz,123,456 qux,000], " 123,456"], ["Inner garbage" => qw [123,foo,456 1a3,456], "123, 456"], ["Empty string" => ""], ["Garbage" => "wibble", "\n", "foo,123,bar"], ); foreach my $failure (@failures) { my ($reason, @subjects) = @$failure; foreach my $subject (@subjects) { $pattern_c -> no_match ($subject, reason => $reason); } } done_testing (); __END__ Regexp-Common-2017060201/t/number/141_integer_group.t000755 000765 000024 00000012323 12643716764 022533 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use warnings; no warnings 'syntax'; use Regexp::Common; use Test::More; my $r = eval "require Test::Regexp; 1"; unless ($r) { print "1..0 # SKIP Test::Regexp not found\n"; exit; } sub make_test { my ($name, $base, @options) = @_; my $pat = $base; while (@options) { my $opt = shift @options; if (@options && $options [0] !~ /^-/) { my $val = shift @options; $pat = $$pat {$opt => $val}; $name .= ", $opt => $val"; } else { $pat = $$pat {$opt}; $name .= ", $opt"; } } my $keep = $$pat {-keep}; Test::Regexp:: -> new -> init ( pattern => $pat, keep_pattern => $keep, name => $name, ); } my %patterns = ( 2 => make_test ("Integer pattern" => $RE {num} {int}, -sep => ",", -group => 2), 4 => make_test ("Integer pattern" => $RE {num} {int}, -sep => ",", -group => 4), 5_7 => make_test ("Integer pattern" => $RE {num} {int}, -sep => ",", -group => "5,7"), ); my %pass_numbers = ( 2 => [qw [0 00 0,00 00,00 1,23,45,67,89 12,34,56,78,90]], 4 => [qw [0 00 000 0000 0,0000 00,0000 1,2345,6789 12,3456,7890 123,0987,6782,1235]], 5_7 => [qw [0 00 000 0000 00000 000000 0000000 1,23456 12,3456789 8239317,54321 37819,4927658,897423,52904,3906817,34532]], ); foreach my $key (sort {$a cmp $b} keys %patterns) { my $pattern = $patterns {$key}; my $numbers = $pass_numbers {$key}; foreach my $number (@$numbers) { my $c = $number =~ y/,/,/; my $test = $c == 0 ? "No separator" : $c == 1 ? "Single separator" : "Multiple separators"; $pattern -> match ( $number => [ $number, "", $number], test => $test); $pattern -> match ("-$number" => ["-$number", "-", $number], test => "$test, signed (-)"); $pattern -> match ("+$number" => ["+$number", "+", $number], test => "$test, signed (+)"); } } my @failures = ( ["Wrong separator" => { 2 => [qw [0.00 1,23_46,79], "10 13"], 4 => [qw [0.0000 1,2345_6789], "1000 1313"], 5_7 => [qw [0.00000 1,23456_9876543], "10000 131313"], }], ["Leading separator" => { 2 => [qw [,123 ,456,789]], 4 => [qw [,1234 ,4567,7890]], 5_7 => [qw [,123456 ,98765,123456]], }], ["Trailing separator" => { 2 => [qw [123, 456,789,]], 4 => [qw [1234, 4567,1234,]], 5_7 => [qw [123456, 12345,0987654,]], }], ["Double separator" => { 2 => [qw [0,,00 23,45,,89]], 4 => [qw [0,,0000 123,4568,,1789]], 5_7 => [qw [0,,000000 123,456654,,789987]], }], ["No digits" => { 2 => [qw [, ,,]], }], ["Wrong number of digits in group" => { 2 => [qw [1,3,45 1,234,78 489,12 1,234,56,78]], 4 => [qw [13,45 1,23478,0000 11489,1212 1,23456,5678]], 5_7 => [qw [13,4589 1,12345678,98765 87654321,12345 123,4567,12345 123,456,123456]], }], ["Wrong number of digits in last group" => { 2 => [qw [12,4 45,678 1,23,456]], 4 => [qw [847,345 983,59025 123,4567,98387]], 5_7 => [qw [12,4567 89353,94768904 1490,49278,98765432]], }], ["Too many leading digits" => { 2 => [qw [000 123,45 948,89,90,23,24]], 4 => [qw [00000 12345,9489 899421,3890,2940]], 5_7 => [qw [00000000 89478211,904789 95872938,58903,1589387]], }], ["Trailing garbage" => { 2 => [qw [00foo 1,23,45,ba], "12,24 ", "12,24\n"], 4 => [qw [0000foo 1,2345,6789,barr], "12,2424 ", "12,2424\n"], 5_7 => [qw [00000foo 1,234567,67890,barrr], "12,242424 ", "12,242424\n"], }], ["Leading garbage" => { 2 => [qw [f1 foo12,34], " 12,34"], 4 => [qw [f123 foo1234,4567], " 1234,5678"], 5_7 => [qw [f12345 foo12340,04567], " 12340,05678"], }], ["Inner garbage" => { 2 => [qw [12,fo,56 1a,56], "13, 46"], 4 => [qw [1234,foob,5678 1a23,5678], "1234, 4567"], 5_7 => [qw [12345,foobar,5678901 1a23,45678], "1234, 456789"], }], ["Empty string" => { 2 => [""], 4 => [""], 5_7 => [""], }], ["Garbage" => { 2 => ["wibble", "\n", "fo,12,ar"], 4 => ["wibble", "\n", "foob,12,barb"], 5_7 => ["wibble", "\n", "foob,12345,barbaz"], }], ); foreach my $failure (@failures) { my ($reason, $data) = @$failure; foreach my $key (sort {$a cmp $b} keys %$data) { my $pattern = $patterns {$key}; my $subjects = $$data {$key}; foreach my $subject (@$subjects) { $pattern -> no_match ($subject, reason => $reason); } } } done_testing (); __END__ Regexp-Common-2017060201/t/number/701_squares.t000755 000765 000024 00000002766 12723313224 021340 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use warnings; no warnings 'syntax'; use Regexp::Common; use Test::More; use Config; my $r = eval "require Test::Regexp; 1"; unless ($r) { print "1..0 # SKIP Test::Regexp not found\n"; exit; } my $bits64 = $Config {use64bitint}; # # CPAN testers claim it fails on 5.8.8 and darwin 9.0. # $bits64 = 0 if $Config {osname} eq 'darwin' && $Config {osvers} eq '10.0' && $] == 5.010; my $MAX_POWER = $bits64 ? 31 : 15; # # The {-keep} pattern and the one without {-keep} are identical. # my $Test = Test::Regexp:: -> new -> init ( keep_pattern => $RE {num} {square} {-keep}, name => "Square numbers", ); my @squares = map {$_ * $_} 0 .. 100, map {2 ** $_} 7 .. $MAX_POWER; foreach my $square (@squares) { $Test -> match ($square, [$square], test => "$square is a square"); } my @not_squares = map {($_ * $_ - 1, $_ * $_ + 1)} 2 .. 100; { my $max_root = $bits64 ? 3037000499 : 46340; my $max_square = $max_root * $max_root; # # The first square bigger than 2^31 - 1/2^63 - 1. Note we use strings # and pre-calculated values here, avoiding Perl to use doubles. # my $big_square = $bits64 ? "9223372037000250000" : "2147488281"; $Test -> match ($max_square, [$max_square], test => "Largest square"); $Test -> no_match ($big_square, reason => "Square too big"); } foreach my $not_square (@not_squares) { $Test -> no_match ($not_square, reason => "Not a square number"); } done_testing (); __END__ Regexp-Common-2017060201/t/number/801_roman.t000755 000765 000024 00000134413 12722401454 020767 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use warnings; no warnings 'syntax'; use Regexp::Common; use Test::More; my $r = eval "require Test::Regexp; 1"; unless ($r) { print "1..0 # SKIP Test::Regexp not found\n"; exit; } my $Test = Test::Regexp:: -> new -> init ( pattern => $RE {num} {roman}, keep_pattern => $RE {num} {roman} {-keep}, name => "Roman numbers", ); my $n = 0; foreach my $number () { chomp $number; $n ++; my @numbers = ($number); push @numbers => map {local $_ = $_; s/IV/IIII/g; $_} grep {/IV/} @numbers; push @numbers => map {local $_ = $_; s/IX/VIIII/g; $_} grep {/IX/} @numbers; push @numbers => map {local $_ = $_; s/XL/XXXX/g; $_} grep {/XL/} @numbers; push @numbers => map {local $_ = $_; s/XC/LXXXX/g; $_} grep {/XC/} @numbers; push @numbers => map {local $_ = $_; s/CD/CCCC/g; $_} grep {/CD/} @numbers; push @numbers => map {local $_ = $_; s/CM/DCCCC/g; $_} grep {/CM/} @numbers; foreach my $number (@numbers) { $Test -> match ( $number, [$number], test => "Number $n; uppercase"); $Test -> match (lc $number, [lc $number], test => "Number $n; lowercase"); } } foreach my $token (qw [IIIII XXXXX CCCCC MMMMM]) { $Test -> no_match ($token, reason => "Four '1' symbols in a row not allowed"); } foreach my $token (qw [VV LL DD]) { $Test -> no_match ($token, reason => "Two '5' symbols in a row not allowed"); } foreach my $token (qw [IL IC ID IM VX VL VC VD VM XD XM LC LD LM DM]) { $Test -> no_match ($token, reason => "Symbols in illegal order"); } foreach my $token (qw [IVIV IXIX XLXL XCXC CDCD CMCM]) { $Test -> no_match ($token, reason => "Double subtraction not allowed"); } foreach my $token (qw [IIV IIX XXL XXC CCD CCM]) { $Test -> no_match ($token, reason => "Subtracting twice not allowed"); } $Test -> no_match ("", reason => "Empty string is not a match"); foreach my $token (0 .. 9) { $Test -> no_match ($token, reason => "Do not match arabic numerals"); } done_testing; __DATA__ I II III IV V VI VII VIII IX X XI XII XIII XIV XV XVI XVII XVIII XIX XX XXI XXII XXIII XXIV XXV XXVI XXVII XXVIII XXIX XXX XXXI XXXII XXXIII XXXIV XXXV XXXVI XXXVII XXXVIII XXXIX XL XLI XLII XLIII XLIV XLV XLVI XLVII XLVIII XLIX L LI LII LIII LIV LV LVI LVII LVIII LIX LX LXI LXII LXIII LXIV LXV LXVI LXVII LXVIII LXIX LXX LXXI LXXII LXXIII LXXIV LXXV LXXVI LXXVII LXXVIII LXXIX LXXX LXXXI LXXXII LXXXIII LXXXIV LXXXV LXXXVI LXXXVII LXXXVIII LXXXIX XC XCI XCII XCIII XCIV XCV XCVI XCVII XCVIII XCIX C CI CII CIII CIV CV CVI CVII CVIII CIX CX CXI CXII CXIII CXIV CXV CXVI CXVII CXVIII CXIX CXX CXXI CXXII CXXIII CXXIV CXXV CXXVI CXXVII CXXVIII CXXIX CXXX CXXXI CXXXII CXXXIII CXXXIV CXXXV CXXXVI CXXXVII CXXXVIII CXXXIX CXL CXLI CXLII CXLIII CXLIV CXLV CXLVI CXLVII CXLVIII CXLIX CL CLI CLII CLIII CLIV CLV CLVI CLVII CLVIII CLIX CLX CLXI CLXII CLXIII CLXIV CLXV CLXVI CLXVII CLXVIII CLXIX CLXX CLXXI CLXXII CLXXIII CLXXIV CLXXV CLXXVI CLXXVII CLXXVIII CLXXIX CLXXX CLXXXI CLXXXII CLXXXIII CLXXXIV CLXXXV CLXXXVI CLXXXVII CLXXXVIII CLXXXIX CXC CXCI CXCII CXCIII CXCIV CXCV CXCVI CXCVII CXCVIII CXCIX CC CCI CCII CCIII CCIV CCV CCVI CCVII CCVIII CCIX CCX CCXI CCXII CCXIII CCXIV CCXV CCXVI CCXVII CCXVIII CCXIX CCXX CCXXI CCXXII CCXXIII CCXXIV CCXXV CCXXVI CCXXVII CCXXVIII CCXXIX CCXXX CCXXXI CCXXXII CCXXXIII CCXXXIV CCXXXV CCXXXVI CCXXXVII CCXXXVIII CCXXXIX CCXL CCXLI CCXLII CCXLIII CCXLIV CCXLV CCXLVI CCXLVII CCXLVIII CCXLIX CCL CCLI CCLII CCLIII CCLIV CCLV CCLVI CCLVII CCLVIII CCLIX CCLX CCLXI CCLXII CCLXIII CCLXIV CCLXV CCLXVI CCLXVII CCLXVIII CCLXIX CCLXX CCLXXI CCLXXII CCLXXIII CCLXXIV CCLXXV CCLXXVI CCLXXVII CCLXXVIII CCLXXIX CCLXXX CCLXXXI CCLXXXII CCLXXXIII CCLXXXIV CCLXXXV CCLXXXVI CCLXXXVII CCLXXXVIII CCLXXXIX CCXC CCXCI CCXCII CCXCIII CCXCIV CCXCV CCXCVI CCXCVII CCXCVIII CCXCIX CCC CCCI CCCII CCCIII CCCIV CCCV CCCVI CCCVII CCCVIII CCCIX CCCX CCCXI CCCXII CCCXIII CCCXIV CCCXV CCCXVI CCCXVII CCCXVIII CCCXIX CCCXX CCCXXI CCCXXII CCCXXIII CCCXXIV CCCXXV CCCXXVI CCCXXVII CCCXXVIII CCCXXIX CCCXXX CCCXXXI CCCXXXII CCCXXXIII CCCXXXIV CCCXXXV CCCXXXVI CCCXXXVII CCCXXXVIII CCCXXXIX CCCXL CCCXLI CCCXLII CCCXLIII CCCXLIV CCCXLV CCCXLVI CCCXLVII CCCXLVIII CCCXLIX CCCL CCCLI CCCLII CCCLIII CCCLIV CCCLV CCCLVI CCCLVII CCCLVIII CCCLIX CCCLX CCCLXI CCCLXII CCCLXIII CCCLXIV CCCLXV CCCLXVI CCCLXVII CCCLXVIII CCCLXIX CCCLXX CCCLXXI CCCLXXII CCCLXXIII CCCLXXIV CCCLXXV CCCLXXVI CCCLXXVII CCCLXXVIII CCCLXXIX CCCLXXX CCCLXXXI CCCLXXXII CCCLXXXIII CCCLXXXIV CCCLXXXV CCCLXXXVI CCCLXXXVII CCCLXXXVIII CCCLXXXIX CCCXC CCCXCI CCCXCII CCCXCIII CCCXCIV CCCXCV CCCXCVI CCCXCVII CCCXCVIII CCCXCIX CD CDI CDII CDIII CDIV CDV CDVI CDVII CDVIII CDIX CDX CDXI CDXII CDXIII CDXIV CDXV CDXVI CDXVII CDXVIII CDXIX CDXX CDXXI CDXXII CDXXIII CDXXIV CDXXV CDXXVI CDXXVII CDXXVIII CDXXIX CDXXX CDXXXI CDXXXII CDXXXIII CDXXXIV CDXXXV CDXXXVI CDXXXVII CDXXXVIII CDXXXIX CDXL CDXLI CDXLII CDXLIII CDXLIV CDXLV CDXLVI CDXLVII CDXLVIII CDXLIX CDL CDLI CDLII CDLIII CDLIV CDLV CDLVI CDLVII CDLVIII CDLIX CDLX CDLXI CDLXII CDLXIII CDLXIV CDLXV CDLXVI CDLXVII CDLXVIII CDLXIX CDLXX CDLXXI CDLXXII CDLXXIII CDLXXIV CDLXXV CDLXXVI CDLXXVII CDLXXVIII CDLXXIX CDLXXX CDLXXXI CDLXXXII CDLXXXIII CDLXXXIV CDLXXXV CDLXXXVI CDLXXXVII CDLXXXVIII CDLXXXIX CDXC CDXCI CDXCII CDXCIII CDXCIV CDXCV CDXCVI CDXCVII CDXCVIII CDXCIX D DI DII DIII DIV DV DVI DVII DVIII DIX DX DXI DXII DXIII DXIV DXV DXVI DXVII DXVIII DXIX DXX DXXI DXXII DXXIII DXXIV DXXV DXXVI DXXVII DXXVIII DXXIX DXXX DXXXI DXXXII DXXXIII DXXXIV DXXXV DXXXVI DXXXVII DXXXVIII DXXXIX DXL DXLI DXLII DXLIII DXLIV DXLV DXLVI DXLVII DXLVIII DXLIX DL DLI DLII DLIII DLIV DLV DLVI DLVII DLVIII DLIX DLX DLXI DLXII DLXIII DLXIV DLXV DLXVI DLXVII DLXVIII DLXIX DLXX DLXXI DLXXII DLXXIII DLXXIV DLXXV DLXXVI DLXXVII DLXXVIII DLXXIX DLXXX DLXXXI DLXXXII DLXXXIII DLXXXIV DLXXXV DLXXXVI DLXXXVII DLXXXVIII DLXXXIX DXC DXCI DXCII DXCIII DXCIV DXCV DXCVI DXCVII DXCVIII DXCIX DC DCI DCII DCIII DCIV DCV DCVI DCVII DCVIII DCIX DCX DCXI DCXII DCXIII DCXIV DCXV DCXVI DCXVII DCXVIII DCXIX DCXX DCXXI DCXXII DCXXIII DCXXIV DCXXV DCXXVI DCXXVII DCXXVIII DCXXIX DCXXX DCXXXI DCXXXII DCXXXIII DCXXXIV DCXXXV DCXXXVI DCXXXVII DCXXXVIII DCXXXIX DCXL DCXLI DCXLII DCXLIII DCXLIV DCXLV DCXLVI DCXLVII DCXLVIII DCXLIX DCL DCLI DCLII DCLIII DCLIV DCLV DCLVI DCLVII DCLVIII DCLIX DCLX DCLXI DCLXII DCLXIII DCLXIV DCLXV DCLXVI DCLXVII DCLXVIII DCLXIX DCLXX DCLXXI DCLXXII DCLXXIII DCLXXIV DCLXXV DCLXXVI DCLXXVII DCLXXVIII DCLXXIX DCLXXX DCLXXXI DCLXXXII DCLXXXIII DCLXXXIV DCLXXXV DCLXXXVI DCLXXXVII DCLXXXVIII DCLXXXIX DCXC DCXCI DCXCII DCXCIII DCXCIV DCXCV DCXCVI DCXCVII DCXCVIII DCXCIX DCC DCCI DCCII DCCIII DCCIV DCCV DCCVI DCCVII DCCVIII DCCIX DCCX DCCXI DCCXII DCCXIII DCCXIV DCCXV DCCXVI DCCXVII DCCXVIII DCCXIX DCCXX DCCXXI DCCXXII DCCXXIII DCCXXIV DCCXXV DCCXXVI DCCXXVII DCCXXVIII DCCXXIX DCCXXX DCCXXXI DCCXXXII DCCXXXIII DCCXXXIV DCCXXXV DCCXXXVI DCCXXXVII DCCXXXVIII DCCXXXIX DCCXL DCCXLI DCCXLII DCCXLIII DCCXLIV DCCXLV DCCXLVI DCCXLVII DCCXLVIII DCCXLIX DCCL DCCLI DCCLII DCCLIII DCCLIV DCCLV DCCLVI DCCLVII DCCLVIII DCCLIX DCCLX DCCLXI DCCLXII DCCLXIII DCCLXIV DCCLXV DCCLXVI DCCLXVII DCCLXVIII DCCLXIX DCCLXX DCCLXXI DCCLXXII DCCLXXIII DCCLXXIV DCCLXXV DCCLXXVI DCCLXXVII DCCLXXVIII DCCLXXIX DCCLXXX DCCLXXXI DCCLXXXII DCCLXXXIII DCCLXXXIV DCCLXXXV DCCLXXXVI DCCLXXXVII DCCLXXXVIII DCCLXXXIX DCCXC DCCXCI DCCXCII DCCXCIII DCCXCIV DCCXCV DCCXCVI DCCXCVII DCCXCVIII DCCXCIX DCCC DCCCI DCCCII DCCCIII DCCCIV DCCCV DCCCVI DCCCVII DCCCVIII DCCCIX DCCCX DCCCXI DCCCXII DCCCXIII DCCCXIV DCCCXV DCCCXVI DCCCXVII DCCCXVIII DCCCXIX DCCCXX DCCCXXI DCCCXXII DCCCXXIII DCCCXXIV DCCCXXV DCCCXXVI DCCCXXVII DCCCXXVIII DCCCXXIX DCCCXXX DCCCXXXI DCCCXXXII DCCCXXXIII DCCCXXXIV DCCCXXXV DCCCXXXVI DCCCXXXVII DCCCXXXVIII DCCCXXXIX DCCCXL DCCCXLI DCCCXLII DCCCXLIII DCCCXLIV DCCCXLV DCCCXLVI DCCCXLVII DCCCXLVIII DCCCXLIX DCCCL DCCCLI DCCCLII DCCCLIII DCCCLIV DCCCLV DCCCLVI DCCCLVII DCCCLVIII DCCCLIX DCCCLX DCCCLXI DCCCLXII DCCCLXIII DCCCLXIV DCCCLXV DCCCLXVI DCCCLXVII DCCCLXVIII DCCCLXIX DCCCLXX DCCCLXXI DCCCLXXII DCCCLXXIII DCCCLXXIV DCCCLXXV DCCCLXXVI DCCCLXXVII DCCCLXXVIII DCCCLXXIX DCCCLXXX DCCCLXXXI DCCCLXXXII DCCCLXXXIII DCCCLXXXIV DCCCLXXXV DCCCLXXXVI DCCCLXXXVII DCCCLXXXVIII DCCCLXXXIX DCCCXC DCCCXCI DCCCXCII DCCCXCIII DCCCXCIV DCCCXCV DCCCXCVI DCCCXCVII DCCCXCVIII DCCCXCIX CM CMI CMII CMIII CMIV CMV CMVI CMVII CMVIII CMIX CMX CMXI CMXII CMXIII CMXIV CMXV CMXVI CMXVII CMXVIII CMXIX CMXX CMXXI CMXXII CMXXIII CMXXIV CMXXV CMXXVI CMXXVII CMXXVIII CMXXIX CMXXX CMXXXI CMXXXII CMXXXIII CMXXXIV CMXXXV CMXXXVI CMXXXVII CMXXXVIII CMXXXIX CMXL CMXLI CMXLII CMXLIII CMXLIV CMXLV CMXLVI CMXLVII CMXLVIII CMXLIX CML CMLI CMLII CMLIII CMLIV CMLV CMLVI CMLVII CMLVIII CMLIX CMLX CMLXI CMLXII CMLXIII CMLXIV CMLXV CMLXVI CMLXVII CMLXVIII CMLXIX CMLXX CMLXXI CMLXXII CMLXXIII CMLXXIV CMLXXV CMLXXVI CMLXXVII CMLXXVIII CMLXXIX CMLXXX CMLXXXI CMLXXXII CMLXXXIII CMLXXXIV CMLXXXV CMLXXXVI CMLXXXVII CMLXXXVIII CMLXXXIX CMXC CMXCI CMXCII CMXCIII CMXCIV CMXCV CMXCVI CMXCVII CMXCVIII CMXCIX M MI MII MIII MIV MV MVI MVII MVIII MIX MX MXI MXII MXIII MXIV MXV MXVI MXVII MXVIII MXIX MXX MXXI MXXII MXXIII MXXIV MXXV MXXVI MXXVII MXXVIII MXXIX MXXX MXXXI MXXXII MXXXIII MXXXIV MXXXV MXXXVI MXXXVII MXXXVIII MXXXIX MXL MXLI MXLII MXLIII MXLIV MXLV MXLVI MXLVII MXLVIII MXLIX ML MLI MLII MLIII MLIV MLV MLVI MLVII MLVIII MLIX MLX MLXI MLXII MLXIII MLXIV MLXV MLXVI MLXVII MLXVIII MLXIX MLXX MLXXI MLXXII MLXXIII MLXXIV MLXXV MLXXVI MLXXVII MLXXVIII MLXXIX MLXXX MLXXXI MLXXXII MLXXXIII MLXXXIV MLXXXV MLXXXVI MLXXXVII MLXXXVIII MLXXXIX MXC MXCI MXCII MXCIII MXCIV MXCV MXCVI MXCVII MXCVIII MXCIX MC MCI MCII MCIII MCIV MCV MCVI MCVII MCVIII MCIX MCX MCXI MCXII MCXIII MCXIV MCXV MCXVI MCXVII MCXVIII MCXIX MCXX MCXXI MCXXII MCXXIII MCXXIV MCXXV MCXXVI MCXXVII MCXXVIII MCXXIX MCXXX MCXXXI MCXXXII MCXXXIII MCXXXIV MCXXXV MCXXXVI MCXXXVII MCXXXVIII MCXXXIX MCXL MCXLI MCXLII MCXLIII MCXLIV MCXLV MCXLVI MCXLVII MCXLVIII MCXLIX MCL MCLI MCLII MCLIII MCLIV MCLV MCLVI MCLVII MCLVIII MCLIX MCLX MCLXI MCLXII MCLXIII MCLXIV MCLXV MCLXVI MCLXVII MCLXVIII MCLXIX MCLXX MCLXXI MCLXXII MCLXXIII MCLXXIV MCLXXV MCLXXVI MCLXXVII MCLXXVIII MCLXXIX MCLXXX MCLXXXI MCLXXXII MCLXXXIII MCLXXXIV MCLXXXV MCLXXXVI MCLXXXVII MCLXXXVIII MCLXXXIX MCXC MCXCI MCXCII MCXCIII MCXCIV MCXCV MCXCVI MCXCVII MCXCVIII MCXCIX MCC MCCI MCCII MCCIII MCCIV MCCV MCCVI MCCVII MCCVIII MCCIX MCCX MCCXI MCCXII MCCXIII MCCXIV MCCXV MCCXVI MCCXVII MCCXVIII MCCXIX MCCXX MCCXXI MCCXXII MCCXXIII MCCXXIV MCCXXV MCCXXVI MCCXXVII MCCXXVIII MCCXXIX MCCXXX MCCXXXI MCCXXXII MCCXXXIII MCCXXXIV MCCXXXV MCCXXXVI MCCXXXVII MCCXXXVIII MCCXXXIX MCCXL MCCXLI MCCXLII MCCXLIII MCCXLIV MCCXLV MCCXLVI MCCXLVII MCCXLVIII MCCXLIX MCCL MCCLI MCCLII MCCLIII MCCLIV MCCLV MCCLVI MCCLVII MCCLVIII MCCLIX MCCLX MCCLXI MCCLXII MCCLXIII MCCLXIV MCCLXV MCCLXVI MCCLXVII MCCLXVIII MCCLXIX MCCLXX MCCLXXI MCCLXXII MCCLXXIII MCCLXXIV MCCLXXV MCCLXXVI MCCLXXVII MCCLXXVIII MCCLXXIX MCCLXXX MCCLXXXI MCCLXXXII MCCLXXXIII MCCLXXXIV MCCLXXXV MCCLXXXVI MCCLXXXVII MCCLXXXVIII MCCLXXXIX MCCXC MCCXCI MCCXCII MCCXCIII MCCXCIV MCCXCV MCCXCVI MCCXCVII MCCXCVIII MCCXCIX MCCC MCCCI MCCCII MCCCIII MCCCIV MCCCV MCCCVI MCCCVII MCCCVIII MCCCIX MCCCX MCCCXI MCCCXII MCCCXIII MCCCXIV MCCCXV MCCCXVI MCCCXVII MCCCXVIII MCCCXIX MCCCXX MCCCXXI MCCCXXII MCCCXXIII MCCCXXIV MCCCXXV MCCCXXVI MCCCXXVII MCCCXXVIII MCCCXXIX MCCCXXX MCCCXXXI MCCCXXXII MCCCXXXIII MCCCXXXIV MCCCXXXV MCCCXXXVI MCCCXXXVII MCCCXXXVIII MCCCXXXIX MCCCXL MCCCXLI MCCCXLII MCCCXLIII MCCCXLIV MCCCXLV MCCCXLVI MCCCXLVII MCCCXLVIII MCCCXLIX MCCCL MCCCLI MCCCLII MCCCLIII MCCCLIV MCCCLV MCCCLVI MCCCLVII MCCCLVIII MCCCLIX MCCCLX MCCCLXI MCCCLXII MCCCLXIII MCCCLXIV MCCCLXV MCCCLXVI MCCCLXVII MCCCLXVIII MCCCLXIX MCCCLXX MCCCLXXI MCCCLXXII MCCCLXXIII MCCCLXXIV MCCCLXXV MCCCLXXVI MCCCLXXVII MCCCLXXVIII MCCCLXXIX MCCCLXXX MCCCLXXXI MCCCLXXXII MCCCLXXXIII MCCCLXXXIV MCCCLXXXV MCCCLXXXVI MCCCLXXXVII MCCCLXXXVIII MCCCLXXXIX MCCCXC MCCCXCI MCCCXCII MCCCXCIII MCCCXCIV MCCCXCV MCCCXCVI MCCCXCVII MCCCXCVIII MCCCXCIX MCD MCDI MCDII MCDIII MCDIV MCDV MCDVI MCDVII MCDVIII MCDIX MCDX MCDXI MCDXII MCDXIII MCDXIV MCDXV MCDXVI MCDXVII MCDXVIII MCDXIX MCDXX MCDXXI MCDXXII MCDXXIII MCDXXIV MCDXXV MCDXXVI MCDXXVII MCDXXVIII MCDXXIX MCDXXX MCDXXXI MCDXXXII MCDXXXIII MCDXXXIV MCDXXXV MCDXXXVI MCDXXXVII MCDXXXVIII MCDXXXIX MCDXL MCDXLI MCDXLII MCDXLIII MCDXLIV MCDXLV MCDXLVI MCDXLVII MCDXLVIII MCDXLIX MCDL MCDLI MCDLII MCDLIII MCDLIV MCDLV MCDLVI MCDLVII MCDLVIII MCDLIX MCDLX MCDLXI MCDLXII MCDLXIII MCDLXIV MCDLXV MCDLXVI MCDLXVII MCDLXVIII MCDLXIX MCDLXX MCDLXXI MCDLXXII MCDLXXIII MCDLXXIV MCDLXXV MCDLXXVI MCDLXXVII MCDLXXVIII MCDLXXIX MCDLXXX MCDLXXXI MCDLXXXII MCDLXXXIII MCDLXXXIV MCDLXXXV MCDLXXXVI MCDLXXXVII MCDLXXXVIII MCDLXXXIX MCDXC MCDXCI MCDXCII MCDXCIII MCDXCIV MCDXCV MCDXCVI MCDXCVII MCDXCVIII MCDXCIX MD MDI MDII MDIII MDIV MDV MDVI MDVII MDVIII MDIX MDX MDXI MDXII MDXIII MDXIV MDXV MDXVI MDXVII MDXVIII MDXIX MDXX MDXXI MDXXII MDXXIII MDXXIV MDXXV MDXXVI MDXXVII MDXXVIII MDXXIX MDXXX MDXXXI MDXXXII MDXXXIII MDXXXIV MDXXXV MDXXXVI MDXXXVII MDXXXVIII MDXXXIX MDXL MDXLI MDXLII MDXLIII MDXLIV MDXLV MDXLVI MDXLVII MDXLVIII MDXLIX MDL MDLI MDLII MDLIII MDLIV MDLV MDLVI MDLVII MDLVIII MDLIX MDLX MDLXI MDLXII MDLXIII MDLXIV MDLXV MDLXVI MDLXVII MDLXVIII MDLXIX MDLXX MDLXXI MDLXXII MDLXXIII MDLXXIV MDLXXV MDLXXVI MDLXXVII MDLXXVIII MDLXXIX MDLXXX MDLXXXI MDLXXXII MDLXXXIII MDLXXXIV MDLXXXV MDLXXXVI MDLXXXVII MDLXXXVIII MDLXXXIX MDXC MDXCI MDXCII MDXCIII MDXCIV MDXCV MDXCVI MDXCVII MDXCVIII MDXCIX MDC MDCI MDCII MDCIII MDCIV MDCV MDCVI MDCVII MDCVIII MDCIX MDCX MDCXI MDCXII MDCXIII MDCXIV MDCXV MDCXVI MDCXVII MDCXVIII MDCXIX MDCXX MDCXXI MDCXXII MDCXXIII MDCXXIV MDCXXV MDCXXVI MDCXXVII MDCXXVIII MDCXXIX MDCXXX MDCXXXI MDCXXXII MDCXXXIII MDCXXXIV MDCXXXV MDCXXXVI MDCXXXVII MDCXXXVIII MDCXXXIX MDCXL MDCXLI MDCXLII MDCXLIII MDCXLIV MDCXLV MDCXLVI MDCXLVII MDCXLVIII MDCXLIX MDCL MDCLI MDCLII MDCLIII MDCLIV MDCLV MDCLVI MDCLVII MDCLVIII MDCLIX MDCLX MDCLXI MDCLXII MDCLXIII MDCLXIV MDCLXV MDCLXVI MDCLXVII MDCLXVIII MDCLXIX MDCLXX MDCLXXI MDCLXXII MDCLXXIII MDCLXXIV MDCLXXV MDCLXXVI MDCLXXVII MDCLXXVIII MDCLXXIX MDCLXXX MDCLXXXI MDCLXXXII MDCLXXXIII MDCLXXXIV MDCLXXXV MDCLXXXVI MDCLXXXVII MDCLXXXVIII MDCLXXXIX MDCXC MDCXCI MDCXCII MDCXCIII MDCXCIV MDCXCV MDCXCVI MDCXCVII MDCXCVIII MDCXCIX MDCC MDCCI MDCCII MDCCIII MDCCIV MDCCV MDCCVI MDCCVII MDCCVIII MDCCIX MDCCX MDCCXI MDCCXII MDCCXIII MDCCXIV MDCCXV MDCCXVI MDCCXVII MDCCXVIII MDCCXIX MDCCXX MDCCXXI MDCCXXII MDCCXXIII MDCCXXIV MDCCXXV MDCCXXVI MDCCXXVII MDCCXXVIII MDCCXXIX MDCCXXX MDCCXXXI MDCCXXXII MDCCXXXIII MDCCXXXIV MDCCXXXV MDCCXXXVI MDCCXXXVII MDCCXXXVIII MDCCXXXIX MDCCXL MDCCXLI MDCCXLII MDCCXLIII MDCCXLIV MDCCXLV MDCCXLVI MDCCXLVII MDCCXLVIII MDCCXLIX MDCCL MDCCLI MDCCLII MDCCLIII MDCCLIV MDCCLV MDCCLVI MDCCLVII MDCCLVIII MDCCLIX MDCCLX MDCCLXI MDCCLXII MDCCLXIII MDCCLXIV MDCCLXV MDCCLXVI MDCCLXVII MDCCLXVIII MDCCLXIX MDCCLXX MDCCLXXI MDCCLXXII MDCCLXXIII MDCCLXXIV MDCCLXXV MDCCLXXVI MDCCLXXVII MDCCLXXVIII MDCCLXXIX MDCCLXXX MDCCLXXXI MDCCLXXXII MDCCLXXXIII MDCCLXXXIV MDCCLXXXV MDCCLXXXVI MDCCLXXXVII MDCCLXXXVIII MDCCLXXXIX MDCCXC MDCCXCI MDCCXCII MDCCXCIII MDCCXCIV MDCCXCV MDCCXCVI MDCCXCVII MDCCXCVIII MDCCXCIX MDCCC MDCCCI MDCCCII MDCCCIII MDCCCIV MDCCCV MDCCCVI MDCCCVII MDCCCVIII MDCCCIX MDCCCX MDCCCXI MDCCCXII MDCCCXIII MDCCCXIV MDCCCXV MDCCCXVI MDCCCXVII MDCCCXVIII MDCCCXIX MDCCCXX MDCCCXXI MDCCCXXII MDCCCXXIII MDCCCXXIV MDCCCXXV MDCCCXXVI MDCCCXXVII MDCCCXXVIII MDCCCXXIX MDCCCXXX MDCCCXXXI MDCCCXXXII MDCCCXXXIII MDCCCXXXIV MDCCCXXXV MDCCCXXXVI MDCCCXXXVII MDCCCXXXVIII MDCCCXXXIX MDCCCXL MDCCCXLI MDCCCXLII MDCCCXLIII MDCCCXLIV MDCCCXLV MDCCCXLVI MDCCCXLVII MDCCCXLVIII MDCCCXLIX MDCCCL MDCCCLI MDCCCLII MDCCCLIII MDCCCLIV MDCCCLV MDCCCLVI MDCCCLVII MDCCCLVIII MDCCCLIX MDCCCLX MDCCCLXI MDCCCLXII MDCCCLXIII MDCCCLXIV MDCCCLXV MDCCCLXVI MDCCCLXVII MDCCCLXVIII MDCCCLXIX MDCCCLXX MDCCCLXXI MDCCCLXXII MDCCCLXXIII MDCCCLXXIV MDCCCLXXV MDCCCLXXVI MDCCCLXXVII MDCCCLXXVIII MDCCCLXXIX MDCCCLXXX MDCCCLXXXI MDCCCLXXXII MDCCCLXXXIII MDCCCLXXXIV MDCCCLXXXV MDCCCLXXXVI MDCCCLXXXVII MDCCCLXXXVIII MDCCCLXXXIX MDCCCXC MDCCCXCI MDCCCXCII MDCCCXCIII MDCCCXCIV MDCCCXCV MDCCCXCVI MDCCCXCVII MDCCCXCVIII MDCCCXCIX MCM MCMI MCMII MCMIII MCMIV MCMV MCMVI MCMVII MCMVIII MCMIX MCMX MCMXI MCMXII MCMXIII MCMXIV MCMXV MCMXVI MCMXVII MCMXVIII MCMXIX MCMXX MCMXXI MCMXXII MCMXXIII MCMXXIV MCMXXV MCMXXVI MCMXXVII MCMXXVIII MCMXXIX MCMXXX MCMXXXI MCMXXXII MCMXXXIII MCMXXXIV MCMXXXV MCMXXXVI MCMXXXVII MCMXXXVIII MCMXXXIX MCMXL MCMXLI MCMXLII MCMXLIII MCMXLIV MCMXLV MCMXLVI MCMXLVII MCMXLVIII MCMXLIX MCML MCMLI MCMLII MCMLIII MCMLIV MCMLV MCMLVI MCMLVII MCMLVIII MCMLIX MCMLX MCMLXI MCMLXII MCMLXIII MCMLXIV MCMLXV MCMLXVI MCMLXVII MCMLXVIII MCMLXIX MCMLXX MCMLXXI MCMLXXII MCMLXXIII MCMLXXIV MCMLXXV MCMLXXVI MCMLXXVII MCMLXXVIII MCMLXXIX MCMLXXX MCMLXXXI MCMLXXXII MCMLXXXIII MCMLXXXIV MCMLXXXV MCMLXXXVI MCMLXXXVII MCMLXXXVIII MCMLXXXIX MCMXC MCMXCI MCMXCII MCMXCIII MCMXCIV MCMXCV MCMXCVI MCMXCVII MCMXCVIII MCMXCIX MM MMI MMII MMIII MMIV MMV MMVI MMVII MMVIII MMIX MMX MMXI MMXII MMXIII MMXIV MMXV MMXVI MMXVII MMXVIII MMXIX MMXX MMXXI MMXXII MMXXIII MMXXIV MMXXV MMXXVI MMXXVII MMXXVIII MMXXIX MMXXX MMXXXI MMXXXII MMXXXIII MMXXXIV MMXXXV MMXXXVI MMXXXVII MMXXXVIII MMXXXIX MMXL MMXLI MMXLII MMXLIII MMXLIV MMXLV MMXLVI MMXLVII MMXLVIII MMXLIX MML MMLI MMLII MMLIII MMLIV MMLV MMLVI MMLVII MMLVIII MMLIX MMLX MMLXI MMLXII MMLXIII MMLXIV MMLXV MMLXVI MMLXVII MMLXVIII MMLXIX MMLXX MMLXXI MMLXXII MMLXXIII MMLXXIV MMLXXV MMLXXVI MMLXXVII MMLXXVIII MMLXXIX MMLXXX MMLXXXI MMLXXXII MMLXXXIII MMLXXXIV MMLXXXV MMLXXXVI MMLXXXVII MMLXXXVIII MMLXXXIX MMXC MMXCI MMXCII MMXCIII MMXCIV MMXCV MMXCVI MMXCVII MMXCVIII MMXCIX MMC MMCI MMCII MMCIII MMCIV MMCV MMCVI MMCVII MMCVIII MMCIX MMCX MMCXI MMCXII MMCXIII MMCXIV MMCXV MMCXVI MMCXVII MMCXVIII MMCXIX MMCXX MMCXXI MMCXXII MMCXXIII MMCXXIV MMCXXV MMCXXVI MMCXXVII MMCXXVIII MMCXXIX MMCXXX MMCXXXI MMCXXXII MMCXXXIII MMCXXXIV MMCXXXV MMCXXXVI MMCXXXVII MMCXXXVIII MMCXXXIX MMCXL MMCXLI MMCXLII MMCXLIII MMCXLIV MMCXLV MMCXLVI MMCXLVII MMCXLVIII MMCXLIX MMCL MMCLI MMCLII MMCLIII MMCLIV MMCLV MMCLVI MMCLVII MMCLVIII MMCLIX MMCLX MMCLXI MMCLXII MMCLXIII MMCLXIV MMCLXV MMCLXVI MMCLXVII MMCLXVIII MMCLXIX MMCLXX MMCLXXI MMCLXXII MMCLXXIII MMCLXXIV MMCLXXV MMCLXXVI MMCLXXVII MMCLXXVIII MMCLXXIX MMCLXXX MMCLXXXI MMCLXXXII MMCLXXXIII MMCLXXXIV MMCLXXXV MMCLXXXVI MMCLXXXVII MMCLXXXVIII MMCLXXXIX MMCXC MMCXCI MMCXCII MMCXCIII MMCXCIV MMCXCV MMCXCVI MMCXCVII MMCXCVIII MMCXCIX MMCC MMCCI MMCCII MMCCIII MMCCIV MMCCV MMCCVI MMCCVII MMCCVIII MMCCIX MMCCX MMCCXI MMCCXII MMCCXIII MMCCXIV MMCCXV MMCCXVI MMCCXVII MMCCXVIII MMCCXIX MMCCXX MMCCXXI MMCCXXII MMCCXXIII MMCCXXIV MMCCXXV MMCCXXVI MMCCXXVII MMCCXXVIII MMCCXXIX MMCCXXX MMCCXXXI MMCCXXXII MMCCXXXIII MMCCXXXIV MMCCXXXV MMCCXXXVI MMCCXXXVII MMCCXXXVIII MMCCXXXIX MMCCXL MMCCXLI MMCCXLII MMCCXLIII MMCCXLIV MMCCXLV MMCCXLVI MMCCXLVII MMCCXLVIII MMCCXLIX MMCCL MMCCLI MMCCLII MMCCLIII MMCCLIV MMCCLV MMCCLVI MMCCLVII MMCCLVIII MMCCLIX MMCCLX MMCCLXI MMCCLXII MMCCLXIII MMCCLXIV MMCCLXV MMCCLXVI MMCCLXVII MMCCLXVIII MMCCLXIX MMCCLXX MMCCLXXI MMCCLXXII MMCCLXXIII MMCCLXXIV MMCCLXXV MMCCLXXVI MMCCLXXVII MMCCLXXVIII MMCCLXXIX MMCCLXXX MMCCLXXXI MMCCLXXXII MMCCLXXXIII MMCCLXXXIV MMCCLXXXV MMCCLXXXVI MMCCLXXXVII MMCCLXXXVIII MMCCLXXXIX MMCCXC MMCCXCI MMCCXCII MMCCXCIII MMCCXCIV MMCCXCV MMCCXCVI MMCCXCVII MMCCXCVIII MMCCXCIX MMCCC MMCCCI MMCCCII MMCCCIII MMCCCIV MMCCCV MMCCCVI MMCCCVII MMCCCVIII MMCCCIX MMCCCX MMCCCXI MMCCCXII MMCCCXIII MMCCCXIV MMCCCXV MMCCCXVI MMCCCXVII MMCCCXVIII MMCCCXIX MMCCCXX MMCCCXXI MMCCCXXII MMCCCXXIII MMCCCXXIV MMCCCXXV MMCCCXXVI MMCCCXXVII MMCCCXXVIII MMCCCXXIX MMCCCXXX MMCCCXXXI MMCCCXXXII MMCCCXXXIII MMCCCXXXIV MMCCCXXXV MMCCCXXXVI MMCCCXXXVII MMCCCXXXVIII MMCCCXXXIX MMCCCXL MMCCCXLI MMCCCXLII MMCCCXLIII MMCCCXLIV MMCCCXLV MMCCCXLVI MMCCCXLVII MMCCCXLVIII MMCCCXLIX MMCCCL MMCCCLI MMCCCLII MMCCCLIII MMCCCLIV MMCCCLV MMCCCLVI MMCCCLVII MMCCCLVIII MMCCCLIX MMCCCLX MMCCCLXI MMCCCLXII MMCCCLXIII MMCCCLXIV MMCCCLXV MMCCCLXVI MMCCCLXVII MMCCCLXVIII MMCCCLXIX MMCCCLXX MMCCCLXXI MMCCCLXXII MMCCCLXXIII MMCCCLXXIV MMCCCLXXV MMCCCLXXVI MMCCCLXXVII MMCCCLXXVIII MMCCCLXXIX MMCCCLXXX MMCCCLXXXI MMCCCLXXXII MMCCCLXXXIII MMCCCLXXXIV MMCCCLXXXV MMCCCLXXXVI MMCCCLXXXVII MMCCCLXXXVIII MMCCCLXXXIX MMCCCXC MMCCCXCI MMCCCXCII MMCCCXCIII MMCCCXCIV MMCCCXCV MMCCCXCVI MMCCCXCVII MMCCCXCVIII MMCCCXCIX MMCD MMCDI MMCDII MMCDIII MMCDIV MMCDV MMCDVI MMCDVII MMCDVIII MMCDIX MMCDX MMCDXI MMCDXII MMCDXIII MMCDXIV MMCDXV MMCDXVI MMCDXVII MMCDXVIII MMCDXIX MMCDXX MMCDXXI MMCDXXII MMCDXXIII MMCDXXIV MMCDXXV MMCDXXVI MMCDXXVII MMCDXXVIII MMCDXXIX MMCDXXX MMCDXXXI MMCDXXXII MMCDXXXIII MMCDXXXIV MMCDXXXV MMCDXXXVI MMCDXXXVII MMCDXXXVIII MMCDXXXIX MMCDXL MMCDXLI MMCDXLII MMCDXLIII MMCDXLIV MMCDXLV MMCDXLVI MMCDXLVII MMCDXLVIII MMCDXLIX MMCDL MMCDLI MMCDLII MMCDLIII MMCDLIV MMCDLV MMCDLVI MMCDLVII MMCDLVIII MMCDLIX MMCDLX MMCDLXI MMCDLXII MMCDLXIII MMCDLXIV MMCDLXV MMCDLXVI MMCDLXVII MMCDLXVIII MMCDLXIX MMCDLXX MMCDLXXI MMCDLXXII MMCDLXXIII MMCDLXXIV MMCDLXXV MMCDLXXVI MMCDLXXVII MMCDLXXVIII MMCDLXXIX MMCDLXXX MMCDLXXXI MMCDLXXXII MMCDLXXXIII MMCDLXXXIV MMCDLXXXV MMCDLXXXVI MMCDLXXXVII MMCDLXXXVIII MMCDLXXXIX MMCDXC MMCDXCI MMCDXCII MMCDXCIII MMCDXCIV MMCDXCV MMCDXCVI MMCDXCVII MMCDXCVIII MMCDXCIX MMD MMDI MMDII MMDIII MMDIV MMDV MMDVI MMDVII MMDVIII MMDIX MMDX MMDXI MMDXII MMDXIII MMDXIV MMDXV MMDXVI MMDXVII MMDXVIII MMDXIX MMDXX MMDXXI MMDXXII MMDXXIII MMDXXIV MMDXXV MMDXXVI MMDXXVII MMDXXVIII MMDXXIX MMDXXX MMDXXXI MMDXXXII MMDXXXIII MMDXXXIV MMDXXXV MMDXXXVI MMDXXXVII MMDXXXVIII MMDXXXIX MMDXL MMDXLI MMDXLII MMDXLIII MMDXLIV MMDXLV MMDXLVI MMDXLVII MMDXLVIII MMDXLIX MMDL MMDLI MMDLII MMDLIII MMDLIV MMDLV MMDLVI MMDLVII MMDLVIII MMDLIX MMDLX MMDLXI MMDLXII MMDLXIII MMDLXIV MMDLXV MMDLXVI MMDLXVII MMDLXVIII MMDLXIX MMDLXX MMDLXXI MMDLXXII MMDLXXIII MMDLXXIV MMDLXXV MMDLXXVI MMDLXXVII MMDLXXVIII MMDLXXIX MMDLXXX MMDLXXXI MMDLXXXII MMDLXXXIII MMDLXXXIV MMDLXXXV MMDLXXXVI MMDLXXXVII MMDLXXXVIII MMDLXXXIX MMDXC MMDXCI MMDXCII MMDXCIII MMDXCIV MMDXCV MMDXCVI MMDXCVII MMDXCVIII MMDXCIX MMDC MMDCI MMDCII MMDCIII MMDCIV MMDCV MMDCVI MMDCVII MMDCVIII MMDCIX MMDCX MMDCXI MMDCXII MMDCXIII MMDCXIV MMDCXV MMDCXVI MMDCXVII MMDCXVIII MMDCXIX MMDCXX MMDCXXI MMDCXXII MMDCXXIII MMDCXXIV MMDCXXV MMDCXXVI MMDCXXVII MMDCXXVIII MMDCXXIX MMDCXXX MMDCXXXI MMDCXXXII MMDCXXXIII MMDCXXXIV MMDCXXXV MMDCXXXVI MMDCXXXVII MMDCXXXVIII MMDCXXXIX MMDCXL MMDCXLI MMDCXLII MMDCXLIII MMDCXLIV MMDCXLV MMDCXLVI MMDCXLVII MMDCXLVIII MMDCXLIX MMDCL MMDCLI MMDCLII MMDCLIII MMDCLIV MMDCLV MMDCLVI MMDCLVII MMDCLVIII MMDCLIX MMDCLX MMDCLXI MMDCLXII MMDCLXIII MMDCLXIV MMDCLXV MMDCLXVI MMDCLXVII MMDCLXVIII MMDCLXIX MMDCLXX MMDCLXXI MMDCLXXII MMDCLXXIII MMDCLXXIV MMDCLXXV MMDCLXXVI MMDCLXXVII MMDCLXXVIII MMDCLXXIX MMDCLXXX MMDCLXXXI MMDCLXXXII MMDCLXXXIII MMDCLXXXIV MMDCLXXXV MMDCLXXXVI MMDCLXXXVII MMDCLXXXVIII MMDCLXXXIX MMDCXC MMDCXCI MMDCXCII MMDCXCIII MMDCXCIV MMDCXCV MMDCXCVI MMDCXCVII MMDCXCVIII MMDCXCIX MMDCC MMDCCI MMDCCII MMDCCIII MMDCCIV MMDCCV MMDCCVI MMDCCVII MMDCCVIII MMDCCIX MMDCCX MMDCCXI MMDCCXII MMDCCXIII MMDCCXIV MMDCCXV MMDCCXVI MMDCCXVII MMDCCXVIII MMDCCXIX MMDCCXX MMDCCXXI MMDCCXXII MMDCCXXIII MMDCCXXIV MMDCCXXV MMDCCXXVI MMDCCXXVII MMDCCXXVIII MMDCCXXIX MMDCCXXX MMDCCXXXI MMDCCXXXII MMDCCXXXIII MMDCCXXXIV MMDCCXXXV MMDCCXXXVI MMDCCXXXVII MMDCCXXXVIII MMDCCXXXIX MMDCCXL MMDCCXLI MMDCCXLII MMDCCXLIII MMDCCXLIV MMDCCXLV MMDCCXLVI MMDCCXLVII MMDCCXLVIII MMDCCXLIX MMDCCL MMDCCLI MMDCCLII MMDCCLIII MMDCCLIV MMDCCLV MMDCCLVI MMDCCLVII MMDCCLVIII MMDCCLIX MMDCCLX MMDCCLXI MMDCCLXII MMDCCLXIII MMDCCLXIV MMDCCLXV MMDCCLXVI MMDCCLXVII MMDCCLXVIII MMDCCLXIX MMDCCLXX MMDCCLXXI MMDCCLXXII MMDCCLXXIII MMDCCLXXIV MMDCCLXXV MMDCCLXXVI MMDCCLXXVII MMDCCLXXVIII MMDCCLXXIX MMDCCLXXX MMDCCLXXXI MMDCCLXXXII MMDCCLXXXIII MMDCCLXXXIV MMDCCLXXXV MMDCCLXXXVI MMDCCLXXXVII MMDCCLXXXVIII MMDCCLXXXIX MMDCCXC MMDCCXCI MMDCCXCII MMDCCXCIII MMDCCXCIV MMDCCXCV MMDCCXCVI MMDCCXCVII MMDCCXCVIII MMDCCXCIX MMDCCC MMDCCCI MMDCCCII MMDCCCIII MMDCCCIV MMDCCCV MMDCCCVI MMDCCCVII MMDCCCVIII MMDCCCIX MMDCCCX MMDCCCXI MMDCCCXII MMDCCCXIII MMDCCCXIV MMDCCCXV MMDCCCXVI MMDCCCXVII MMDCCCXVIII MMDCCCXIX MMDCCCXX MMDCCCXXI MMDCCCXXII MMDCCCXXIII MMDCCCXXIV MMDCCCXXV MMDCCCXXVI MMDCCCXXVII MMDCCCXXVIII MMDCCCXXIX MMDCCCXXX MMDCCCXXXI MMDCCCXXXII MMDCCCXXXIII MMDCCCXXXIV MMDCCCXXXV MMDCCCXXXVI MMDCCCXXXVII MMDCCCXXXVIII MMDCCCXXXIX MMDCCCXL MMDCCCXLI MMDCCCXLII MMDCCCXLIII MMDCCCXLIV MMDCCCXLV MMDCCCXLVI MMDCCCXLVII MMDCCCXLVIII MMDCCCXLIX MMDCCCL MMDCCCLI MMDCCCLII MMDCCCLIII MMDCCCLIV MMDCCCLV MMDCCCLVI MMDCCCLVII MMDCCCLVIII MMDCCCLIX MMDCCCLX MMDCCCLXI MMDCCCLXII MMDCCCLXIII MMDCCCLXIV MMDCCCLXV MMDCCCLXVI MMDCCCLXVII MMDCCCLXVIII MMDCCCLXIX MMDCCCLXX MMDCCCLXXI MMDCCCLXXII MMDCCCLXXIII MMDCCCLXXIV MMDCCCLXXV MMDCCCLXXVI MMDCCCLXXVII MMDCCCLXXVIII MMDCCCLXXIX MMDCCCLXXX MMDCCCLXXXI MMDCCCLXXXII MMDCCCLXXXIII MMDCCCLXXXIV MMDCCCLXXXV MMDCCCLXXXVI MMDCCCLXXXVII MMDCCCLXXXVIII MMDCCCLXXXIX MMDCCCXC MMDCCCXCI MMDCCCXCII MMDCCCXCIII MMDCCCXCIV MMDCCCXCV MMDCCCXCVI MMDCCCXCVII MMDCCCXCVIII MMDCCCXCIX MMCM MMCMI MMCMII MMCMIII MMCMIV MMCMV MMCMVI MMCMVII MMCMVIII MMCMIX MMCMX MMCMXI MMCMXII MMCMXIII MMCMXIV MMCMXV MMCMXVI MMCMXVII MMCMXVIII MMCMXIX MMCMXX MMCMXXI MMCMXXII MMCMXXIII MMCMXXIV MMCMXXV MMCMXXVI MMCMXXVII MMCMXXVIII MMCMXXIX MMCMXXX MMCMXXXI MMCMXXXII MMCMXXXIII MMCMXXXIV MMCMXXXV MMCMXXXVI MMCMXXXVII MMCMXXXVIII MMCMXXXIX MMCMXL MMCMXLI MMCMXLII MMCMXLIII MMCMXLIV MMCMXLV MMCMXLVI MMCMXLVII MMCMXLVIII MMCMXLIX MMCML MMCMLI MMCMLII MMCMLIII MMCMLIV MMCMLV MMCMLVI MMCMLVII MMCMLVIII MMCMLIX MMCMLX MMCMLXI MMCMLXII MMCMLXIII MMCMLXIV MMCMLXV MMCMLXVI MMCMLXVII MMCMLXVIII MMCMLXIX MMCMLXX MMCMLXXI MMCMLXXII MMCMLXXIII MMCMLXXIV MMCMLXXV MMCMLXXVI MMCMLXXVII MMCMLXXVIII MMCMLXXIX MMCMLXXX MMCMLXXXI MMCMLXXXII MMCMLXXXIII MMCMLXXXIV MMCMLXXXV MMCMLXXXVI MMCMLXXXVII MMCMLXXXVIII MMCMLXXXIX MMCMXC MMCMXCI MMCMXCII MMCMXCIII MMCMXCIV MMCMXCV MMCMXCVI MMCMXCVII MMCMXCVIII MMCMXCIX MMM MMMI MMMII MMMIII MMMIV MMMV MMMVI MMMVII MMMVIII MMMIX MMMX MMMXI MMMXII MMMXIII MMMXIV MMMXV MMMXVI MMMXVII MMMXVIII MMMXIX MMMXX MMMXXI MMMXXII MMMXXIII MMMXXIV MMMXXV MMMXXVI MMMXXVII MMMXXVIII MMMXXIX MMMXXX MMMXXXI MMMXXXII MMMXXXIII MMMXXXIV MMMXXXV MMMXXXVI MMMXXXVII MMMXXXVIII MMMXXXIX MMMXL MMMXLI MMMXLII MMMXLIII MMMXLIV MMMXLV MMMXLVI MMMXLVII MMMXLVIII MMMXLIX MMML MMMLI MMMLII MMMLIII MMMLIV MMMLV MMMLVI MMMLVII MMMLVIII MMMLIX MMMLX MMMLXI MMMLXII MMMLXIII MMMLXIV MMMLXV MMMLXVI MMMLXVII MMMLXVIII MMMLXIX MMMLXX MMMLXXI MMMLXXII MMMLXXIII MMMLXXIV MMMLXXV MMMLXXVI MMMLXXVII MMMLXXVIII MMMLXXIX MMMLXXX MMMLXXXI MMMLXXXII MMMLXXXIII MMMLXXXIV MMMLXXXV MMMLXXXVI MMMLXXXVII MMMLXXXVIII MMMLXXXIX MMMXC MMMXCI MMMXCII MMMXCIII MMMXCIV MMMXCV MMMXCVI MMMXCVII MMMXCVIII MMMXCIX MMMC MMMCI MMMCII MMMCIII MMMCIV MMMCV MMMCVI MMMCVII MMMCVIII MMMCIX MMMCX MMMCXI MMMCXII MMMCXIII MMMCXIV MMMCXV MMMCXVI MMMCXVII MMMCXVIII MMMCXIX MMMCXX MMMCXXI MMMCXXII MMMCXXIII MMMCXXIV MMMCXXV MMMCXXVI MMMCXXVII MMMCXXVIII MMMCXXIX MMMCXXX MMMCXXXI MMMCXXXII MMMCXXXIII MMMCXXXIV MMMCXXXV MMMCXXXVI MMMCXXXVII MMMCXXXVIII MMMCXXXIX MMMCXL MMMCXLI MMMCXLII MMMCXLIII MMMCXLIV MMMCXLV MMMCXLVI MMMCXLVII MMMCXLVIII MMMCXLIX MMMCL MMMCLI MMMCLII MMMCLIII MMMCLIV MMMCLV MMMCLVI MMMCLVII MMMCLVIII MMMCLIX MMMCLX MMMCLXI MMMCLXII MMMCLXIII MMMCLXIV MMMCLXV MMMCLXVI MMMCLXVII MMMCLXVIII MMMCLXIX MMMCLXX MMMCLXXI MMMCLXXII MMMCLXXIII MMMCLXXIV MMMCLXXV MMMCLXXVI MMMCLXXVII MMMCLXXVIII MMMCLXXIX MMMCLXXX MMMCLXXXI MMMCLXXXII MMMCLXXXIII MMMCLXXXIV MMMCLXXXV MMMCLXXXVI MMMCLXXXVII MMMCLXXXVIII MMMCLXXXIX MMMCXC MMMCXCI MMMCXCII MMMCXCIII MMMCXCIV MMMCXCV MMMCXCVI MMMCXCVII MMMCXCVIII MMMCXCIX MMMCC MMMCCI MMMCCII MMMCCIII MMMCCIV MMMCCV MMMCCVI MMMCCVII MMMCCVIII MMMCCIX MMMCCX MMMCCXI MMMCCXII MMMCCXIII MMMCCXIV MMMCCXV MMMCCXVI MMMCCXVII MMMCCXVIII MMMCCXIX MMMCCXX MMMCCXXI MMMCCXXII MMMCCXXIII MMMCCXXIV MMMCCXXV MMMCCXXVI MMMCCXXVII MMMCCXXVIII MMMCCXXIX MMMCCXXX MMMCCXXXI MMMCCXXXII MMMCCXXXIII MMMCCXXXIV MMMCCXXXV MMMCCXXXVI MMMCCXXXVII MMMCCXXXVIII MMMCCXXXIX MMMCCXL MMMCCXLI MMMCCXLII MMMCCXLIII MMMCCXLIV MMMCCXLV MMMCCXLVI MMMCCXLVII MMMCCXLVIII MMMCCXLIX MMMCCL MMMCCLI MMMCCLII MMMCCLIII MMMCCLIV MMMCCLV MMMCCLVI MMMCCLVII MMMCCLVIII MMMCCLIX MMMCCLX MMMCCLXI MMMCCLXII MMMCCLXIII MMMCCLXIV MMMCCLXV MMMCCLXVI MMMCCLXVII MMMCCLXVIII MMMCCLXIX MMMCCLXX MMMCCLXXI MMMCCLXXII MMMCCLXXIII MMMCCLXXIV MMMCCLXXV MMMCCLXXVI MMMCCLXXVII MMMCCLXXVIII MMMCCLXXIX MMMCCLXXX MMMCCLXXXI MMMCCLXXXII MMMCCLXXXIII MMMCCLXXXIV MMMCCLXXXV MMMCCLXXXVI MMMCCLXXXVII MMMCCLXXXVIII MMMCCLXXXIX MMMCCXC MMMCCXCI MMMCCXCII MMMCCXCIII MMMCCXCIV MMMCCXCV MMMCCXCVI MMMCCXCVII MMMCCXCVIII MMMCCXCIX MMMCCC MMMCCCI MMMCCCII MMMCCCIII MMMCCCIV MMMCCCV MMMCCCVI MMMCCCVII MMMCCCVIII MMMCCCIX MMMCCCX MMMCCCXI MMMCCCXII MMMCCCXIII MMMCCCXIV MMMCCCXV MMMCCCXVI MMMCCCXVII MMMCCCXVIII MMMCCCXIX MMMCCCXX MMMCCCXXI MMMCCCXXII MMMCCCXXIII MMMCCCXXIV MMMCCCXXV MMMCCCXXVI MMMCCCXXVII MMMCCCXXVIII MMMCCCXXIX MMMCCCXXX MMMCCCXXXI MMMCCCXXXII MMMCCCXXXIII MMMCCCXXXIV MMMCCCXXXV MMMCCCXXXVI MMMCCCXXXVII MMMCCCXXXVIII MMMCCCXXXIX MMMCCCXL MMMCCCXLI MMMCCCXLII MMMCCCXLIII MMMCCCXLIV MMMCCCXLV MMMCCCXLVI MMMCCCXLVII MMMCCCXLVIII MMMCCCXLIX MMMCCCL MMMCCCLI MMMCCCLII MMMCCCLIII MMMCCCLIV MMMCCCLV MMMCCCLVI MMMCCCLVII MMMCCCLVIII MMMCCCLIX MMMCCCLX MMMCCCLXI MMMCCCLXII MMMCCCLXIII MMMCCCLXIV MMMCCCLXV MMMCCCLXVI MMMCCCLXVII MMMCCCLXVIII MMMCCCLXIX MMMCCCLXX MMMCCCLXXI MMMCCCLXXII MMMCCCLXXIII MMMCCCLXXIV MMMCCCLXXV MMMCCCLXXVI MMMCCCLXXVII MMMCCCLXXVIII MMMCCCLXXIX MMMCCCLXXX MMMCCCLXXXI MMMCCCLXXXII MMMCCCLXXXIII MMMCCCLXXXIV MMMCCCLXXXV MMMCCCLXXXVI MMMCCCLXXXVII MMMCCCLXXXVIII MMMCCCLXXXIX MMMCCCXC MMMCCCXCI MMMCCCXCII MMMCCCXCIII MMMCCCXCIV MMMCCCXCV MMMCCCXCVI MMMCCCXCVII MMMCCCXCVIII MMMCCCXCIX MMMCD MMMCDI MMMCDII MMMCDIII MMMCDIV MMMCDV MMMCDVI MMMCDVII MMMCDVIII MMMCDIX MMMCDX MMMCDXI MMMCDXII MMMCDXIII MMMCDXIV MMMCDXV MMMCDXVI MMMCDXVII MMMCDXVIII MMMCDXIX MMMCDXX MMMCDXXI MMMCDXXII MMMCDXXIII MMMCDXXIV MMMCDXXV MMMCDXXVI MMMCDXXVII MMMCDXXVIII MMMCDXXIX MMMCDXXX MMMCDXXXI MMMCDXXXII MMMCDXXXIII MMMCDXXXIV MMMCDXXXV MMMCDXXXVI MMMCDXXXVII MMMCDXXXVIII MMMCDXXXIX MMMCDXL MMMCDXLI MMMCDXLII MMMCDXLIII MMMCDXLIV MMMCDXLV MMMCDXLVI MMMCDXLVII MMMCDXLVIII MMMCDXLIX MMMCDL MMMCDLI MMMCDLII MMMCDLIII MMMCDLIV MMMCDLV MMMCDLVI MMMCDLVII MMMCDLVIII MMMCDLIX MMMCDLX MMMCDLXI MMMCDLXII MMMCDLXIII MMMCDLXIV MMMCDLXV MMMCDLXVI MMMCDLXVII MMMCDLXVIII MMMCDLXIX MMMCDLXX MMMCDLXXI MMMCDLXXII MMMCDLXXIII MMMCDLXXIV MMMCDLXXV MMMCDLXXVI MMMCDLXXVII MMMCDLXXVIII MMMCDLXXIX MMMCDLXXX MMMCDLXXXI MMMCDLXXXII MMMCDLXXXIII MMMCDLXXXIV MMMCDLXXXV MMMCDLXXXVI MMMCDLXXXVII MMMCDLXXXVIII MMMCDLXXXIX MMMCDXC MMMCDXCI MMMCDXCII MMMCDXCIII MMMCDXCIV MMMCDXCV MMMCDXCVI MMMCDXCVII MMMCDXCVIII MMMCDXCIX MMMD MMMDI MMMDII MMMDIII MMMDIV MMMDV MMMDVI MMMDVII MMMDVIII MMMDIX MMMDX MMMDXI MMMDXII MMMDXIII MMMDXIV MMMDXV MMMDXVI MMMDXVII MMMDXVIII MMMDXIX MMMDXX MMMDXXI MMMDXXII MMMDXXIII MMMDXXIV MMMDXXV MMMDXXVI MMMDXXVII MMMDXXVIII MMMDXXIX MMMDXXX MMMDXXXI MMMDXXXII MMMDXXXIII MMMDXXXIV MMMDXXXV MMMDXXXVI MMMDXXXVII MMMDXXXVIII MMMDXXXIX MMMDXL MMMDXLI MMMDXLII MMMDXLIII MMMDXLIV MMMDXLV MMMDXLVI MMMDXLVII MMMDXLVIII MMMDXLIX MMMDL MMMDLI MMMDLII MMMDLIII MMMDLIV MMMDLV MMMDLVI MMMDLVII MMMDLVIII MMMDLIX MMMDLX MMMDLXI MMMDLXII MMMDLXIII MMMDLXIV MMMDLXV MMMDLXVI MMMDLXVII MMMDLXVIII MMMDLXIX MMMDLXX MMMDLXXI MMMDLXXII MMMDLXXIII MMMDLXXIV MMMDLXXV MMMDLXXVI MMMDLXXVII MMMDLXXVIII MMMDLXXIX MMMDLXXX MMMDLXXXI MMMDLXXXII MMMDLXXXIII MMMDLXXXIV MMMDLXXXV MMMDLXXXVI MMMDLXXXVII MMMDLXXXVIII MMMDLXXXIX MMMDXC MMMDXCI MMMDXCII MMMDXCIII MMMDXCIV MMMDXCV MMMDXCVI MMMDXCVII MMMDXCVIII MMMDXCIX MMMDC MMMDCI MMMDCII MMMDCIII MMMDCIV MMMDCV MMMDCVI MMMDCVII MMMDCVIII MMMDCIX MMMDCX MMMDCXI MMMDCXII MMMDCXIII MMMDCXIV MMMDCXV MMMDCXVI MMMDCXVII MMMDCXVIII MMMDCXIX MMMDCXX MMMDCXXI MMMDCXXII MMMDCXXIII MMMDCXXIV MMMDCXXV MMMDCXXVI MMMDCXXVII MMMDCXXVIII MMMDCXXIX MMMDCXXX MMMDCXXXI MMMDCXXXII MMMDCXXXIII MMMDCXXXIV MMMDCXXXV MMMDCXXXVI MMMDCXXXVII MMMDCXXXVIII MMMDCXXXIX MMMDCXL MMMDCXLI MMMDCXLII MMMDCXLIII MMMDCXLIV MMMDCXLV MMMDCXLVI MMMDCXLVII MMMDCXLVIII MMMDCXLIX MMMDCL MMMDCLI MMMDCLII MMMDCLIII MMMDCLIV MMMDCLV MMMDCLVI MMMDCLVII MMMDCLVIII MMMDCLIX MMMDCLX MMMDCLXI MMMDCLXII MMMDCLXIII MMMDCLXIV MMMDCLXV MMMDCLXVI MMMDCLXVII MMMDCLXVIII MMMDCLXIX MMMDCLXX MMMDCLXXI MMMDCLXXII MMMDCLXXIII MMMDCLXXIV MMMDCLXXV MMMDCLXXVI MMMDCLXXVII MMMDCLXXVIII MMMDCLXXIX MMMDCLXXX MMMDCLXXXI MMMDCLXXXII MMMDCLXXXIII MMMDCLXXXIV MMMDCLXXXV MMMDCLXXXVI MMMDCLXXXVII MMMDCLXXXVIII MMMDCLXXXIX MMMDCXC MMMDCXCI MMMDCXCII MMMDCXCIII MMMDCXCIV MMMDCXCV MMMDCXCVI MMMDCXCVII MMMDCXCVIII MMMDCXCIX MMMDCC MMMDCCI MMMDCCII MMMDCCIII MMMDCCIV MMMDCCV MMMDCCVI MMMDCCVII MMMDCCVIII MMMDCCIX MMMDCCX MMMDCCXI MMMDCCXII MMMDCCXIII MMMDCCXIV MMMDCCXV MMMDCCXVI MMMDCCXVII MMMDCCXVIII MMMDCCXIX MMMDCCXX MMMDCCXXI MMMDCCXXII MMMDCCXXIII MMMDCCXXIV MMMDCCXXV MMMDCCXXVI MMMDCCXXVII MMMDCCXXVIII MMMDCCXXIX MMMDCCXXX MMMDCCXXXI MMMDCCXXXII MMMDCCXXXIII MMMDCCXXXIV MMMDCCXXXV MMMDCCXXXVI MMMDCCXXXVII MMMDCCXXXVIII MMMDCCXXXIX MMMDCCXL MMMDCCXLI MMMDCCXLII MMMDCCXLIII MMMDCCXLIV MMMDCCXLV MMMDCCXLVI MMMDCCXLVII MMMDCCXLVIII MMMDCCXLIX MMMDCCL MMMDCCLI MMMDCCLII MMMDCCLIII MMMDCCLIV MMMDCCLV MMMDCCLVI MMMDCCLVII MMMDCCLVIII MMMDCCLIX MMMDCCLX MMMDCCLXI MMMDCCLXII MMMDCCLXIII MMMDCCLXIV MMMDCCLXV MMMDCCLXVI MMMDCCLXVII MMMDCCLXVIII MMMDCCLXIX MMMDCCLXX MMMDCCLXXI MMMDCCLXXII MMMDCCLXXIII MMMDCCLXXIV MMMDCCLXXV MMMDCCLXXVI MMMDCCLXXVII MMMDCCLXXVIII MMMDCCLXXIX MMMDCCLXXX MMMDCCLXXXI MMMDCCLXXXII MMMDCCLXXXIII MMMDCCLXXXIV MMMDCCLXXXV MMMDCCLXXXVI MMMDCCLXXXVII MMMDCCLXXXVIII MMMDCCLXXXIX MMMDCCXC MMMDCCXCI MMMDCCXCII MMMDCCXCIII MMMDCCXCIV MMMDCCXCV MMMDCCXCVI MMMDCCXCVII MMMDCCXCVIII MMMDCCXCIX MMMDCCC MMMDCCCI MMMDCCCII MMMDCCCIII MMMDCCCIV MMMDCCCV MMMDCCCVI MMMDCCCVII MMMDCCCVIII MMMDCCCIX MMMDCCCX MMMDCCCXI MMMDCCCXII MMMDCCCXIII MMMDCCCXIV MMMDCCCXV MMMDCCCXVI MMMDCCCXVII MMMDCCCXVIII MMMDCCCXIX MMMDCCCXX MMMDCCCXXI MMMDCCCXXII MMMDCCCXXIII MMMDCCCXXIV MMMDCCCXXV MMMDCCCXXVI MMMDCCCXXVII MMMDCCCXXVIII MMMDCCCXXIX MMMDCCCXXX MMMDCCCXXXI MMMDCCCXXXII MMMDCCCXXXIII MMMDCCCXXXIV MMMDCCCXXXV MMMDCCCXXXVI MMMDCCCXXXVII MMMDCCCXXXVIII MMMDCCCXXXIX MMMDCCCXL MMMDCCCXLI MMMDCCCXLII MMMDCCCXLIII MMMDCCCXLIV MMMDCCCXLV MMMDCCCXLVI MMMDCCCXLVII MMMDCCCXLVIII MMMDCCCXLIX MMMDCCCL MMMDCCCLI MMMDCCCLII MMMDCCCLIII MMMDCCCLIV MMMDCCCLV MMMDCCCLVI MMMDCCCLVII MMMDCCCLVIII MMMDCCCLIX MMMDCCCLX MMMDCCCLXI MMMDCCCLXII MMMDCCCLXIII MMMDCCCLXIV MMMDCCCLXV MMMDCCCLXVI MMMDCCCLXVII MMMDCCCLXVIII MMMDCCCLXIX MMMDCCCLXX MMMDCCCLXXI MMMDCCCLXXII MMMDCCCLXXIII MMMDCCCLXXIV MMMDCCCLXXV MMMDCCCLXXVI MMMDCCCLXXVII MMMDCCCLXXVIII MMMDCCCLXXIX MMMDCCCLXXX MMMDCCCLXXXI MMMDCCCLXXXII MMMDCCCLXXXIII MMMDCCCLXXXIV MMMDCCCLXXXV MMMDCCCLXXXVI MMMDCCCLXXXVII MMMDCCCLXXXVIII MMMDCCCLXXXIX MMMDCCCXC MMMDCCCXCI MMMDCCCXCII MMMDCCCXCIII MMMDCCCXCIV MMMDCCCXCV MMMDCCCXCVI MMMDCCCXCVII MMMDCCCXCVIII MMMDCCCXCIX MMMCM MMMCMI MMMCMII MMMCMIII MMMCMIV MMMCMV MMMCMVI MMMCMVII MMMCMVIII MMMCMIX MMMCMX MMMCMXI MMMCMXII MMMCMXIII MMMCMXIV MMMCMXV MMMCMXVI MMMCMXVII MMMCMXVIII MMMCMXIX MMMCMXX MMMCMXXI MMMCMXXII MMMCMXXIII MMMCMXXIV MMMCMXXV MMMCMXXVI MMMCMXXVII MMMCMXXVIII MMMCMXXIX MMMCMXXX MMMCMXXXI MMMCMXXXII MMMCMXXXIII MMMCMXXXIV MMMCMXXXV MMMCMXXXVI MMMCMXXXVII MMMCMXXXVIII MMMCMXXXIX MMMCMXL MMMCMXLI MMMCMXLII MMMCMXLIII MMMCMXLIV MMMCMXLV MMMCMXLVI MMMCMXLVII MMMCMXLVIII MMMCMXLIX MMMCML MMMCMLI MMMCMLII MMMCMLIII MMMCMLIV MMMCMLV MMMCMLVI MMMCMLVII MMMCMLVIII MMMCMLIX MMMCMLX MMMCMLXI MMMCMLXII MMMCMLXIII MMMCMLXIV MMMCMLXV MMMCMLXVI MMMCMLXVII MMMCMLXVIII MMMCMLXIX MMMCMLXX MMMCMLXXI MMMCMLXXII MMMCMLXXIII MMMCMLXXIV MMMCMLXXV MMMCMLXXVI MMMCMLXXVII MMMCMLXXVIII MMMCMLXXIX MMMCMLXXX MMMCMLXXXI MMMCMLXXXII MMMCMLXXXIII MMMCMLXXXIV MMMCMLXXXV MMMCMLXXXVI MMMCMLXXXVII MMMCMLXXXVIII MMMCMLXXXIX MMMCMXC MMMCMXCI MMMCMXCII MMMCMXCIII MMMCMXCIV MMMCMXCV MMMCMXCVI MMMCMXCVII MMMCMXCVIII MMMCMXCIX MMMM MMMMI MMMMII MMMMIII MMMMIV MMMMV MMMMVI MMMMVII MMMMVIII MMMMIX MMMMX MMMMXI MMMMXII MMMMXIII MMMMXIV MMMMXV MMMMXVI MMMMXVII MMMMXVIII MMMMXIX MMMMXX MMMMXXI MMMMXXII MMMMXXIII MMMMXXIV MMMMXXV MMMMXXVI MMMMXXVII MMMMXXVIII MMMMXXIX MMMMXXX MMMMXXXI MMMMXXXII MMMMXXXIII MMMMXXXIV MMMMXXXV MMMMXXXVI MMMMXXXVII MMMMXXXVIII MMMMXXXIX MMMMXL MMMMXLI MMMMXLII MMMMXLIII MMMMXLIV MMMMXLV MMMMXLVI MMMMXLVII MMMMXLVIII MMMMXLIX MMMML MMMMLI MMMMLII MMMMLIII MMMMLIV MMMMLV MMMMLVI MMMMLVII MMMMLVIII MMMMLIX MMMMLX MMMMLXI MMMMLXII MMMMLXIII MMMMLXIV MMMMLXV MMMMLXVI MMMMLXVII MMMMLXVIII MMMMLXIX MMMMLXX MMMMLXXI MMMMLXXII MMMMLXXIII MMMMLXXIV MMMMLXXV MMMMLXXVI MMMMLXXVII MMMMLXXVIII MMMMLXXIX MMMMLXXX MMMMLXXXI MMMMLXXXII MMMMLXXXIII MMMMLXXXIV MMMMLXXXV MMMMLXXXVI MMMMLXXXVII MMMMLXXXVIII MMMMLXXXIX MMMMXC MMMMXCI MMMMXCII MMMMXCIII MMMMXCIV MMMMXCV MMMMXCVI MMMMXCVII MMMMXCVIII MMMMXCIX MMMMC MMMMCI MMMMCII MMMMCIII MMMMCIV MMMMCV MMMMCVI MMMMCVII MMMMCVIII MMMMCIX MMMMCX MMMMCXI MMMMCXII MMMMCXIII MMMMCXIV MMMMCXV MMMMCXVI MMMMCXVII MMMMCXVIII MMMMCXIX MMMMCXX MMMMCXXI MMMMCXXII MMMMCXXIII MMMMCXXIV MMMMCXXV MMMMCXXVI MMMMCXXVII MMMMCXXVIII MMMMCXXIX MMMMCXXX MMMMCXXXI MMMMCXXXII MMMMCXXXIII MMMMCXXXIV MMMMCXXXV MMMMCXXXVI MMMMCXXXVII MMMMCXXXVIII MMMMCXXXIX MMMMCXL MMMMCXLI MMMMCXLII MMMMCXLIII MMMMCXLIV MMMMCXLV MMMMCXLVI MMMMCXLVII MMMMCXLVIII MMMMCXLIX MMMMCL MMMMCLI MMMMCLII MMMMCLIII MMMMCLIV MMMMCLV MMMMCLVI MMMMCLVII MMMMCLVIII MMMMCLIX MMMMCLX MMMMCLXI MMMMCLXII MMMMCLXIII MMMMCLXIV MMMMCLXV MMMMCLXVI MMMMCLXVII MMMMCLXVIII MMMMCLXIX MMMMCLXX MMMMCLXXI MMMMCLXXII MMMMCLXXIII MMMMCLXXIV MMMMCLXXV MMMMCLXXVI MMMMCLXXVII MMMMCLXXVIII MMMMCLXXIX MMMMCLXXX MMMMCLXXXI MMMMCLXXXII MMMMCLXXXIII MMMMCLXXXIV MMMMCLXXXV MMMMCLXXXVI MMMMCLXXXVII MMMMCLXXXVIII MMMMCLXXXIX MMMMCXC MMMMCXCI MMMMCXCII MMMMCXCIII MMMMCXCIV MMMMCXCV MMMMCXCVI MMMMCXCVII MMMMCXCVIII MMMMCXCIX MMMMCC MMMMCCI MMMMCCII MMMMCCIII MMMMCCIV MMMMCCV MMMMCCVI MMMMCCVII MMMMCCVIII MMMMCCIX MMMMCCX MMMMCCXI MMMMCCXII MMMMCCXIII MMMMCCXIV MMMMCCXV MMMMCCXVI MMMMCCXVII MMMMCCXVIII MMMMCCXIX MMMMCCXX MMMMCCXXI MMMMCCXXII MMMMCCXXIII MMMMCCXXIV MMMMCCXXV MMMMCCXXVI MMMMCCXXVII MMMMCCXXVIII MMMMCCXXIX MMMMCCXXX MMMMCCXXXI MMMMCCXXXII MMMMCCXXXIII MMMMCCXXXIV MMMMCCXXXV MMMMCCXXXVI MMMMCCXXXVII MMMMCCXXXVIII MMMMCCXXXIX MMMMCCXL MMMMCCXLI MMMMCCXLII MMMMCCXLIII MMMMCCXLIV MMMMCCXLV MMMMCCXLVI MMMMCCXLVII MMMMCCXLVIII MMMMCCXLIX MMMMCCL MMMMCCLI MMMMCCLII MMMMCCLIII MMMMCCLIV MMMMCCLV MMMMCCLVI MMMMCCLVII MMMMCCLVIII MMMMCCLIX MMMMCCLX MMMMCCLXI MMMMCCLXII MMMMCCLXIII MMMMCCLXIV MMMMCCLXV MMMMCCLXVI MMMMCCLXVII MMMMCCLXVIII MMMMCCLXIX MMMMCCLXX MMMMCCLXXI MMMMCCLXXII MMMMCCLXXIII MMMMCCLXXIV MMMMCCLXXV MMMMCCLXXVI MMMMCCLXXVII MMMMCCLXXVIII MMMMCCLXXIX MMMMCCLXXX MMMMCCLXXXI MMMMCCLXXXII MMMMCCLXXXIII MMMMCCLXXXIV MMMMCCLXXXV MMMMCCLXXXVI MMMMCCLXXXVII MMMMCCLXXXVIII MMMMCCLXXXIX MMMMCCXC MMMMCCXCI MMMMCCXCII MMMMCCXCIII MMMMCCXCIV MMMMCCXCV MMMMCCXCVI MMMMCCXCVII MMMMCCXCVIII MMMMCCXCIX MMMMCCC MMMMCCCI MMMMCCCII MMMMCCCIII MMMMCCCIV MMMMCCCV MMMMCCCVI MMMMCCCVII MMMMCCCVIII MMMMCCCIX MMMMCCCX MMMMCCCXI MMMMCCCXII MMMMCCCXIII MMMMCCCXIV MMMMCCCXV MMMMCCCXVI MMMMCCCXVII MMMMCCCXVIII MMMMCCCXIX MMMMCCCXX MMMMCCCXXI MMMMCCCXXII MMMMCCCXXIII MMMMCCCXXIV MMMMCCCXXV MMMMCCCXXVI MMMMCCCXXVII MMMMCCCXXVIII MMMMCCCXXIX MMMMCCCXXX MMMMCCCXXXI MMMMCCCXXXII MMMMCCCXXXIII MMMMCCCXXXIV MMMMCCCXXXV MMMMCCCXXXVI MMMMCCCXXXVII MMMMCCCXXXVIII MMMMCCCXXXIX MMMMCCCXL MMMMCCCXLI MMMMCCCXLII MMMMCCCXLIII MMMMCCCXLIV MMMMCCCXLV MMMMCCCXLVI MMMMCCCXLVII MMMMCCCXLVIII MMMMCCCXLIX MMMMCCCL MMMMCCCLI MMMMCCCLII MMMMCCCLIII MMMMCCCLIV MMMMCCCLV MMMMCCCLVI MMMMCCCLVII MMMMCCCLVIII MMMMCCCLIX MMMMCCCLX MMMMCCCLXI MMMMCCCLXII MMMMCCCLXIII MMMMCCCLXIV MMMMCCCLXV MMMMCCCLXVI MMMMCCCLXVII MMMMCCCLXVIII MMMMCCCLXIX MMMMCCCLXX MMMMCCCLXXI MMMMCCCLXXII MMMMCCCLXXIII MMMMCCCLXXIV MMMMCCCLXXV MMMMCCCLXXVI MMMMCCCLXXVII MMMMCCCLXXVIII MMMMCCCLXXIX MMMMCCCLXXX MMMMCCCLXXXI MMMMCCCLXXXII MMMMCCCLXXXIII MMMMCCCLXXXIV MMMMCCCLXXXV MMMMCCCLXXXVI MMMMCCCLXXXVII MMMMCCCLXXXVIII MMMMCCCLXXXIX MMMMCCCXC MMMMCCCXCI MMMMCCCXCII MMMMCCCXCIII MMMMCCCXCIV MMMMCCCXCV MMMMCCCXCVI MMMMCCCXCVII MMMMCCCXCVIII MMMMCCCXCIX MMMMCD MMMMCDI MMMMCDII MMMMCDIII MMMMCDIV MMMMCDV MMMMCDVI MMMMCDVII MMMMCDVIII MMMMCDIX MMMMCDX MMMMCDXI MMMMCDXII MMMMCDXIII MMMMCDXIV MMMMCDXV MMMMCDXVI MMMMCDXVII MMMMCDXVIII MMMMCDXIX MMMMCDXX MMMMCDXXI MMMMCDXXII MMMMCDXXIII MMMMCDXXIV MMMMCDXXV MMMMCDXXVI MMMMCDXXVII MMMMCDXXVIII MMMMCDXXIX MMMMCDXXX MMMMCDXXXI MMMMCDXXXII MMMMCDXXXIII MMMMCDXXXIV MMMMCDXXXV MMMMCDXXXVI MMMMCDXXXVII MMMMCDXXXVIII MMMMCDXXXIX MMMMCDXL MMMMCDXLI MMMMCDXLII MMMMCDXLIII MMMMCDXLIV MMMMCDXLV MMMMCDXLVI MMMMCDXLVII MMMMCDXLVIII MMMMCDXLIX MMMMCDL MMMMCDLI MMMMCDLII MMMMCDLIII MMMMCDLIV MMMMCDLV MMMMCDLVI MMMMCDLVII MMMMCDLVIII MMMMCDLIX MMMMCDLX MMMMCDLXI MMMMCDLXII MMMMCDLXIII MMMMCDLXIV MMMMCDLXV MMMMCDLXVI MMMMCDLXVII MMMMCDLXVIII MMMMCDLXIX MMMMCDLXX MMMMCDLXXI MMMMCDLXXII MMMMCDLXXIII MMMMCDLXXIV MMMMCDLXXV MMMMCDLXXVI MMMMCDLXXVII MMMMCDLXXVIII MMMMCDLXXIX MMMMCDLXXX MMMMCDLXXXI MMMMCDLXXXII MMMMCDLXXXIII MMMMCDLXXXIV MMMMCDLXXXV MMMMCDLXXXVI MMMMCDLXXXVII MMMMCDLXXXVIII MMMMCDLXXXIX MMMMCDXC MMMMCDXCI MMMMCDXCII MMMMCDXCIII MMMMCDXCIV MMMMCDXCV MMMMCDXCVI MMMMCDXCVII MMMMCDXCVIII MMMMCDXCIX MMMMD MMMMDI MMMMDII MMMMDIII MMMMDIV MMMMDV MMMMDVI MMMMDVII MMMMDVIII MMMMDIX MMMMDX MMMMDXI MMMMDXII MMMMDXIII MMMMDXIV MMMMDXV MMMMDXVI MMMMDXVII MMMMDXVIII MMMMDXIX MMMMDXX MMMMDXXI MMMMDXXII MMMMDXXIII MMMMDXXIV MMMMDXXV MMMMDXXVI MMMMDXXVII MMMMDXXVIII MMMMDXXIX MMMMDXXX MMMMDXXXI MMMMDXXXII MMMMDXXXIII MMMMDXXXIV MMMMDXXXV MMMMDXXXVI MMMMDXXXVII MMMMDXXXVIII MMMMDXXXIX MMMMDXL MMMMDXLI MMMMDXLII MMMMDXLIII MMMMDXLIV MMMMDXLV MMMMDXLVI MMMMDXLVII MMMMDXLVIII MMMMDXLIX MMMMDL MMMMDLI MMMMDLII MMMMDLIII MMMMDLIV MMMMDLV MMMMDLVI MMMMDLVII MMMMDLVIII MMMMDLIX MMMMDLX MMMMDLXI MMMMDLXII MMMMDLXIII MMMMDLXIV MMMMDLXV MMMMDLXVI MMMMDLXVII MMMMDLXVIII MMMMDLXIX MMMMDLXX MMMMDLXXI MMMMDLXXII MMMMDLXXIII MMMMDLXXIV MMMMDLXXV MMMMDLXXVI MMMMDLXXVII MMMMDLXXVIII MMMMDLXXIX MMMMDLXXX MMMMDLXXXI MMMMDLXXXII MMMMDLXXXIII MMMMDLXXXIV MMMMDLXXXV MMMMDLXXXVI MMMMDLXXXVII MMMMDLXXXVIII MMMMDLXXXIX MMMMDXC MMMMDXCI MMMMDXCII MMMMDXCIII MMMMDXCIV MMMMDXCV MMMMDXCVI MMMMDXCVII MMMMDXCVIII MMMMDXCIX MMMMDC MMMMDCI MMMMDCII MMMMDCIII MMMMDCIV MMMMDCV MMMMDCVI MMMMDCVII MMMMDCVIII MMMMDCIX MMMMDCX MMMMDCXI MMMMDCXII MMMMDCXIII MMMMDCXIV MMMMDCXV MMMMDCXVI MMMMDCXVII MMMMDCXVIII MMMMDCXIX MMMMDCXX MMMMDCXXI MMMMDCXXII MMMMDCXXIII MMMMDCXXIV MMMMDCXXV MMMMDCXXVI MMMMDCXXVII MMMMDCXXVIII MMMMDCXXIX MMMMDCXXX MMMMDCXXXI MMMMDCXXXII MMMMDCXXXIII MMMMDCXXXIV MMMMDCXXXV MMMMDCXXXVI MMMMDCXXXVII MMMMDCXXXVIII MMMMDCXXXIX MMMMDCXL MMMMDCXLI MMMMDCXLII MMMMDCXLIII MMMMDCXLIV MMMMDCXLV MMMMDCXLVI MMMMDCXLVII MMMMDCXLVIII MMMMDCXLIX MMMMDCL MMMMDCLI MMMMDCLII MMMMDCLIII MMMMDCLIV MMMMDCLV MMMMDCLVI MMMMDCLVII MMMMDCLVIII MMMMDCLIX MMMMDCLX MMMMDCLXI MMMMDCLXII MMMMDCLXIII MMMMDCLXIV MMMMDCLXV MMMMDCLXVI MMMMDCLXVII MMMMDCLXVIII MMMMDCLXIX MMMMDCLXX MMMMDCLXXI MMMMDCLXXII MMMMDCLXXIII MMMMDCLXXIV MMMMDCLXXV MMMMDCLXXVI MMMMDCLXXVII MMMMDCLXXVIII MMMMDCLXXIX MMMMDCLXXX MMMMDCLXXXI MMMMDCLXXXII MMMMDCLXXXIII MMMMDCLXXXIV MMMMDCLXXXV MMMMDCLXXXVI MMMMDCLXXXVII MMMMDCLXXXVIII MMMMDCLXXXIX MMMMDCXC MMMMDCXCI MMMMDCXCII MMMMDCXCIII MMMMDCXCIV MMMMDCXCV MMMMDCXCVI MMMMDCXCVII MMMMDCXCVIII MMMMDCXCIX MMMMDCC MMMMDCCI MMMMDCCII MMMMDCCIII MMMMDCCIV MMMMDCCV MMMMDCCVI MMMMDCCVII MMMMDCCVIII MMMMDCCIX MMMMDCCX MMMMDCCXI MMMMDCCXII MMMMDCCXIII MMMMDCCXIV MMMMDCCXV MMMMDCCXVI MMMMDCCXVII MMMMDCCXVIII MMMMDCCXIX MMMMDCCXX MMMMDCCXXI MMMMDCCXXII MMMMDCCXXIII MMMMDCCXXIV MMMMDCCXXV MMMMDCCXXVI MMMMDCCXXVII MMMMDCCXXVIII MMMMDCCXXIX MMMMDCCXXX MMMMDCCXXXI MMMMDCCXXXII MMMMDCCXXXIII MMMMDCCXXXIV MMMMDCCXXXV MMMMDCCXXXVI MMMMDCCXXXVII MMMMDCCXXXVIII MMMMDCCXXXIX MMMMDCCXL MMMMDCCXLI MMMMDCCXLII MMMMDCCXLIII MMMMDCCXLIV MMMMDCCXLV MMMMDCCXLVI MMMMDCCXLVII MMMMDCCXLVIII MMMMDCCXLIX MMMMDCCL MMMMDCCLI MMMMDCCLII MMMMDCCLIII MMMMDCCLIV MMMMDCCLV MMMMDCCLVI MMMMDCCLVII MMMMDCCLVIII MMMMDCCLIX MMMMDCCLX MMMMDCCLXI MMMMDCCLXII MMMMDCCLXIII MMMMDCCLXIV MMMMDCCLXV MMMMDCCLXVI MMMMDCCLXVII MMMMDCCLXVIII MMMMDCCLXIX MMMMDCCLXX MMMMDCCLXXI MMMMDCCLXXII MMMMDCCLXXIII MMMMDCCLXXIV MMMMDCCLXXV MMMMDCCLXXVI MMMMDCCLXXVII MMMMDCCLXXVIII MMMMDCCLXXIX MMMMDCCLXXX MMMMDCCLXXXI MMMMDCCLXXXII MMMMDCCLXXXIII MMMMDCCLXXXIV MMMMDCCLXXXV MMMMDCCLXXXVI MMMMDCCLXXXVII MMMMDCCLXXXVIII MMMMDCCLXXXIX MMMMDCCXC MMMMDCCXCI MMMMDCCXCII MMMMDCCXCIII MMMMDCCXCIV MMMMDCCXCV MMMMDCCXCVI MMMMDCCXCVII MMMMDCCXCVIII MMMMDCCXCIX MMMMDCCC MMMMDCCCI MMMMDCCCII MMMMDCCCIII MMMMDCCCIV MMMMDCCCV MMMMDCCCVI MMMMDCCCVII MMMMDCCCVIII MMMMDCCCIX MMMMDCCCX MMMMDCCCXI MMMMDCCCXII MMMMDCCCXIII MMMMDCCCXIV MMMMDCCCXV MMMMDCCCXVI MMMMDCCCXVII MMMMDCCCXVIII MMMMDCCCXIX MMMMDCCCXX MMMMDCCCXXI MMMMDCCCXXII MMMMDCCCXXIII MMMMDCCCXXIV MMMMDCCCXXV MMMMDCCCXXVI MMMMDCCCXXVII MMMMDCCCXXVIII MMMMDCCCXXIX MMMMDCCCXXX MMMMDCCCXXXI MMMMDCCCXXXII MMMMDCCCXXXIII MMMMDCCCXXXIV MMMMDCCCXXXV MMMMDCCCXXXVI MMMMDCCCXXXVII MMMMDCCCXXXVIII MMMMDCCCXXXIX MMMMDCCCXL MMMMDCCCXLI MMMMDCCCXLII MMMMDCCCXLIII MMMMDCCCXLIV MMMMDCCCXLV MMMMDCCCXLVI MMMMDCCCXLVII MMMMDCCCXLVIII MMMMDCCCXLIX MMMMDCCCL MMMMDCCCLI MMMMDCCCLII MMMMDCCCLIII MMMMDCCCLIV MMMMDCCCLV MMMMDCCCLVI MMMMDCCCLVII MMMMDCCCLVIII MMMMDCCCLIX MMMMDCCCLX MMMMDCCCLXI MMMMDCCCLXII MMMMDCCCLXIII MMMMDCCCLXIV MMMMDCCCLXV MMMMDCCCLXVI MMMMDCCCLXVII MMMMDCCCLXVIII MMMMDCCCLXIX MMMMDCCCLXX MMMMDCCCLXXI MMMMDCCCLXXII MMMMDCCCLXXIII MMMMDCCCLXXIV MMMMDCCCLXXV MMMMDCCCLXXVI MMMMDCCCLXXVII MMMMDCCCLXXVIII MMMMDCCCLXXIX MMMMDCCCLXXX MMMMDCCCLXXXI MMMMDCCCLXXXII MMMMDCCCLXXXIII MMMMDCCCLXXXIV MMMMDCCCLXXXV MMMMDCCCLXXXVI MMMMDCCCLXXXVII MMMMDCCCLXXXVIII MMMMDCCCLXXXIX MMMMDCCCXC MMMMDCCCXCI MMMMDCCCXCII MMMMDCCCXCIII MMMMDCCCXCIV MMMMDCCCXCV MMMMDCCCXCVI MMMMDCCCXCVII MMMMDCCCXCVIII MMMMDCCCXCIX MMMMCM MMMMCMI MMMMCMII MMMMCMIII MMMMCMIV MMMMCMV MMMMCMVI MMMMCMVII MMMMCMVIII MMMMCMIX MMMMCMX MMMMCMXI MMMMCMXII MMMMCMXIII MMMMCMXIV MMMMCMXV MMMMCMXVI MMMMCMXVII MMMMCMXVIII MMMMCMXIX MMMMCMXX MMMMCMXXI MMMMCMXXII MMMMCMXXIII MMMMCMXXIV MMMMCMXXV MMMMCMXXVI MMMMCMXXVII MMMMCMXXVIII MMMMCMXXIX MMMMCMXXX MMMMCMXXXI MMMMCMXXXII MMMMCMXXXIII MMMMCMXXXIV MMMMCMXXXV MMMMCMXXXVI MMMMCMXXXVII MMMMCMXXXVIII MMMMCMXXXIX MMMMCMXL MMMMCMXLI MMMMCMXLII MMMMCMXLIII MMMMCMXLIV MMMMCMXLV MMMMCMXLVI MMMMCMXLVII MMMMCMXLVIII MMMMCMXLIX MMMMCML MMMMCMLI MMMMCMLII MMMMCMLIII MMMMCMLIV MMMMCMLV MMMMCMLVI MMMMCMLVII MMMMCMLVIII MMMMCMLIX MMMMCMLX MMMMCMLXI MMMMCMLXII MMMMCMLXIII MMMMCMLXIV MMMMCMLXV MMMMCMLXVI MMMMCMLXVII MMMMCMLXVIII MMMMCMLXIX MMMMCMLXX MMMMCMLXXI MMMMCMLXXII MMMMCMLXXIII MMMMCMLXXIV MMMMCMLXXV MMMMCMLXXVI MMMMCMLXXVII MMMMCMLXXVIII MMMMCMLXXIX MMMMCMLXXX MMMMCMLXXXI MMMMCMLXXXII MMMMCMLXXXIII MMMMCMLXXXIV MMMMCMLXXXV MMMMCMLXXXVI MMMMCMLXXXVII MMMMCMLXXXVIII MMMMCMLXXXIX MMMMCMXC MMMMCMXCI MMMMCMXCII MMMMCMXCIII MMMMCMXCIV MMMMCMXCV MMMMCMXCVI MMMMCMXCVII MMMMCMXCVIII MMMMCMXCIX Regexp-Common-2017060201/t/number/decimal.t000755 000765 000024 00000010361 13070654573 020665 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use lib qw {blib/lib}, "."; use Regexp::Common qw /RE_num_decimal/; use t::Common; my $decimal = $RE {num} {decimal}; # The following arrays contain valid numbers in the respective bases - # and the numbers aren't valid in the next array. my @data = ( [36 => [qw /regexp common perl5/]], [16 => [qw /deadbeaf c0c0a c1a0 55b/]], [10 => [qw /81320981536123490812346123 129 9/]], [ 8 => [qw /777 153/]], [ 2 => [qw /0 1 1010101110/]], ); my (%targets, @tests); foreach my $entry (@data) { my ($base, $list) = @$entry; $targets {"${base}_int"} = { list => $list, query => sub {$_ [0]}, wanted => sub {$_ [0], "", $_ [0], $_ [0], undef, undef} }; for my $exp ([dot => "."], [comma => ","]) { my ($name, $punct) = @$exp; $targets {"${base}_int_${name}"} = { list => $list, query => sub {$_ [0] . $punct}, wanted => sub {$_ [0] . $punct, "", $_ [0] . $punct, $_ [0], $punct, ""} }; $targets {"${base}_${name}_frac"} = { list => $list, query => sub {$_ [0] . $punct}, wanted => sub {$_ [0] . $punct, "", $_ [0] . $punct, $_ [0], $punct, ""} }; $targets {"${base}_minus_${name}_frac"} = { list => $list, query => sub {"-" . $_ [0] . $punct}, wanted => sub {"-" . $_ [0] . $punct, "-", $_ [0] . $punct, $_ [0], $punct, ""} }; $targets {"${base}_plus_${name}_frac"} = { list => $list, query => sub {"+" . $_ [0] . $punct}, wanted => sub {"+" . $_ [0] . $punct, "+", $_ [0] . $punct, $_ [0], $punct, ""} }; } $targets {"${base}_minus_int"} = { list => $list, query => sub {"-" . $_ [0]}, wanted => sub {"-" . $_ [0], "-", $_ [0], $_ [0], "", ""} }; $targets {"${base}_plus_int"} = { list => $list, query => sub {"+" . $_ [0]}, wanted => sub {"+" . $_ [0], "+", $_ [0], $_ [0], "", ""} }; } $targets {dot} = { list => ['.'], query => sub {$_ [0]}, }; sub __ { map {;"${_}_int", "${_}_int_dot", "${_}_minus_int", "${_}_plus_int", "${_}_dot_frac", "${_}_minus_dot_frac", "${_}_plus_dot_frac", } @_ } sub _2 { map {;"${_}_minus_int", "${_}_plus_int", "${_}_minus_dot_frac", "${_}_plus_dot_frac", } @_ } sub _3 { map {;"${_}_int", "${_}_int_dot", "${_}_dot_frac", } @_ } push @tests => { name => 'basic', re => $decimal, sub => \&RE_num_decimal, pass => [__ (grep {$_ <= 10} map {$$_ [0]} @data)], fail => [__ (grep {$_ > 10} map {$$_ [0]} @data), "dot"], }; push @tests => { name => 'basic -- signed', re => $decimal -> {-sign => '[-+]'}, sub => \&RE_num_decimal, sub_args => [-sign => '[-+]'], pass => [ _2 (grep {$_ <= 10} map {$$_ [0]} @data)], fail => [(_3 (grep {$_ <= 10} map {$$_ [0]} @data)), __ (grep {$_ > 10} map {$$_ [0]} @data), "dot"], }; foreach my $data (@data) { my $base = $$data [0]; my @passes = __ grep {$_ <= $base} map {$$_ [0]} @data; my @failures = __ grep {$_ > $base} map {$$_ [0]} @data; my @commas = grep {/^${base}_.*comma/} keys %targets; push @tests => { name => "base_${base}", re => $RE {num} {decimal} {-base => $base}, sub => \&RE_num_decimal, sub_args => [-base => $base], pass => [@passes], fail => [@failures, @commas, "dot"], }; push @tests => { name => "base_${base}_comma", re => $RE {num} {decimal} {-base => $base} {-radix => ","}, sub => \&RE_num_decimal, sub_args => [-base => $base, -radix => ","], pass => [(grep {!/dot/} @passes), @commas], fail => [(grep {/^${base}/} @failures)], }; } run_new_tests targets => \%targets, tests => \@tests, version_from => 'Regexp::Common::number', ; __END__ Regexp-Common-2017060201/t/number/number.t000755 000765 000024 00000001623 13070654573 020560 0ustar00abigailstaff000000 000000 #!/usr/bin/perl # # Test for the support functions of Regexp::Common::number # use strict; use lib qw {blib/lib}, "."; use Regexp::Common; use t::Common; my @wrong_bases = (0, 40); my @correct_bases = (1, 29, 36); my @types = qw /decimal real/; my $tests = (@wrong_bases + @correct_bases) * @types; my $count = 0; print "1..$tests\n"; foreach my $base (@wrong_bases) { foreach my $type (@types) { eval {"" =~ $RE {num} {$type} {-base => $base}}; printf "%s %d - \$RE {num} {$type} {-base => $base}\n" => $@ && $@ =~ /Base must be between 1 and 36/ ? "ok" : "not ok", ++ $count; } } foreach my $base (@correct_bases) { foreach my $type (@types) { eval {"" =~ $RE {num} {$type} {-base => $base}}; printf "%s %d - \$RE {num} {$type} {-base => $base}\n" => $@ ? "not ok" : "ok", ++ $count; } } __END__ Regexp-Common-2017060201/t/net/101_ipv4.t000755 000765 000024 00000004141 12116413566 020022 0ustar00abigailstaff000000 000000 # VOODOO LINE-NOISE my($C,$M,$P,$N,$S);END{print"1..$C\n$M";print"\nfailed: $N\n"if$N} sub ok{$C++; $M.= ($_[0]||!@_)?"ok $C\n":($N++,"not ok $C (". ((caller 1)[1]||(caller 0)[1]).":".((caller 1)[2]||(caller 0)[2]).")\n")} # sub try{$P=qr/^$_[0]$/}sub fail{ok($S=$_[0]!~$P)}sub pass{ok($S=$_[0]=~$P)} sub try { $P = qr /^$_[0]/ } sub pass { ok ($_ [0] =~ $P && $& eq $_ [0]) } sub fail { ok ($_ [0] !~ $P || $& ne $_ [0]) } # LOAD use Regexp::Common; ok; # DOTTED DECIMAL try $RE{net}{IPv4}; pass '0.0.0.0'; pass '1.1.1.1'; pass '255.255.255.255'; pass '255.0.128.23'; fail '256.0.128.23'; fail '255.0.1287.23'; fail '255.a.127.23'; fail '255 0 127 23'; fail '255,0,127,23'; fail '255012723'; try $RE{net}{IPv4}{dec}; pass '0.0.0.0'; pass '1.1.1.1'; pass '255.255.255.255'; pass '255.0.128.23'; fail '256.0.128.23'; fail '255.0.1287.23'; fail '255.a.127.23'; fail '255 0 127 23'; fail '255,0,127,23'; fail '255012723'; # DOTTED HEXADECIMAL # try $RE{net}{IPv4}{hex}; pass '0.0.0.0'; pass '1.1.1.1'; pass '55.55.25.5'; pass '7A.B4.2C.D'; pass 'FF.FF.FF.FF'; fail 'FF.FF.FF.1FF'; fail '255.0.1287.23'; fail '255.a.127.23'; fail '255 0 127 23'; fail '255,0,127,23'; fail '255012723'; try $RE{net}{IPv4}{hex}{-sep=>""}; fail '0.0.0.0'; fail '1.1.1.1'; pass '55552505'; pass '7AB42CD'; pass 'FFFFFFFF'; fail 'FFFFFF1FF'; fail '55 55 25 05'; fail '7A B4 2C D'; fail 'FF FF FF FF'; fail 'FF FF FF 1FF'; try $RE{net}{IPv4}{hex}{-sep=>" "}; fail '0.0.0.0'; fail '1.1.1.1'; fail '55552505'; fail '7AB42CD'; fail 'FFFFFFFF'; fail 'FFFFFF1FF'; pass '55 55 25 05'; pass '7A B4 2C D'; pass 'FF FF FF FF'; fail 'FF FF FF 1FF'; # DOTTED OCTAL # try $RE{net}{IPv4}{oct}; pass '0.0.0.0'; pass '1.1.1.1'; pass '55.55.25.5'; fail '7A.B4.2C.D'; pass '377.377.377.377'; fail '400.400.400.400'; fail '377.377.377.1377'; fail '255.a.127.23'; fail '255 0 127 23'; fail '255,0,127,23'; fail '255012723'; # DOTTED BINARY # try $RE{net}{IPv4}{bin}; pass '0.0.0.0'; pass '1.1.1.1'; pass '101010.101011.1.10000000'; fail '12.01.01.01'; fail '101010101.101011.1.10000000'; fail '10101010-101011-1-10000000'; fail '10101010101011110000000'; Regexp-Common-2017060201/t/net/102_ipv4_strict.t000755 000765 000024 00000003176 12722651537 021427 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use warnings; no warnings 'syntax'; use Regexp::Common; use Test::More; my $r = eval "require Test::Regexp; 1"; unless ($r) { print "1..0 # SKIP Test::Regexp not found\n"; exit; } my $Test = Test::Regexp:: -> new -> init ( pattern => $RE {net} {IPv4} {strict}, keep_pattern => $RE {net} {IPv4} {strict} {-keep}, name => "Strict IPv4 addresses", ); foreach my $number (0 .. 999) { my $address = "$number.$number.$number.$number"; if ($number < 256) { $Test -> match ($address, [$address, $number, $number, $number, $number], test => "Accept number $number"); if ($number < 10) { my $address = sprintf "%d.%d.%02d.%d" => ($number) x 4; $Test -> no_match ($address, reason => "Leading 0 not allowed"); } if ($number < 100) { my $address = sprintf "%d.%03d.%d.%d" => ($number) x 4; $Test -> no_match ($address, reason => "Leading 0 not allowed"); } } else { $Test -> no_match ($address, reason => "Number exceeds 256"); } } $Test -> no_match ("1.2.3.4.5", reason => "To many octets"); $Test -> no_match ("1.2.3", reason => "No enough octets"); $Test -> no_match ("12.34.ab.56", reason => "Non numbers in octets"); $Test -> no_match ("1.1234.2.3", reason => "Too many digits in octet"); $Test -> no_match ("12:34:45:67", reason => "Incorrect separator"); $Test -> no_match ("+12.34.56.78", reason => "Garbage before address"); $Test -> no_match ("12.34.56.78 ", reason => "Garbage after address"); done_testing; Regexp-Common-2017060201/t/net/111_ipv6.t000755 000765 000024 00000013012 12723313224 020014 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use warnings; no warnings 'syntax'; use Regexp::Common; my $count = 0; my $PAT; END {print "1..$count\n"} sub try { $PAT = shift; my $name = shift; print "# $name\n"; } sub pass { my $address = shift; my $r = $address =~ /^$PAT/ && $address eq $&; printf "%s %d # Matching %s\n", $r ? "ok" : "not ok", ++ $count, $address; } sub fail { my $address = shift; my $r = $address !~ /^$PAT/ || $address ne $&; printf "%s %d # Failing %s\n", $r ? "ok" : "not ok", ++ $count, $address; } sub match { my $address = $_ [0]; my @matches = @_; my $r = $address =~ /^$PAT/ && $address eq $&; printf "%s %d # Matching %s\n", $r ? "ok" : "not ok", ++ $count, $address; if (!$r) { for my $i (0 .. @matches) { printf "not ok %d # SKIP\n" => ++ $count; } return; } # # Correct number of matches? # printf "%s %d # Number of matches\n" => @matches == @- - 1 ? "ok" : "not ok", ++ $count; for (my $i = 0; $i < @matches; $i ++) { no strict 'refs'; my $matched = ${$i + 1}; printf "%s %d # \$%d eq '%s'\n" => $matched eq $matches [$i] ? "ok" : "not ok", ++ $count, $i + 1, $matches [$i]; } } try $RE {net} {IPv6} => '$RE {net} {IPv6}'; pass "2001:0db8:85a3:0000:0000:8a2e:0370:7334"; pass "2001:db8:85a3:0:0:8a2e:370:7334"; # Leading 0's removed pass "2001:DB8:85A3:0:0:8A2E:370:7334"; # Upper case allowed pass "2001:Db8:85A3:0:0:8a2E:370:7334"; # Mixed case allowed pass "2001:db8:85a3::8a2e:370:7334"; # Contractions pass "2001:db8::8a2e:370:7334"; pass "2001::8a2e:370:7334"; pass "::8a2e:370:7334"; pass "::370:7334"; pass "::7334"; pass "::"; fail "2001:0db8:85a3:0000:0000:8a2e:0370:7334:1234"; # Too many parts fail "2001:0db8:85a3:0000:0000:8a2e:0370"; # Not enough parts fail "20013:db8:85a3:0:0:8a2e:370:7334"; # Part too long fail "2001:0db8:85a3:0000:0000:8a2e:0370:7334:"; # Trailing separator fail ":2001:0db8:85a3:0000:0000:8a2e:0370:7334"; # Leading separator fail "2001:db8:85a3:0::8a2e:370:7334"; # Only one unit removed fail "2001::8a2e:370::7334"; # Two contractions fail "2001:::8a2e:370:7334"; # Three separators fail "2001.db8.85a3.0.0.8a2e.370.7334"; # Wrong separator try $RE {net} {IPv6} {-style => "hex"} => '$RE {net} {IPv6} {-style => "hex"}'; pass "2001:db8:85a3:0:0:8a2e:370:7334"; # Lower case allowed fail "2001:DB8:85A3:0:0:8A2E:370:7334"; # Upper case not allowed fail "2001:Db8:85A3:0:0:8a2E:370:7334"; # Mixed case not allowed try $RE {net} {IPv6} {-style => "HEX"} => '$RE {net} {IPv6} {-style => "HEX"}'; fail "2001:db8:85a3:0:0:8a2e:370:7334"; # Lower case allowed pass "2001:DB8:85A3:0:0:8A2E:370:7334"; # Upper case not allowed fail "2001:Db8:85A3:0:0:8a2E:370:7334"; # Mixed case not allowed try $RE {net} {IPv6} {-sep => "[.]"} => '$RE {net} {IPv6} {-sep => "[.]"}'; pass "2001.db8.85a3.0.0.8a2e.370.7334"; # Lower case allowed pass "2001.DB8.85A3.0.0.8A2E.370.7334"; # Upper case allowed fail "2001:db8:85a3:0:0:8a2e:370:7334"; # Fail on default sep try $RE {net} {IPv6} {-keep} => '$RE {net} {IPv6} {-keep}'; match "2001:0db8:85a3:0000:0000:8a2e:0370:7334" => "2001", "0db8", "85a3", "0000", "0000", "8a2e", "0370", "7334"; match "2001:0db8:85a3:0:0:8a2e:0370:7334" => "2001", "0db8", "85a3", "0", "0", "8a2e", "0370", "7334"; match "2001:db8:85a3:0:0:8a2e:370:7334" => "2001", "db8", "85a3", "0", "0", "8a2e", "370", "7334"; match "2001:db8:85a3::8a2e:370:7334" => "2001", "db8", "85a3", "", "", "8a2e", "370", "7334"; match "2001:db8::8a2e:370:7334" => "2001", "db8", "", "", "", "8a2e", "370", "7334"; match "2001::8a2e:370:7334" => "2001", "", "", "", "", "8a2e", "370", "7334"; match "::8a2e:370:7334" => "", "", "", "", "", "8a2e", "370", "7334"; match "::370:7334" => "", "", "", "", "", "", "370", "7334"; match "::7334" => "", "", "", "", "", "", "", "7334"; match "::" => "", "", "", "", "", "", "", ""; fail "2001:0db8:85a3:0000:0000:8a2e:0370:7334:1234"; # Too many parts fail "2001:0db8:85a3:0000:0000:8a2e:0370"; # Not enough parts fail "20013:db8:85a3:0:0:8a2e:370:7334"; # Part too long fail "2001:0db8:85a3:0000:0000:8a2e:0370:7334:"; # Trailing separator fail ":2001:0db8:85a3:0000:0000:8a2e:0370:7334"; # Leading separator fail "2001:db8:85a3:0::8a2e:370:7334"; # Only one unit removed fail "2001::8a2e:370::7334"; # Two contractions fail "2001:::8a2e:370:7334"; # Three separators fail "2001.db8.85a3.0.0.8a2e.370.7334"; # Wrong separator try $RE {net} {IPv6} {-style => 'HEX'} {-sep => '[.]'} {-keep} => q [$RE {net} {IPv6} {-style => 'HEX'} {-sep => '[.]'} {-keep}]; match "2001.DB8.85A3..8A2E.370.7334" => "2001", "DB8", "85A3", "", "", "8A2E", "370", "7334"; __END__ Regexp-Common-2017060201/t/net/121_mac.t000755 000765 000024 00000006013 12723313224 017674 0ustar00abigailstaff000000 000000 # VOODOO LINE-NOISE my($C,$M,$P,$N,$S);END{print"1..$C\n$M";print"\nfailed: $N\n"if$N} sub ok{$C++; $M.= ($_[0]||!@_)?"ok $C\n":($N++,"not ok $C (". ((caller 1)[1]||(caller 0)[1]).":".((caller 1)[2]||(caller 0)[2]).")\n")} sub try{$P=qr/^$_[0]$/}sub fail{ok($S=$_[0]!~$P)}sub pass{ok($S=$_[0]=~$P)} # LOAD use Regexp::Common; ok; try $RE{net}{MAC}; pass '0:0:0:0:0:0'; pass '1:1:1:1:1:1'; pass 'a:b:c:d:e:f'; pass 'a0:b0:c0:d0:e0:f0'; pass 'a0:b0:6:80:e0:f'; fail '0:0:0:0:0'; fail '1:1:1:1:1:1:1'; fail 'a:b:c:d:e:g'; fail 'a0-b0-c0-d0-e0-f0'; fail '255:255:255:255:255:255'; try $RE{net}{MAC}{hex}; pass '0:0:0:0:0:0'; pass '1:1:1:1:1:1'; pass 'a:b:c:d:e:f'; pass 'a0:b0:c0:d0:e0:f0'; pass 'a0:b0:6:80:e0:f'; fail '0:0:0:0:0'; fail '1:1:1:1:1:1:1'; fail 'a:b:c:d:e:g'; fail 'a0-b0-c0-d0-e0-f0'; fail '255:255:255:255:255:255'; try $RE{net}{MAC}{dec}; pass '0:0:0:0:0:0'; pass '1:1:1:1:1:1'; pass '10:11:12:13:14:15'; pass '255:255:255:56:255:255'; pass '255:255:27:255:255:255'; pass '255:255:255:255:255:30'; fail '0:0:0:0:0'; fail '1:1:1:1:1:1:1'; fail 'a:b:c:d:e:f'; fail '0-0-0-0-0--0'; fail '255:255:255:256:255:255:'; fail '255:255:274:255:255:255:'; fail '255:255:255:255:255:300:'; try $RE{net}{MAC}{oct}; pass '0:0:0:0:0:0'; pass '1:1:1:1:1:1'; pass '10:11:12:13:14:15'; pass '377:377:377:56:377:377'; pass '377:377:27:377:377:377'; pass '377:377:377:377:377:30'; fail '0:0:0:0:0'; fail '1:1:1:1:1:1:1'; fail '1:1:1:1:8:1'; fail 'a:b:c:d:e:f'; fail '0-0-0-0-0-0'; fail '377:377:377:400:377:377'; fail '377:377:379:377:377:377'; fail '377:377:377:377:377:380'; try $RE{net}{MAC}{bin}; pass '0:0:0:0:0:0'; pass '1:1:1:1:1:1'; pass '10:11:100:101:110:111'; pass '11111111:11111111:11111111:1111111:11111111:11111111'; pass '11111111:11111111:11111111:11111110:11111111:11111111'; pass '11111111:11111111:11111111:11111111:11111111:11111111'; fail '0:0:0:0:0'; fail '1:1:1:1:1:1:1'; fail '1:1:1:1:111111111:1'; fail 'a:b:c:d:e:f'; fail '0-0-0-0-0-0'; try $RE{net}{MAC}{hex}{-sep => ""}; pass '000000'; pass '111111'; pass 'abcdef'; pass 'a0b0c0d0e0f'; pass 'a0b0680e0f'; fail 'cdefgh'; fail 'a0-b0-c0-d0-e0-f0'; fail '255255255255255255'; try $RE{net}{MAC}{hex}{-sep => " "}; pass '0 0 0 0 0 0'; pass '1 1 1 1 1 1'; pass 'a b c d e f'; pass 'a0 b0 c0 d0 e0 f0'; pass 'a0 b0 6 80 e0 f'; fail '0 0 0 0 0'; fail '1 1 1 1 1 1 1'; fail 'c d e f g h'; fail 'a0-b0-c0-d0-e0-f0'; fail '255 255 255 255 255 255'; ok '08:09:0a:0b:0c:0d' eq $RE{net}{MAC} -> subs ('8:9:a:b:c:d'); ok '08:09:0a:0b:0c:0d' eq $RE{net}{MAC}{hex} -> subs ('8:9:a:b:c:d'); ok '08:09:0a:0b:0c:0d' eq $RE{net}{MAC}{hex}{-sep => '-'} -> subs ('8-9-a-b-c-d'); ok '08:09:0a:0b:0c:0d' eq $RE{net}{MAC}{hex}{-sep => ''} -> subs ('89abcd'); ok '08:09:0a:0b:0c:0d' eq $RE{net}{MAC}{dec} -> subs ('8:9:10:11:12:13'); ok '08:09:0a:0b:0c:0d' eq $RE{net}{MAC}{oct} -> subs ('10:11:12:13:14:15'); ok '08:09:0a:0b:0c:0d' eq $RE{net}{MAC}{bin} -> subs ('1000:1001:1010:1011:1100:1101'); ok '8:9:a:b:c:g' eq $RE{net}{MAC}{hex} -> subs ('8:9:a:b:c:g'); Regexp-Common-2017060201/t/net/131_domain.t000755 000765 000024 00000006072 12117651121 020407 0ustar00abigailstaff000000 000000 # VOODOO LINE-NOISE my($C,$M,$P,$N,$S);END{print"1..$C\n$M";print"\nfailed: $N\n"if$N} sub ok{$C++; $M.= ($_[0]||!@_)?"ok $C\n":($N++,"not ok $C (". ((caller 1)[1]||(caller 0)[1]).":".((caller 1)[2]||(caller 0)[2]).")\n")} sub try{$P=qr/^$_[0]$/}sub fail{ok($S=$_[0]!~$P)}sub pass{ok($S=$_[0]=~$P)} # LOAD use Regexp::Common; ok; # Domains. my @data = ( ['host.example.com' => 'PPPP'], ['a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p.q.r.s.t.u.v.w.x.y.z' => 'PPPP'], ['A.B.C.D.E.F.G.H.I.J.K.L.M.N.O.P.Q.R.S.T.U.V.W.X.Y.Z' => 'PPPP'], ['host1.example.com' => 'PPPP'], ['host-1.example.com' => 'PPPP'], ['host' => 'PPPP'], ['a-----------------1.example.com' => 'PPPP'], ['a123456a.example.com' => 'PPPP'], # # 63 char limit # ['abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789.com' => 'PPPP'], ['abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789a.com' => 'FFFF'], # # By default, we can match a single space, but not two # [' ', => 'PFPF'], [' ' => 'FFFF'], # # Parts may only start with a number if -rfc1101 is given # ['123host.example.com' => 'FFPP'], ['host.12example.com' => 'FFPP'], # # But it may not look it starts with an IP address # ['127.0.0.1' => 'FFFF'], ['127.0.0.1.com' => 'FFFF'], ['127.0.0.1333.com' => 'FFPP'], # # Parts may not end with a dash # ['host-.example.com' => 'FFFF'], # # May not end with a dot # ['host.example.com.' => 'FFFF'], # # Mind your dots and spaces # ['host. .example.com' => 'FFFF'], ['host..example.com' => 'FFFF'], ['host .example.com' => 'FFFF'], ['ho st.example.com' => 'FFFF'], ); my @pats = ( ['$RE {net} {domain}' => $RE {net} {domain}], ['$RE {net} {domain} {-nospace}' => $RE {net} {domain} {-nospace}], ['$RE {net} {domain} {-rfc1101}' => $RE {net} {domain} {-rfc1101}], ['$RE {net} {domain} {-nospace} {-rfc1101}' => $RE {net} {domain} {-nospace} {-rfc1101}], ); foreach (my $i = 0; $i < @pats; $i ++) { my ($name, $pat) = @{$pats [$i]}; try $pat; $M .= "# Trying $name\n"; foreach my $entry (@data) { my ($domain, $results) = @$entry; my $entry = substr $results, $i, 1; $entry eq 'P' ? pass $domain : fail $domain; } } Regexp-Common-2017060201/t/delimited/101_delimited.t000755 000765 000024 00000030304 12722155233 022247 0ustar00abigailstaff000000 000000 #!/opt/perl/bin/perl use strict; use warnings; no warnings 'syntax'; use Regexp::Common; use Test::More; my $r = eval "require Test::Regexp; 1"; unless ($r) { print "1..0 # SKIP Test::Regexp not found\n"; exit; } sub make_test { my ($name, $pat) = @_; my $keep = $$pat {-keep}; Test::Regexp:: -> new -> init ( pattern => $pat, keep_pattern => $keep, name => $name, ); } # # Test double quoted delimiter # { my $test = make_test "Double quoted string" => $RE {delimited} {-delim => '"'}; $test -> match (q {"a few words"}, [q {"a few words"}, q {"}, q {a few words}, q {"}], test => "Simple string"), $test -> match (q {"a few \ words"}, [q {"a few \ words"}, q {"}, q {a few \ words}, q {"}], test => "Simple string with escape"), $test -> match (q {"a few \" words"}, [q {"a few \" words"}, q {"}, q {a few \" words}, q {"}], test => "Simple string with escaped delimiter"), $test -> match (q {"a 'few' words"}, [q {"a 'few' words"}, q {"}, q {a 'few' words}, q {"}], test => "Simple string with single quotes"), $test -> no_match (q {'a few words'}, reason => "Wrong delimiters"); $test -> no_match (q {a few words"}, reason => "No opening delimiter"); $test -> no_match (q {"a few words}, reason => "No closing delimiter"); $test -> no_match (q {"a few" words"}, reason => "Unescaped delimiter"); $test -> no_match (q {"a few\\\\" words"}, reason => "Escaped escape"); $test -> no_match (q { "a few words"}, reason => "Characters before opening delimiter"); $test -> no_match (q {"a few words" }, reason => "Characters after opening delimiter"); } # # Test single quoted delimiter # { my $test = make_test "Single quoted string" => $RE {delimited} {-delim => "'"}; $test -> match (q {'a few words'}, [q {'a few words'}, q {'}, q {a few words}, q {'}], test => "Simple string"), $test -> match (q {'a few \ words'}, [q {'a few \ words'}, q {'}, q {a few \ words}, q {'}], test => "Simple string with escape"), $test -> match (q {'a few \' words'}, [q {'a few \' words'}, q {'}, q {a few \' words}, q {'}], test => "Simple string with escaped delimiter"), $test -> match (q {'a "few" words'}, [q {'a "few" words'}, q {'}, q {a "few" words}, q {'}], test => "Simple string with double quotes"), $test -> no_match (q {"a few words"}, reason => "Wrong delimiters"); $test -> no_match (q {a few words'}, reason => "No opening delimiter"); $test -> no_match (q {'a few words}, reason => "No closing delimiter"); $test -> no_match (q {'a few' words'}, reason => "Unescaped delimiter"); $test -> no_match (q {'a few\\\\' words'}, reason => "Escaped escape"); $test -> no_match (q { 'a few words'}, reason => "Characters before opening delimiter"); $test -> no_match (q {'a few words' }, reason => "Characters after opening delimiter"); } # # Test an odd (space) delimiter # { my $test = make_test "Space quoted string" => $RE {delimited} {-delim => " "}; $test -> match (q { a-few-words }, [q { a-few-words }, q { }, q {a-few-words}, q { }], test => "Simple string"), $test -> match (q { a-few-\-words }, [q { a-few-\-words }, q { }, q {a-few-\-words}, q { }], test => "Simple string with escape"), $test -> match (q { a-few-\ -words }, [q { a-few-\ -words }, q { }, q {a-few-\ -words}, q { }], test => "Simple string with escaped delimiter"), $test -> no_match (q {"a few words"}, reason => "Wrong delimiters"); } # # Test $RE {quoted}. This automatically tests multiple delimiters as well. # { my $test = make_test "Quoted string (using 'quoted')" => $RE {quoted}; $test -> match (q {"a few words"}, [q {"a few words"}, q {"}, q {a few words}, q {"}], test => "Simple string, using double quotes"), $test -> match (q {'a few words'}, [q {'a few words'}, q {'}, q {a few words}, q {'}], test => "Simple string, using single quotes"), $test -> match (q {`a few words`}, [q {`a few words`}, q {`}, q {a few words}, q {`}], test => "Simple string, using backticks"), $test -> match (q {"a few \ words"}, [q {"a few \ words"}, q {"}, q {a few \ words}, q {"}], test => "Double quoted string with escape"), $test -> match (q {'a few \ words'}, [q {'a few \ words'}, q {'}, q {a few \ words}, q {'}], test => "Single quoted string with escape"), $test -> match (q {`a few \ words`}, [q {`a few \ words`}, q {`}, q {a few \ words}, q {`}], test => "Backtick quoted string with escape"), $test -> match (q {"a few \" words"}, [q {"a few \" words"}, q {"}, q {a few \" words}, q {"}], test => "Double quoted string with escaped delimiter"), $test -> match (q {'a few \' words'}, [q {'a few \' words'}, q {'}, q {a few \' words}, q {'}], test => "Single quoted string with escaped delimiter"), $test -> match (q {`a few \` words`}, [q {`a few \` words`}, q {`}, q {a few \` words}, q {`}], test => "Backtick quoted string with escaped delimiter"), $test -> match (q {"a 'few' words"}, [q {"a 'few' words"}, q {"}, q {a 'few' words}, q {"}], test => "Double quoted string with single quotes"), $test -> match (q {'a "few" words'}, [q {'a "few" words'}, q {'}, q {a "few" words}, q {'}], test => "Single quoted string with double quotes"), $test -> match (q {`a "few" words`}, [q {`a "few" words`}, q {`}, q {a "few" words}, q {`}], test => "Backtick quoted string with double quotes"), $test -> no_match (q {'a few words"}, reason => "Mixed delimiters"); $test -> no_match (q {'a few words`}, reason => "Mixed delimiters"); $test -> no_match (q {"a few words`}, reason => "Mixed delimiters"); $test -> no_match (q {"a few words'}, reason => "Mixed delimiters"); $test -> no_match (q {`a few words"}, reason => "Mixed delimiters"); $test -> no_match (q {`a few words'}, reason => "Mixed delimiters"); } # # Test an another delimiter # { my $test = make_test "Bang as delimiter" => $RE {delimited} {-delim => '"'} {-esc => '!'}; $test -> match (q {"a few words"}, [q {"a few words"}, q {"}, q {a few words}, q {"}], test => "Simple string"), $test -> match (q {"a few ! words"}, [q {"a few ! words"}, q {"}, q {a few ! words}, q {"}], test => "Simple string with escape"), $test -> match (q {"a few !" words"}, [q {"a few !" words"}, q {"}, q {a few !" words}, q {"}], test => "Simple string with escaped delimiter"), $test -> no_match (q {"a few\" words"}, reason => "Incorrect escape"); $test -> no_match (q {"a few!!" words"}, reason => "Escaped escape"); } # # Test delimiter and escape the same characters # { my $test = make_test "Delimiter is same as escape" => $RE {delimited} {-delim => '!'} {-esc => '!'}; $test -> match (q {!a few words!}, [q {!a few words!}, q {!}, q {a few words}, q {!}], test => "Simple string"), $test -> match (q {!a few !! words!}, [q {!a few !! words!}, q {!}, q {a few !! words}, q {!}], test => "Simple string with escaped delimiter"), $test -> no_match (q {!a few\! words!}, reason => "Incorrect escape"); $test -> no_match (q {!a few! words!}, reason => "Escape must be followed by delimiter"); } # # Test multiple escapes; they should match up with the delimiters # { my $test = make_test "Multiple escape characters" => $RE {quoted} {-esc => '!_'}; $test -> match (q {"a few words"}, [q {"a few words"}, q {"}, q {a few words}, q {"}], test => "Simple string"); $test -> match (q {"a !"few words"}, [q {"a !"few words"}, q {"}, q {a !"few words}, q {"}], test => "Simple string, with escape"); $test -> match (q {'a _'few words'}, [q {'a _'few words'}, q {'}, q {a _'few words}, q {'}], test => "Simple string, with another delimiter/escape"); $test -> match (q {`a _`few words`}, [q {`a _`few words`}, q {`}, q {a _`few words}, q {`}], test => "Escape copied when there are more delimiters"); $test -> no_match (q {"a _"few words"}, reason => "Incorrect delimiter"); $test -> no_match (q {'a !'few words'}, reason => "Incorrect delimiter"); $test -> no_match (q {`a !`few words`}, reason => "Incorrect delimiter"); $test -> no_match (q {"a \"few words"}, reason => "Incorrect delimiter"); } # # Test no escape character # { my $test = make_test "Double quoted string" => $RE {delimited} {-delim => '"'} {-esc =>}; $test -> match (q {"a few words"}, [q {"a few words"}, q {"}, q {a few words}, q {"}], test => "Simple string"), $test -> no_match (q {"a few" words"}, reason => "Delimiter in string"); $test -> no_match (q {"a few\" words"}, reason => "There is no escape"); } # # Test different closing delimiters # { my $test = make_test "Bracketed strings" => $RE {delimited} { -delim => '([{<'} {-cdelim => ')]}>'}; $test -> match ("(a few words)", ["(a few words)", "(", "a few words", ")"], test => "Using parenthesis"); $test -> match ("[a few words]", ["[a few words]", "[", "a few words", "]"], test => "Using brackets"); $test -> match ("{a few words}", ["{a few words}", "{", "a few words", "}"], test => "Using braces"); $test -> match ("", ["", "<", "a few words", ">"], test => "Using angle brackets"); $test -> match ("[a [few words]", ["[a [few words]", "[", "a [few words", "]"], test => "Opening delimiter needs no escape"); $test -> match ('[a [few\] words]', ['[a [few\] words]', "[", 'a [few\] words', "]"], test => "Closing delimiter needs escape"); $test -> no_match ("[a few words}", reason => "Mismatched delimiters"); $test -> no_match ("(a few words>", reason => "Mismatched delimiters"); $test -> no_match ("{a few words{", reason => "Using opening delimiter as the closing delimiter"); $test -> no_match (">a few words>", reason => "Using closing delimiter as the opening delimiter"); $test -> no_match ("[a [few] words]", reason => "Unescaped closing delimiter"); } # # Use less closing delimiters than opening delimiters # { my $test = make_test "Less closing delimiters than opening delimiters" => $RE {delimited} { -delim => "\x{AB}<"} {-cdelim => "\x{BB}"}; $test -> match ("\x{AB}a few words\x{BB}", ["\x{AB}a few words\x{BB}", "\x{AB}", "a few words", "\x{BB}"], test => "Using double angled quotation marks"); $test -> match (" "Closing delimiter repeats"); } done_testing; __END__ Regexp-Common-2017060201/t/delimited/111_bquoted.t000755 000765 000024 00000023604 12722267732 021770 0ustar00abigailstaff000000 000000 #!/opt/perl/bin/perl use strict; use warnings; no warnings 'syntax'; use Regexp::Common; use Test::More; my $r = eval "require Test::Regexp; 1"; unless ($r) { print "1..0 # SKIP Test::Regexp not found\n"; exit; } unless ($] >= 5.014) { print "1..0 # SKIP Pattern not available on this version of Perl\n"; exit; } sub make_test { my ($name, $pat) = @_; my $keep = $$pat {-keep}; Test::Regexp:: -> new -> init ( pattern => $pat, keep_pattern => $keep, name => $name, ); } # # Pairs of brackets # my @pairs = map {[chr $$_ [1], chr ($$_ [2] // ($$_ [1] + 1)), $$_ [0]]} ["parenthesis" => 0x0028, 0x0029], ["square bracket" => 0x005B, 0x005D], ["curly brackets" => 0x007B, 0x007D], ["double quotation marks" => 0x201C], ["quotation marks" => 0x2018], ["single pointing angle quotation marks" => 0x2039], ["pointing double angle quotation marks" => 0x00AB, 0x00BB], ["fullwidth parenthesis" => 0xFF08], ["fullwidth square brackets" => 0xFF3B, 0xFF3D], ["fullwidth curly brackets" => 0xFF5B, 0xFF5D], ["fullwidth white parenthesis" => 0xFF5F], ["white parenthesis" => 0x2985], ["white square brackets" => 0x301A], ["white curly brackets" => 0x2983], ["corner brackets" => 0x300C], ["angle brackets" => 0x3008], ["double angle brackets" => 0x300A], ["black lenticular brackets" => 0x3010], ["tortoise shell brackets" => 0x3014], ["black tortoise shell brackets" => 0x2997], ["white corner brackets" => 0x300E], ["white lenticular brackets", => 0x3016], ["white tortoise shell brackets" => 0x3018], ["halfwidth corner brackets" => 0xFF62], ["mathematical white square brackets" => 0x27E6], ["mathematical angle brackets" => 0x27E8], ["mathematical double angle brackets" => 0x27EA], ["mathematical flattened parenthesis" => 0x27EE], ["mathematical white tortoise shell brackets" => 0x27EC], ["ceiling" => 0x2308], ["floor" => 0x230A], ["Z notation image brackets" => 0x2987], ["Z notation binding brackets" => 0x2989], ["heavy single commas" => 0x275B], ["heavy double commas" => 0x275D], ["medium parenthesis ornaments" => 0x2768], ["medium flattened parenthesis ornaments" => 0x276A], ["medium curly bracket ornaments" => 0x2774], ["medium pointing angle bracket ornaments" => 0x276C], ["heavy pointing angle quotation mark ornaments" => 0x276E], ["heavy pointing angle bracket ornaments" => 0x2770], ["light tortoise shell bracket ornaments" => 0x2772], ["ornate parenthesis" => 0xFD3E], ["top-bottom parenthesis" => 0x23DC], ["top-bottom square brackets" => 0x23B4], ["top-bottom curly brackets" => 0x23DE], ["top-bottom tortoise shell brackets" => 0x23E0], ["presentation form for vertical corner brackets" => 0xFE41], ["presentation form for vertical white corner brackets" => 0xFE43], ["presentation form for vertical tortoise shell brackets" => 0xFE39], ["presentation form for vertical black lenticul brackets" => 0xFE3B], ["presentation form for vertical white lenticul brackets" => 0xFE17], ["presentation form for vertical angle brackets" => 0xFE3F], ["presentation form for vertical double angle brackets" => 0xFE3D], ["presentation form for vertical square brackets" => 0xFE47], ["presentation form for vertical curly brackets" => 0xFE37], ["pointing angle brackets" => 0x2329], ["angle brackets with dots" => 0x2991], ["pointing curved angle brackets" => 0x29FC], ["small parenthesis" => 0xFE59], ["small curly brackets" => 0xFE5B], ["small tortoise shell brackets" => 0xFE5D], ["superscript parenthesis" => 0x207D], ["subscript parenthesis" => 0x208D], ["square brackets with underbars" => 0x298B], ["square brackets with top-bottom ticks" => 0x298D], ["square brackets with bottom-top ticks" => 0x298F], ["square brackets with quills" => 0x2045], ["top half brackets" => 0x2E22], ["bottom half brackets" => 0x2E24], ["S-shaped bag delimiters" => 0x27C5], ["arcs with less/greater than brackets" => 0x2993], ["double arcs with greater/less than brackets" => 0x2995], ["sideways U brackets" => 0x2E26], ["double parenthesis" => 0x2E28], ["wiggly fences" => 0x29D8], ["double wiggly fences" => 0x29DA], ["low paraphrase brackets" => 0x2E1C], ["raised omission brackets" => 0x2E0C], ["substitution brackets" => 0x2E02], ["double substitution brackets" => 0x2E04], ["transposition brackets" => 0x2E09], ["Ogham feather marks" => 0x169B], ["Tibetan marks gug rtags" => 0x0F3A], ["Tibetan marks ang khang" => 0x0F3C], ; # # Test double quoted delimiter # { my $test = make_test "Bracketed string" => $RE {bquoted}; foreach my $pair (@pairs) { my ($left, $right, $name) = @$pair; $test -> match ("${left}A few words${right}", ["${left}A few words${right}", $left, "A few words", $right], test => "Using ${name} as delimiters"); $test -> match ("${left}A few ${left}words${right}", ["${left}A few ${left}words${right}", $left, "A few ${left}words", $right], test => "Using ${name} as delimiters; " . "use opening delimiter in string"); $test -> match ("${left}A few \\${right}words${right}", ["${left}A few \\${right}words${right}", $left, "A few \\${right}words", $right], test => "Using ${name} as delimiters; " . "use escaped closing delimiter in string"); $test -> match ("${left}A few\nwords${right}", ["${left}A few\nwords${right}", $left, "A few\nwords", $right], test => "Using ${name} as delimiters; " . "don't trip over newlines"); $test -> no_match ("${left}A few words${left}", reason => "Using opening delimiter " . "as the closing one"); $test -> no_match ("${right}A few words${right}", reason => "Using closing delimiter " . "as the opening one"); $test -> no_match ("${left}A few ${right}words${right}", reason => "Unescaped closing delimiter in string"); $test -> no_match ("${left}A few words\\${right}", reason => "Escaping the closing delimiter is bad"); $test -> no_match ("${left}A few \\\\${right}words${right}", reason => "Unescaped the escape neutralizes"); } foreach (my $i = 0; $i < @pairs; $i ++) { my $j = ($i + 7) ** 2; $j %= @pairs; if ($j == $i) { $j += 15; $j %= @pairs; } my $left = $pairs [$i] [0]; my $right = $pairs [$j] [1]; $test -> no_match ("${left}A few words${right}", reason => "Mismatched delimiters"); } } done_testing; Regexp-Common-2017060201/t/comment/delimited.t000755 000765 000024 00000005750 13070654573 021407 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use lib "blib/lib", "."; use Regexp::Common qw /RE_comment_ALL/; use t::Common qw /run_new_tests/; use warnings; my @delimited = do { no warnings; ( [qw {comment ;} => ['Algol 60']], [qw {/* */} => [qw {ALPACA B C C-- LPC PL/I}]], [qw {; ;} => [qw {Befunge-98 Funge-98 Shelta}]], [qw {} => [qw {BML}]], [qw !{ }! => [qw {False}]], [qw {, ,} => [qw {Haifu}]], [qw {/** */} => [qw {JavaDoc}]], [qw {(* *)} => [qw {Oberon}]], [qw {" "} => [qw {Smalltalk}]], [qw {|| !!} => [qw {*W}]], ) }; # # Some basic comments, not including delimiters. # my @comments = ("", "This is a comment", "This is a\nmultiline comment", "\n", "*", "\n*\n", "/*", "(*", "||", "{"); # Targets, and test suites. my %targets; my @tests; foreach my $entry (@delimited) { my ($start, $end) = @$entry [0, 1]; my $langs = $$entry [2]; my $pass_key = "pass_${start}_${end}"; my $fail_key = "fail_${start}_${end}"; $targets {$pass_key} = { list => \@comments, query => sub {$start . $_ [0] . $end}, wanted => sub {$_, $start, $_ [0], $end}, }; # Create bad comments. my @bad_comments; # No terminating token. push @bad_comments => map {"$start$_"} @comments; # No starting token. push @bad_comments => map {"$_$end"} grep {index ($_, $start)} @comments; # Double terminators. push @bad_comments => map {"$start$_$end$end"} @comments; # Double the comment. push @bad_comments => map {"$start$_$end" x 2} @comments; # Different token. my @bad_tokens = grep {index $_ -> [0], $start} @delimited; push @bad_comments => map {my $c = $_; map {$_ -> [0] . $c . $_ -> [1]} @bad_tokens } @comments; # No tokens. push @bad_comments => @comments; # Text preceeding comment. push @bad_comments => map {"Text $start$_$end"} @comments; # Some more. push @bad_comments => ""; push @bad_comments => "/* This is a C comment */" if $start ne '/*'; push @bad_comments => "{ This is a Pascal comment }" if $start ne '{'; $targets {$fail_key} = { list => \@bad_comments, }; foreach my $lang (@$langs) { my $langX = $lang; $langX =~ s/\W/X/g; no strict 'refs'; push @tests => { name => $lang, regex => $RE {comment} {$lang}, sub => \&{"RE_comment_$langX"}, pass => [$pass_key], fail => [$fail_key], skip_sub => sub {$lang eq 'JavaDoc' && $_ [0] eq 'fail' && $_ [1] eq '/***/'}, } } } run_new_tests tests => \@tests, targets => \%targets, version_from => 'Regexp::Common::comment', __END__ Regexp-Common-2017060201/t/comment/html.t000755 000765 000024 00000004645 13070654573 020415 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use lib "blib/lib", "."; use Regexp::Common qw /RE_comment_HTML/; use t::Common qw /run_new_tests cross/; use warnings; my @good = ("", "This is a comment", "This is - a comment", "This is - - comment", ">This is a comment", ">This is a comment<", "This is comment", ">", "<>", "><", "<"); my @spec = ("", ">", "->", " [0], ss, $_ -> [1], ss, $_ -> [2], ss]} cross \@spec, \@spec, \@spec; # Targets, and test suites. my %targets; my @tests; $targets {simple} = { list => \@good, query => sub {""}, wanted => sub {$_, ""}, }; $targets {simple_space} = { list => \@spaced, query => sub {""}, wanted => sub {$_, ""}, }; $targets {crossed2} = { list => \@cross3, query => sub {"", # Missing ! "", # Not enough dashes, "", # Too many starting dashes. "", # Space after ", # Garbage after comment )} @good; $targets {bad1} = { list => \@bad, }; $targets {bad2} = { list => \@crossed, query => sub {""}, }; push @tests => { name => 'HTML', regex => $RE {comment} {HTML}, pass => [qw /simple simple_space crossed crossed2/], fail => [qw /bad1 bad2/], sub => \&RE_comment_HTML, }; run_new_tests tests => \@tests, targets => \%targets, version_from => 'Regexp::Common::comment', ; __END__ Regexp-Common-2017060201/t/comment/nested.t000755 000765 000024 00000015302 13070654573 020723 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use lib "blib/lib", "."; use Regexp::Common qw /pattern RE_comment_ALL/; use t::Common qw /run_new_tests cross ww/; use warnings; pattern name => [qw /comment fairy-language-1/], create => sub {my $re = Regexp::Common::comment::nested "-(-", "-)-"; exists $_ [1] -> {-keep} ? qr /($re)/ : qr /$re/ }, version => 5.006 ; pattern name => [qw /comment fairy-language-2/], create => sub {my $re = Regexp::Common::comment::nested "(", ")"; exists $_ [1] -> {-keep} ? qr /($re)/ : qr /$re/ }, version => 5.006 ; my @data = do { no warnings; ( { nested_tokens => [["(*" => "*)"]], languages => [qw /Caml Modula-2 Modula-3/], }, { start_tokens => ["//"], nested_tokens => [["/*" => "*/"]], languages => [qw /Dylan/], }, { start_tokens => ["--", "---", "-----"], nested_tokens => [["{-", "-}"]], languages => [qw /Haskell/], }, { start_tokens => ["!"], # Should not be followed by \ nested_tokens => [["!\\", "\\!"]], languages => [qw /Hugo/], }, { start_tokens => ["#"], nested_tokens => [["(*" => "*)"]], languages => [qw /SLIDE/], }, { nested_tokens => [["-(-" => "-)-"]], languages => [qw /fairy-language-1/], }, { nested_tokens => [["(" => ")"]], languages => [qw /fairy-language-2/], }, ); }; $$_ {start_tokens} ||= [] for @data; $$_ {nested_tokens} ||= [] for @data; my @s_tokens = do { my %h; grep {!$h {$_} ++} map {@{$$_ {start_tokens}}} @data }; my @pairs = do { my %h; grep {!$h {$$_ [0]} {$$_ [1]} ++} map {@{$$_ {nested_tokens}}} @data }; # # Create some comments. # my @comments = ("", "This is a comment", "This is a\nmultiline comment", "\n", map {" $_ "} @s_tokens); my @no_eol = grep {!/\n/} @comments; my (%targets, @tests); foreach my $s_token (@s_tokens) { my $pass_key = "start_pass_$s_token"; my $fail_key = "start_fail_$s_token"; $targets {$pass_key} = { list => \@no_eol, query => sub {$s_token . $_ [0] . "\n"}, }; # Build a list of "bad" comments. my @bad; # No trailing newline. push @bad => map {"$s_token$_"} @no_eol; # Double newline. push @bad => map {"$s_token$_\n\n"} @no_eol; # Double comment. push @bad => map {"$s_token$_\n" x 2} @no_eol; # Leading garbage. push @bad => map {ww (1, 10) . "$s_token$_\n"} @no_eol; # Trailing garbage. push @bad => map {"$s_token$_\n" . ww (1, 10)} @no_eol; $targets {$fail_key} = { list => \@bad, }; } my @parts = cross ["", "[]", "\n"], ["", "7^%", "\n"], ["", "comment", "\n"]; foreach my $pair (@pairs) { my ($start, $end) = @$pair; my $pass_key = "nested_pass_${start}_${end}"; my $fail_key = "nested_fail_${start}_${end}"; $targets {"${pass_key}_simple"} = { list => \@comments, query => sub {$start . $_ [0] . $end}, }; my @nested = map {$start . $$_ [0] . $start . $$_ [1] . $end . $$_ [2] . $end} @parts; $targets {"${pass_key}_nested"} = { list => \@nested, }; # Build a list of "bad" comments. my @bad; # No end token. push @bad => map {"$start$_"} @comments; # No begin token. push @bad => map {"$_$end"} @comments; # Double end token. push @bad => map {"$start$_$end$end"} @comments; # Double begin token. push @bad => map {"$start$start$_$end"} @comments; # Double comment. push @bad => map {"$start$_$end" x 2} @comments; # Leading garbage. push @bad => map {ww (1, 10) . "$start$_$end"} @comments; # Trailing garbage. push @bad => map {"$start$_$end" . ww (1, 10)} @comments; # Bad nested comments. # Extra start token. push @bad => map {"$start$_"} @nested; # Extra end token. push @bad => map {"$_$end"} @nested; # Leading garbage. push @bad => map {ww (1, 10) . $_} @nested; # Trailing garbage. push @bad => map {$_ . ww (1, 10)} @nested; # Double comment. push @bad => map {$_ x 2} @nested; $targets {$fail_key} = { list => \@bad }; } foreach my $data (@data) { foreach my $language (@{$$data {languages}}) { my (@passes, @failures); foreach my $my_token (@{$$data {start_tokens}}) { push @passes => "start_pass_$my_token"; push @failures => "start_fail_$my_token"; } foreach my $s_token (@s_tokens) { # Failure, unless there's a token that's a prefix of $s_token. my $ok = 1; foreach my $my_token (@{$$data {start_tokens}}) { $ok = 0 if index ($s_token, $my_token) == 0; } push @failures => "start_pass_$s_token" if $ok; } foreach my $my_pair (@{$$data {nested_tokens}}) { my ($my_start, $my_end) = @$my_pair; push @passes => "nested_pass_${my_start}_${my_end}_simple", "nested_pass_${my_start}_${my_end}_nested"; push @failures => "nested_fail_${my_start}_${my_end}"; } foreach my $pair (@pairs) { my ($start, $end) = @$pair; # Failure, unless there's a pair that fits. my $ok = 1; foreach my $my_pair (@{$$data {nested_tokens}}) { my ($my_start, $my_end) = @$my_pair; $ok = 0 if index ($start, $my_start) == 0 && rindex ($end, $my_end) == length ($end) - length ($my_end); } push @failures => "nested_pass_${start}_${end}_simple", "nested_pass_${start}_${end}_nested" if $ok; } (my $sub = "RE_comment_$language") =~ s/\W/X/g; my $test = { name => $language, re => $RE {comment} {$language}, pass => \@passes, fail => \@failures, }; # If we call 'pattern' after the 'use Regexp::Common', we won't # (can't) import a subroutine. no strict 'refs'; $$test {sub} = \&{$sub} if defined &{"main::$sub"}; push @tests => $test; } } run_new_tests tests => \@tests, targets => \%targets, version_from => 'Regexp::Common::comment', version => 5.006, ; __END__ Regexp-Common-2017060201/t/comment/pascal.t000755 000765 000024 00000005015 13070654573 020704 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use lib "blib/lib", "."; use Regexp::Common qw /RE_comment_Pascal/; use t::Common qw /run_new_tests/; use warnings; my @open = qw [{ (*]; my @close = qw [} *)]; # # Some basic comments, not including delimiters. # my @comments = ("", "This is a comment", "This is a\nmultiline comment", "\n", "*", "\n*\n", "**", "*****", "** **", "/*", "||"); # Targets, and test suites. my %targets; my @tests; foreach my $start (@open) { foreach my $end (@close) { my $lang = "Pascal"; my $pass_key = "pass_${start}_${end}"; my $fail_key = "fail_${start}_${end}"; $targets {$pass_key} = { list => \@comments, query => sub {$start . $_ [0] . $end}, wanted => sub {$_, $start, $_ [0], $end}, }; # Create bad comments. my @bad_comments; # No terminating token. push @bad_comments => map {"$start$_"} @comments; # No starting token. push @bad_comments => map {"$_$end"} grep {index ($_, $start)} @comments; # Double terminators. push @bad_comments => map {"$start$_$end$end"} @comments; # Double the comment. push @bad_comments => map {"$start$_$end" x 2} @comments; # Different token. my @bad_open = qw [// /* --]; my @bad_close = (qw [*/ --], "\n"); foreach my $close (@close) { push @bad_comments => map {my $o = $_; map {"ot$_$close"} @comments} @bad_open; } foreach my $open (@open) { push @bad_comments => map {my $c = $_; map {"$open$_$c"} @comments} @bad_close; } # No tokens. push @bad_comments => @comments; # Text preceeding comment. push @bad_comments => map {"Text $start$_$end"} @comments; # Some more. push @bad_comments => ""; push @bad_comments => "/* This is a C comment */"; $targets {$fail_key} = { list => \@bad_comments, }; no strict 'refs'; push @tests => { name => $lang, regex => $RE {comment} {$lang}, sub => \&{"RE_comment_$lang"}, pass => [$pass_key], fail => [$fail_key], } } } run_new_tests tests => \@tests, targets => \%targets, version_from => 'Regexp::Common::comment', __END__ Regexp-Common-2017060201/t/comment/single_line.t000755 000765 000024 00000014560 13070654573 021736 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use lib "blib/lib", "."; use Regexp::Common qw /RE_comment_ALL/; use t::Common qw /run_new_tests ww/; use warnings; # 1. List of tokens. # 2. List of languages. my @data = do { no warnings; ( {start_tokens => ["\\"], # No qw here, 5.6.0 parses it incorrectly. languages => [qw {ABC Forth}], }, {start_tokens => [qw {# //}], languages => [qw {Advisor}], }, {start_tokens => [qw {--}], languages => [qw {Ada Alan Eiffel lua}], }, {start_tokens => [qw {;}], languages => [qw {Advsys CQL Lisp LOGO M MUMPS REBOL Scheme SMITH zonefile}], }, {start_tokens => [qw {#}], languages => [qw {awk fvwm2 Icon m4 mutt Perl Python QML R Ruby shell Tcl}], }, {start_tokens => [qw {* ! REM}], languages => [[BASIC => 'mvEnterprise']], }, {start_tokens => [qw {//}], languages => [qw {beta-Juliet Portia Ubercode}, q {Crystal Report}], }, {start_tokens => [qw {%}], languages => [qw {CLU LaTeX TeX slrn}], }, {start_tokens => [qw {!}], languages => [qw {Fortran}], }, {start_tokens => [qw {NB}], languages => [qw {ILLGOL}], }, {start_tokens => ["PLEASE NOT", "PLEASE NOT", "PLEASE N'T", "DO NOT", "DO N'T", "DO NOT", "PLEASE DO NOT", "PLEASE DO NOT", "PLEASE DO N'T"], languages => [qw {INTERCAL}]}, {start_tokens => [qw {NB.}], languages => [qw {J}], }, {start_tokens => [qw !{!], languages => [[qw {Pascal Alice}]], end_tokens => [qw !}!], }, {start_tokens => [qw {. ;}], languages => [qw {PL/B}], }, {start_tokens => [qw {`}], languages => [qw {Q-BAL}], }, {start_tokens => [qw {-- --- -----}], languages => [qw {SQL}], # SQL comments start with /-{2,}/ }, {start_tokens => ['\\"'], # No qw here, 5.6.0 parses it incorrectly. languages => [qw {troff}], }, {start_tokens => [qw {"}], languages => [qw {vi}], }, {start_tokens => [qw {'}], languages => [qw {ZZT-OOP}], }, ); }; # # Extract the markers. # # my @tokens = map {@{$$_ {start_tokens}}} @data; my @tokens; foreach my $data (@data) { if ($$data {end_tokens}) { push @tokens => map {[$$data {start_tokens} [$_] => $$data {end_tokens} [$_]]} 0 .. $#{$$data {start_tokens}}; } else { push @tokens => map {[$_ => "\n"]} @{$$data {start_tokens}} } } # # Some basic comments, not including delimiters. # my @comments = ("", "This is a comment", "A\tcomment", "Another /* comment"); # Targets, and test suites. my %targets; my @tests; my @bad; foreach my $token (@tokens) { my ($start, $end) = @$token; my $pass_key = "pass_${start}_${end}"; my $fail_key = "fail_${start}_${end}"; my @my_bad; $targets {$pass_key} = { list => \@comments, query => sub {$start . $_ [0] . $end}, wanted => sub {$_, $start, $_ [0], $end}, }; # No trailing newline. push @bad => map {"$start$_"} @comments; # No leading token. push @bad => map {"$_$end"} @comments; # Double newlines. push @my_bad => map {"$start$_$end$end"} @comments; # Double comments. push @my_bad => map {"$start$_$end" x 2} @comments; # Garbage trailing the comments. push @my_bad => map {"$start$_$end" . ww (1, 5)} @comments; # Garbage leading the comments. push @my_bad => map {ww (1, 5) . "$start$_$end"} @comments; $targets {$fail_key} = { list => \@my_bad } } # A few extras. push @bad => ("/* This is a C comment */", "(* This is a Pascal comment *)", ""); $targets {bad} = { list => \@bad }; foreach my $entry (@data) { my ($start_tokens, $langs) = @$entry {qw /start_tokens languages/}; my $end_tokens = $$entry {end_tokens} ? $$entry {end_tokens} : [("\n") x @$start_tokens]; my @my_tokens = map {[$$start_tokens [$_], $$end_tokens [$_]]} 0 .. $#$start_tokens; my %my_tokens = map {$_ => 1} map {join _ => $$start_tokens [$_], $$end_tokens [$_]} 0 .. $#$start_tokens; my @pass_tokens = map {join _ => "pass", $$start_tokens [$_], $$end_tokens [$_]} 0 .. $#$start_tokens; # # Find out what should fail. # # 1. A global 'bad' list. # my @fail_tokens = ("bad"); # # 2. Failures for our tokens. # push @fail_tokens => map {join _ => "fail", $$start_tokens [$_], $$end_tokens [$_]} 0 .. $#$start_tokens; # # 3. Passes for tokens that aren't ours, and don't "fit" ours. # TOKEN: foreach my $token (@tokens) { my ($start, $end) = @$token; foreach my $my_token (@my_tokens) { my ($my_start, $my_end) = @$my_token; if ($start =~ /^\Q$my_start\E/ && $end =~ /\Q$my_end\E$/) { next TOKEN; } } push @fail_tokens => join _ => pass => @$token; } foreach my $lang (@$langs) { my $name = ref $lang ? join "/" => @$lang : $lang; my $re = ref $lang ? $RE {comment} {$lang -> [0]} {$lang -> [1]} : $RE {comment} {$lang}; my $sub = ref $lang ? join "_" => "RE_comment", @$lang : "RE_comment_$lang"; $sub =~ s/\W/X/g; no strict 'refs'; push @tests => { name => $name, regex => $re, sub => \&$sub, pass => \@pass_tokens, fail => \@fail_tokens, }; } } run_new_tests tests => \@tests, targets => \%targets, version_from => 'Regexp::Common::comment', __END__ Regexp-Common-2017060201/t/comment/single_or_multiline.t000755 000765 000024 00000012271 13070654573 023506 0ustar00abigailstaff000000 000000 #!/usr/bin/perl use strict; use lib "blib/lib", "."; use Regexp::Common qw /RE_comment_ALL/; use t::Common qw /run_new_tests ww/; use warnings; # 1. tokens for single line comments. # 2. start/end tokens for multi-line comments. # 3. list of languages this applies to. my @data = do { no warnings; ( [[qw {//}] => [[qw {/* */}]] => [qw {C++ C# Cg ECMAScript FPL Java JavaScript}], ], [[qw {#}] => [[qw {/* */}]] => [qw {Nickle}], ], [[qw {//}] => [[qw !{ }!], [qw !(* *)!]] => [[qw /Pascal Delphi/], [qw /Pascal Free/], [qw /Pascal GPC/]], ], [[qw {!}] => [[qw {/* */}]] => [qw {PEARL}] ], [[qw {# //}] => [[qw {/* */}]] => [qw {PHP}] ], [[qw {--}] => [[qw {/* */}]] => [qw {PL/SQL}] ] ); }; # Grab the single line tokens. my @s_tokens = do {my %h; grep {!$h {$_} ++} map {@{$$_ [0]}} @data}; # Grab the multiline line tokens. my @mo_tokens = do {my %h; grep {!$h {$_} ++} map {map {$$_ [0]} @{$$_ [1]}} @data}; my @mc_tokens = do {my %h; grep {!$h {$_} ++} map {map {$$_ [1]} @{$$_ [1]}} @data}; my @comments = ("", "This is a comment", "This is a\nmultiline comment", "\n", (map {" $_ "} @s_tokens, @mo_tokens, @mc_tokens)); my @no_eol = grep {!/\n/} @comments; # Targets, and test suites. my %targets; my @tests; my @bad; # Tests for the single line comments (including failures). foreach my $token (@s_tokens) { my $key = "single_$token"; my $fkey = "single_fail_$token"; $targets {$key} = { list => \@no_eol, query => sub {$token . $_ [0] . "\n"}, }; my @s_bad; # No trailing newline. push @s_bad => map {"$token$_"} @no_eol; # Double newline. push @s_bad => map {"$token$_\n\n"} @no_eol; # Double comment. push @s_bad => map {"$token$_\n" x 2} @no_eol; # Leading garbage. push @s_bad => map {ww (1, 10) . "$token$_\n"} @no_eol; # Trailing garbage. push @s_bad => map {"$token$_\n" . ww (1, 10)} @no_eol; $targets {$fkey} = { list => \@s_bad, }; } # No leading token. $targets {single_fail} = { list => [map {"$_\n"} @no_eol], }; # Tests for the multi line comments (including failures). for (my $i = 0; $i < @mc_tokens; $i ++) { my $start = $mo_tokens [$i]; my $end = $mc_tokens [$i]; my $key = "multi_${start}_$end"; my $key2 = "multi2_${start}_$end"; my $fkey = "multi_fail_${start}_$end"; my @list = grep {!/\Q$end/} @comments; $targets {$key} = { list => \@list, query => sub {$start . $_ [0] . $end}, }; # Doubling the start token should be ok. $targets {$key2} = { list => \@list, query => sub {$start . $start . $_ [0] . $end}, }; my @m_bad; # No starting token. push @m_bad => map {"$_$end"} @comments; # No ending token. push @m_bad => map {"$start$_"} @comments; # Double the comment. push @m_bad => map {"$start$_$end" x 2} @comments; # Leading garbage. push @m_bad => map {ww (1, 5) . "$start$_$end"} @comments; # Trailing garbage. push @m_bad => map {"$start$_$end" . ww (1, 5)} @comments; $targets {$fkey} = { list => \@m_bad, }; } # No tokens at all. $targets {fail} = { list => \@comments, }; foreach my $data (@data) { my ($singles, $doubles, $langs) = @$data; my %s_seen; my %m_seen; $s_seen {$_} = 1 for @$singles; $m_seen {join "_" => @$_} = 1 for @$doubles; my @passes = map {"single_$_"} @$singles; push @passes => map {join _ => "multi", @$_} @$doubles; push @passes => map {join _ => "multi2", @$_} @$doubles; my @failures = map {"single_$_"} grep {!$s_seen {$_}} @s_tokens; push @failures => map {"single_fail_$_"} @$singles; push @failures => "single_fail"; # Multiline comments using *other* delimiters. push @failures => map {join _ => "multi", $_} grep {!$m_seen {$_}} map {join _ => $mo_tokens [$_], $mc_tokens [$_]} 0 .. $#mo_tokens; push @failures => map {join _ => "multi_fail", @$_} @$doubles; push @failures => "fail"; foreach my $lang (@$langs) { my $name = ref $lang ? join "/" => @$lang : $lang; my $sub = ref $lang ? join "_" => "RE_comment", @$lang : "RE_comment_$lang"; $sub =~ s/\W/X/g; my $re = ref $lang ? $RE {comment} {$$lang [0]} {$$lang [1]} : $RE {comment} {$lang}; no strict 'refs'; push @tests => { name => $name, re => $re, sub => \&{$sub}, pass => \@passes, fail => \@failures, }; } } run_new_tests tests => \@tests, targets => \%targets, version_from => 'Regexp::Common::comment', __END__ Regexp-Common-2017060201/lib/Regexp/000755 000765 000024 00000000000 13114360501 017323 5ustar00abigailstaff000000 000000 Regexp-Common-2017060201/lib/Regexp/Common/000755 000765 000024 00000000000 13114360501 020553 5ustar00abigailstaff000000 000000 Regexp-Common-2017060201/lib/Regexp/Common.pm000644 000765 000024 00000063545 13114356476 021146 0ustar00abigailstaff000000 000000 package Regexp::Common; use 5.10.0; use strict; use warnings; no warnings 'syntax'; our $VERSION = '2017060201'; our %RE; our %sub_interface; our $AUTOLOAD; sub _croak { require Carp; goto &Carp::croak; } sub _carp { require Carp; goto &Carp::carp; } sub new { my ($class, @data) = @_; my %self; tie %self, $class, @data; return \%self; } sub TIEHASH { my ($class, @data) = @_; bless \@data, $class; } sub FETCH { my ($self, $extra) = @_; return bless ref($self)->new(@$self, $extra), ref($self); } my %imports = map {$_ => "Regexp::Common::$_"} qw /balanced CC comment delimited lingua list net number profanity SEN URI whitespace zip/; sub import { shift; # Shift off the class. tie %RE, __PACKAGE__; { no strict 'refs'; *{caller() . "::RE"} = \%RE; } my $saw_import; my $no_defaults; my %exclude; foreach my $entry (grep {!/^RE_/} @_) { if ($entry eq 'pattern') { no strict 'refs'; *{caller() . "::pattern"} = \&pattern; next; } # This used to prevent $; from being set. We still recognize it, # but we won't do anything. if ($entry eq 'clean') { next; } if ($entry eq 'no_defaults') { $no_defaults ++; next; } if (my $module = $imports {$entry}) { $saw_import ++; eval "require $module;"; die $@ if $@; next; } if ($entry =~ /^!(.*)/ && $imports {$1}) { $exclude {$1} ++; next; } # As a last resort, try to load the argument. my $module = $entry =~ /^Regexp::Common/ ? $entry : "Regexp::Common::" . $entry; eval "require $module;"; die $@ if $@; } unless ($saw_import || $no_defaults) { foreach my $module (values %imports) { next if $exclude {$module}; eval "require $module;"; die $@ if $@; } } my %exported; foreach my $entry (grep {/^RE_/} @_) { if ($entry =~ /^RE_(\w+_)?ALL$/) { my $m = defined $1 ? $1 : ""; my $re = qr /^RE_${m}.*$/; while (my ($sub, $interface) = each %sub_interface) { next if $exported {$sub}; next unless $sub =~ /$re/; { no strict 'refs'; *{caller() . "::$sub"} = $interface; } $exported {$sub} ++; } } else { next if $exported {$entry}; _croak "Can't export unknown subroutine &$entry" unless $sub_interface {$entry}; { no strict 'refs'; *{caller() . "::$entry"} = $sub_interface {$entry}; } $exported {$entry} ++; } } } sub AUTOLOAD { _croak "Can't $AUTOLOAD" } sub DESTROY {} my %cache; my $fpat = qr/^(-\w+)/; sub _decache { my @args = @{tied %{$_[0]}}; my @nonflags = grep {!/$fpat/} @args; my $cache = get_cache(@nonflags); _croak "Can't create unknown regex: \$RE{" . join("}{",@args) . "}" unless exists $cache->{__VAL__}; _croak "Perl $] does not support the pattern " . "\$RE{" . join("}{",@args) . "}.\nYou need Perl $cache->{__VAL__}{version} or later" unless ($cache->{__VAL__}{version}||0) <= $]; my %flags = ( %{$cache->{__VAL__}{default}}, map { /$fpat\Q$;\E(.*)/ ? ($1 => $2) : /$fpat/ ? ($1 => undef) : () } @args); $cache->{__VAL__}->_clone_with(\@args, \%flags); } use overload q{""} => \&_decache; sub get_cache { my $cache = \%cache; foreach (@_) { $cache = $cache->{$_} || ($cache->{$_} = {}); } return $cache; } sub croak_version { my ($entry, @args) = @_; } sub pattern { my %spec = @_; _croak 'pattern() requires argument: name => [ @list ]' unless $spec{name} && ref $spec{name} eq 'ARRAY'; _croak 'pattern() requires argument: create => $sub_ref_or_string' unless $spec{create}; if (ref $spec{create} ne "CODE") { my $fixed_str = "$spec{create}"; $spec{create} = sub { $fixed_str } } my @nonflags; my %default; foreach ( @{$spec{name}} ) { if (/$fpat=(.*)/) { $default{$1} = $2; } elsif (/$fpat\s*$/) { $default{$1} = undef; } else { push @nonflags, $_; } } my $entry = get_cache(@nonflags); if ($entry->{__VAL__}) { _carp "Overriding \$RE{" . join("}{",@nonflags) . "}"; } $entry->{__VAL__} = bless { create => $spec{create}, match => $spec{match} || \&generic_match, subs => $spec{subs} || \&generic_subs, version => $spec{version}, default => \%default, }, 'Regexp::Common::Entry'; foreach (@nonflags) {s/\W/X/g} my $subname = "RE_" . join ("_", @nonflags); $sub_interface{$subname} = sub { push @_ => undef if @_ % 2; my %flags = @_; my $pat = $spec{create}->($entry->{__VAL__}, {%default, %flags}, \@nonflags); if (exists $flags{-keep}) { $pat =~ s/\Q(?k:/(/g; } else { $pat =~ s/\Q(?k:/(?:/g; } return exists $flags {-i} ? qr /(?i:$pat)/ : qr/$pat/; }; return 1; } sub generic_match {$_ [1] =~ /$_[0]/} sub generic_subs {$_ [1] =~ s/$_[0]/$_[2]/} sub matches { my ($self, $str) = @_; my $entry = $self -> _decache; $entry -> {match} -> ($entry, $str); } sub subs { my ($self, $str, $newstr) = @_; my $entry = $self -> _decache; $entry -> {subs} -> ($entry, $str, $newstr); return $str; } package Regexp::Common::Entry; # use Carp; use overload q{""} => sub { my ($self) = @_; my $pat = $self->{create}->($self, $self->{flags}, $self->{args}); if (exists $self->{flags}{-keep}) { $pat =~ s/\Q(?k:/(/g; } else { $pat =~ s/\Q(?k:/(?:/g; } if (exists $self->{flags}{-i}) { $pat = "(?i)$pat" } return $pat; }; sub _clone_with { my ($self, $args, $flags) = @_; bless { %$self, args=>$args, flags=>$flags }, ref $self; } 1; __END__ =pod =head1 NAME Regexp::Common - Provide commonly requested regular expressions =head1 SYNOPSIS # STANDARD USAGE use Regexp::Common; while (<>) { /$RE{num}{real}/ and print q{a number}; /$RE{quoted}/ and print q{a ['"`] quoted string}; m[$RE{delimited}{-delim=>'/'}] and print q{a /.../ sequence}; /$RE{balanced}{-parens=>'()'}/ and print q{balanced parentheses}; /$RE{profanity}/ and print q{a #*@%-ing word}; } # SUBROUTINE-BASED INTERFACE use Regexp::Common 'RE_ALL'; while (<>) { $_ =~ RE_num_real() and print q{a number}; $_ =~ RE_quoted() and print q{a ['"`] quoted string}; $_ =~ RE_delimited(-delim=>'/') and print q{a /.../ sequence}; $_ =~ RE_balanced(-parens=>'()'} and print q{balanced parentheses}; $_ =~ RE_profanity() and print q{a #*@%-ing word}; } # IN-LINE MATCHING... if ( $RE{num}{int}->matches($text) ) {...} # ...AND SUBSTITUTION my $cropped = $RE{ws}{crop}->subs($uncropped); # ROLL-YOUR-OWN PATTERNS use Regexp::Common 'pattern'; pattern name => ['name', 'mine'], create => '(?i:J[.]?\s+A[.]?\s+Perl-Hacker)', ; my $name_matcher = $RE{name}{mine}; pattern name => [ 'lineof', '-char=_' ], create => sub { my $flags = shift; my $char = quotemeta $flags->{-char}; return '(?:^$char+$)'; }, match => sub { my ($self, $str) = @_; return $str !~ /[^$self->{flags}{-char}]/; }, subs => sub { my ($self, $str, $replacement) = @_; $_[1] =~ s/^$self->{flags}{-char}+$//g; }, ; my $asterisks = $RE{lineof}{-char=>'*'}; # DECIDING WHICH PATTERNS TO LOAD. use Regexp::Common qw /comment number/; # Comment and number patterns. use Regexp::Common qw /no_defaults/; # Don't load any patterns. use Regexp::Common qw /!delimited/; # All, but delimited patterns. =head1 DESCRIPTION By default, this module exports a single hash (C<%RE>) that stores or generates commonly needed regular expressions (see L<"List of available patterns">). There is an alternative, subroutine-based syntax described in L<"Subroutine-based interface">. =head2 General syntax for requesting patterns To access a particular pattern, C<%RE> is treated as a hierarchical hash of hashes (of hashes...), with each successive key being an identifier. For example, to access the pattern that matches real numbers, you specify: $RE{num}{real} and to access the pattern that matches integers: $RE{num}{int} Deeper layers of the hash are used to specify I: arguments that modify the resulting pattern in some way. The keys used to access these layers are prefixed with a minus sign and may have a value; if a value is given, it's done by using a multidimensional key. For example, to access the pattern that matches base-2 real numbers with embedded commas separating groups of three digits (e.g. 10,101,110.110101101): $RE{num}{real}{-base => 2}{-sep => ','}{-group => 3} Through the magic of Perl, these flag layers may be specified in any order (and even interspersed through the identifier keys!) so you could get the same pattern with: $RE{num}{real}{-sep => ','}{-group => 3}{-base => 2} or: $RE{num}{-base => 2}{real}{-group => 3}{-sep => ','} or even: $RE{-base => 2}{-group => 3}{-sep => ','}{num}{real} etc. Note, however, that the relative order of amongst the identifier keys I significant. That is: $RE{list}{set} would not be the same as: $RE{set}{list} =head2 Flag syntax In versions prior to 2.113, flags could also be written as C<{"-flag=value"}>. This no longer works, although C<{"-flag$;value"}> still does. However, C<< {-flag => 'value'} >> is the preferred syntax. =head2 Universal flags Normally, flags are specific to a single pattern. However, there is two flags that all patterns may specify. =over 4 =item C<-keep> By default, the patterns provided by C<%RE> contain no capturing parentheses. However, if the C<-keep> flag is specified (it requires no value) then any significant substrings that the pattern matches are captured. For example: if ($str =~ $RE{num}{real}{-keep}) { $number = $1; $whole = $3; $decimals = $5; } Special care is needed if a "kept" pattern is interpolated into a larger regular expression, as the presence of other capturing parentheses is likely to change the "number variables" into which significant substrings are saved. See also L<"Adding new regular expressions">, which describes how to create new patterns with "optional" capturing brackets that respond to C<-keep>. =item C<-i> Some patterns or subpatterns only match lowercase or uppercase letters. If one wants the do case insensitive matching, one option is to use the C regexp modifier, or the special sequence C<(?i)>. But if the functional interface is used, one does not have this option. The C<-i> switch solves this problem; by using it, the pattern will do case insensitive matching. =back =head2 OO interface and inline matching/substitution The patterns returned from C<%RE> are objects, so rather than writing: if ($str =~ /$RE{some}{pattern}/ ) {...} you can write: if ( $RE{some}{pattern}->matches($str) ) {...} For matching this would seem to have no great advantage apart from readability (but see below). For substitutions, it has other significant benefits. Frequently you want to perform a substitution on a string without changing the original. Most people use this: $changed = $original; $changed =~ s/$RE{some}{pattern}/$replacement/; The more adept use: ($changed = $original) =~ s/$RE{some}{pattern}/$replacement/; Regexp::Common allows you do write this: $changed = $RE{some}{pattern}->subs($original=>$replacement); Apart from reducing precedence-angst, this approach has the added advantages that the substitution behaviour can be optimized from the regular expression, and the replacement string can be provided by default (see L<"Adding new regular expressions">). For example, in the implementation of this substitution: $cropped = $RE{ws}{crop}->subs($uncropped); the default empty string is provided automatically, and the substitution is optimized to use: $uncropped =~ s/^\s+//; $uncropped =~ s/\s+$//; rather than: $uncropped =~ s/^\s+|\s+$//g; =head2 Subroutine-based interface The hash-based interface was chosen because it allows regexes to be effortlessly interpolated, and because it also allows them to be "curried". For example: my $num = $RE{num}{int}; my $commad = $num->{-sep=>','}{-group=>3}; my $duodecimal = $num->{-base=>12}; However, the use of tied hashes does make the access to Regexp::Common patterns slower than it might otherwise be. In contexts where impatience overrules laziness, Regexp::Common provides an additional subroutine-based interface. For each (sub-)entry in the C<%RE> hash (C<$RE{key1}{key2}{etc}>), there is a corresponding exportable subroutine: C. The name of each subroutine is the underscore-separated concatenation of the I keys that locate the same pattern in C<%RE>. Flags are passed to the subroutine in its argument list. Thus: use Regexp::Common qw( RE_ws_crop RE_num_real RE_profanity ); $str =~ RE_ws_crop() and die "Surrounded by whitespace"; $str =~ RE_num_real(-base=>8, -sep=>" ") or next; $offensive = RE_profanity(-keep); $str =~ s/$offensive/$bad{$1}++; ""/ge; Note that, unlike the hash-based interface (which returns objects), these subroutines return ordinary C'd regular expressions. Hence they do not curry, nor do they provide the OO match and substitution inlining described in the previous section. It is also possible to export subroutines for all available patterns like so: use Regexp::Common 'RE_ALL'; Or you can export all subroutines with a common prefix of keys like so: use Regexp::Common 'RE_num_ALL'; which will export C and C (and if you have create more patterns who have first key I, those will be exported as well). In general, I will export all subroutines whose pattern names have first keys I ... I. =head2 Adding new regular expressions You can add your own regular expressions to the C<%RE> hash at run-time, using the exportable C subroutine. It expects a hash-like list of key/value pairs that specify the behaviour of the pattern. The various possible argument pairs are: =over 4 =item C [ @list ]> A required argument that specifies the name of the pattern, and any flags it may take, via a reference to a list of strings. For example: pattern name => [qw( line of -char )], # other args here ; This specifies an entry C<$RE{line}{of}>, which may take a C<-char> flag. Flags may also be specified with a default value, which is then used whenever the flag is specified without an explicit value (but not when the flag is omitted). For example: pattern name => [qw( line of -char=_ )], # default char is '_' # other args here ; =item C $sub_ref_or_string> A required argument that specifies either a string that is to be returned as the pattern: pattern name => [qw( line of underscores )], create => q/(?:^_+$)/ ; or a reference to a subroutine that will be called to create the pattern: pattern name => [qw( line of -char=_ )], create => sub { my ($self, $flags) = @_; my $char = quotemeta $flags->{-char}; return '(?:^$char+$)'; }, ; If the subroutine version is used, the subroutine will be called with three arguments: a reference to the pattern object itself, a reference to a hash containing the flags and their values, and a reference to an array containing the non-flag keys. Whatever the subroutine returns is stringified as the pattern. No matter how the pattern is created, it is immediately postprocessed to include or exclude capturing parentheses (according to the value of the C<-keep> flag). To specify such "optional" capturing parentheses within the regular expression associated with C, use the notation C<(?k:...)>. Any parentheses of this type will be converted to C<(...)> when the C<-keep> flag is specified, or C<(?:...)> when it is not. It is a Regexp::Common convention that the outermost capturing parentheses always capture the entire pattern, but this is not enforced. =item C $sub_ref> An optional argument that specifies a subroutine that is to be called when the C<$RE{...}-Ematches(...)> method of this pattern is invoked. The subroutine should expect two arguments: a reference to the pattern object itself, and the string to be matched against. It should return the same types of values as a C does. pattern name => [qw( line of -char )], create => sub {...}, match => sub { my ($self, $str) = @_; $str !~ /[^$self->{flags}{-char}]/; }, ; =item C $sub_ref> An optional argument that specifies a subroutine that is to be called when the C<$RE{...}-Esubs(...)> method of this pattern is invoked. The subroutine should expect three arguments: a reference to the pattern object itself, the string to be changed, and the value to be substituted into it. The third argument may be C, indicating the default substitution is required. The subroutine should return the same types of values as an C does. For example: pattern name => [ 'lineof', '-char=_' ], create => sub {...}, subs => sub { my ($self, $str, $ignore_replacement) = @_; $_[1] =~ s/^$self->{flags}{-char}+$//g; }, ; Note that such a subroutine will almost always need to modify C<$_[1]> directly. =item C $minimum_perl_version> If this argument is given, it specifies the minimum version of perl required to use the new pattern. Attempts to use the pattern with earlier versions of perl will generate a fatal diagnostic. =back =head2 Loading specific sets of patterns. By default, all the sets of patterns listed below are made available. However, it is possible to indicate which sets of patterns should be made available - the wanted sets should be given as arguments to C. Alternatively, it is also possible to indicate which sets of patterns should not be made available - those sets will be given as argument to the C statement, but are preceded with an exclaimation mark. The argument I indicates none of the default patterns should be made available. This is useful for instance if all you want is the C subroutine. Examples: use Regexp::Common qw /comment number/; # Comment and number patterns. use Regexp::Common qw /no_defaults/; # Don't load any patterns. use Regexp::Common qw /!delimited/; # All, but delimited patterns. It's also possible to load your own set of patterns. If you have a module C that makes patterns available, you can have it made available with use Regexp::Common qw /my_patterns/; Note that the default patterns will still be made available - only if you use I, or mention one of the default sets explicitly, the non mentioned defaults aren't made available. =head2 List of available patterns The patterns listed below are currently available. Each set of patterns has its own manual page describing the details. For each pattern set named I, the manual page I describes the details. Currently available are: =over 4 =item Regexp::Common::balanced Provides regexes for strings with balanced parenthesized delimiters. =item Regexp::Common::comment Provides regexes for comments of various languages (43 languages currently). =item Regexp::Common::delimited Provides regexes for delimited strings. =item Regexp::Common::lingua Provides regexes for palindromes. =item Regexp::Common::list Provides regexes for lists. =item Regexp::Common::net Provides regexes for IPv4, IPv6, and MAC addresses. =item Regexp::Common::number Provides regexes for numbers (integers and reals). =item Regexp::Common::profanity Provides regexes for profanity. =item Regexp::Common::whitespace Provides regexes for leading and trailing whitespace. =item Regexp::Common::zip Provides regexes for zip codes. =back =head2 Forthcoming patterns and features Future releases of the module will also provide patterns for the following: * email addresses * HTML/XML tags * more numerical matchers, * mail headers (including multiline ones), * more URLS * telephone numbers of various countries * currency (universal 3 letter format, Latin-1, currency names) * dates * binary formats (e.g. UUencoded, MIMEd) If you have other patterns or pattern generators that you think would be generally useful, please send them to the maintainer -- preferably as source code using the C subroutine. Submissions that include a set of tests will be especially welcome. =head1 DIAGNOSTICS =over 4 =item C The subroutine-based interface didn't recognize the requested subroutine. Often caused by a spelling mistake or an incompletely specified name. =item C Regexp::Common doesn't have a generator for the requested pattern. Often indicates a misspelt or missing parameter. =item C The requested pattern requires advanced regex features (e.g. recursion) that not available in your version of Perl. Time to upgrade. =item C<< pattern() requires argument: name => [ @list ] >> Every user-defined pattern specification must have a name. =item C<< pattern() requires argument: create => $sub_ref_or_string >> Every user-defined pattern specification must provide a pattern creation mechanism: either a pattern string or a reference to a subroutine that returns the pattern string. =item C The C<< $RE{num}{real}{-base=>'I'} >> pattern uses the characters [0-9A-Z] to represent the digits of various bases. Hence it only produces regular expressions for bases up to hexatricensimal. =item C The pattern has no default delimiter. You need to write: C<< $RE{delimited}{-delim=>I'} >> for some character I =back =head1 ACKNOWLEDGEMENTS Deepest thanks to the many people who have encouraged and contributed to this project, especially: Elijah, Jarkko, Tom, Nat, Ed, and Vivek. Further thanks go to: Alexandr Ciornii, Blair Zajac, Bob Stockdale, Charles Thomas, Chris Vertonghen, the CPAN Testers, David Hand, Fany, Geoffrey Leach, Hermann-Marcus Behrens, Jerome Quelin, Jim Cromie, Lars Wilke, Linda Julien, Mike Arms, Mike Castle, Mikko, Murat Uenalan, RafaE<235>l Garcia-Suarez, Ron Savage, Sam Vilain, Slaven Rezic, Smylers, Tim Maher, and all the others I've forgotten. =head1 AUTHOR Damian Conway (damian@conway.org) =head1 MAINTENANCE This package is maintained by Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Bound to be plenty. For a start, there are many common regexes missing. Send them in to I. There are some POD issues when installing this module using a pre-5.6.0 perl; some manual pages may not install, or may not install correctly using a perl that is that old. You might consider upgrading your perl. =head1 NOT A BUG =over 4 =item * The various patterns are not anchored. That is, a pattern like C<< $RE {num} {int} >> will match against "abc4def", because a substring of the subject matches. This is by design, and not a bug. If you want the pattern to be anchored, use something like: my $integer = $RE {num} {int}; $subj =~ /^$integer$/ and print "Matches!\n"; =back =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. Regexp-Common-2017060201/lib/Regexp/Common/_support.pm000644 000765 000024 00000004030 13114356476 023001 0ustar00abigailstaff000000 000000 package Regexp::Common::_support; use 5.10.0; use strict; use warnings; no warnings 'syntax'; our $VERSION = '2017060201'; # # Returns true/false, depending whether the given the argument # satisfies the LUHN checksum. # See http://www.webopedia.com/TERM/L/Luhn_formula.html. # # Note that this function is intended to be called from regular # expression, so it should NOT use a regular expression in any way. # sub luhn { my $arg = shift; my $even = 0; my $sum = 0; while (length $arg) { my $num = chop $arg; return if $num lt '0' || $num gt '9'; if ($even && (($num *= 2) > 9)) {$num = 1 + ($num % 10)} $even = 1 - $even; $sum += $num; } !($sum % 10) } sub import { my $pack = shift; my $caller = caller; no strict 'refs'; *{$caller . "::" . $_} = \&{$pack . "::" . $_} for @_; } 1; __END__ =pod =head1 NAME Regexp::Common::support -- Support functions for Regexp::Common. =head1 SYNOPSIS use Regexp::Common::_support qw /luhn/; luhn ($number) # Returns true/false. =head1 DESCRIPTION This module contains some subroutines to be used by other C modules. It's not intended to be used directly. Subroutines from the module may disappear without any notice, or their meaning or interface may change without notice. =over 4 =item luhn This subroutine returns true if its argument passes the luhn checksum test. =back =head1 SEE ALSO L. =head1 AUTHOR Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Bound to be plenty. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/balanced.pm000644 000765 000024 00000012275 13114356476 022671 0ustar00abigailstaff000000 000000 package Regexp::Common::balanced; { use 5.10.0; use strict; use warnings; no warnings 'syntax'; use Regexp::Common qw /pattern clean no_defaults/; our $VERSION = '2017060201'; my %closer = ( '{'=>'}', '('=>')', '['=>']', '<'=>'>' ); my %cache; sub nested { my ($start, $finish) = @_; return $cache {$start} {$finish} if exists $cache {$start} {$finish}; my @starts = map {s/\\(.)/$1/g; $_} grep {length} $start =~ /([^|\\]+|\\.)+/gs; my @finishes = map {s/\\(.)/$1/g; $_} grep {length} $finish =~ /([^|\\]+|\\.)+/gs; push @finishes => ($finishes [-1]) x (@starts - @finishes); my @re; local $" = "|"; foreach my $begin (@starts) { my $end = shift @finishes; my $qb = quotemeta $begin; my $qe = quotemeta $end; my $fb = quotemeta substr $begin => 0, 1; my $fe = quotemeta substr $end => 0, 1; my $tb = quotemeta substr $begin => 1; my $te = quotemeta substr $end => 1; my $add; if ($fb eq $fe) { push @re => qq /(?:$qb(?:(?>[^$fb]+)|$fb(?!$tb)(?!$te)|(?-1))*$qe)/; } else { my @clauses = "(?>[^$fb$fe]+)"; push @clauses => "$fb(?!$tb)" if length $tb; push @clauses => "$fe(?!$te)" if length $te; push @clauses => "(?-1)"; push @re => qq /(?:$qb(?:@clauses)*$qe)/; } } $cache {$start} {$finish} = qr /(@re)/; } pattern name => [qw /balanced -parens=() -begin= -end=/], create => sub { my $flag = $_[1]; unless (defined $flag -> {-begin} && length $flag -> {-begin} && defined $flag -> {-end} && length $flag -> {-end}) { my @open = grep {index ($flag->{-parens}, $_) >= 0} ('[','(','{','<'); my @close = map {$closer {$_}} @open; $flag -> {-begin} = join "|" => @open; $flag -> {-end} = join "|" => @close; } return nested @$flag {qw /-begin -end/}; }, ; } 1; __END__ =pod =head1 NAME Regexp::Common::balanced -- provide regexes for strings with balanced parenthesized delimiters or arbitrary delimiters. =head1 SYNOPSIS use Regexp::Common qw /balanced/; while (<>) { /$RE{balanced}{-parens=>'()'}/ and print q{balanced parentheses\n}; } =head1 DESCRIPTION Please consult the manual of L for a general description of the works of this interface. Do not use this module directly, but load it via I. =head2 C<$RE{balanced}{-parens}> Returns a pattern that matches a string that starts with the nominated opening parenthesis or bracket, contains characters and properly nested parenthesized subsequences, and ends in the matching parenthesis. More than one type of parenthesis can be specified: $RE{balanced}{-parens=>'(){}'} in which case all specified parenthesis types must be correctly balanced within the string. Since version 2013030901, C<< $1 >> will always be set (to the entire matched substring), regardless whether C<< {-keep} >> is used or not. =head2 C<< $RE{balanced}{-begin => "begin"}{-end => "end"} >> Returns a pattern that matches a string that is properly balanced using the I and I strings as start and end delimiters. Multiple sets of begin and end strings can be given by separating them by C<|>s (which can be escaped with a backslash). qr/$RE{balanced}{-begin => "do|if|case"}{-end => "done|fi|esac"}/ will match properly balanced strings that either start with I and end with I, start with I and end with I, or start with I and end with I. If I<-end> contains less cases than I<-begin>, the last case of I<-end> is repeated. If it contains more cases than I<-begin>, the extra cases are ignored. If either of I<-begin> or I<-end> isn't given, or is empty, I<< -begin => '(' >> and I<< -end => ')' >> are assumed. Since version 2013030901, C<< $1 >> will always be set (to the entire matched substring), regardless whether C<< {-keep} >> is used or not. =head2 Note Since version 2013030901 the pattern will make of the recursive construct C<< (?-1) >>, instead of using the problematic C<< (??{ }) >> construct. This fixes an problem that was introduced in the 5.17 development track. =head1 SEE ALSO L for a general description of how to use this interface. =head1 AUTHOR Damian Conway (damian@conway.org) =head1 MAINTENANCE This package is maintained by Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Bound to be plenty. For a start, there are many common regexes missing. Send them in to I. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/CC.pm000644 000765 000024 00000006027 13114356476 021423 0ustar00abigailstaff000000 000000 package Regexp::Common::CC; use 5.10.0; use strict; use warnings; no warnings 'syntax'; use Regexp::Common qw /pattern clean no_defaults/; use Regexp::Common::_support qw /luhn/; our $VERSION = '2017060201'; my @cards = ( # Name Prefix Length mod 10 [Mastercard => '5[1-5]', 16, 1], [Visa => '4', [13, 16], 1], [Amex => '3[47]', 15, 1], # Carte Blanche ['Diners Club' => '3(?:0[0-5]|[68])', 14, 1], [Discover => '6011', 16, 1], [enRoute => '2(?:014|149)', 15, 0], [JCB => [['3', 16, 1], ['2131|1800', 15, 1]]], ); foreach my $card (@cards) { my ($name, $prefix, $length, $mod) = @$card; # Skip the harder ones for now. next if ref $prefix || ref $length; next unless $mod; my $times = $length + $mod; pattern name => [CC => $name], create => sub { use re 'eval'; qr <((?=($prefix))[0-9]{$length}) (?(?{Regexp::Common::_support::luhn $1})|(?!))>x } ; } 1; __END__ =pod =head1 NAME Regexp::Common::CC -- provide patterns for credit card numbers. =head1 SYNOPSIS use Regexp::Common qw /CC/; while (<>) { /^$RE{CC}{Mastercard}$/ and print "Mastercard card number\n"; } =head1 DESCRIPTION Please consult the manual of L for a general description of the works of this interface. Do not use this module directly, but load it via I. This module offers patterns for credit card numbers of several major credit card types. Currently, the supported cards are: I, I, I, and I. =head1 SEE ALSO L for a general description of how to use this interface. =over 4 =item L Credit Card Validation - Check Digits =item L Everything you ever wanted to know about CC's =item L Luhn formula =back =head1 AUTHORS Damian Conway S<(I)> and Abigail S<(I)>. =head1 MAINTENANCE This package is maintained by Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Bound to be plenty. Send them in to S>. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/comment.pm000644 000765 000024 00000075170 13114356476 022605 0ustar00abigailstaff000000 000000 package Regexp::Common::comment; use 5.10.0; use strict; use warnings; no warnings 'syntax'; use Regexp::Common qw /pattern clean no_defaults/; our $VERSION = '2017060201'; my @generic = ( {languages => [qw /ABC Forth/], to_eol => ['\\\\']}, # This is for just a *single* backslash. {languages => [qw /Ada Alan Eiffel lua/], to_eol => ['--']}, {languages => [qw /Advisor/], to_eol => ['#|//']}, {languages => [qw /Advsys CQL Lisp LOGO M MUMPS REBOL Scheme SMITH zonefile/], to_eol => [';']}, {languages => ['Algol 60'], from_to => [[qw /comment ;/]]}, {languages => [qw {ALPACA B C C-- LPC PL/I}], from_to => [[qw {/* */}]]}, {languages => [qw /awk fvwm2 Icon m4 mutt Perl Python QML R Ruby shell Tcl/], to_eol => ['#']}, {languages => [[BASIC => 'mvEnterprise']], to_eol => ['[*!]|REM']}, {languages => [qw /Befunge-98 Funge-98 Shelta/], id => [';']}, {languages => ['beta-Juliet', 'Crystal Report', 'Portia', 'Ubercode'], to_eol => ['//']}, {languages => ['BML'], from_to => [['']], }, {languages => [qw /C++/, 'C#', qw /Cg ECMAScript FPL Java JavaScript/], to_eol => ['//'], from_to => [[qw {/* */}]]}, {languages => [qw /CLU LaTeX slrn TeX/], to_eol => ['%']}, {languages => [qw /False/], from_to => [[qw !{ }!]]}, {languages => [qw /Fortran/], to_eol => ['!']}, {languages => [qw /Haifu/], id => [',']}, {languages => [qw /ILLGOL/], to_eol => ['NB']}, {languages => [qw /INTERCAL/], to_eol => [q{(?:(?:PLEASE(?:\s+DO)?|DO)\s+)?(?:NOT|N'T)}]}, {languages => [qw /J/], to_eol => ['NB[.]']}, {languages => [qw /JavaDoc/], from_to => [[qw {/** */}]]}, {languages => [qw /Nickle/], to_eol => ['#'], from_to => [[qw {/* */}]]}, {languages => [qw /Oberon/], from_to => [[qw /(* *)/]]}, {languages => [[qw /Pascal Delphi/], [qw /Pascal Free/], [qw /Pascal GPC/]], to_eol => ['//'], from_to => [[qw !{ }!], [qw !(* *)!]]}, {languages => [[qw /Pascal Workshop/]], id => [qw /"/], from_to => [[qw !{ }!], [qw !(* *)!], [qw !/* */!]]}, {languages => [qw /PEARL/], to_eol => ['!'], from_to => [[qw {/* */}]]}, {languages => [qw /PHP/], to_eol => ['#', '//'], from_to => [[qw {/* */}]]}, {languages => [qw !PL/B!], to_eol => ['[.;]']}, {languages => [qw !PL/SQL!], to_eol => ['--'], from_to => [[qw {/* */}]]}, {languages => [qw /Q-BAL/], to_eol => ['`']}, {languages => [qw /Smalltalk/], id => ['"']}, {languages => [qw /SQL/], to_eol => ['-{2,}']}, {languages => [qw /troff/], to_eol => ['\\\"']}, {languages => [qw /vi/], to_eol => ['"']}, {languages => [qw /*W/], from_to => [[qw {|| !!}]]}, {languages => [qw /ZZT-OOP/], to_eol => ["'"]}, ); my @plain_or_nested = ( [Caml => undef, "(*" => "*)"], [Dylan => "//", "/*" => "*/"], [Haskell => "-{2,}", "{-" => "-}"], [Hugo => "!(?!\\\\)", "!\\" => "\\!"], [SLIDE => "#", "(*" => "*)"], ['Modula-2' => undef, "(*" => "*)"], ['Modula-3' => undef, "(*" => "*)"], ); # # Helper subs. # sub combine { local $_ = join "|", @_; if (@_ > 1) { s/\(\?k:/(?:/g; $_ = "(?k:$_)"; } $_ } sub to_eol ($) {"(?k:(?k:$_[0])(?k:[^\\n]*)(?k:\\n))"} sub id ($) {"(?k:(?k:$_[0])(?k:[^$_[0]]*)(?k:$_[0]))"} # One char only! sub from_to { my ($begin, $end) = @_; my $qb = quotemeta $begin; my $qe = quotemeta $end; my $fe = quotemeta substr $end => 0, 1; my $te = quotemeta substr $end => 1; "(?k:(?k:$qb)(?k:(?:[^$fe]+|$fe(?!$te))*)(?k:$qe))"; } my $count = 0; sub nested { my ($begin, $end) = @_; $count ++; my $r = '(??{$Regexp::Common::comment ['. $count . ']})'; my $qb = quotemeta $begin; my $qe = quotemeta $end; my $fb = quotemeta substr $begin => 0, 1; my $fe = quotemeta substr $end => 0, 1; my $tb = quotemeta substr $begin => 1; my $te = quotemeta substr $end => 1; use re 'eval'; my $re; if ($fb eq $fe) { $re = qr /(?:$qb(?:(?>[^$fb]+)|$fb(?!$tb)(?!$te)|$r)*$qe)/; } else { local $" = "|"; my @clauses = "(?>[^$fb$fe]+)"; push @clauses => "$fb(?!$tb)" if length $tb; push @clauses => "$fe(?!$te)" if length $te; push @clauses => $r; $re = qr /(?:$qb(?:@clauses)*$qe)/; } $Regexp::Common::comment [$count] = qr/$re/; } # # Process data. # foreach my $info (@plain_or_nested) { my ($language, $mark, $begin, $end) = @$info; pattern name => [comment => $language], create => sub {my $re = nested $begin => $end; my $prefix = defined $mark ? $mark . "[^\n]*\n|" : ""; exists $_ [1] -> {-keep} ? qr /($prefix$re)/ : qr /$prefix$re/ }, ; } foreach my $group (@generic) { my $pattern = combine +(map {to_eol $_} @{$group -> {to_eol}}), (map {from_to @$_} @{$group -> {from_to}}), (map {id $_} @{$group -> {id}}), ; foreach my $language (@{$group -> {languages}}) { pattern name => [comment => ref $language ? @$language : $language], create => $pattern, ; } } # # Other languages. # # http://www.pascal-central.com/docs/iso10206.txt pattern name => [qw /comment Pascal/], create => '(?k:' . '(?k:[{]|[(][*])' . '(?k:[^}*]*(?:[*](?![)])[^}*]*)*)' . '(?k:[}]|[*][)])' . ')' ; # http://www.templetons.com/brad/alice/language/ pattern name => [qw /comment Pascal Alice/], create => '(?k:(?k:[{])(?k:[^}\n]*)(?k:[}]))' ; # http://westein.arb-phys.uni-dortmund.de/~wb/a68s.txt pattern name => [qw (comment), 'Algol 68'], create => q {(?k:(?:#[^#]*#)|} . q {(?:\bco\b(?:[^c]+|\Bc|\bc(?!o\b))*\bco\b)|} . q {(?:\bcomment\b(?:[^c]+|\Bc|\bc(?!omment\b))*\bcomment\b))} ; # See rules 91 and 92 of ISO 8879 (SGML). # Charles F. Goldfarb: "The SGML Handbook". # Oxford: Oxford University Press. 1990. ISBN 0-19-853737-9. # Ch. 10.3, pp 390. pattern name => [qw (comment HTML)], create => q {(?k:(?k:))}, ; pattern name => [qw /comment SQL MySQL/], create => q {(?k:(?:#|-- )[^\n]*\n|} . q {/\*(?:(?>[^*;"']+)|"[^"]*"|'[^']*'|\*(?!/))*(?:;|\*/))}, ; # Anything that isn't <>[]+-., # http://home.wxs.nl/~faase009/Ha_BF.html pattern name => [qw /comment Brainfuck/], create => '(?k:[^<>\[\]+\-.,]+)' ; # Squeak is a variant of Smalltalk-80. # http://www.squeak. # http://mucow.com/squeak-qref.html pattern name => [qw /comment Squeak/], create => '(?k:(?k:")(?k:[^"]*(?:""[^"]*)*)(?k:"))' ; # # Scores of less than 5 or above 17.... # http://www.cliff.biffle.org/esoterica/beatnik.html @Regexp::Common::comment::scores = (1, 3, 3, 2, 1, 4, 2, 4, 1, 8, 5, 1, 3, 1, 1, 3, 10, 1, 1, 1, 1, 4, 4, 8, 4, 10); { my ($s, $x); pattern name => [qw /comment Beatnik/], create => sub { use re 'eval'; my $re = qr {\b([A-Za-z]+)\b (?(?{($s, $x) = (0, lc $^N); $s += $Regexp::Common::comment::scores [ord (chop $x) - ord ('a')] while length $x; $s >= 5 && $s < 18})XXX|)}x; $re; }, ; } # http://www.cray.com/craydoc/manuals/007-3692-005/html-007-3692-005/ # (Goto table of contents/3.3 Source Form) # Fortran, in fixed format. Comments start with a C, c or * in the first # column, or a ! anywhere, but the sixth column. Then end with a newline. pattern name => [qw /comment Fortran fixed/], create => '(?k:(?k:(?:^[Cc*]|(? [qw /comment COBOL/], create => '(?<=^......)(?k:(?k:[*])(?k:[^\n]*)(?k:\n))', ; 1; __END__ =pod =head1 NAME Regexp::Common::comment -- provide regexes for comments. =head1 SYNOPSIS use Regexp::Common qw /comment/; while (<>) { /$RE{comment}{C}/ and print "Contains a C comment\n"; /$RE{comment}{C++}/ and print "Contains a C++ comment\n"; /$RE{comment}{PHP}/ and print "Contains a PHP comment\n"; /$RE{comment}{Java}/ and print "Contains a Java comment\n"; /$RE{comment}{Perl}/ and print "Contains a Perl comment\n"; /$RE{comment}{awk}/ and print "Contains an awk comment\n"; /$RE{comment}{HTML}/ and print "Contains an HTML comment\n"; } use Regexp::Common qw /comment RE_comment_HTML/; while (<>) { $_ =~ RE_comment_HTML() and print "Contains an HTML comment\n"; } =head1 DESCRIPTION Please consult the manual of L for a general description of the works of this interface. Do not use this module directly, but load it via I. This modules gives you regular expressions for comments in various languages. =head2 THE LANGUAGES Below, the comments of each of the languages are described. The patterns are available as C<$RE{comment}{I}>, foreach language I. Some languages have variants; it's described at the individual languages how to get the patterns for the variants. Unless mentioned otherwise, C<{-keep}> sets C<$1>, C<$2>, C<$3> and C<$4> to the entire comment, the opening marker, the content of the comment, and the closing marker (for many languages, the latter is a newline) respectively. =over 4 =item ABC Comments in I start with a backslash (C<\>), and last till the end of the line. See L. =item Ada Comments in I start with C<-->, and last till the end of the line. =item Advisor I is a language used by the HP product I. Comments for this language start with either C<#> or C, and last till the end of the line. =item Advsys Comments for the I language start with C<;> and last till the end of the line. See also L. =item Alan I comments start with C<-->, and last till the end of the line. See also L. =item Algol 60 Comments in the I language start with the keyword C, and end with a C<;>. See L. =item Algol 68 In I, comments are either delimited by C<#>, or by one of the keywords C or C. The keywords should not be part of another word. See L. With C<{-keep}>, only C<$1> will be set, returning the entire comment. =item ALPACA The I language has comments starting with C and ending with C<*/>. =item awk The I programming language uses comments that start with C<#> and end at the end of the line. =item B The I language has comments starting with C and ending with C<*/>. =item BASIC There are various forms of BASIC around. Currently, we only support the variant supported by I, whose pattern is available as C<$RE{comment}{BASIC}{mvEnterprise}>. Comments in this language start with a C, a C<*> or the keyword C, and end till the end of the line. See L. =item Beatnik The esotoric language I only uses words consisting of letters. Words are scored according to the rules of Scrabble. Words scoring less than 5 points, or 18 points or more are considered comments (although the compiler might mock at you if you score less than 5 points). Regardless whether C<{-keep}>, C<$1> will be set, and set to the entire comment. This pattern requires I or newer. =item beta-Juliet The I programming language has comments that start with C and that continue till the end of the line. See also L. =item Befunge-98 The esotoric language I uses comments that start and end with a C<;>. See L. =item BML I, or I is an HTML templating language that uses comments starting with C<< >, and ending with C<< c_?> >>. See L. =item Brainfuck The minimal language I uses only eight characters, C>, C>, C<[>, C<]>, C<+>, C<->, C<.> and C<,>. Any other characters are considered comments. With C<{-keep}>, C<$1> is set to the entire comment. =item C The I language has comments starting with C and ending with C<*/>. =item C-- The I language has comments starting with C and ending with C<*/>. See L. =item C++ The I language has two forms of comments. Comments that start with C and last till the end of the line, and comments that start with C, and end with C<*/>. If C<{-keep}> is used, only C<$1> will be set, and set to the entire comment. =item C# The I language has two forms of comments. Comments that start with C and last till the end of the line, and comments that start with C, and end with C<*/>. If C<{-keep}> is used, only C<$1> will be set, and set to the entire comment. See L. =item Caml Comments in I start with C<(*>, end with C<*)>, and can be nested. See L and L. =item Cg The I language has two forms of comments. Comments that start with C and last till the end of the line, and comments that start with C, and end with C<*/>. If C<{-keep}> is used, only C<$1> will be set, and set to the entire comment. See L. =item CLU In C, a comment starts with a procent sign (C<%>), and ends with the next newline. See L and L. =item COBOL Traditionally, comments in I are indicated by an asteriks in the seventh column. This is what the pattern matches. Modern compiler may more lenient though. See L, and L. =item CQL Comments in the chess query language (I) start with a semi colon (C<;>) and last till the end of the line. See L. =item Crystal Report The formula editor in I uses comments that start with C, and end with the end of the line. =item Dylan There are two types of comments in I. They either start with C, or are nested comments, delimited with C and C<*/>. Under C<{-keep}>, only C<$1> will be set, returning the entire comment. This pattern requires I or newer. =item ECMAScript The I language has two forms of comments. Comments that start with C and last till the end of the line, and comments that start with C, and end with C<*/>. If C<{-keep}> is used, only C<$1> will be set, and set to the entire comment. I is Netscapes implementation of I. See L, and L. =item Eiffel I comments start with C<-->, and last till the end of the line. =item False In I, comments start with C<{> and end with C<}>. See L =item FPL The I language has two forms of comments. Comments that start with C and last till the end of the line, and comments that start with C, and end with C<*/>. If C<{-keep}> is used, only C<$1> will be set, and set to the entire comment. =item Forth Comments in Forth start with C<\>, and end with the end of the line. See also L. =item Fortran There are two forms of I. There's free form I, which has comments that start with C, and end at the end of the line. The pattern for this is given by C<$RE{Fortran}>. Fixed form I, which has been obsoleted, has comments that start with C, C or C<*> in the first column, or with C anywhere, but the sixth column. The pattern for this are given by C<$RE{Fortran}{fixed}>. See also L. =item Funge-98 The esotoric language I uses comments that start and end with a C<;>. =item fvwm2 Configuration files for I have comments starting with a C<#> and lasting the rest of the line. =item Haifu I, an esotoric language using haikus, has comments starting and ending with a C<,>. See L. =item Haskell There are two types of comments in I. They either start with at least two dashes, or are nested comments, delimited with C<{-> and C<-}>. Under C<{-keep}>, only C<$1> will be set, returning the entire comment. This pattern requires I or newer. =item HTML In I, comments only appear inside a I. A comment declaration starts with a C!>, and ends with a C>. Inside this declaration, we have zero or more comments. Comments starts with C<--> and end with C<-->, and are optionally followed by whitespace. The pattern C<$RE{comment}{HTML}> recognizes those comment declarations (and hence more than a comment). Note that this is not the same as something that starts with C!--> and ends with C<--E>, because the following will be matched completely: Second Comment Do not be fooled by what your favourite browser thinks is an HTML comment. If C<{-keep}> is used, the following are returned: =over 4 =item $1 captures the entire comment declaration. =item $2 captures the MDO (markup declaration open), C!>. =item $3 captures the content between the MDO and the MDC. =item $4 captures the (last) comment, without the surrounding dashes. =item $5 captures the MDC (markup declaration close), C>. =back =item Hugo There are two types of comments in I. They either start with C (which cannot be followed by a C<\>), or are nested comments, delimited with C and C<\!>. Under C<{-keep}>, only C<$1> will be set, returning the entire comment. This pattern requires I or newer. =item Icon I has comments that start with C<#> and end at the next new line. See L, L, and L. =item ILLGOL The esotoric language I uses comments starting with I and lasting till the end of the line. See L. =item INTERCAL Comments in INTERCAL are single line comments. They start with one of the keywords C or C, and can optionally be preceded by the keywords C and C. If both keywords are used, C precedes C. Keywords are separated by whitespace. =item J The language I uses comments that start with C, and that last till the end of the line. See L, and L. =item Java The I language has two forms of comments. Comments that start with C and last till the end of the line, and comments that start with C, and end with C<*/>. If C<{-keep}> is used, only C<$1> will be set, and set to the entire comment. =item JavaDoc The I documentation syntax is demarked with a subset of ordinary Java comments to separate it from code. Comments start with C end with C<*/>. If C<{-keep}> is used, only C<$1> will be set, and set to the entire comment. See L. =item JavaScript The I language has two forms of comments. Comments that start with C and last till the end of the line, and comments that start with C, and end with C<*/>. If C<{-keep}> is used, only C<$1> will be set, and set to the entire comment. I is Netscapes implementation of I. See L, and L. =item LaTeX The documentation language I uses comments starting with C<%> and ending at the end of the line. =item Lisp Comments in I start with a semi-colon (C<;>) and last till the end of the line. =item LPC The I language has comments starting with C and ending with C<*/>. =item LOGO Comments for the language I start with C<;>, and last till the end of the line. =item lua Comments for the I language start with C<-->, and last till the end of the line. See also L. =item M, MUMPS In C (aka C), comments start with a semi-colon, and last till the end of a line. The language specification requires the semi-colon to be preceded by one or more Is. Those characters default to a space, but that's configurable. This requirement, of preceding the comment with linestart characters is B tested for. See L, L, and L. =item m4 By default, the preprocessor language I uses single line comments, that start with a C<#> and continue to the end of the line, including the newline. The pattern C<$RE {comment} {m4}> matches such comments. In I, it is possible to change the starting token though. See L, L, and L. =item Modula-2 In C, comments start with C<(*>, and end with C<*)>. Comments may be nested. See L. =item Modula-3 In C, comments start with C<(*>, and end with C<*)>. Comments may be nested. See L. =item mutt Configuration files for I have comments starting with a C<#> and lasting the rest of the line. =item Nickle The I language has one line comments starting with C<#> (like Perl), or multiline comments delimited by C and C<*/> (like C). Under C<-keep>, only C<$1> will be set. See also L. =item Oberon Comments in I start with C<(*> and end with C<*)>. See L. =item Pascal There are many implementations of Pascal. This modules provides pattern for comments of several implementations. =over 4 =item C<$RE{comment}{Pascal}> This is the pattern that recognizes comments according to the Pascal ISO standard. This standard says that comments start with either C<{>, or C<(*>, and end with C<}> or C<*)>. This means that C<{*)> and C<(*}> are considered to be comments. Many Pascal applications don't allow this. See L =item C<$RE{comment}{Pascal}{Alice}> The I compiler accepts comments that start with C<{> and end with C<}>. Comments are not allowed to contain newlines. See L. =item C<$RE{comment}{Pascal}{Delphi}>, C<$RE{comment}{Pascal}{Free}> and C<$RE{comment}{Pascal}{GPC}> The I, I and the I implementations of Pascal all have comments that either start with C and last till the end of the line, are delimited with C<{> and C<}> or are delimited with C<(*> and C<*)>. Patterns for those comments are given by C<$RE{comment}{Pascal}{Delphi}>, C<$RE{comment}{Pascal}{Free}> and C<$RE{comment}{Pascal}{GPC}> respectively. These patterns only set C<$1> when C<{-keep}> is used, which will then include the entire comment. See L, L and L. =item C<$RE{comment}{Pascal}{Workshop}> The I compiler, from SUN Microsystems, allows comments that are delimited with either C<{> and C<}>, delimited with C<(*)> and C<*>), delimited with C, and C<*/>, or starting and ending with a double quote (C<">). When C<{-keep}> is used, only C<$1> is set, and returns the entire comment. See L. =back =item PEARL Comments in I start with a C and last till the end of the line, or start with C and end with C<*/>. With C<{-keep}>, C<$1> will be set to the entire comment. =item PHP Comments in I start with either C<#> or C and last till the end of the line, or are delimited by C and C<*/>. With C<{-keep}>, C<$1> will be set to the entire comment. =item PL/B In I, comments start with either C<.> or C<;>, and end with the next newline. See L. =item PL/I The I language has comments starting with C and ending with C<*/>. =item PL/SQL In I, comments either start with C<--> and run till the end of the line, or start with C and end with C<*/>. =item Perl I uses comments that start with a C<#>, and continue till the end of the line. =item Portia The I programming language has comments that start with C, and last till the end of the line. =item Python I uses comments that start with a C<#>, and continue till the end of the line. =item Q-BAL Comments in the I language start with C<`> (a backtick), and contine till the end of the line. =item QML In C, comments start with C<#> and last till the end of the line. See L. =item R The statistical language I uses comments that start with a C<#> and end with the following new line. See L. =item REBOL Comments for the I language start with C<;> and last till the end of the line. =item Ruby Comments in I start with C<#> and last till the end of the time. =item Scheme I comments start with C<;>, and last till the end of the line. See L. =item shell Comments in various Is start with a C<#> and end at the end of the line. =item Shelta The esotoric language I uses comments that start and end with a C<;>. See L. =item SLIDE The I language has two froms of comments. First there is the line comment, which starts with a C<#> and includes the rest of the line (just like Perl). Second, there is the multiline, nested comment, which are delimited by C<(*> and C<*)>. Under C{-keep}>, only C<$1> is set, and is set to the entire comment. See L. =item slrn Configuration files for I have comments starting with a C<%> and lasting the rest of the line. =item Smalltalk I uses comments that start and end with a double quote, C<">. =item SMITH Comments in the I language start with C<;>, and last till the end of the line. =item Squeak In the Smalltalk variant I, comments start and end with C<">. Double quotes can appear inside comments by doubling them. =item SQL Standard I uses comments starting with two or more dashes, and ending at the end of the line. I does not follow the standard. Instead, it allows comments that start with a C<#> or C<-- > (that's two dashes and a space) ending with the following newline, and comments starting with C, and ending with the next C<;> or C<*/> that isn't inside single or double quotes. A pattern for this is returned by C<$RE{comment}{SQL}{MySQL}>. With C<{-keep}>, only C<$1> will be set, and it returns the entire comment. =item Tcl In I, comments start with C<#> and continue till the end of the line. =item TeX The documentation language I uses comments starting with C<%> and ending at the end of the line. =item troff The document formatting language I uses comments starting with C<\">, and continuing till the end of the line. =item Ubercode The Windows programming language I uses comments that start with C and continue to the end of the line. See L. =item vi In configuration files for the editor I, one can use comments starting with C<">, and ending at the end of the line. =item *W In the language I<*W>, comments start with C<||>, and end with C. =item zonefile Comments in DNS Is start with C<;>, and continue till the end of the line. =item ZZT-OOP The in-game language I uses comments that start with a C<'> character, and end at the following newline. See L. =back =head1 REFERENCES =over 4 =item B<[Go 90]> Charles F. Goldfarb: I. Oxford: Oxford University Press. B<1990>. ISBN 0-19-853737-9. Ch. 10.3, pp 390-391. =back =head1 SEE ALSO L for a general description of how to use this interface. =head1 AUTHOR Damian Conway (damian@conway.org) =head1 MAINTENANCE This package is maintained by Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Bound to be plenty. For a start, there are many common regexes missing. Send them in to I. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/delimited.pm000644 000765 000024 00000027766 13114356476 023113 0ustar00abigailstaff000000 000000 package Regexp::Common::delimited; use 5.10.0; use strict; use warnings; no warnings 'syntax'; use Regexp::Common qw /pattern clean no_defaults/; use charnames ':full'; our $VERSION = '2017060201'; sub gen_delimited { my ($dels, $escs, $cdels) = @_; # return '(?:\S*)' unless $dels =~ /\S/; if (defined $escs && length $escs) { $escs .= substr ($escs, -1) x (length ($dels) - length ($escs)); } if (defined $cdels && length $cdels) { $cdels .= substr ($cdels, -1) x (length ($dels) - length ($cdels)); } else { $cdels = $dels; } my @pat = (); for (my $i = 0; $i < length $dels; $i ++) { my $del = quotemeta substr ($dels, $i, 1); my $cdel = quotemeta substr ($cdels, $i, 1); my $esc = defined $escs && length ($escs) ? quotemeta substr ($escs, $i, 1) : ""; if ($cdel eq $esc) { push @pat => "(?k:$del)(?k:[^$cdel]*(?:(?:$cdel$cdel)[^$cdel]*)*)(?k:$cdel)"; } elsif (length $esc) { push @pat => "(?k:$del)(?k:[^$esc$cdel]*(?:$esc.[^$esc$cdel]*)*)(?k:$cdel)"; } else { push @pat => "(?k:$del)(?k:[^$cdel]*)(?k:$cdel)"; } } my $pat = join '|', @pat; return "(?k:(?|$pat))"; } sub _croak { require Carp; goto &Carp::croak; } pattern name => [qw( delimited -delim= -esc=\\ -cdelim= )], create => sub {my $flags = $_[1]; _croak 'Must specify delimiter in $RE{delimited}' unless length $flags->{-delim}; return gen_delimited (@{$flags}{-delim, -esc, -cdelim}); }, ; pattern name => [qw( quoted -esc=\\ )], create => sub {my $flags = $_[1]; return gen_delimited (q{"'`}, $flags -> {-esc}); }, ; my @bracket_pairs; if ($] >= 5.014) { # # List from http://xahlee.info/comp/unicode_matching_brackets.html # @bracket_pairs = map {ref $_ ? $_ : /!/ ? [(do {my $x = $_; $x =~ s/!/TOP/; $x}, do {my $x = $_; $x =~ s/!/BOTTOM/; $x})] : [(do {my $x = $_; $x =~ s/\?/LEFT/; $x}, do {my $x = $_; $x =~ s/\?/RIGHT/; $x})]} "? PARENTHESIS", "? SQUARE BRACKET", "? CURLY BRACKET", "? DOUBLE QUOTATION MARK", "? SINGLE QUOTATION MARK", "SINGLE ?-POINTING ANGLE QUOTATION MARK", "?-POINTING DOUBLE ANGLE QUOTATION MARK", "FULLWIDTH ? PARENTHESIS", "FULLWIDTH ? SQUARE BRACKET", "FULLWIDTH ? CURLY BRACKET", "FULLWIDTH ? WHITE PARENTHESIS", "? WHITE PARENTHESIS", "? WHITE SQUARE BRACKET", "? WHITE CURLY BRACKET", "? CORNER BRACKET", "? ANGLE BRACKET", "? DOUBLE ANGLE BRACKET", "? BLACK LENTICULAR BRACKET", "? TORTOISE SHELL BRACKET", "? BLACK TORTOISE SHELL BRACKET", "? WHITE CORNER BRACKET", "? WHITE LENTICULAR BRACKET", "? WHITE TORTOISE SHELL BRACKET", "HALFWIDTH ? CORNER BRACKET", "MATHEMATICAL ? WHITE SQUARE BRACKET", "MATHEMATICAL ? ANGLE BRACKET", "MATHEMATICAL ? DOUBLE ANGLE BRACKET", "MATHEMATICAL ? FLATTENED PARENTHESIS", "MATHEMATICAL ? WHITE TORTOISE SHELL BRACKET", "? CEILING", "? FLOOR", "Z NOTATION ? IMAGE BRACKET", "Z NOTATION ? BINDING BRACKET", [ "HEAVY SINGLE TURNED COMMA QUOTATION MARK ORNAMENT", "HEAVY SINGLE " . "COMMA QUOTATION MARK ORNAMENT", ], [ "HEAVY DOUBLE TURNED COMMA QUOTATION MARK ORNAMENT", "HEAVY DOUBLE " . "COMMA QUOTATION MARK ORNAMENT", ], "MEDIUM ? PARENTHESIS ORNAMENT", "MEDIUM FLATTENED ? PARENTHESIS ORNAMENT", "MEDIUM ? CURLY BRACKET ORNAMENT", "MEDIUM ?-POINTING ANGLE BRACKET ORNAMENT", "HEAVY ?-POINTING ANGLE QUOTATION MARK ORNAMENT", "HEAVY ?-POINTING ANGLE BRACKET ORNAMENT", "LIGHT ? TORTOISE SHELL BRACKET ORNAMENT", "ORNATE ? PARENTHESIS", "! PARENTHESIS", "! SQUARE BRACKET", "! CURLY BRACKET", "! TORTOISE SHELL BRACKET", "PRESENTATION FORM FOR VERTICAL ? CORNER BRACKET", "PRESENTATION FORM FOR VERTICAL ? WHITE CORNER BRACKET", "PRESENTATION FORM FOR VERTICAL ? TORTOISE SHELL BRACKET", "PRESENTATION FORM FOR VERTICAL ? BLACK LENTICULAR BRACKET", "PRESENTATION FORM FOR VERTICAL ? WHITE LENTICULAR BRACKET", "PRESENTATION FORM FOR VERTICAL ? ANGLE BRACKET", "PRESENTATION FORM FOR VERTICAL ? DOUBLE ANGLE BRACKET", "PRESENTATION FORM FOR VERTICAL ? SQUARE BRACKET", "PRESENTATION FORM FOR VERTICAL ? CURLY BRACKET", "?-POINTING ANGLE BRACKET", "? ANGLE BRACKET WITH DOT", "?-POINTING CURVED ANGLE BRACKET", "SMALL ? PARENTHESIS", "SMALL ? CURLY BRACKET", "SMALL ? TORTOISE SHELL BRACKET", "SUPERSCRIPT ? PARENTHESIS", "SUBSCRIPT ? PARENTHESIS", "? SQUARE BRACKET WITH UNDERBAR", [ "LEFT SQUARE BRACKET WITH TICK IN TOP CORNER", "RIGHT SQUARE BRACKET WITH TICK IN BOTTOM CORNER", ], [ "LEFT SQUARE BRACKET WITH TICK IN BOTTOM CORNER", "RIGHT SQUARE BRACKET WITH TICK IN TOP CORNER", ], "? SQUARE BRACKET WITH QUILL", "TOP ? HALF BRACKET", "BOTTOM ? HALF BRACKET", "? S-SHAPED BAG DELIMITER", [ "LEFT ARC LESS-THAN BRACKET", "RIGHT ARC GREATER-THAN BRACKET", ], [ "DOUBLE LEFT ARC GREATER-THAN BRACKET", "DOUBLE RIGHT ARC LESS-THAN BRACKET", ], "? SIDEWAYS U BRACKET", "? DOUBLE PARENTHESIS", "? WIGGLY FENCE", "? DOUBLE WIGGLY FENCE", "? LOW PARAPHRASE BRACKET", "? RAISED OMISSION BRACKET", "? SUBSTITUTION BRACKET", "? DOTTED SUBSTITUTION BRACKET", "? TRANSPOSITION BRACKET", [ "OGHAM FEATHER MARK", "OGHAM REVERSED FEATHER MARK", ], [ "TIBETAN MARK GUG RTAGS GYON", "TIBETAN MARK GUG RTAGS GYAS", ], [ "TIBETAN MARK ANG KHANG GYON", "TIBETAN MARK ANG KHANG GYAS", ], ; # # Filter out unknown characters; this may run on an older version # of Perl with an old version of Unicode. # @bracket_pairs = grep {defined charnames::string_vianame ($$_ [0]) && defined charnames::string_vianame ($$_ [1])} @bracket_pairs; if (@bracket_pairs) { my $delims = join "" => map {charnames::string_vianame ($$_ [0])} @bracket_pairs; my $cdelims = join "" => map {charnames::string_vianame ($$_ [1])} @bracket_pairs; pattern name => [qw (bquoted -esc=\\)], create => sub {my $flags = $_ [1]; return gen_delimited ($delims, $flags -> {-esc}, $cdelims); }, version => 5.014, ; } } # # Return the Unicode names of the pairs of matching delimiters. # sub bracket_pairs {@bracket_pairs} 1; __END__ =pod =head1 NAME Regexp::Common::delimited -- provides a regex for delimited strings =head1 SYNOPSIS use Regexp::Common qw /delimited/; while (<>) { /$RE{delimited}{-delim=>'"'}/ and print 'a \" delimited string'; /$RE{delimited}{-delim=>'/'}/ and print 'a \/ delimited string'; } =head1 DESCRIPTION Please consult the manual of L for a general description of the works of this interface. Do not use this module directly, but load it via I. =head2 C<$RE{delimited}{-delim}{-cdelim}{-esc}> Returns a pattern that matches a single-character-delimited substring, with optional internal escaping of the delimiter. When C<-delim => I> is specified, each character in the sequence I is a possible delimiter. There is no default delimiter, so this flag must always be specified. By default, the closing delimiter is the same character as the opening delimiter. If this is not wanted, for instance, if you want to match a string with symmetric delimiters, you can specify the closing delimiter(s) with C<-cdelim => I>. Each character in I is matched with the corresponding character supplied with the C<-delim> option. If the C<-cdelim> option has less characters than the C<-delim> option, the last character is repeated as often as necessary. If the C<-cdelim> option has more characters than the C<-delim> option, the extra characters are ignored. If C<-esc => I> is specified, each character in the sequence I is the delimiter for the corresponding character in the C<-delim=I> list. The default escape is backslash. For example: $RE{delimited}{-delim=>'"'} # match "a \" delimited string" $RE{delimited}{-delim=>'"'}{-esc=>'"'} # match "a "" delimited string" $RE{delimited}{-delim=>'/'} # match /a \/ delimited string/ $RE{delimited}{-delim=>q{'"}} # match "string" or 'string' $RE{delimited}{-delim=>"("}{-cdelim=>")"} # match (string) Under C<-keep> (See L): =over 4 =item $1 captures the entire match =item $2 captures the opening delimiter =item $3 captures delimited portion of the string =item $4 captures the closing delimiter =back =head2 $RE{quoted}{-esc} A synonym for C<< $RE {delimited} {-delim => q {'"`}} {...} >>. =head2 $RE {bquoted} {-esc} This is a pattern which matches delimited strings, where the delimiters are a set of matching brackets. Currently, this comes 85 pairs. This includes the 60 pairs of bidirection paired brackets, as listed in L<< http://www.unicode.org/Public/UNIDATA/BidiBrackets.txt >>. The other 25 pairs are the quotation marks, the double quotation marks, the single and double pointing quoation marks, the heavy single and double commas, 4 pairs of top-bottom parenthesis and brackets, 9 pairs of presentation form for vertical brackets, and the low paraphrase, raised omission, substitution, double substitution, and transposition brackets. In a future update, pairs may be added (or deleted). This pattern requires perl 5.14.0 or higher. For a full list of bracket pairs, inspect the output of C<< Regexp::Common::delimited::bracket_pair () >>, which returns a list of two element arrays, each holding the Unicode names of matching pair of delimiters. The C<< {-esc => I } >> works as in the C<< $RE {delimited} >> pattern. If C<< {-keep} >> is given, the following things will be captured: =over 4 =item $1 captures the entire match =item $2 captures the opening delimiter =item $3 captures delimited portion of the string =item $4 captures the closing delimiter =back =head1 SEE ALSO L for a general description of how to use this interface. =head1 AUTHOR Damian Conway (damian@conway.org) =head1 MAINTENANCE This package is maintained by Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Bound to be plenty. For a start, there are many common regexes missing. Send them in to I. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/lingua.pm000644 000765 000024 00000004615 13114356476 022416 0ustar00abigailstaff000000 000000 package Regexp::Common::lingua; use 5.10.0; use strict; use warnings; no warnings 'syntax'; use Regexp::Common qw /pattern clean no_defaults/; our $VERSION = '2017060201'; pattern name => [qw /lingua palindrome -chars=[A-Za-z]/], create => sub { use re 'eval'; my $keep = exists $_ [1] -> {-keep}; my $ch = $_ [1] -> {-chars}; my $idx = $keep ? "1:$ch" : "0:$ch"; my $r = "(??{\$Regexp::Common::lingua::pd{'" . $idx . "'}})"; $Regexp::Common::lingua::pd {$idx} = $keep ? qr /($ch|($ch)($r)?\2)/ : qr /$ch|($ch)($r)?\1/; # print "[$ch]: ", $Regexp::Common::lingua::pd {$idx}, "\n"; # $Regexp::Common::lingua::pd {$idx}; }, ; 1; __END__ =pod =head1 NAME Regexp::Common::lingua -- provide regexes for language related stuff. =head1 SYNOPSIS use Regexp::Common qw /lingua/; while (<>) { /^$RE{lingua}{palindrome}$/ and print "is a palindrome\n"; } =head1 DESCRIPTION Please consult the manual of L for a general description of the works of this interface. Do not use this module directly, but load it via I. =head2 C<$RE{lingua}{palindrome}> Returns a pattern that recognizes a palindrome, a string that is the same if you reverse it. By default, it only matches strings consisting of letters, but this can be changed using the C<{-chars}> option. This option takes a character class (default is C<[A-Za-z]>) as argument. If C<{-keep}> is used, only C<$1> will be set, and set to the entire match. This pattern requires at least perl 5.6.0. =head1 SEE ALSO L for a general description of how to use this interface. =head1 AUTHOR Damian Conway (damian@conway.org) =head1 MAINTENANCE This package is maintained by Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Many regexes are missing. Send them in to I. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/list.pm000644 000765 000024 00000010235 13114356476 022105 0ustar00abigailstaff000000 000000 package Regexp::Common::list; use 5.10.0; use strict; use warnings; no warnings 'syntax'; use Regexp::Common qw /pattern clean no_defaults/; our $VERSION = '2017060201'; sub gen_list_pattern { my ($pat, $sep, $lsep) = @_; $lsep = $sep unless defined $lsep; return "(?k:(?:(?:$pat)(?:$sep))*(?:$pat)(?k:$lsep)(?:$pat))"; } my $defpat = '.*?\S'; my $defsep = '\s*,\s*'; pattern name => ['list', "-pat=$defpat", "-sep=$defsep", '-lastsep'], create => sub {gen_list_pattern (@{$_[1]}{-pat, -sep, -lastsep})}, ; pattern name => ['list', 'conj', '-word=(?:and|or)'], create => sub {gen_list_pattern($defpat, $defsep, '\s*,?\s*'.$_[1]->{-word}.'\s*'); }, ; pattern name => ['list', 'and'], create => sub {gen_list_pattern ($defpat, $defsep, '\s*,?\s*and\s*')}, ; pattern name => ['list', 'or'], create => sub {gen_list_pattern ($defpat, $defsep, '\s*,?\s*or\s*')}, ; 1; __END__ =pod =head1 NAME Regexp::Common::list -- provide regexes for lists =head1 SYNOPSIS use Regexp::Common qw /list/; while (<>) { /$RE{list}{-pat => '\w+'}/ and print "List of words"; /$RE{list}{-pat => $RE{num}{real}}/ and print "List of numbers"; } =head1 DESCRIPTION Please consult the manual of L for a general description of the works of this interface. Do not use this module directly, but load it via I. =head2 C<$RE{list}{-pat}{-sep}{-lastsep}> Returns a pattern matching a list of (at least two) substrings. If C<-pat=I

> is specified, it defines the pattern for each substring in the list. By default, I

is C. In Regexp::Common 0.02 or earlier, the default pattern was C. But that will match a single space, causing unintended parsing of C as a list of four elements instead of 3 (with C<-word> being C<(?:and)>). One consequence is that a list of the form "a,,b" will no longer be parsed. Use the pattern C to be able to parse this, but see the previous remark. If C<-sep=I

> is specified, it defines the pattern I

to be used as a separator between each pair of substrings in the list, except the final two. By default I

is C. If C<-lastsep=I

> is specified, it defines the pattern I

to be used as a separator between the final two substrings in the list. By default I

is the same as the pattern specified by the C<-sep> flag. For example: $RE{list}{-pat=>'\w+'} # match a list of word chars $RE{list}{-pat=>$RE{num}{real}} # match a list of numbers $RE{list}{-sep=>"\t"} # match a tab-separated list $RE{list}{-lastsep=>',\s+and\s+'} # match a proper English list Under C<-keep>: =over 4 =item $1 captures the entire list =item $2 captures the last separator =back =head2 C<$RE{list}{conj}{-word=I}> An alias for C<< $RE{list}{-lastsep=>'\s*,?\s*I\s*'} >> If C<-word> is not specified, the default pattern is C. For example: $RE{list}{conj}{-word=>'et'} # match Jean, Paul, et Satre $RE{list}{conj}{-word=>'oder'} # match Bonn, Koln oder Hamburg =head2 C<$RE{list}{and}> An alias for C<< $RE{list}{conj}{-word=>'and'} >> =head2 C<$RE{list}{or}> An alias for C<< $RE{list}{conj}{-word=>'or'} >> =head1 SEE ALSO L for a general description of how to use this interface. =head1 AUTHOR Damian Conway (damian@conway.org) =head1 MAINTENANCE This package is maintained by Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Bound to be plenty. For a start, there are many common regexes missing. Send them in to I. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/net.pm000644 000765 000024 00000031614 13114356476 021724 0ustar00abigailstaff000000 000000 package Regexp::Common::net; use 5.10.0; use strict; use warnings; no warnings 'syntax'; use Regexp::Common qw /pattern clean no_defaults/; our $VERSION = '2017060201'; my %IPunit = ( dec => q{(?k:25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})}, oct => q{(?k:[0-3]?[0-7]{1,2})}, hex => q{(?k:[0-9a-fA-F]{1,2})}, bin => q{(?k:[0-1]{1,8})}, strict => q{(?k:2(?:5[0-5]?|[0-4][0-9]?|[6-9]?)|1[0-9]{0,2}|[3-9][0-9]?|0)}, ); my %MACunit = ( %IPunit, hex => q{(?k:[0-9a-fA-F]{1,2})}, ); my %IPv6unit = ( hex => q {(?k:[0-9a-f]{1,4})}, HEX => q {(?k:[0-9A-F]{1,4})}, HeX => q {(?k:[0-9a-fA-F]{1,4})}, ); sub dec {$_}; sub bin {oct "0b$_"} my $IPdefsep = '[.]'; my $MACdefsep = ':'; my $IPv6defsep = ':'; pattern name => [qw (net IPv4)], create => "(?k:$IPunit{dec}$IPdefsep$IPunit{dec}$IPdefsep" . "$IPunit{dec}$IPdefsep$IPunit{dec})", ; pattern name => [qw (net MAC)], create => "(?k:" . join ($MACdefsep => ($MACunit{hex}) x 6) . ")", subs => sub { $_ [1] = join ":" => map {sprintf "%02x" => hex} split /$MACdefsep/ => $_ [1] if $_ [1] =~ /$_[0]/ }, ; foreach my $type (qw /dec oct hex bin strict/) { pattern name => [qw (net IPv4), $type, "-sep=$IPdefsep"], create => sub {my $sep = $_ [1] -> {-sep}; "(?k:$IPunit{$type}$sep$IPunit{$type}$sep" . "$IPunit{$type}$sep$IPunit{$type})" }, ; pattern name => [qw (net MAC), $type, "-sep=$MACdefsep"], create => sub {my $sep = $_ [1] -> {-sep}; "(?k:" . join ($sep => ($MACunit{$type}) x 6) . ")", }, subs => sub { return if $] < 5.006 and $type eq 'bin'; $_ [1] = join ":" => map {sprintf "%02x" => eval $type} $2, $3, $4, $5, $6, $7 if $_ [1] =~ $RE {net} {MAC} {$type} {-sep => $_ [0] -> {flags} {-sep}} {-keep}; }, ; } my %cache6; pattern name => [qw (net IPv6), "-sep=$IPv6defsep", "-style=HeX"], create => sub { my $style = $_ [1] {-style}; my $sep = $_ [1] {-sep}; return $cache6 {$style, $sep} if $cache6 {$style, $sep}; my @re; die "Impossible style '$style'\n" unless exists $IPv6unit {$style}; # # Nothing missing # push @re => join $sep => ($IPv6unit {$style}) x 8; # # For "double colon" representations, at least 2 units must # be omitted, leaving us with at most 6 units. 0 units is also # possible. Note we can have at most one double colon. # for (my $l = 0; $l <= 6; $l ++) { # # We prefer to do longest match, so larger $r gets priority # for (my $r = 6 - $l; $r >= 0; $r --) { # # $l is the number of blocks left of the double colon, # $r is the number of blocks left of the double colon, # $m is the number of omitted blocks # my $m = 8 - $l - $r; my $patl = $l ? ($IPv6unit {$style} . $sep) x $l : $sep; my $patr = $r ? ($sep . $IPv6unit {$style}) x $r : $sep; my $patm = "(?k:)" x $m; my $pat = $patl . $patm . $patr; push @re => "(?:$pat)"; } } local $" = "|"; $cache6 {$style, $sep} = qq /(?k:(?|@re))/; }, ; my $letter = "[A-Za-z]"; my $let_dig = "[A-Za-z0-9]"; my $let_dig_hyp = "[-A-Za-z0-9]"; # Domain names, from RFC 1035. pattern name => [qw (net domain -nospace= -rfc1101=)], create => sub { my $rfc1101 = exists $_ [1] {-rfc1101} && !defined $_ [1] {-rfc1101}; my $lead = $rfc1101 ? "(?!$RE{net}{IPv4}(?:[.]|\$))$let_dig" : $letter; if (exists $_ [1] {-nospace} && !defined $_ [1] {-nospace}) { return "(?k:$lead(?:(?:$let_dig_hyp){0,61}$let_dig)?" . "(?:\\.$lead(?:(?:$let_dig_hyp){0,61}$let_dig)?)*)" } else { return "(?k: |(?:$lead(?:(?:$let_dig_hyp){0,61}$let_dig)?" . "(?:\\.$lead(?:(?:$let_dig_hyp){0,61}$let_dig)?)*))" } }, ; 1; __END__ =head1 NAME Regexp::Common::net -- provide regexes for IPv4, IPv6, and MAC addresses. =head1 SYNOPSIS use Regexp::Common qw /net/; while (<>) { /$RE{net}{IPv4}/ and print "Dotted decimal IP address"; /$RE{net}{IPv4}{hex}/ and print "Dotted hexadecimal IP address"; /$RE{net}{IPv4}{oct}{-sep => ':'}/ and print "Colon separated octal IP address"; /$RE{net}{IPv4}{bin}/ and print "Dotted binary IP address"; /$RE{net}{MAC}/ and print "MAC address"; /$RE{net}{MAC}{oct}{-sep => " "}/ and print "Space separated octal MAC address"; } =head1 DESCRIPTION Please consult the manual of L for a general description of the works of this interface. Do not use this module directly, but load it via I. This modules gives you regular expressions for various style IPv4, IPv6, and MAC (or ethernet) addresses. =head2 C<$RE{net}{IPv4}> Returns a pattern that matches a valid IP address in "dotted decimal". Note that while C<318.99.183.11> is not a valid IP address, it does match C, but this is because C<318.99.183.11> contains a valid IP address, namely C<18.99.183.11>. To prevent the unwanted matching, one needs to anchor the regexp: C. For this pattern and the next four, under C<-keep> (See L): =over 4 =item $1 captures the entire match =item $2 captures the first component of the address =item $3 captures the second component of the address =item $4 captures the third component of the address =item $5 captures the final component of the address =back =head2 C<$RE{net}{IPv4}{dec}{-sep}> Returns a pattern that matches a valid IP address in "dotted decimal". Leading 0s are allowed, as long as each component does not exceed 3 digits. If C<< -sep=I

>> is specified the pattern I

is used as the separator. By default I

is C. =head2 C<$RE{net}{IPv4}{strict}{-sep}> Returns a pattern that matches a valid IP address in "dotted decimal", but disallow any leading 0s. If C<< -sep=I

>> is specified the pattern I

is used as the separator. By default I

>> is specified the pattern I

is used as the separator. By default I

is C. C<< -sep="" >> and C<< -sep=" " >> are useful alternatives. =head2 C<$RE{net}{IPv4}{oct}{-sep}> Returns a pattern that matches a valid IP address in "dotted octal" If C<< -sep=I

>> is specified the pattern I

is used as the separator. By default I

is C. =head2 C<$RE{net}{IPv4}{bin}{-sep}> Returns a pattern that matches a valid IP address in "dotted binary" If C<< -sep=I

>> is specified the pattern I

is used as the separator. By default I

is C. =head2 C<$RE{net}{MAC}> Returns a pattern that matches a valid MAC or ethernet address as colon separated hexadecimals. For this pattern, and the next four, under C<-keep> (See L): =over 4 =item $1 captures the entire match =item $2 captures the first component of the address =item $3 captures the second component of the address =item $4 captures the third component of the address =item $5 captures the fourth component of the address =item $6 captures the fifth component of the address =item $7 captures the sixth and final component of the address =back This pattern, and the next four, have a C method as well, which will transform a matching MAC address into so called canonical format. Canonical format means that every component of the address will be exactly two hexadecimals (with a leading zero if necessary), and the components will be separated by a colon. =head2 C<$RE{net}{MAC}{dec}{-sep}> Returns a pattern that matches a valid MAC address as colon separated decimals. If C<< -sep=I

>> is specified the pattern I

is used as the separator. By default I

is C. =head2 C<$RE{net}{MAC}{hex}{-sep}> Returns a pattern that matches a valid MAC address as colon separated hexadecimals, with the letters C to C in lower case. If C<< -sep=I

>> is specified the pattern I

is used as the separator. By default I

is C. =head2 C<$RE{net}{MAC}{oct}{-sep}> Returns a pattern that matches a valid MAC address as colon separated octals. If C<< -sep=I

>> is specified the pattern I

is used as the separator. By default I

is C. =head2 C<$RE{net}{MAC}{bin}{-sep}> Returns a pattern that matches a valid MAC address as colon separated binary numbers. If C<< -sep=I

>> is specified the pattern I

is used as the separator. By default I

is C. =head2 C<< $RE{net}{IPv6}{-sep => ':'}{-style => 'HeX'} >> Returns a pattern matching IPv6 numbers. An IPv6 address consists of eight groups of four hexadecimal digits, separated by colons. In each group, leading zeros may be omitted. Two or more consecutive groups consisting of only zeros may be omitted (including any colons separating them), resulting into two sets of groups, separated by a double colon. (Each of the groups may be empty; C<< :: >> is a valid address, equal to C<< 0000:0000:0000:0000:0000:0000:0000:0000 >>). The hex numbers may be in either case. If the C<< -sep >> option is used, its argument is a pattern that matches the separator that separates groups. This defaults to C<< : >>. The C<< -style >> option is used to denote which case the hex numbers may be. The default style, C<< 'HeX' >> indicates both lower case letters C<< 'a' >> to C<< 'f' >> and upper case letters C<< 'A' >> to C<< 'F' >> will be matched. The style C<< 'HEX' >> restricts matching to upper case letters, and C<< 'hex' >> only matches lower case letters. If C<< {-keep} >> is used, C<< $1 >> to C<< $9 >> will be set. C<< $1 >> will be set to the matched address, while C<< $2 >> to C<< $9 >> will be set to each matched group. If a group is omitted because it contains all zeros, its matching variable will be the empty string. Example: "2001:db8:85a3::8a2e:370:7334" =~ /$RE{net}{IPv6}{-keep}/; print $2; # '2001' print $4; # '85a3' print $6; # Empty string print $8; # '370' Perl 5.10 (or later) is required for this pattern. =head2 C<$RE{net}{domain}> Returns a pattern to match domains (and hosts) as defined in RFC 1035. Under I{-keep} only the entire domain name is returned. RFC 1035 says that a single space can be a domainname too. So, the pattern returned by C<$RE{net}{domain}> recognizes a single space as well. This is not always what people want. If you want to recognize domainnames, but not a space, you can do one of two things, either use /(?! )$RE{net}{domain}/ or use the C<{-nospace}> option (without an argument). RFC 1035 does B allow host or domain names to start with a digits; however, this restriction is relaxed in RFC 1101; this RFC allows host and domain names to start with a digit, as long as the first part of a domain does not look like an IP address. If the C<< {-rfc1101} >> option is given (as in C<< $RE {net} {domain} {-rfc1101} >>), we will match using the relaxed rules. =head1 REFERENCES =over 4 =item B Mockapetris, P.: I. November 1987. =item B Mockapetris, P.: I. April 1987. =back =head1 SEE ALSO L for a general description of how to use this interface. =head1 AUTHOR Damian Conway I. =head1 MAINTENANCE This package is maintained by Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Bound to be plenty. For a start, there are many common regexes missing. Send them in to I. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/number.pm000644 000765 000024 00000035220 13114356476 022423 0ustar00abigailstaff000000 000000 package Regexp::Common::number; use 5.10.0; use strict; use warnings; no warnings 'syntax'; use Config; use Regexp::Common qw /pattern clean no_defaults/; our $VERSION = '2017060201'; sub _croak { require Carp; goto &Carp::croak; } my $digits = join ("", 0 .. 9, "A" .. "Z"); sub int_creator { my $flags = $_ [1]; my ($sep, $group, $base, $places, $sign) = @{$flags} {qw /-sep -group -base -places -sign/}; # Deal with the bases. _croak "Base must be between 1 and 36" unless $base >= 1 && $base <= 36; my $chars = substr $digits, 0, $base; $sep = ',' if exists $flags -> {-sep} && !defined $flags -> {-sep}; my $max = $group; $max = $2 if $group =~ /^\s*(\d+)\s*,\s*(\d+)\s*$/; my $quant = $places ? "{$places}" : "+"; return $sep ? qq {(?k:(?k:$sign)(?k:[$chars]{1,$max}} . qq {(?:$sep} . qq {[$chars]{$group})*))} : qq {(?k:(?k:$sign)(?k:[$chars]$quant))} } sub real_creator { my ($base, $places, $radix, $sep, $group, $expon, $sign) = @{$_[1]}{-base, -places, -radix, -sep, -group, -expon, -sign}; _croak "Base must be between 1 and 36" unless $base >= 1 && $base <= 36; $sep = ',' if exists $_[1]->{-sep} && !defined $_[1]->{-sep}; if ($base > 14 && $expon =~ /^[Ee]$/) {$expon = 'G'} foreach ($radix, $sep, $expon) {$_ = "[$_]" if 1 == length} my $chars = substr $digits, 0, $base; return $sep ? qq {(?k:(?i)(?k:$sign)(?k:(?=$radix?[$chars])} . qq {(?k:[$chars]{1,$group}(?:(?:$sep)[$chars]{$group})*)} . qq {(?:(?k:$radix)(?k:[$chars]{$places}))?)} . qq {(?:(?k:$expon)(?k:(?k:$sign)(?k:[$chars]+))|))} : qq {(?k:(?i)(?k:$sign)(?k:(?=$radix?[$chars])} . qq {(?k:[$chars]*)(?:(?k:$radix)(?k:[$chars]{$places}))?)} . qq {(?:(?k:$expon)(?k:(?k:$sign)(?k:[$chars]+))|))}; } sub decimal_creator { my ($base, $places, $radix, $sep, $group, $sign) = @{$_[1]}{-base, -places, -radix, -sep, -group, -sign}; _croak "Base must be between 1 and 36" unless $base >= 1 && $base <= 36; $sep = ',' if exists $_[1]->{-sep} && !defined $_[1]->{-sep}; foreach ($radix, $sep) {$_ = "[$_]" if 1 == length} my $chars = substr $digits, 0, $base; return $sep ? qq {(?k:(?i)(?k:$sign)(?k:(?=$radix?[$chars])} . qq {(?k:[$chars]{1,$group}(?:(?:$sep)[$chars]{$group})*)} . qq {(?:(?k:$radix)(?k:[$chars]{$places}))?))} : qq {(?k:(?i)(?k:$sign)(?k:(?=$radix?[$chars])} . qq {(?k:[$chars]*)(?:(?k:$radix)(?k:[$chars]{$places}))?))} } pattern name => [qw (num int -sep= -base=10 -group=3 -sign=[-+]?)], create => \&int_creator, ; pattern name => [qw (num real -base=10), '-places=0,', qw (-radix=[.] -sep= -group=3 -expon=E -sign=[-+]?)], create => \&real_creator, ; pattern name => [qw (num decimal -base=10), '-places=0,', qw (-radix=[.] -sep= -group=3 -sign=[-+]?)], create => \&decimal_creator, ; sub real_synonym { my ($name, $base) = @_; pattern name => ['num', $name, '-places=0,', '-radix=[.]', '-sep=', '-group=3', '-expon=E', '-sign=[-+]?'], create => sub {my %flags = (%{$_[1]}, -base => $base); real_creator (undef, \%flags); } ; } real_synonym (hex => 16); real_synonym (dec => 10); real_synonym (oct => 8); real_synonym (bin => 2); # 2147483647 == 2^31 - 1 # 9223372036854775807 == 2^63 - 1 pattern name => [qw (num square)], create => sub { use re 'eval'; my $sixty_four_bits = $Config {use64bitint}; # # CPAN testers claim it fails on 5.8.8 and darwin 9.0. # my $num = $sixty_four_bits ? '0*(?:(?:9(?:[0-1][0-9]{17}' . '|2(?:[0-1][0-9]{16}' . '|2(?:[0-2][0-9]{15}' . '|3(?:[0-2][0-9]{14}' . '|3(?:[0-6][0-9]{13}' . '|7(?:[0-1][0-9]{12}' . '|20(?:[0-2][0-9]{10}' . '|3(?:[0-5][0-9]{9}' . '|6(?:[0-7][0-9]{8}' . '|8(?:[0-4][0-9]{7}' . '|5(?:[0-3][0-9]{6}' . '|4(?:[0-6][0-9]{5}' . '|7(?:[0-6][0-9]{4}' . '|7(?:[0-4][0-9]{3}' . '|5(?:[0-7][0-9]{2}' . '|80(?:[0-6])))))))))))))))))|[1-8]?[0-9]{0,18})' : '0*(?:2(?:[0-0][0-9]{8}' . '|1(?:[0-3][0-9]{7}' . '|4(?:[0-6][0-9]{6}' . '|7(?:[0-3][0-9]{5}' . '|4(?:[0-7][0-9]{4}' . '|8(?:[0-2][0-9]{3}' . '|3(?:[0-5][0-9]{2}' . '|6(?:[0-3][0-9]{1}' . '|4[0-7])))))))))|1?[0-9]{1,9}'; qr {($num)(?(?{length $^N && sqrt ($^N) == int sqrt ($^N)})|(?!))} }, ; pattern name => [qw (num roman)], create => '(?xi)(?=[MDCLXVI]) (?k:M{0,4} (?:C[DM]|D?C{0,4})? (?:X[LC]|L?X{0,4})? (?:I[VX]|V?I{0,4})?)' ; 1; __END__ =pod =head1 NAME Regexp::Common::number -- provide regexes for numbers =head1 SYNOPSIS use Regexp::Common qw /number/; while (<>) { /^$RE{num}{int}$/ and print "Integer\n"; /^$RE{num}{real}$/ and print "Real\n"; /^$RE{num}{real}{-base => 16}$/ and print "Hexadecimal real\n"; } =head1 DESCRIPTION Please consult the manual of L for a general description of the works of this interface. Do not use this module directly, but load it via I. =head2 C<$RE{num}{int}{-base}{-sep}{-group}{-places}{-sign}> Returns a pattern that matches an integer. If C<< -base => I >> is specified, the integer is in base I, with C<< 2 <= I <= 36 >>. For bases larger than 10, upper case letters are used. The default base is 10. If C<< -sep => I

>> is specified, the pattern I

is required as a grouping marker within the number. If this option is not given, no grouping marker is used. If C<< -group => I >> is specified, digits between grouping markers must be grouped in sequences of exactly I digits. The default value of I is 3. If C<< -group => I >> is specified, digits between grouping markers must be grouped in sequences of at least I digits, and at most I digits. This option is ignored unless the C<< -sep >> option is used. If C<< -places => I >> is specified, the integer recognized must be exactly I digits wide. If C<< -places => I >> is specified, the integer must be at least I wide, and at most I characters. There is no default, which means that integers are unlimited in size. This option is ignored if the C<< -sep >> option is used. If C<< -sign => I

>> is used, it's a pattern the leading sign has to match. This defaults to C<< [-+]? >>, which means the number is optionally preceded by a minus or a plus. If you want to match unsigned integers, use C<< $RE{num}{int}{-sign => ''} >>. For example: $RE{num}{int} # match 1234567 $RE{num}{int}{-sep=>','} # match 1,234,567 $RE{num}{int}{-sep=>',?'} # match 1234567 or 1,234,567 $RE{num}{int}{-sep=>'.'}{-group=>4} # match 1.2345.6789 Under C<-keep> (see L): =over 4 =item $1 captures the entire number =item $2 captures the optional sign of the number =item $3 captures the complete set of digits =back =head2 C<$RE{num}{real}{-base}{-radix}{-places}{-sep}{-group}{-expon}> Returns a pattern that matches a floating-point number. If C<-base=I> is specified, the number is assumed to be in that base (with A..Z representing the digits for 11..36). By default, the base is 10. If C<-radix=I

> is specified, the pattern I

is used as the radix point for the number (i.e. the "decimal point" in base 10). The default is C. If C<-places=I> is specified, the number is assumed to have exactly I places after the radix point. If C<-places=I> is specified, the number is assumed to have between I and I places after the radix point. By default, the number of places is unrestricted. If C<-sep=I

> specified, the pattern I

is required as a grouping marker within the pre-radix section of the number. By default, no separator is allowed. If C<-group=I> is specified, digits between grouping separators must be grouped in sequences of exactly I characters. The default value of I is 3. If C<-expon=I

> is specified, the pattern I

is used as the exponential marker. The default value of I

is C. If C<-sign=I

> is specified, the pattern I

is used to match the leading sign (and the sign of the exponent). This defaults to C<< [-+]? >>, means means that an optional plus or minus sign can be used. For example: $RE{num}{real} # matches 123.456 or -0.1234567 $RE{num}{real}{-places=>2} # matches 123.45 or -0.12 $RE{num}{real}{-places=>'0,3'} # matches 123.456 or 0 or 9.8 $RE{num}{real}{-sep=>'[,.]?'} # matches 123,456 or 123.456 $RE{num}{real}{-base=>3'} # matches 121.102 Under C<-keep>: =over 4 =item $1 captures the entire match =item $2 captures the optional sign of the number =item $3 captures the complete mantissa =item $4 captures the whole number portion of the mantissa =item $5 captures the radix point =item $6 captures the fractional portion of the mantissa =item $7 captures the optional exponent marker =item $8 captures the entire exponent value =item $9 captures the optional sign of the exponent =item $10 captures the digits of the exponent =back =head2 C<$RE{num}{dec}{-radix}{-places}{-sep}{-group}{-expon}> A synonym for C<< $RE{num}{real}{-base=>10}{...} >> =head2 C<$RE{num}{oct}{-radix}{-places}{-sep}{-group}{-expon}> A synonym for C<< $RE{num}{real}{-base=>8}{...} >> =head2 C<$RE{num}{bin}{-radix}{-places}{-sep}{-group}{-expon}> A synonym for C<< $RE{num}{real}{-base=>2}{...} >> =head2 C<$RE{num}{hex}{-radix}{-places}{-sep}{-group}{-expon}> A synonym for C<< $RE{num}{real}{-base=>16}{...} >> =head2 C<$RE{num}{decimal}{-base}{-radix}{-places}{-sep}{-group}> The same as C<$RE{num}{real}>, except that an exponent isn't allowed. Hence, this returns a pattern matching I numbers. If C<-base=I> is specified, the number is assumed to be in that base (with A..Z representing the digits for 11..36). By default, the base is 10. If C<-radix=I

> is specified, the pattern I

is used as the radix point for the number (i.e. the "decimal point" in base 10). The default is C. If C<-places=I> is specified, the number is assumed to have exactly I places after the radix point. If C<-places=I> is specified, the number is assumed to have between I and I places after the radix point. By default, the number of places is unrestricted. If C<-sep=I

> specified, the pattern I

is required as a grouping marker within the pre-radix section of the number. By default, no separator is allowed. If C<-group=I> is specified, digits between grouping separators must be grouped in sequences of exactly I characters. The default value of I is 3. For example: $RE{num}{decimal} # matches 123.456 or -0.1234567 $RE{num}{decimal}{-places=>2} # matches 123.45 or -0.12 $RE{num}{decimal}{-places=>'0,3'} # matches 123.456 or 0 or 9.8 $RE{num}{decimal}{-sep=>'[,.]?'} # matches 123,456 or 123.456 $RE{num}{decimal}{-base=>3'} # matches 121.102 Under C<-keep>: =over 4 =item $1 captures the entire match =item $2 captures the optional sign of the number =item $3 captures the complete mantissa =item $4 captures the whole number portion of the mantissa =item $5 captures the radix point =item $6 captures the fractional portion of the mantissa =back =head2 C<$RE{num}{square}> Returns a pattern that matches a (decimal) square. Because Perl's arithmetic is lossy when using integers over about 53 bits, this pattern only recognizes numbers less than 9000000000000000, if one uses a Perl that is configured to use 64 bit integers. Otherwise, the limit is 2147483647. These restrictions were introduced in versions 2.116 and 2.117 of Regexp::Common. Regardless whether C<-keep> was set, the matched number will be returned in C<$1>. =head2 C<$RE{num}{roman}> Returns a pattern that matches an integer written in Roman numbers. Case doesn't matter. There is no unique way of writing Roman numerals, but we will not match anything. We require the Roman numerals to list the symbols in order (largest first). The symbols for thousand (C<< M >>), hundred (C<< C >>), ten (C<< X >>), and one (C<< I >>) can not be repeated more than four times. The symbols for five hundred (C<< D >>), fifty (C<< L >>), and five (C<< V >>) may not appear more than once. A sequence of four repeated characters may also be written as a subtraction: by using the repeated character just once, and have it followed by the symbol which is 5 or 10 as large. So, four can be written as C<< IIII >>, or as C<< IV >>, and nine may be written as C<< VIIII >> or C<< IX >>. This corresponds to most modern uses of Roman numerals. The largest number which will be matched is 4999, or C<< MMMMDCCCCLXXXXVIIII >>, or C<< MMMMCMXCIX >>. Under C<-keep>, the number will be captured in $1. =head1 SEE ALSO L for a general description of how to use this interface. =head1 AUTHOR Damian Conway (damian@conway.org) =head1 MAINTENANCE This package is maintained by Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Bound to be plenty. For a start, there are many common regexes missing. Send them in to I. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/profanity.pm000644 000765 000024 00000010570 13114356476 023147 0ustar00abigailstaff000000 000000 package Regexp::Common::profanity; use 5.10.0; use strict; use warnings; no warnings 'syntax'; use Regexp::Common qw /pattern clean no_defaults/; our $VERSION = '2017060201'; my $profanity = '(?:cvff(?:\\ gnxr|\\-gnxr|gnxr|r(?:ef|[feq])|vat|l)?|dhvzf?|fuvg(?:g(?:r(?:ef|[qe])|vat|l)|r(?:ef|[fqel])|vat|[fr])?|g(?:heqf?|jngf?)|jnax(?:r(?:ef|[eq])|vat|f)?|n(?:ef(?:r(?:\\ ubyr|\\-ubyr|ubyr|[fq])|vat|r)|ff(?:\\ ubyrf?|\\-ubyrf?|rq|ubyrf?|vat))|o(?:hyy(?:\\ fuvg(?:g(?:r(?:ef|[qe])|vat)|f)?|\\-fuvg(?:g(?:r(?:ef|[qe])|vat)|f)?|fuvg(?:g(?:r(?:ef|[qe])|vat)|f)?)|ybj(?:\\ wbof?|\\-wbof?|wbof?))|p(?:bpx(?:\\ fhpx(?:ref?|vat)|\\-fhpx(?:ref?|vat)|fhpx(?:ref?|vat))|enc(?:c(?:r(?:ef|[eq])|vat|l)|f)?|h(?:agf?|z(?:vat|zvat|f)))|qvpx(?:\\ urnq|\\-urnq|rq|urnq|vat|yrff|f)|s(?:hpx(?:rq|vat|f)?|neg(?:r[eq]|vat|[fl])?|rygpu(?:r(?:ef|[efq])|vat)?)|un(?:eq[\\-\\ ]?ba|ys(?:\\ n[fe]|\\-n[fe]|n[fe])frq)|z(?:bgure(?:\\ shpx(?:ref?|vat)|\\-shpx(?:ref?|vat)|shpx(?:ref?|vat))|hgu(?:n(?:\\ shpx(?:ref?|vat|[nnn])|\\-shpx(?:ref?|vat|[nnn])|shpx(?:ref?|vat|[nnn]))|re(?:\\ shpx(?:ref?|vat)|\\-shpx(?:ref?|vat)|shpx(?:ref?|vat)))|reqr?))'; my $contextual = '(?:c(?:bex|e(?:bax|vpxf?)|hff(?:vrf|l)|vff(?:\\ gnxr|\\-gnxr|gnxr|r(?:ef|[feq])|vat|l)?)|dhvzf?|ebbg(?:r(?:ef|[eq])|vat|f)?|f(?:bq(?:q(?:rq|vat)|f)?|chax|perj(?:rq|vat|f)?|u(?:nt(?:t(?:r(?:ef|[qe])|vat)|f)?|vg(?:g(?:r(?:ef|[qe])|vat|l)|r(?:ef|[fqel])|vat|[fr])?))|g(?:heqf?|jngf?|vgf?)|jnax(?:r(?:ef|[eq])|vat|f)?|n(?:ef(?:r(?:\\ ubyr|\\-ubyr|ubyr|[fq])|vat|r)|ff(?:\\ ubyrf?|\\-ubyrf?|rq|ubyrf?|vat))|o(?:ba(?:r(?:ef|[fe])|vat|r)|h(?:ttre|yy(?:\\ fuvg(?:g(?:r(?:ef|[qe])|vat)|f)?|\\-fuvg(?:g(?:r(?:ef|[qe])|vat)|f)?|fuvg(?:g(?:r(?:ef|[qe])|vat)|f)?))|n(?:fgneq|yy(?:r(?:ef|[qe])|vat|f)?)|yb(?:bql|j(?:\\ wbof?|\\-wbof?|wbof?)))|p(?:bpx(?:\\ fhpx(?:ref?|vat)|\\-fhpx(?:ref?|vat)|fhpx(?:ref?|vat)|f)?|enc(?:c(?:r(?:ef|[eq])|vat|l)|f)?|h(?:agf?|z(?:vat|zvat|f)))|q(?:batf?|vpx(?:\\ urnq|\\-urnq|rq|urnq|vat|yrff|f)?)|s(?:hpx(?:rq|vat|f)?|neg(?:r[eq]|vat|[fl])?|rygpu(?:r(?:ef|[efq])|vat)?)|u(?:hzc(?:r(?:ef|[eq])|vat|f)?|n(?:eq[\\-\\ ]?ba|ys(?:\\ n[fe]|\\-n[fe]|n[fe])frq))|z(?:bgure(?:\\ shpx(?:ref?|vat)|\\-shpx(?:ref?|vat)|shpx(?:ref?|vat))|hgu(?:n(?:\\ shpx(?:ref?|vat|[nnn])|\\-shpx(?:ref?|vat|[nnn])|shpx(?:ref?|vat|[nnn]))|re(?:\\ shpx(?:ref?|vat)|\\-shpx(?:ref?|vat)|shpx(?:ref?|vat)))|reqr?))'; tr/A-Za-z/N-ZA-Mn-za-m/ foreach $profanity, $contextual; pattern name => [qw (profanity)], create => '(?:\b(?k:' . $profanity . ')\b)', ; pattern name => [qw (profanity contextual)], create => '(?:\b(?k:' . $contextual . ')\b)', ; 1; __END__ =pod =head1 NAME Regexp::Common::profanity -- provide regexes for profanity =head1 SYNOPSIS use Regexp::Common qw /profanity/; while (<>) { /$RE{profanity}/ and print "Contains profanity\n"; } =head1 DESCRIPTION Please consult the manual of L for a general description of the works of this interface. Do not use this module directly, but load it via I. =head2 $RE{profanity} Returns a pattern matching words -- such as Carlin's "big seven" -- that are most likely to give offense. Note that correct anatomical terms are deliberately I included in the list. Under C<-keep> (see L): =over 4 =item $1 captures the entire word =back =head2 C<$RE{profanity}{contextual}> Returns a pattern matching words that are likely to give offense when used in specific contexts, but which also have genuinely non-offensive meanings. Under C<-keep> (see L): =over 4 =item $1 captures the entire word =back =head1 SEE ALSO L for a general description of how to use this interface. =head1 AUTHOR Damian Conway (damian@conway.org) =head1 MAINTENANCE This package is maintained by Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Bound to be plenty. For a start, there are many common regexes missing. Send them in to I. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/SEN.pm000644 000765 000024 00000006751 13114356476 021567 0ustar00abigailstaff000000 000000 package Regexp::Common::SEN; use 5.10.0; use strict; use warnings; no warnings 'syntax'; use Regexp::Common qw /pattern clean no_defaults/; our $VERSION = '2017060201'; =begin does_not_exist sub par11 { my $string = shift; my $sum = 0; for my $i (0 .. length ($string) - 1) { my $c = substr ($string, $i, 1); $sum += $c * (length ($string) - $i) } !($sum % 11) } =end does_not_exist =cut # http://www.ssa.gov/history/ssn/geocard.html pattern name => [qw /SEN USA SSN -sep=-/], create => sub { my $sep = $_ [1] {-sep}; "(?k:(?k:[1-9][0-9][0-9]|0[1-9][0-9]|00[1-9])$sep" . "(?k:[1-9][0-9]|0[1-9])$sep" . "(?k:[1-9][0-9][0-9][0-9]|0[1-9][0-9][0-9]|" . "00[1-9][0-9]|000[1-9]))" }, ; =begin does_not_exist It's not clear whether this is the right checksum. # http://www.google.nl/search?q=cache:8m1zKNYrEO0J:www.enschede.nl/nieuw/projecten/aanbesteding/integratie/pve%2520Bijlage%25207.5.doc+Sofi+nummer+formaat&hl=en&start=56&lr=lang_en|lang_nl&ie=UTF-8 pattern name => [qw /SEN Netherlands SoFi/], create => sub { # 9 digits (d1 d2 d3 d4 d5 d6 d7 d8 d9) # 9*d1 + 8*d2 + 7*d3 + 6*d4 + 5*d5 + 4*d6 + 3*d7 + 2*d8 + 1*d9 # == 0 mod 11. qr /([0-9]{9})(?(?{par11 ($^N)})|(?!))/; } ; =end does_not_exist =cut 1; __END__ =pod =head1 NAME Regexp::Common::SEN -- provide regexes for Social-Economical Numbers. =head1 SYNOPSIS use Regexp::Common qw /SEN/; while (<>) { /^$RE{SEN}{USA}{SSN}$/ and print "Social Security Number\n"; } =head1 DESCRIPTION Please consult the manual of L for a general description of the works of this interface. Do not use this module directly, but load it via I. =head2 C<$RE{SEN}{USA}{SSN}{-sep}> Returns a pattern that matches an American Social Security Number (SSN). SSNs consist of three groups of numbers, separated by a hyphen (C<->). This pattern only checks for a valid structure, that is, it validates whether a number is valid SSN, was a valid SSN, or maybe a valid SSN in the future. There are almost a billion possible SSNs, and about 400 million are in use, or have been in use. If C<-sep=I

> is specified, the pattern I

is used as the separator between the groups of numbers. Under C<-keep> (see L): =over 4 =item $1 captures the entire SSN. =item $2 captures the first group of digits (the area number). =item $3 captures the second group of digits (the group number). =item $4 captures the third group of digits (the serial number). =back =head1 SEE ALSO L for a general description of how to use this interface. =head1 AUTHORS Damian Conway and Abigail. =head1 MAINTENANCE This package is maintained by Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Bound to be plenty. For a start, there are many common regexes missing. Send them in to I. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/URI/000755 000765 000024 00000000000 13114360501 021212 5ustar00abigailstaff000000 000000 Regexp-Common-2017060201/lib/Regexp/Common/URI.pm000644 000765 000024 00000006411 13114356476 021572 0ustar00abigailstaff000000 000000 package Regexp::Common::URI; use 5.10.0; use strict; use warnings; no warnings 'syntax'; use Exporter (); our @ISA = qw /Exporter/; our @EXPORT_OK = qw /register_uri/; use Regexp::Common qw /pattern clean no_defaults/; our $VERSION = '2017060201'; # Use 'require' here, not 'use', so we delay running them after we are compiled. # We also do it using an 'eval'; this saves us from have repeated similar # lines. The eval is further explained in 'perldoc -f require'. my @uris = qw /fax file ftp gopher http pop prospero news tel telnet tv wais/; foreach my $uri (@uris) { eval "require Regexp::Common::URI::$uri"; die $@ if $@; } my %uris; sub register_uri { my ($scheme, $uri) = @_; $uris {$scheme} = $uri; } pattern name => [qw (URI)], create => sub {my $uri = join '|' => values %uris; $uri =~ s/\(\?k:/(?:/g; "(?k:$uri)"; }, ; 1; __END__ =pod =head1 NAME Regexp::Common::URI -- provide patterns for URIs. =head1 SYNOPSIS use Regexp::Common qw /URI/; while (<>) { /$RE{URI}{HTTP}/ and print "Contains an HTTP URI.\n"; } =head1 DESCRIPTION Patterns for the following URIs are supported: fax, file, FTP, gopher, HTTP, news, NTTP, pop, prospero, tel, telnet, tv and WAIS. Each is documented in the I>, manual page, for the appropriate scheme (in lowercase), except for I URIs which are found in I. =head2 C<$RE{URI}> Return a pattern that recognizes any of the supported URIs. With C<{-keep}>, only the entire URI is returned (in C<$1>). =head1 REFERENCES =over 4 =item B<[DRAFT-URI-TV]> Zigmond, D. and Vickers, M: I. December 2000. =item B<[DRAFT-URL-FTP]> Casey, James: I. November 1996. =item B<[RFC 1035]> Mockapetris, P.: I. November 1987. =item B<[RFC 1738]> Berners-Lee, Tim, Masinter, L., McCahill, M.: I. December 1994. =item B<[RFC 2396]> Berners-Lee, Tim, Fielding, R., and Masinter, L.: I. August 1998. =item B<[RFC 2616]> Fielding, R., Gettys, J., Mogul, J., Frystyk, H., Masinter, L., Leach, P. and Berners-Lee, Tim: I. June 1999. =item B<[RFC 2806]> Vaha-Sipila, A.: I. April 2000. =back =head1 SEE ALSO L for a general description of how to use this interface. =head1 AUTHOR Damian Conway (damian@conway.org) =head1 MAINTENANCE This package is maintained by Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Bound to be plenty. For a start, there are many common regexes missing. Send them in to I. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/whitespace.pm000644 000765 000024 00000003652 13114356476 023273 0ustar00abigailstaff000000 000000 package Regexp::Common::whitespace; use 5.10.0; use strict; use warnings; no warnings 'syntax'; use Regexp::Common qw /pattern clean no_defaults/; our $VERSION = '2017060201'; pattern name => [qw (ws crop)], create => '(?:^\s+|\s+$)', subs => sub {$_[1] =~ s/^\s+//; $_[1] =~ s/\s+$//;} ; 1; __END__ =pod =head1 NAME Regexp::Common::whitespace -- provides a regex for leading or trailing whitescape =head1 SYNOPSIS use Regexp::Common qw /whitespace/; while (<>) { s/$RE{ws}{crop}//g; # Delete surrounding whitespace } =head1 DESCRIPTION Please consult the manual of L for a general description of the works of this interface. Do not use this module directly, but load it via I. =head2 C<$RE{ws}{crop}> Returns a pattern that identifies leading or trailing whitespace. For example: $str =~ s/$RE{ws}{crop}//g; # Delete surrounding whitespace The call: $RE{ws}{crop}->subs($str); is optimized (but probably still slower than doing the s///g explicitly). This pattern does not capture under C<-keep>. =head1 SEE ALSO L for a general description of how to use this interface. =head1 AUTHOR Damian Conway (damian@conway.org) =head1 MAINTENANCE This package is maintained by Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Bound to be plenty. For a start, there are many common regexes missing. Send them in to I. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/zip.pm000644 000765 000024 00000574652 13114356476 021756 0ustar00abigailstaff000000 000000 package Regexp::Common::zip; use 5.10.0; use strict; use warnings; no warnings 'syntax'; use Regexp::Common qw /pattern clean no_defaults/; our $VERSION = '2017060201'; # # Prefer '[0-9]' over \d, because the latter may include more # in Unicode string. # # # ISO and Cept codes. ISO code is the second column, Cept code is # the third. First column matches either. # # http://cept.org/ecc/topics/numbering-networks/numbering-related- # cooperation/the-cept-countries-joining-year-to-cept, # -cept-and-iso-country-codes,-e164-and-e212-country-codes # (http://bit.ly/1Ue268b) # my %code = ( Australia => [qw /AUS? AU AUS/], Austria => [qw /AU?T AT AUT/], Belgium => [qw /BE? BE B/], Denmark => [qw /DK DK DK/], France => [qw /FR? FR F/], Germany => [qw /DE? DE D/], Greenland => [qw /GL GL GL/], Italy => [qw /IT? IT I/], Liechtenstein => [qw /LIE? LI LIE/], Luxembourg => [qw /LU? LU L/], Monaco => [qw /MC MC MC/], Netherlands => [qw /NL NL NL/], Norway => [qw /NO? NO N/], 'San Marino' => [qw /SM SM SM/], Spain => [qw /ES? ES E/], Switzerland => [qw /CH CH CH/], USA => [qw /USA? US USA/], 'Vatican City' => [qw /VA VA VA/], ); # Returns the empty string if the argument is undefined, the argument otherwise. sub __ {defined $_ [0] ? $_ [0] : ""} # Used for allowable options. If the value starts with 'y', the option is # required ("{1,1}" is returned, if the value starts with 'n', the option # is disallowed ("{0,0}" is returned), otherwise, the option is allowed, # but not required ("{0,1}" is returned). sub _t { if (defined $_ [0]) { if ($_ [0] =~ /^y/i) {return "{1,1}"} if ($_ [0] =~ /^n/i) {return "{0,0}"} } "{0,1}" } # Returns the (sub)pattern for the country named '$name', and the # -country option '$country'. sub _c { my ($name, $country) = @_; if (defined $country && $country ne "") { if ($country eq 'iso') {return $code {$name} [1]} if ($country eq 'cept') {return $code {$name} [2]} return $country; } $code {$name} [0] } my %zip = ( # # Postal codes are four digits, but not all combinations are used. # # Valid codes from: # https://en.wikipedia.org/wiki/List_of_postal_codes_in_Austria # Austria => "(?k:1(?:[0-8][0-9][0-9]|90[01])" . "|2(?:[0-3][0-9][0-9]|" . "4(?:0[0-9]|1[0-3]|2[1-5]|3[1-9]|[4-6][0-9]|7[0-5]|" . "8[1-9]|9[0-9])|" . "[5-7][0-9][0-9]|" . "8(?:[0-7][0-9]|8[01]))" . "|3(?:0(?:0[1-9]|[1-9][0-9])|" . "[12][0-9][0-9]|" . "3(?:[0-2][0-9]|3[0-5]|[4-9][0-9])|" . "[4-8][0-9][0-9]|" . "9(?:[0-6][0-9]|7[0-3]))" . "|4(?:[01][0-9][0-9]|" . "2(?:[0-8][0-9]|9[0-4])|" . "3(?:0[0-3]|[1-8][0-9]|9[0-2])|" . "4(?:[0-1][0-9]|2[01]|3[1-9]|[4-9][0-9])|" . "[5-8][0-9][0-9]|" . "9(?:[0-7][0-9]|8[0-5]))" . "|5(?:0[0-9][0-9]|" . "1(?:0[0-9]|1[0-4]|[23][0-9]|4[0-5]|5[1-9]|[6-9][0-9])|" . "2(?:0[0-5]|1[1-9]|[2-7][0-9]|8[0-3])|" . "3(?:0[0-3]|1[01]|2[1-9]|[34][0-9]|5[01]|60)|" . "[4-6][0-9][0-9]|" . "7(?:[0-6][0-9]|7[01]))" . "|6(?:[0-5][0-9][0-9]|" . "6(?:[0-8][0-9]|9[01])|" . "[78][0-9][0-9]|" . "9(?:[0-8][0-9]|9[0-3]))" . "|7(?:[0-3][0-9][0-9]|" . "4(?:0[0-9]|1[0-3]|2[1-9]|[3-9][0-9])|" . "5(?:[0-6][0-9]|7[0-3]))" . "|8(?:[0-2][0-9][0-9]|" . "3(?:[0-5][0-9]|6[0-3]|8[0-5])|" . "4(?:0[1-9]|[1-9][0-9])|" . "[5-8][0-9][0-9]|" . "9(?:[0-8][0-9]|9[0-3]))" . "|9(?:[0-6][0-9][0-9]|" . "7(?:[0-7][0-9]|8[0-2])|" . "8(?:[0-6][0-9]|7[0-3])|" . "9(?:[0-8][0-9]|9[0-2]))" . ")", # # Postal codes of the form: 'DDDD', with the first digit representing # the province; the others distribution sectors. Postal codes do not # start with a zero. Not all combinations are in use. # # Data from http://download.geonames.org/export/zip/BE.zip # Belgium => "(?k:1(?:0(?:0[05-9]|1[0-2]|20|3[01]|4[013-57-9]|50|60|70|8[0-3]|90)|" . "1(?:0[05]|10|20|30|40|50|60|70|80|90)|" . "2(?:0[01]|1[02])|" . "3(?:0[01]|1[05]|2[05]|3[0-2]|4[0-28]|5[07]|6[07]|70|80|90)|" . "4(?:0[0-24]|1[04]|2[018]|3[05]|40|5[07]|6[01]|" . "7[0-46]|80|9[05])|" . "5(?:0[0-2]|4[017]|60|70)|" . "6(?:0[0-2]|20|30|40|5[0-4]|7[0134])|" . "7(?:0[0-3]|3[01]|4[0-25]|5[05]|6[01]|70|8[05]|90)|" . "8(?:0[04]|18|20|3[01]|40|5[0-3]|6[01]|80)|" . "9(?:10|3[0-4]|50|70|8[0-2]))" . "|2(?:0(?:00|18|20|30|40|50|60|70)|" . "1(?:00|10|40|50|60|70|80)|" . "2(?:00|2[0-3]|3[05]|4[023]|50|60|7[05]|8[08]|90)|" . "3(?:00|10|2[0-38]|30|40|50|60|70|8[0-27]|90)|" . "4(?:00|3[01]|40|50|60|70|80|9[01])|" . "5(?:00|20|3[01]|4[07]|50|60|70|80|90)|" . "6(?:00|10|2[07]|30|40|50|60)|" . "8(?:0[01]|1[12]|20|30|4[05]|50|6[01]|70|80|90)|" . "9(?:00|10|20|30|40|50|60|70|80|90))" . "|3(?:0(?:0[01]|1[028]|20|40|5[0-4]|6[01]|7[018]|80|90)|" . "1(?:1[018]|2[08]|30|40|50|9[01])|" . "2(?:0[0-2]|1[0-2]|2[01]|7[0-2]|9[034])|" . "3(?:00|2[01]|50|60|70|8[014]|9[01])|" . "4(?:0[014]|40|5[04]|6[01]|7[0-3])|" . "5(?:0[01]|1[0-2]|20|30|4[05]|50|60|70|8[0-3]|90)|" . "6(?:00|2[01]|3[01]|40|50|6[058]|70|80|90)|" . "7(?:00|17|2[0-4]|3[02]|4[026]|70|9[0-38])|" . "8(?:0[036]|3[0-2]|40|50|70|9[01])|" . "9(?:00|10|20|30|4[015]|50|60|7[01]|80|90))" . "|4(?:0(?:00|20|3[0-2]|4[0-2]|5[0-3]|90)|" . "1(?:0[0-2]|2[0-2]|30|4[01]|51|6[0-3]|7[01]|8[01]|90)|" . "2(?:1[07-9]|5[02-47]|6[013]|8[07])|" . "3(?:00|17|4[027]|5[017]|6[07])|" . "4(?:00|20|3[0-2]|5[0-38]|60|70|80)|" . "5(?:00|20|3[07]|40|5[07]|60|7[07]|90)|" . "6(?:0[0-26-8]|10|2[0134]|3[0-3]|5[0-4]|7[0-2]|8[0-4]|90)|" . "7(?:0[01]|1[01]|2[018]|3[01]|50|6[01]|7[01]|8[02-4]|9[01])|" . "8(?:0[0-2]|2[01]|3[0147]|4[015]|5[0-2]|6[01]|7[07]|80|90)|" . "9(?:00|10|20|50|60|70|8[037]|90))" . "|5(?:0(?:0[0-4]|2[0-24]|3[0-2]|60|70|8[01])|" . "1(?:0[01]|40|50|70|90)|" . "3(?:00|10|3[02-46]|40|5[0-4]|6[0-4]|7[02467]|80)|" . "5(?:0[0-4]|2[0-4]|3[07]|4[0-4]|5[05]|6[0-4]|7[0-6]|80|90)|" . "6(?:00|2[01]|30|4[0146]|5[01]|60|70|80))" . "|6(?:0(?:0[01]|10|20|3[0-2]|4[0-4]|6[01])|" . "1(?:1[01]|20|4[0-2]|50|8[0-3])|" . "2(?:00|1[01]|2[0-4]|3[08]|40|50|80)|" . "4(?:4[01]|6[0-4]|70)|" . "5(?:00|11|3[0-46]|4[023]|6[07]|9[0-46])|" . "6(?:00|3[07]|4[02]|6[0-36]|7[0-4]|8[016-8]|9[028])|" . "7(?:0[046]|17|2[0134]|30|4[0-37]|50|6[0-279]|8[0-2]|9[0-2])|" . "8(?:00|1[0-3]|2[0134]|3[0-468]|40|5[0-36]|60|70|8[07]|90)|" . "9(?:00|2[0-2479]|4[01]|5[0-3]|60|7[0-2]|8[02-467]|9[07]))" . "|7(?:0(?:00|1[0-2]|2[0-24]|3[0-4]|4[01]|50|6[0-3]|70|80|90)|" . "1(?:00|10|20|3[0134]|4[01]|60|70|8[01]|9[01])|" . "3(?:0[01]|2[0-2]|3[0-4]|40|50|70|8[027]|90)|" . "5(?:0[0-46]|2[0-2]|3[0-468]|4[0238])|" . "6(?:0[0-48]|1[018]|2[0-4]|4[0-3])|" . "7(?:00|1[12]|30|4[023]|50|60|8[0-4])|" . "8(?:0[0-4]|1[0-2]|2[23]|30|50|6[0-46]|70|80|90)|" . "9(?:0[01346]|1[0-2]|4[0-3]|5[01]|7[0-3]))" . "|8(?:0(?:00|20)|" . "2(?:00|1[01])|" . "3(?:0[01]|10|40|7[07]|80)|" . "4(?:00|2[01]|3[0-4]|50|60|70|80|90)|" . "5(?:0[01]|1[01]|20|3[01]|40|5[0-4]|60|7[023]|8[0-37])|" . "6(?:00|10|20|30|4[07]|50|60|70|80|9[01])|" . "7(?:00|10|20|30|40|5[05]|60|70|80|9[0-3])|" . "8(?:00|10|20|30|40|5[01]|60|70|80|90)|" . "9(?:0[02468]|20|30|40|5[0-46-8]|7[028]|80))" . "|9(?:0(?:00|3[0-2]|4[0-2]|5[0-2]|60|70|80|90)|" . "1(?:00|1[12]|20|30|40|50|60|70|8[05]|90)|" . "2(?:00|20|30|40|5[05]|60|70|80|90)|" . "3(?:0[08]|10|20|40)|" . "4(?:0[0-46]|20|5[01]|7[023])|" . "5(?:0[06]|2[01]|5[0-2]|7[0-2])|" . "6(?:00|20|3[06]|6[017]|8[018]|90)|" . "7(?:00|50|7[0-2]|90)|" . "8(?:00|10|20|3[01]|40|50|60|70|8[01]|90)|" . "9(?:00|10|2[01]|3[0-2]|40|50|6[018]|7[01]|8[0-28]|9[0-2]))" . ")", # # Postal codes of the form: 'DDDD', with the first digit representing # the distribution region, the second digit the distribution district. # Postal codes do not start with a zero. Postal codes starting with '39' # are in Greenland, and not included in the pattern. # Denmark => "(?k:0(?:800|" . "9(?:00|17|60|99))" . "|1(?:0(?:00|5[0-9]|6[0-9]|7[0-4]|9[2358])|" . "1(?:0[0-7]|1[0-9]|2[0-9]|3[01]|4[078]|5[0-9]|6[0-24-9]|" . "7[0-5])|" . "2(?:0[0-9]|1[013-9]|2[01]|40|5[013-79]|6[013-8]|7[01]|91)|" . "3(?:0[0-46-9]|1[0-9]|2[0-9]|5[02-9]|6[0-9]|7[01])|" . "4(?:0[0-36-9]|1[0-9]|2[0-9]|3[0-9]|4[018]|5[0-9]|" . "6[02-46-8]|7[0-2])|" . "5(?:00|13|3[23]|5[0-9]|6[0-46-9]|7[0-7]|9[29])|" . "6(?:0[0-46-9]|1[0-9]|2[0-4]|3[0-5]|5[0-9]|6[0-9]|7[0-7]|99)|" . "7(?:0[0-9]|1[0-24-9]|2[0-9]|3[0-9]|49|5[0-9]|6[0-6]|" . "7[0-57]|8[05-7]|9[09])|" . "8(?:0[0-9]|1[0-9]|2[02-9]|5[0-7]|6[0-8]|7[0-9])|" . "9(?:0[0-689]|1[0-7]|2[0-8]|5[0-9]|6[0-7]|7[0-4]))" . "|2(?:000|" . "1(?:00|50)|" . "200|" . "300|" . "4(?:00|50)|" . "500|" . "6(?:0[05]|10|2[05]|3[05]|40|50|6[05]|70|80|90)|" . "7(?:00|20|30|40|50|6[05]|70|91)|" . "8(?:00|20|30|40|50|60|70|80)|" . "9(?:00|20|30|42|50|60|70|80|90))" . "|3(?:0(?:00|50|60|70|80)|" . "1(?:00|20|40|50)|" . "2(?:00|10|20|30|50)|" . "3(?:00|10|20|30|60|70|90)|" . "4(?:00|50|60|80|90)|" . "5(?:00|20|40|50)|" . "6(?:00|30|50|60|70)|" . "7(?:00|20|30|40|51|60|70|82|90))" . "|4(?:0(?:00|30|40|50|60|70)|" . "1(?:00|30|40|60|7[134]|80|90)|" . "2(?:00|20|30|4[1-3]|50|6[12]|70|81|9[1356])|" . "3(?:00|20|30|40|50|60|70|90)|" . "4(?:00|20|40|50|60|70|80|90)|" . "5(?:00|20|3[24]|40|50|60|7[1-3]|8[13]|9[1-3])|" . "6(?:00|2[1-3]|32|40|5[2-4]|60|7[1-3]|8[1-4]|90)|" . "7(?:00|20|3[356]|50|60|7[1-3]|80|9[1-3])|" . "8(?:00|40|50|6[23]|7[1-4]|80|9[1245])|" . "9(?:00|1[23]|20|30|4[134]|5[1-3]|60|70|83|90))" . "|5(?:000|" . "2(?:00|10|20|30|40|50|60|70|90)|" . "3(?:00|20|30|50|70|80|90)|" . "4(?:00|50|6[2-46]|7[14]|85|9[12])|" . "5(?:00|40|50|60|80|9[12])|" . "6(?:00|10|20|31|42|72|83|90)|" . "7(?:00|50|62|7[12]|92)|" . "8(?:00|5[346]|63|7[14]|8[1-4]|92)|" . "9(?:00|3[25]|53|60|70|85))" . "|6(?:0(?:00|40|5[12]|64|70|9[1-4])|" . "100|" . "2(?:00|30|40|61|70|80)|" . "3(?:00|10|20|30|40|60|72|92)|" . "4(?:00|30|40|70)|" . "5(?:00|10|20|3[45]|41|60|80)|" . "6(?:00|2[1-3]|30|40|50|60|70|8[23]|90)|" . "7(?:0[05]|1[05]|20|31|40|5[23]|60|71|80|92)|" . "8(?:00|18|23|30|40|5[1-57]|62|70|80|93)|" . "9(?:00|20|33|40|50|60|7[13]|80|90))" . "|7(?:0(?:0[07]|80)|" . "1(?:00|20|30|40|50|60|7[13]|8[2-4]|90)|" . "2(?:00|50|60|70|80)|" . "3(?:00|2[13]|30|6[12])|" . "4(?:00|30|4[12]|51|70|80|90)|" . "5(?:00|40|50|60|70)|" . "6(?:00|20|50|60|73|80)|" . "7(?:00|30|4[12]|5[25]|60|70|90)|" . "8(?:00|30|40|50|60|70|84)|" . "9(?:00|50|60|70|80|90))" . "|8(?:000|" . "2(?:00|10|20|30|4[05]|50|60|70)|" . "3(?:0[05]|10|20|30|40|5[05]|6[12]|70|8[0-2])|" . "4(?:00|10|20|44|50|6[24]|7[12])|" . "5(?:00|20|30|4[134]|50|60|70|8[156]|92)|" . "6(?:00|20|32|4[13]|5[34]|60|70|80)|" . "7(?:00|2[1-3]|32|40|5[12]|6[2356]|8[13])|" . "8(?:00|3[0-2]|40|50|60|70|8[1-3])|" . "9(?:00|20|30|40|50|6[013]|70|8[13]|90))" . "|9(?:000|" . "2(?:00|10|20|30|40|60|70|80|93)|" . "3(?:00|10|20|30|40|52|62|70|8[0-2])|" . "4(?:00|30|40|60|80|9[023])|" . "5(?:00|10|20|30|41|50|60|7[45])|" . "6(?:00|10|20|3[12]|40|70|81|90)|" . "7(?:00|40|50|60)|" . "8(?:00|30|50|70|81)|" . "9(?:00|40|70|8[12]|90))" . ")", # # 5 Digit postal code, with leading 0s. # # Codes starting with 980 are reserved for Monaco, and not recognized # by the pattern. # # Data from: http://download.geonames.org/export/zip/FR.zip # France => "(?k:0(?:1(?:0(?:0[0-9]|1[0-9]|20|59|6[019]|90)|1(?:0[0-9]|" . "1[0-25-7]|2[0-9]|30|40|5[0-58]|60|7[0-4]|90)|" . "2(?:0[0-468]|1[0-367]|20|30|40|50|60|70|80|90)|" . "3(?:0[0-36]|10|20|30|40|50|6[0569]|70|80|90)|4(?:00|" . "10|20|30|4[0-3]|50|60|70|80)|5(?:0[0-68]|10|40|50|60|" . "70|80|90)|6(?:0[0-46]|3[02378]|40|60|80)|7(?:0[0-8]|" . "10|50)|8(?:00|51)|9(?:21|60|90))|" . "2(?:0(?:0[0-9]|1[0-9]|2[05])|1(?:0[0-9]|10|20|30|40|5[01]|" . "60|70|90)|2(?:0[0-9]|10|20|30|40|50|60|70|90)|" . "3(?:0[0-39]|1[045]|2[0-79]|3[01]|40|50|60|70|80|90)|" . "4(?:0[0-79]|10|20|30|40|50|60|70|80|90)|5(?:00|10|20|" . "40|50|70|80|90)|6(?:0[0-49]|10|20|30|40|50|70|80|90)|" . "7(?:00|20|60|90)|8(?:00|10|20|30|40|50|60|70|80)|" . "93[09])|" . "3(?:0(?:0[03-8]|1[0-9]|21)|1(?:0[0-9]|10|20|30|40|50|60|" . "70|90)|2(?:0[0-9]|10|20|30|40|50|60|70|90)|" . "3(?:0[0-79]|1[01459]|2[019]|30|40|50|60|70|80|90)|" . "4(?:0[0-3569]|10|20|30|40|5[02]|60|70)|5(?:00|10)|" . "6(?:00|30)|700|800)|" . "4(?:0(?:0[0-69]|1[0-9]|29)|1(?:0[0-7]|1[09]|20|30|40|50|" . "60|70|80|90)|2(?:0[0-39]|10|20|30|40|50|60|70|80|90)|" . "3(?:0[01]|10|20|30|40|50|60|70|80)|4(?:00|10|20)|" . "5(?:00|10|30)|6(?:00|60)|700|8(?:00|50|60|70)|99[05])|" . "5(?:0(?:0[0-8]|1[0-24-69])|1(?:0[0-57]|10|20|30|40|50|60|" . "70|90)|2(?:0[0-289]|20|30|40|50|60|90)|3(?:00|10|20|" . "30|40|50|80)|4(?:00|60|70|80)|5(?:00|60)|600|700|800)|" . "6(?:0(?:0[0-9]|1[0-36]|3[2-6]|4[4-9]|5[03]|7[1389]|8[2-5]|" . "99)|1(?:0[0-35-9]|1[03-79]|2[156]|3[0-35-79]|4[0-3]|" . "5[0-7]|6[0-247]|7[0-357]|8[0-79]|90)|2(?:0[0-69]|" . "1[0-2]|2[0-9]|3[0-9]|4[0-2]|5[0-579]|60|7[0-2]|" . "8[1-46-9]|9[02-59])|3(?:0[0-69]|10|20|30|4[0-589]|" . "5[2-47-9]|6[049]|7[0-369]|80|9[0-2])|4(?:0[0-8]|1[04]|" . "20|30|40|50|60|70|80)|5(?:0[0-8]|1[013-8]|20|3[0-245]|" . "40|50|60|70|80|90)|6(?:0[0-79]|10|20|3[1-4]|40|50|" . "6[06]|70|90)|7(?:0[0-689]|10|2[13]|30|40|50|90)|" . "8(?:0[0-68]|10|2[569]|3[013]|50|91)|9(?:0[1-69]|" . "1[02-5]|2[12589]|50|99))|" . "7(?:00[0-7]|1(?:0[0-9]|10|20|3[0-9]|40|50|60|70|90)|" . "2(?:0[0-9]|10|20|30|40|50|60|70|90)|3(?:0[0-9]|10|20|" . "30|40|50|60|70|80)|4(?:0[0-9]|10|30|40|50|60|70)|" . "5(?:0[0-9]|10|20|30|60|70|80|90)|6(?:00|10|30|60|90)|" . "7(?:00|90)|800)|" . "8(?:0(?:0[0-6]|1[0134]|9[089])|1(?:0[1-79]|10|20|30|40|50|" . "60|70|90)|2(?:0[0-9]|10|20|30|40|50|60|70|90)|" . "3(?:0[02-5]|10|20|30|50|60|70|80|90)|4(?:00|10|30|40|" . "50|60)|500|600|700|800)|" . "9(?:0(?:0[0-47-9]|1[4-7])|1(?:0[0-59]|10|20|30|40|60|90)|" . "2(?:0[019]|10|20|30|40|50|70|90)|3(?:0[01]|10|20|30|" . "40|50|90)|4(?:0[01]|20|60)|500|600|700|800))" . "|1(?:0(?:0(?:0[0-9]|1[0-58]|2[56]|3[0-2]|42|8[0189]|9[126])|" . "1(?:0[0-5]|10|2[0-28]|30|40|5[0-4]|60|70|80|90)|" . "2(?:0[0-28]|10|20|30|40|50|60|70|80|90)|3(?:00|10|20|" . "30|40|5[0-35]|60|7[01]|80|90)|4(?:0[0-4]|10|20|3[0-3]|" . "40|50)|5(?:00|10)|60[0-356]|700|800|9(?:0[12]|10))|" . "1(?:0(?:0[0-579]|1[0-25-7]|2[0-29])|1(?:0[0-9]|10|20|30|" . "40|50|60|70|90)|2(?:0[0-589]|10|20|30|40|50|60|70|90)|" . "3(?:0[0134]|10|20|30|40|50|60|70|80|90)|4(?:0[0-29]|" . "10|20|30|40|5[1-3]|80|9[0-4])|5(?:00|10|40|60|70|80|" . "90)|6(?:00|10|20)|7(?:00|8[12459]|90)|8(?:0[0235-8]|" . "1[06]|23|3[3568]|48|5[05]|60|7[05-8]|8[05]|9[08]))|" . "2(?:0(?:0[0-357-9]|19|2[0-9]|3[0-59]|40)|1(?:0[0-4689]|10|" . "20|30|40|50|60|70|90)|2(?:0[0-4]|10|20|30|40|50|60|70|" . "90)|3(?:00|10|20|30|40|50|60|70|80|90)|4(?:0[0-2]|10|" . "20|30|40|50|60|70|80|90)|5(?:00|10|20|40|50|60|80)|" . "6(?:00|20|30|40)|7(?:00|20|40|80)|8(?:00|50))|" . "3(?:0(?:0[0-9]|1[0-6]|20|6[67]|8[0589]|9[0-9])|1(?:0[0-9]|" . "1[0-9]|2[0-46-9]|3[0-389]|4[0-289]|5[0-35-9]|" . "6[013-589]|7[078]|8[0-2]|9[0-26])|2(?:0[0-3579]|" . "1[013-9]|2[0-8]|3[0-69]|4[0-589]|5[0-9]|6[0-9]|7[0-9]|" . "8[0-24-9]|9[0-9])|3(?:0[0-46-9]|1[0-9]|2[0-8]|" . "3[0-589]|4[02-8]|5[0-24-79]|6[0-46-9]|7[0-24-9]|" . "8[0-9]|9[0-79])|4(?:0[0-46]|1[0-7]|2[014-68]|3[0-245]|" . "4[0-8]|5[0-8]|6[02-47]|7[0-48]|8[0-49]|9[03])|" . "5(?:0[0-3]|1[0-4689]|2[0-589]|3[0-389]|4[0-35-9]|" . "5[0-289]|6[06-8]|7[02]|8[013]|9[0-49])|6(?:0[0-9]|" . "1[0-24-79]|2[015-9]|3[0-357]|4[0-369]|5[0-689]|6[0-9]|" . "7[0-8]|8[013-57-9]|9[0-9])|7(?:0[0-589]|1[02-9]|" . "2[0-9]|3[0-3]|4[0-79]|5[0-257-9]|6[046]|7[0-9]|" . "8[0-59]|9[0-9])|8(?:0[0-9]|1[02-5]|2[0-589]|3[0-689]|" . "4[0-24-7]|5[0-9]|6[0-478]|70|8[01379]|9[05])|" . "9(?:0[024-8]|1[01]|2[0-4]|3[0-37]|4[0-2]|50|60|80|90))|" . "4(?:0(?:0[05-9]|1[0-9]|2[03-9]|3[0-9]|4[05-8]|5[0-489]|" . "6[1-7]|7[04-9]|8[1-69]|9[0-9])|1(?:0[0-9]|1[0-47]|" . "2[0135-8]|30|40|50|6[0-258]|70|90)|2(?:0[0-57-9]|10|" . "20|30|40|50|60|70|80|90)|3(?:10|20|30|40|50|60|70|80|" . "90)|4(?:0[0-9]|10|20|30|40|50|6[0-29]|70|80|90)|" . "5(?:0[0-589]|10|20|30|40|50|70|90)|6(?:0[0-3]|10|20|" . "30|40|5[0-49]|70|80|90)|7(?:00|10|30|40|50|60|70|80|" . "9[01])|8(?:0[0-9]|10|30|40|50|60|80)|9(?:0[1-9]|" . "1[0-69]|2[0-6]|3[0-4]|4[09]|50|60|70|80|90))|" . "5(?:0(?:0[0-8]|1[0-57-9])|1(?:0[0-79]|10|20|30|40|50|60|" . "70|90)|2(?:00|10|2[09]|30|40|50|60|70|90)|3(?:00|10|" . "20|40|50|80)|4(?:00|30)|5(?:00|90)|600|700|800)|" . "6(?:0(?:0[0-8]|1[0-9]|2[0-6])|1(?:0[0-9]|1[0-3]|2[01]|30|" . "40|50|60|70|90)|2(?:00|10|20|30|40|50|60|70|90)|" . "3(?:00|10|20|30|40|50|60|70|80|90)|4(?:00|10|20|30|40|" . "50|60|70|80|90)|5(?:00|10|60|70|90)|6(?:00|20)|7(?:00|" . "10|20|30)|800|9(?:0[1-9]|1[0-9]|2[09]|5[0-59]|99))|" . "7(?:0(?:0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-5]|5[1-6]|" . "7[1-689]|8[6-9])|1(?:0[0-9]|1[0-9]|2[013]|3[0236-9]|" . "40|50|60|70|8[0-9]|90)|2(?:0[0-9]|1[0145]|20|30|40|50|" . "60|70|8[1459]|90)|3(?:0[0-9]|1[0-4]|20|30|40|50|60|70|" . "80|90)|4(?:00|1[0-69]|20|30|4[0-69]|50|60|70|80|90)|" . "5(?:0[0-49]|10|20|30|40|50|60|70|80|90)|6(?:00|10|20|" . "30|40|50|70|90)|7(?:00|30|40|50|70|80)|8(?:00|10|40|" . "70|80|90)|9(?:20|40))|" . "8(?:0(?:0[0-7]|1[2-69]|2[0-9]|3[0-79])|1(?:0[0-9]|10|20|" . "30|40|50|60|70|90)|2(?:0[0-7]|10|20|30|40|50|60|70|" . "90)|3(?:00|10|20|30|40|50|60|70|80|90)|4(?:00|10)|" . "5(?:00|10|20|70)|600|700|800|9(?:1[01]|2[02-4]|3[459]|" . "4[015]|98))|" . "9(?:0(?:0[0-79]|1[1257-9]|33)|1(?:0[0-9]|1[01346-9]|20|30|" . "40|50|60|70|90)|2(?:0[0-489]|10|20|3[0-2]|40|50|60|70|" . "90)|3(?:00|1[0-9]|20|30|40|50|6[01]|70|80|90)|4(?:00|" . "10|30|50|60|70|90)|5(?:00|10|20|50|60)|600|700|800))" . "|2(?:0(?:0(?:00|90)|1(?:00|1[0-9]|2[1-9]|3[0-9]|4[0-8]|5[0-37]|" . "6[02-9]|7[0-9]|8[0-9]|9[0-57-9])|2(?:00|1[2-57-9]|" . "2[0-9]|3[0-9]|4[02-8]|5[0-369]|60|7[02569]|8[7-9]|" . "9[0-9])|3(?:0[2-69]|11)|4(?:0[1-35-9]|1[0-46-9])|" . "5(?:0[1-4]|3[78])|6(?:0[014]|11|20)|70[0-3]|900)|" . "1(?:0(?:0[0-9]|1[0-9]|2[1-9]|3[0-9]|4[0-9]|5[1-9]|" . "6[0-35-9]|7[0-9]|8[013-689]|9[2378])|1(?:10|2[01]|30|" . "40|50|60|70|90)|2(?:0[0-9]|1[09]|20|30|40|50|6[0-2]|" . "70|90)|3(?:0[0-59]|10|20|30|40|50|60|70|80|90)|" . "4(?:0[0-39]|10|20|30|40|50|60|70|90)|5(?:0[0-269]|10|" . "20|30|40|50|60|70|80|90)|6(?:0[0-49]|10|30|40|90)|" . "7(?:0[0-59]|19|60)|8(?:0[0-369]|20|50)|9(?:00|10|98))|" . "2(?:0(?:0[0-5]|1[4-7]|2[1-79]|3[1-5]|4[1-69]|7[09]|8[09]|" . "9[1-35689])|1(?:0[0-9]|1[01]|20|30|40|50|60|70|" . "9[0-69])|2(?:0[0-69]|10|20|30|40|50|60|70|90)|" . "3(?:0[0-9]|10|20|30|40|50|60|70|80|90)|4(?:0[02-59]|" . "10|20|30|40|50|60|70|80|90)|5(?:0[0-59]|10|20|30|40|" . "50|60|70|80|90)|6(?:0[02-79]|10|20|30|40|50|60|80|90)|" . "7(?:00|10|20|30|40|50|70|80)|8(?:00|10|20|30|60|70)|" . "9(?:30|40|50|60|70|80))|" . "3(?:0(?:0[0-9]|1[13-6]|20)|1(?:00|10|20|30|40|50|60|70|" . "90)|2(?:00|10|20|30|40|50|60|70|90)|3(?:00|20|40|50|" . "60|80)|4(?:00|20|30|50|60|80)|500|600|700|800)|" . "4(?:0(?:0[0-579]|1[0-79]|2[0249]|5[0-359]|60)|" . "1(?:0[0-24-9]|1[0-4]|2[0-2]|30|40|50|60|70|90)|" . "2(?:0[0-689]|1[02]|20|30|40|50|60|70|90)|3(?:00|10|20|" . "30|40|50|60|70|80|90)|4(?:00|10|20|30|40|50|60|70|80|" . "90)|5(?:00|10|20|30|40|50|60|70|80|90)|6(?:00|10|20|" . "30|40|50|60|80)|7(?:00|5[0-2589])|800|9(?:1[0235]|26))|" . "5(?:0(?:0[0-9]|1[0-9]|2[0-79]|3[0-9]|4[0-9]|5[0-246-9]|" . "6[0-389]|7[0-359]|8[02-79]|9[089])|1(?:1[0-9]|20|30|" . "40|50|60|70|90)|2(?:0[0-9]|1[0-9]|20|30|40|50|60|70|" . "90)|3(?:0[0-49]|10|20|30|40|50|60|70|80|90)|" . "4(?:0[0-69]|10|20|30|40|50|6[0-29]|7[09]|80|90)|" . "5(?:0[0-489]|10|20|30|50|60|70|80)|6(?:0[0-9]|10|20|" . "30|40|50|60|80|90)|7(?:0[0-26-9]|20|50|70|90)|8(?:00|" . "20|40|70)|9(?:09|20|3[0-3]|60))|" . "6(?:0(?:0[0-9]|1[0-5]|2[1-9]|3[0-2])|1(?:0[0-9]|1[019]|20|" . "3[01]|40|50|60|70|9[09])|2(?:0[0-9]|1[056]|20|30|" . "4[0-49]|50|60|70|90)|3(?:0[0-49]|10|20|30|40|50|80|" . "90)|4(?:0[0-29]|10|20|50|60|70)|5(?:0[0-49]|10|30|40|" . "60|70)|6(?:0[0-39]|20)|7(?:0[0-29]|30|40|50|6[01]|70|" . "80|90)|80[0-29]|9(?:0[1-79]|5[0-68]))|" . "7(?:0(?:0[0-9]|1[0235-9]|2[1-356]|3[0-9]|40|9[0-9])|" . "1(?:0[0-9]|10|2[0-27]|3[0-8]|40|50|60|70|80|90)|" . "2(?:0[0-9]|10|20|30|40|50|60|70|90)|3(?:0[0-9]|10|20|" . "30|40|50|60|70|80|90)|4(?:0[0-79]|10|20|30|40|50|60|" . "70|80|90)|5(?:0[0-9]|10|20|30|40|50|60|70|80|90)|" . "6(?:0[07]|10|20|30|40|50|60|70|80|90)|7(?:0[0-35]|10|" . "20|30|40|50|60|70|80|90)|8(?:00|10|20|30|50|60|70|90)|" . "9(?:09|1[014]|2[0489]|3[0-369]|4[09]|50))|" . "8(?:0(?:0[0-9]|1[189]|2[3-69]|3[3-9]|4[04]|8[08])|" . "1(?:0[0-689]|1[0-49]|20|3[0-3]|40|50|60|70|90)|" . "2(?:0[0-3579]|1[01]|20|3[0-24]|40|50|60|70|90)|" . "3(?:0[0-59]|10|20|30|40|50|60|80)|4(?:0[0-49]|10|" . "8[019])|50[01]|6(?:00|3[0-3679])|70[0-379]|800|9(?:01|" . "10|20|3[0-35]|44|50))|" . "9(?:0(?:00|18|80)|1(?:0[0-9]|2[0-59]|40|50|60|7[0-4679]|" . "8[0-79]|9[0-369])|2(?:0[06-9]|1[0-37-9]|2[0-57-9]|" . "3[138]|4[0-26]|5[0239]|60|70|8[029]|9[09])|3(?:00|10|" . "2[0-8]|3[0-7]|40|50|60|70|80|9[0-9])|4(?:0[0-4679]|" . "1[0-49]|20|30|40|5[05]|60|70|80|90)|5(?:00|10|20|30|" . "40|5[0-9]|6[013]|70|90)|6(?:0[0269]|10|20|30|40|50|60|" . "7[0-489]|8[0-2489]|90)|7(?:00|10|20|30|40|50|60|70|80|" . "90)|8(?:0[0-46-9]|10|2[0457]|3[03-79]|40|50|60|70|80|" . "90)|9(?:00|10|20|30|40|50|70|80|90)))" . "|3(?:0(?:0(?:0[0-36-9]|1[0-9]|2[0-589]|3[1-69]|4[04589]|" . "5[015])|1(?:0[0-79]|1[0-2459]|2[0-9]|3[0-49]|40|50|60|" . "70|90)|2(?:0[0-79]|10|20|30|40|5[0-35]|60|70|90)|" . "3(?:0[0-2]|1[01389]|20|30|40|50|60|80|90)|4(?:0[0-69]|" . "10|20|30|40|50|60|70|80|90)|5(?:00|10|20|30|40|60|70|" . "80)|6(?:00|10|20|30|40|50|60|70)|7(?:0[0-3]|20|30|40|" . "50|60|70)|8(?:00|20|40|70)|9(?:0[013-8]|1[0-48]|" . "2[0-59]|3[124-79]|4[0-37]|6[09]|7[125]|80))|" . "1(?:0(?:0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|6[0-9]|" . "7[0-9]|8[0-24-689]|9[0-9])|1(?:0[0-4679]|1[02]|2[0-9]|" . "3[0-9]|4[0-29]|5[0-259]|60|70|8[09]|90)|2(?:0[013-5]|" . "10|20|30|4[0-59]|50|60|70|8[09]|90)|3(?:00|1[02-579]|" . "2[0-2569]|30|40|50|60|70|8[09]|90)|4(?:0[0-6]|10|20|" . "3[02]|40|50|60|70|8[09]|90)|5(?:0[03-7]|1[02]|" . "2[0-249]|30|40|50|60|70|8[09]|90)|6(?:0[0-689]|2[019]|" . "50|60|7[0-9]|8[1-359]|92)|7(?:0[0-9]|1[1256]|50|" . "7[0-4679]|80|90)|8(?:0[0-79]|10|20|3[0-29]|40|50|60|" . "70|80)|9(?:0[0-3]|31|4[57]|5[078]|6[02]|9[89]))|" . "2(?:0(?:0[0-57-9]|1[0-46-9]|2[0-2])|1(?:00|10|2[09]|30|40|" . "50|60|70|90)|2(?:0[019]|20|30|40|50|60|70|90)|3(?:00|" . "10|20|30|40|50|60|70|80|90)|4(?:00|10|20|30|40|50|60|" . "80|90)|5(?:0[0-259]|50)|600|7(?:00|20|30)|8(?:00|10))|" . "3(?:0(?:0[0-24-9]|1[0-259]|2[013-9]|3[0-8]|4[0-37-9]|" . "5[0-9]|6[0-9]|7[0-9]|8[0-9]|9[0-9])|1(?:00|1[02-6]|" . "2[013-7]|3[038]|4[018]|5[0-35]|6[04-79]|7[0-5]|" . "8[05-7]|9[0-3])|2(?:00|1[0-49]|20|30|40|50|60|" . "7[0-489]|9[0-5])|3(?:0[0569]|1[0-49]|2[0-4679]|3[05]|" . "4[01]|50|60|70|80|9[0-5])|4(?:0[0-59]|10|20|30|40|" . "5[0-2]|6[019]|70|80|9[0-25])|5(?:0[0-79]|1[05]|" . "2[0-79]|30|40|50|6[0-5]|70|80|90)|6(?:0[0-9]|1[0-5]|" . "2[015-79]|40|5[02]|60|70|8[089]|9[0-9])|7(?:0[0-9]|10|" . "20|3[0-9]|4[017]|50|60|70|80|90)|8(?:0[01]|10|20|30|" . "40|50|60|70|8[0-7]|90)|9(?:0[0-79]|1[0-589]|20|30|50|" . "70|80|9[08]))|" . "4(?:0(?:0[0-46-9]|1[0-2]|2[3-8]|3[02-57-9]|4[0-35689]|" . "5[13-68]|6[0-8]|7[0-9]|8[0235-79]|9[0-9])|1(?:1[0-9]|" . "20|3[0-27-9]|40|50|60|7[0-489]|8[13467]|9[0-9])|" . "2(?:0[0-479]|10|20|30|40|50|6[0-7]|7[04]|80|9[03-9])|" . "3(?:0[0-579]|10|20|30|40|50|60|70|80|9[0-46-9])|" . "4(?:0[0-49]|10|20|3[013-589]|40|50|60|7[037]|80|90)|" . "5(?:0[0-8]|1[03-8]|2[0-69]|3[04-79]|4[03-5]|50|6[04]|" . "70|90)|6(?:00|10|20|30|50|60|7[01]|80|90)|7(?:0[0-2]|" . "10|2[05]|30|4[0-27-9]|5[013]|60|70|90)|8(?:00|10|20|" . "30|50|7[1-5]|80)|9(?:00|2[0356]|3[2-57-9]|4[02-489]|" . "5[4-9]|6[0-2457]|7[02-57]|8[0-79]|90))|" . "5(?:0(?:0[0-9]|1[0-24-68]|2[0-46-9]|3[0-59]|4[02-79]|" . "5[0-57-9]|6[3-79]|7[013689]|8[0-9]|9[0-49])|" . "1(?:0[1-689]|1[134]|20|3[0-7]|40|50|6[0-469]|" . "7[0-24-7]|90)|2(?:0[0-57-9]|10|2[01]|3[056]|40|50|60|" . "70|90)|3(?:0[0-69]|10|20|30|4[0-259]|50|60|70|80|90)|" . "4(?:0[0-9]|1[0-9]|20|3[0-359]|40|50|60|70|80|90)|" . "5(?:0[0-79]|1[0-9]|2[01]|3[0-389]|40|50|60|7[1-46-9]|" . "80|90)|6(?:0[0-356]|10|20|30|40|5[0-39]|60|80|90)|" . "7(?:0[0-9]|11|20|30|4[0-46]|50|6[0-9]|7[0-2]|80)|" . "8(?:0[0-3]|3[0-3]|50|70|90)|9(?:0[0-9]|1[1-9]|2[01]|" . "60|98))|" . "6(?:0(?:0[0-9]|1[0-9]|2[0-9]|3[23])|1(?:0[0-579]|10|20|" . "3[01]|40|50|60|70|80|90)|2(?:00|10|20|30|40|5[05]|60|" . "70|90)|3(?:0[01]|10|20|30|40|50|60|70)|400|50[015]|" . "600|700|800|91[05])|" . "7(?:0(?:0[089]|1[0-9]|2[05-9]|3[2-589]|4[0-57-9]|5[89]|" . "6[01]|7[1-9]|8[0-29]|9[5-9])|1(?:00|10|20|30|40|5[02]|" . "60|7[0-59]|90)|2(?:0[04-69]|10|20|30|40|50|60|70|90)|" . "3(?:0[0-69]|10|2[01]|30|40|50|60|70|80|90)|" . "4(?:0[0-49]|20|60)|5(?:0[0-29]|10|2[01]|30|4[0-29]|" . "5[0-6])|60[0-29]|70[0-359]|800|9(?:1[0-357]|2[124-9]|" . "3[12]|4[12]))|" . "8(?:0(?:0[0-9]|1[0-9]|2[1-9]|3[0-79]|4[0-9]|5[0-4689]|" . "6[135-79]|7[047]|8[019]|9[0-36-9])|1(?:00|1[02-489]|" . "2[0-2]|3[048]|4[0246-8]|5[02-49]|6[0-59]|7[0-469]|80|" . "9[0167])|2(?:0[0-9]|1[016-9]|20|3[0-26]|4[0-469]|" . "5[06]|6[019]|70|80|9[0-35-79])|3(?:0[0-579]|1[1-579]|" . "2[0-2679]|3[0-4]|4[0-35-79]|5[0-46-9]|6[01]|70|80|90)|" . "4(?:0[0-9]|10|20|3[0-79]|40|50|60|70|80|90)|" . "5(?:0[0-9]|1[0169]|2[0-469]|30|40|5[0-79]|60|70|80|" . "9[01])|6(?:0[0-39]|10|20|30|40|50|60|70|80|90)|" . "7(?:0[0-26-9]|10|3[01]|40|50|6[01379]|70|8[0-249]|90)|" . "8(?:0[0-3]|1[67]|21|30|40|50|60|70|80|90)|9(?:00|13|" . "2[0167]|30|4[0134]|50|60|70|80))|" . "9(?:0(?:0[0-9]|1[056]|2[19]|3[0-9])|1(?:0[0-9]|10|20|30|" . "40|50|60|7[01]|8[019]|90)|2(?:0[0-9]|1[019]|20|30|40|" . "50|6[01]|70|90)|3(?:0[0-9]|10|20|30|50|60|70|80)|" . "4(?:0[0-9]|10|60)|5(?:0[0-2]|20|70)|60[0-359]|700|" . "80[0-9]))" . "|4(?:0(?:0(?:0[0-6]|1[1-35-9]|2[1-7]|90)|1(?:0[0-8]|1[058]|20|" . "30|4[01]|50|6[01]|70|80|90)|2(?:0[0-2]|10|20|3[0-259]|" . "40|50|60|70|8[0-26]|90)|3(?:0[0159]|10|20|30|50|60|70|" . "80|90)|4(?:00|10|20|30|40|6[05]|80)|5(?:0[0-2]|10|30|" . "50|60)|6(?:0[0-2]|30|60)|70[015]|80[015]|99[0-4])|" . "1(?:0(?:0[0-9]|1[0-35689]|2[0235689]|3[3-5]|4[23])|" . "1(?:0[0-3569]|10|2[0-2]|30|40|5[01]|60|70|90)|" . "2(?:0[0-7]|10|20|30|40|50|6[01]|70|90)|3(?:00|10|20|" . "30|5[03-57]|60|70)|40[0-26]|500|600|700|800|" . "9(?:0[13-689]|1[03-589]|2[145]|3[0-36]|4[1-3589]|" . "5[018]|6[03-8]|7[0-6]))|" . "2(?:0(?:0[0-9]|1[0-8]|2[1-9]|3[013]|4[1-357-9]|5[0589])|" . "1(?:00|1[014]|2[02-79]|3[01]|40|5[0235]|6[0-9]|" . "7[03469]|90)|2(?:10|20|30|40|60|7[0-35-79]|90)|" . "3(?:0[0-48]|1[0-58]|2[0-38]|3[02-59]|40|5[013-69]|60|" . "70|80|90)|4(?:0[0-9]|1[0-2]|20|30|40|50|60|70|8[0469]|" . "90)|5(?:0[0-359]|10|20|30|40|50|60|70|80|90)|" . "6(?:0[0-9]|10|20|30|40|5[013]|60|70|80)|7(?:0[0-579]|" . "20|40|50|80)|8(?:0[0-9]|10|20|30|40|90)|9(?:20|40|" . "5[0-589]|6[1-9]|90))|" . "3(?:0(?:0[0-689]|1[0-479])|1(?:0[0-3]|10|20|30|40|50|60|" . "70|90)|2(?:0[0-3]|10|20|30|40|50|60|70|90)|3(?:00|20|" . "30|40|50|60|70|80|90)|4(?:00|10|20|30|40|50|90)|" . "5(?:00|10|20|30|50|80|90)|6(?:00|20)|7(?:00|50|70)|" . "8(?:00|10))|" . "4(?:0(?:0[0-9]|1[0-9]|2[0-4]|3[2-68]|4[0-267]|9[02-579])|" . "1(?:0[0-79]|1[05-9]|2[0-469]|30|4[0-69]|5[0-9]|60|" . "7[069]|8[4-8]|9[0-689])|2(?:0[0-59]|1[0-79]|20|" . "3[0-69]|4[0-59]|50|6[0-358]|7[02-7]|90)|3(?:0[0-9]|" . "1[0-9]|2[0-9]|3[0-9]|4[0-69]|5[0-36-9]|60|7[0-39]|80|" . "90)|4(?:0[0-9]|1[02]|20|30|40|50|60|7[0-9]|8[0-4]|90)|" . "5(?:0[0-69]|10|2[0-2]|30|40|50|60|70|80|90)|" . "6(?:0[0-69]|1[0-8]|20|30|40|50|60|70|80|90)|" . "7(?:0[0-36-9]|10|20|30|40|50|60|70|80)|8(?:0[0-9]|" . "1[0-9]|2[1-49]|30|40|50|60|80)|9(?:00|1[1-9]|2[1-9]|" . "3[1-9]|4[124579]|5[1-9]|6[3-9]|7[1-8]|8[0-69]))|" . "5(?:0(?:0[0-9]|1[0-25-79]|2[13589]|3[0-58]|4[0-6]|" . "5[236-8]|6[0-57-9]|7[1-57-9]|8[1278])|1(?:00|10|" . "2[0-259]|30|4[0-79]|50|6[0-689]|70|90)|2(?:0[0-9]|" . "1[0-4]|20|30|40|50|60|70|90)|3(?:0[02-8]|1[02]|20|" . "3[01]|40|60|70|80|90)|4(?:0[0-469]|10|20|3[0-3]|50|60|" . "70|80|90)|5(?:0[0-4]|10|20|30|50|60|70|90)|6(?:00|20|" . "30|40|5[0156]|80)|7(?:0[0-29]|20|30|40|50|60|" . "7[01457])|8(?:0[0-9]|11)|9(?:00|1[0-35-9]|2[0-79]|" . "3[0-8]|4[3-9]|5[0-7]|6[0-9]|7[0-9]|80))|" . "6(?:0(?:0[0-589]|1[04-9]|2[0-3]|9[01])|1(?:0[0-36]|10|20|" . "30|40|50|60|70|90)|2(?:00|10|20|30|40|50|60|70)|" . "3(?:00|10|20|30|40|50|60)|400|500|600|700|800)|" . "7(?:0(?:0[02-8]|13|2[03]|3[0-29])|1(?:10|20|30|40|50|60|" . "70|80|90)|2(?:0[0-57-9]|1[013]|20|30|40|50|60|70|90)|" . "3(?:0[0-57-9]|10|20|30|40|50|60|70|80|90)|4(?:00|10|" . "20|30|40|50|70|80)|5(?:0[0-2]|10|20|5[0-359])|600|700|" . "800|9(?:0[19]|1[0-8]|2[0-59]|31))|" . "8(?:00[0-35-9]|1(?:00|10|20|30|40|50|60|70|90)|2(?:00|10|" . "20|30|40|50|60|70)|3(?:00|10|20|30|40|70)|400|500|600|" . "700|800)|" . "9(?:0(?:0[0-46-9]|1[014-8]|2[0-468]|3[2356]|4[13-79]|" . "5[1-359]|66|7[0-29]|80)|1(?:0[0-79]|1[0-25-79]|" . "2[02-5]|3[05-79]|40|50|60|70|8[0-4]|90)|2(?:20|30|" . "4[0-59]|50|60|70|80|90)|3(?:0[0-9]|1[0-249]|2[0157-9]|" . "30|40|50|60|70|80|90)|4(?:0[0-689]|1[0-578]|2[015-8]|" . "30|40|5[068]|60|8[0146]|90)|5(?:0[0-59]|10|20|30|40|" . "60|70|90)|6(?:0[0-29]|10|20|30|40|50|60|70|80|90)|" . "7(?:00|10|30|40|50|70)|80[0-59]|9(?:0[56]|1[1-39]|" . "2[57]|3[347-9]|4[19])))" . "|5(?:0(?:0(?:0[0-9]|1[0-6]|50)|1(?:0[0-9]|1[03-5]|20|3[01]|40|" . "50|60|70|80|90)|2(?:0[0-9]|1[01]|20|30|40|50|60|70|" . "90)|3(?:0[0-9]|10|20|30|40|50|60|70|80|90)|" . "4(?:0[0-79]|10|20|30|4[0-24-9]|50|60|70|80|90)|5(?:00|" . "10|20|30|40|50|60|70|80|90)|6(?:00|10|20|30|40|5[12]|" . "60|70|80|90)|7(?:00|10|20|30|40|50|60|70)|8(?:00|10|" . "40|50|60|70|80|90)|95[018])|" . "1(?:0(?:0[015-9]|1[0-367]|2[12]|3[5-9]|4[1-3]|5[1-9]|" . "6[0-9]|7[0-79]|8[0-46-9]|9[025-79])|1(?:00|10|2[0-2]|" . "30|40|50|60|70|90)|2(?:0[0-9]|10|20|30|40|50|60|70|" . "90)|3(?:0[0-689]|1[089]|20|3[0-4]|4[09]|50|6[01]|70|" . "80|90)|4(?:0[01]|20|3[0-5]|50|60|70|80|90)|5(?:00|10|" . "20|30|7[1-3])|6(?:0[01]|6[2-4]|7[357-9]|8[2-9])|" . "7(?:00|1[35]|2[1-36])|8(?:0[01]|7[13]|8[46])|90[024])|" . "2(?:0(?:0[0-8]|1[1246])|1(?:0[0-9]|1[0-35]|20|30|40|50|60|" . "70|90)|2(?:0[0-9]|10|20|30|40|50|60|70|90)|3(?:0[01]|" . "10|20|30|40|60|70)|4(?:00|10)|50[0-2]|600|700|800|" . "9(?:0[1-6]|1[579]|20))|" . "3(?:0(?:0[0-9]|1[02-69]|2[0-2]|3[0-2]|6[0-39]|73|8[0-9]|" . "9[013-589])|1(?:0[0-59]|10|20|40|50|60|70|90)|" . "2(?:0[0-5]|10|20|30|40|50|60|70|90)|3(?:00|20|40|50|" . "60|70|80|90)|4(?:00|10|20|40|70|80)|5(?:00|40)|" . "6(?:0[0-2]|40)|700|8(?:00|1[01])|9(?:4[0-2]|5[01]|60|" . "7[01]))|" . "4(?:0(?:0[0-9]|1[0-7]|2[0-39]|3[125-9]|4[1-35-9]|5[2-46]|" . "6[2-4]|7[1-46]|82|9[6-8])|1(?:00|1[0-689]|2[0-39]|" . "3[0-689]|40|5[0-49]|60|70|8[0-69]|90)|2(?:0[0-69]|" . "1[01]|20|30|40|50|6[0-3]|7[0-39]|80|90)|3(?:0[0-59]|" . "1[0-29]|20|30|40|50|60|70|8[05]|90)|4(?:0[0-69]|" . "1[0-4]|2[05]|30|40|50|60|70|80|90)|5(?:0[0-79]|" . "1[0-79]|2[0-9]|30|40|50|60|70|80|90)|6(?:0[0-389]|10|" . "20|30|40|50|60|70|80|90)|7(?:0[0-689]|1[0-69]|20|30|" . "40|50|60|70|80|90)|8(?:0[0-3]|10|20|30|40|50|60|70|80|" . "90)|9(?:00|10|20|3[01349]|4[01]|50|60|70|80|90))|" . "5(?:0(?:0[0-35-8]|1[2-5]|2[01])|1(?:0[0-9]|1[0239]|20|30|" . "40|50|60|70|90)|2(?:0[0-35]|10|2[01]|30|40|50|60|" . "7[01]|90)|3(?:00|10|20)|4(?:00|30)|500|600|700|8(?:00|" . "40))|" . "6(?:0(?:0[0-9]|1[06-9]|2[09]|3[46-9])|1(?:0[0-9]|10|20|30|" . "40|50|60|7[0-589]|90)|2(?:0[01479]|19|20|3[019]|40|50|" . "60|7[0-79]|90)|3(?:0[0-9]|1[0-279]|2[0-9]|30|4[0-39]|" . "50|60|70|8[0-3]|90)|4(?:0[0-79]|1[0139]|20|30|40|50|" . "60|70|80|90)|5(?:0[0-469]|10|20|3[0-2569]|40|50|60|70|" . "80|90)|6(?:0[0-379]|10|20|30|40|50|60|70|80|90)|" . "7(?:0[0-59]|30|40|50|60|70|80)|8(?:0[0-59]|40|5[045]|" . "60|70|80|9[0-369])|9(?:0[0-39]|10|20|30|5[014679]|" . "7[0379]|98))|" . "7(?:0(?:0[03-9]|1[0-9]|2[0138]|3[0-8]|4[014-69]|5[0-4679]|" . "6[1-3]|7[0-9]|8[1-4])|1(?:0[0-689]|19|2[05-9]|3[0-3]|" . "4[0146-9]|5[0-579]|6[0-49]|7[05]|8[015]|9[0-39])|" . "2(?:0[0-9]|1[124-9]|20|3[0-4]|4[05]|5[05]|60|70|" . "8[0-39]|9[0-29])|3(?:0[0-49]|10|20|30|40|5[0-249]|" . "6[0-359]|7[0-39]|8[0-35]|90)|4(?:0[0-59]|1[025]|20|30|" . "4[05]|5[05]|60|70|80|90)|5(?:0[0-9]|1[05]|2[05]|3[05]|" . "40|50|6[05]|70|80|90)|6(?:0[0-9]|1[09]|20|3[05]|4[05]|" . "5[05]|60|70|8[05]|90)|7(?:0[0-59]|10|20|3[019]|4[078]|" . "5[167]|7[02478]|80|90)|8(?:0[013-59]|1[05]|20|30|40|" . "5[05]|6[05]|70|80|90)|9(?:05|1[0-3569]|2[05]|3[05]|40|" . "5[0-57-9]|60|7[0-489]|80|90))|" . "8(?:0(?:0[0-9]|1[3-9]|2[02-9]|3[3469])|1(?:10|20|30|40|50|" . "60|70|80|90)|2(?:0[0-9]|10|20|30|40|50|60|70|90)|" . "3(?:0[0-2]|10|20|30|40|50|60|70|80|90)|4(?:0[0-5]|10|" . "20|30|40|50|60|70|90)|5(?:0[0-38]|30)|6(?:00|4[0-39]|" . "60)|700|800)|" . "9(?:0(?:0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[1-9]|" . "6[0-3569]|7[0-489]|8[0-46-8]|9[127])|1(?:0[08]|1[0-9]|" . "2[0-9]|3[0-9]|4[0-9]|5[0-9]|6[0-9]|7[0-9]|8[0-24-9]|" . "9[0-589])|2(?:0[0237-9]|1[0-9]|2[0-79]|3[0-9]|4[0-79]|" . "5[0-589]|6[0-9]|7[0-57-9]|8[0-8]|9[02-79])|3(?:0[0-9]|" . "1[0-9]|2[0-2689]|3[0-9]|4[1569]|5[0189]|6[0-5]|" . "7[03-9]|8[0-3569]|9[0-39])|4(?:0[0-9]|1[0-369]|" . "2[0-24-9]|3[0-35-7]|4[0-9]|5[0-35-8]|6[0-8]|7[0-689]|" . "8[0-35-7]|9[0-7])|5(?:0[0-9]|10|2[02-49]|3[0-25-7]|" . "4[0-4]|5[0-57-9]|6[0-47-9]|7[0-3]|8[0-46-9]|90)|" . "6(?:0[0-8]|1[0-38]|20|3[0579]|40|5[0-9]|6[0-79]|" . "7[0-37]|8[0-35-79]|90)|7(?:0[0-9]|1[0-9]|2[0-367]|" . "3[0-5]|40|50|60|7[079]|8[0-57-9]|9[0-2])|8(?:00|" . "1[0-8]|20|3[0-289]|4[057-9]|5[0-39]|6[0-9]|7[0-8]|" . "8[0-579]|9[0-9])|9(?:00|10|20|3[0-3]|4[0-48]|5[0-2]|" . "6[0-57]|7[0-2569]|8[014]|9[08])))" . "|6(?:0(?:0(?:0[024-9]|1[0-9]|2[1-9]|3[15])|1(?:0[0-9]|1[0-9]|" . "2[0-36-9]|3[0-248]|4[019]|5[0357]|6[02]|7[035]|" . "8[013-5]|90)|2(?:0[0-9]|10|20|30|40|5[0-2]|60|7[01]|" . "8[01]|9[0-39])|3(?:0[0-9]|1[0-9]|2[0139]|3[02]|40|50|" . "60|70|80|90)|4(?:0[0-369]|10|20|3[0-7]|40|51|60|7[67]|" . "80|90)|5(?:0[0134689]|10|20|30|4[0-4]|5[0-2]|60|70|80|" . "90)|6(?:0[0237-9]|1[0-27-9]|20|3[1-57-9]|4[036-9]|50|" . "60|7[1247]|80|90)|7(?:00|1[01]|2[1-39]|3[0-24]|" . "4[0-59]|5[01]|6[125]|7[12679]|90)|8(?:0[0-5]|10|20|" . "3[1-3]|40|50|60|7[0-2]|80|90)|9(?:0[2389]|1[12]|" . "2[1-4]|3[0-2]|40|50|60|81))|" . "1(?:0(?:0[0-9]|1[1-9]|2[1-4]|4[12]|51)|1(?:0[0-79]|10|20|" . "30|40|50|60|70|90)|2(?:0[0-689]|10|20|30|40|50|60|70|" . "90)|3(?:0[0-6]|10|20|30|40|50|60|70|80|90)|4(?:00|10|" . "20|3[08]|4[08]|5[08]|70|90)|5(?:00|50|60|70)|600|" . "7(?:00|90)|8(?:00|91)|9(?:61|84|9[24]))|" . "2(?:0(?:0[0-57-9]|1[0-9]|2[0-9]|3[0-46]|5[1-59]|6[0-79]|" . "7[0-29]|8[019]|9[0-2])|1(?:0[0-9]|1[0-46-9]|2[0-46-9]|" . "3[0-246-9]|4[0-579]|5[0-35-9]|6[0-24-69]|7[023569]|" . "8[02579]|9[0-469])|2(?:0[0-79]|1[0-357-9]|2[0-68]|" . "3[0-2]|4[025-9]|5[0-9]|60|70|80|90)|3(?:0[0-9]|1[01]|" . "2[0-257]|3[0-6]|40|50|6[01]|70|80|90)|4(?:0[0-8]|" . "1[0-289]|20|30|40|5[0-39]|60|70|80|90)|5(?:0[0-9]|10|" . "20|30|40|50|60|7[05]|80|90)|6(?:0[0-4689]|10|20|30|40|" . "50|60|70|80|90)|7(?:0[0-29]|10|20|30|40|50|60|70|80|" . "90)|8(?:0[0-69]|10|20|30|40|50|60|70|8[0-29]|90)|" . "9(?:0[1-9]|10|2[0-39]|30|40|5[0-5]|6[05-9]|7[0-8]|80|" . "90))|" . "3(?:0(?:0[0-9]|1[0-9]|2[0-489]|3[0-9]|4[02-69]|5[014-8]|" . "6[34])|1(?:00|1[0-9]|2[02]|30|40|50|60|7[0-578]|90)|" . "2(?:0[0-6]|10|20|30|40|50|60|70|90)|3(?:0[0-8]|10|20|" . "30|40|50|60|70|80|90)|4(?:0[0-9]|10|20|30|40|50|60|70|" . "80|90)|5(?:0[0-6]|10|20|30|40|50|60|70|80|90)|6(?:00|" . "10|20|30|40|50|60|70|80|90)|7(?:00|10|20|30|40|50|60|" . "70|80|90)|8(?:0[0-48]|10|20|30|40|50|70|80|90)|9(?:00|" . "10|20|30|40|5[09]|6[0-9]|7[02]|80|90))|" . "4(?:0(?:0[0-46-8]|1[0-35-9]|2[0-47-9]|3[0-9]|4[0-46]|" . "5[0-9]|6[0-24]|7[1589]|8[0-2679]|90)|1(?:0[0-9]|" . "1[0-356]|2[0-2]|30|4[0-35-8]|50|60|70|8[1-57]|90)|" . "2(?:0[0-68]|10|20|3[0-8]|40|50|60|70|90)|3(?:0[0-47]|" . "10|20|30|40|50|60|70|90)|4(?:0[0-4]|10|20|30|40|50|60|" . "70|80|90)|5(?:0[0-6]|1[01]|20|30|60|70)|6(?:0[0-5]|40|" . "60|80)|7(?:0[0-5]|80)|8(?:00|11|70)|990)|" . "5(?:0(?:0[0-9]|1[03-8]|2[0-5])|1(?:0[0-8]|1[0-267]|20|30|" . "40|50|7[01]|90)|2(?:0[0-4]|20|30|40|50|60|70|90)|" . "3(?:0[0-37-9]|1[0-2]|2[01]|30|50|60|70|80|90)|" . "4(?:0[0-2]|10|2[019]|30|40|60|90)|5(?:0[0-3]|10|60|" . "90)|6(?:0[01]|60|70|90)|7(?:0[016]|10)|80[01]|" . "9(?:0[1-57]|1[124578]|2[01]|30|5[01]))|" . "6(?:0(?:0[0-6]|1[1-57-9]|2[015-9]|3[0-49]|46|50|70)|" . "1(?:0[0-3]|1[0-3]|2[0-3]|30|4[0145]|50|6[0-25]|70|80|" . "90)|2(?:0[0-2]|10|20|30|40|50|60|70|80|90)|3(?:0[0-2]|" . "10|20|3[01459]|40|50|60|70|80|90)|4(?:0[0-3]|10|" . "2[0-3]|30|40|50|60|70|80|90)|5(?:0[0-29]|10|30|40|50|" . "60|70)|6(?:0[0-24-69]|10|20|5[0-29]|6[04]|70|80|90)|" . "7(?:0[0-4]|20|30|40|5[015]|60)|8(?:00|20|3[0-26]|45|" . "5[0346]|6[036]|70)|9(?:06|21|3[13]|4[015]|5[019]|" . "6[0-8]|87))|" . "7(?:0(?:0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[3-6]|59|6[01457-9]|" . "7[013-7]|8[0-9]|9[0-3689])|1(?:0[029]|1[02-8]|2[0-69]|" . "3[0-378]|4[0-6]|5[0-258]|6[0-35-79]|7[0-3]|90)|" . "2(?:0[0-79]|1[0-9]|20|3[0-2459]|4[0-39]|50|6[0-29]|70|" . "80|90)|3(?:0[0-8]|1[0-289]|20|30|40|50|60|70|8[0-2]|" . "90)|4(?:0[0-57-9]|1[0-2]|20|30|4[01]|5[0-9]|60|70|80|" . "90)|5(?:0[0-79]|10|2[01]|30|4[0-2]|50|60|70|80|90)|" . "6(?:0[0-9]|10|20|30|40|50|60|70|80|90)|7(?:0[0-9]|10|" . "2[0-8]|30|50|60|70|90)|8(?:0[0-479]|10|20|3[1-4689]|" . "4[0-3]|50|60|70|80|9[12])|9(?:0[05-79]|1[13]|" . "2[0-35-8]|3[0-3]|4[2-489]|5[2357-9]|6[0-79]|7[024-9]|" . "8[0-6]|9[09]))|" . "8(?:0(?:0[0-9]|1[02-9]|2[0-79]|40|5[0-9]|6[0-9]|7[0-467]|" . "8[2-6]|9[0-379])|1(?:00|1[068]|2[014-8]|3[0-49]|40|" . "5[0-39]|60|7[0-3]|80|90)|2(?:00|10|2[01]|30|40|50|" . "6[0-5]|7[0-4]|80|90)|3(?:0[0-9]|1[0-7]|20|3[0-3]|40|" . "50|60|70|80|9[0-39])|4(?:00|10|20|40|60|70|80|90)|" . "5(?:0[0-49]|10|20|30|40|50|60|70|80|90)|6(?:00|10|20|" . "30|40|50|60|80|90)|7(?:0[0-5]|20|30|40|50|60|70|80|" . "90)|8(?:0[0-2469]|20|30|40|50|70|90)|9(?:10|2[013579]|" . "4[13-57-9]|50|6[08]|70|80|90))|" . "9(?:0(?:0[1-9]|6[124])|1(?:00|1[05]|2[04-69]|3[0-2469]|" . "4[0-578]|5[0-49]|6[01]|7[0-3]|9[0-259])|2(?:0[0-9]|" . "1[0-9]|2[05-9]|3[0279]|4[0-7]|5[0-35-9]|6[0-9]|" . "7[0-2569]|8[0-9]|9[0-4])|3(?:0[0-379]|1[0679]|" . "2[0-26-9]|3[06-9]|4[0-9]|5[0-9]|6[0-79]|7[0-3679]|" . "8[0459]|9[0-9])|4(?:0[0-689]|1[0-9]|2[0-9]|3[0-9]|" . "4[0-9]|5[0-9]|6[013-9]|7[024-9]|8[0-9]|9[0-35])|" . "5(?:0[0-359]|1[0-9]|20|3[01]|4[0-4]|5[0-3]|6[013-59]|" . "7[0-4689]|8[0-3]|9[0-5])|6(?:0[0-9]|1[0-3569]|2[0-9]|" . "3[0-9]|4[0-9]|5[0-9]|6[014579]|7[0-79]|8[024-79]|" . "9[0-46])|7(?:0[0-29]|14|2[0679]|3[0-25]|4[0-79]|5[15]|" . "60|7[01]|80|9[0-5])|8(?:0[0-689]|1[1-4679]|2[02-49]|" . "3[0-36]|4[01]|50|60|70|8[1-39]|9[01])|9(?:0[0-8]|10|" . "2[1-6]|3[0-9]|4[25-9]|5[1-57]|6[0-489]|70|98)))" . "|7(?:0(?:0(?:0[0-7]|1[349]|2[0-2]|30)|1(?:0[0-4]|10|20|30|40|" . "50|60|70|80|90)|2(?:0[0-4]|10|20|30|40|50|70|80|90)|" . "3(?:0[0-46]|10|20|60)|4(?:00|40)|500|600|700|80[07])|" . "1(?:0(?:0[0-9]|1[0-27-9]|2[0-9]|31|4[09])|1(?:0[0-9]|" . "1[08]|20|30|40|50|60|70|90)|2(?:0[0-69]|10|20|30|40|" . "50|60|70|90)|3(?:0[0-9]|10|2[0-8]|3[0-79]|40|50|60|70|" . "80|90)|4(?:0[0-57-9]|10|20|30|40|50|60|70|80|90)|" . "5(?:0[0-39]|10|20|30|40|50|70|80|90)|6(?:0[0-49]|20|" . "40|70|80)|7(?:00|10|40|60)|8(?:00|50|70|80)|9(?:60|" . "90))|" . "2(?:0(?:0[0-9]|1[013-689]|2[14-9]|3[02-9]|4[0-57-9]|" . "5[12589]|7[0-359]|8[0-9]|9[1-356])|1(?:0[09]|10|20|30|" . "40|50|60|70|90)|2(?:0[0-3568]|10|20|3[0-4679]|40|50|" . "60|70|90)|3(?:0[0-589]|10|20|30|40|50|60|70|80|90)|" . "4(?:0[0-79]|30|40|50|60|70)|5(?:00|10|30|40|50|60)|" . "6(?:00|10|50)|70[02-5]|800|90[28])|" . "3(?:0(?:0[0-9]|1[014-9]|2[0-24-6]|31|65|7[39]|89|9[14])|" . "1(?:0[0-9]|10|2[0-479]|30|40|5[0-579]|60|70|9[0-39])|" . "2(?:0[0-9]|1[0-2469]|2[013-59]|3[0-259]|40|50|" . "6[01459]|7[067]|9[0-2459])|3(?:0[0-39]|10|2[0-29]|30|" . "40|50|60|7[0-9]|8[12]|90)|4(?:0[0-39]|10|20|40|50|60|" . "70|80|9[0-49])|5(?:00|20|30|40|50|7[0-39]|90)|" . "6(?:0[0-49]|10|20|30|40|60|70)|7(?:0[0-589]|10|20|30|" . "90)|8(?:0[0-24-9]|70))|" . "4(?:0(?:0[0-9]|1[0-6]|2[0145]|3[46]|4[01]|5[459])|" . "1(?:0[0-9]|1[0-3]|20|3[0-79]|40|5[0-9]|6[0-69]|70|90)|" . "2(?:0[0-9]|10|20|30|40|50|60|70|90)|3(?:0[0-57-9]|" . "1[014]|20|3[0-47-9]|40|50|60|7[0-4]|80|90)|" . "4(?:0[0-59]|10|20|30|40|50|60|70|80|90)|5(?:0[0-39]|" . "20|40|50|60|70|80)|6(?:0[0-79]|50|60)|7(?:0[0-469]|" . "40)|8(?:0[0-9]|90)|9(?:10|20|30|4[0-69]|5[0-4]|" . "6[0-469]|70|8[124-9]|9[013-9]))|" . "5(?:0(?:0[0-9]|1[0-9]|2[0134689]|3[0-689]|4[0-9]|5[1-689]|" . "6[0-9]|7[2-9]|8[0-9]|9[02-7])|1(?:0[0-9]|1[0-689]|" . "2[02-9]|3[01489]|4[0-24]|5[0-9]|6[1-9]|7[0-24679]|" . "8[0-24689]|9[124-8])|2(?:0[1-9]|1[0-9]|2[0-46-9]|" . "3[0-9]|4[01348]|5[0236]|6[0-69]|7[02589]|8[0-48]|" . "9[0-24589])|3(?:0[2-9]|1[0-57-9]|2[0-9]|3[0357-9]|" . "4[0-589]|5[0235-9]|6[0-7]|7[0-689]|8[0-9]|9[0-24-9])|" . "4(?:0[0-35-8]|1[0-35-9]|2[0-9]|3[0-24-9]|4[0-79]|" . "5[0-9]|6[02-8]|7[0-9]|8[0-8]|9[0-35-9])|5(?:0[2-9]|" . "1[0-2]|2[1-8]|3[3-8]|4[0-8]|5[0-8]|6[0-9]|7[0-9]|" . "8[0-9]|9[1-9])|6(?:0[0-9]|1[0-46-9]|2[0-9]|3[0-9]|" . "4[0-46-9]|5[0-9]|6[0-57-9]|7[013-57-9]|8[0-357-9]|" . "9[0-46-9])|7(?:0[0-35-9]|1[02-9]|2[0-79]|3[0-247-9]|" . "4[0-357-9]|5[03-79]|6[1-9]|7[0-358]|8[0-69]|9[04689])|" . "8(?:0[02-9]|1[2357-9]|2[0-9]|3[0-9]|4[013-9]|5[0-578]|" . "6[0-9]|7[0-24-9]|8[0-79]|9[0-57-9])|9(?:0[0-57-9]|" . "1[13-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|6[0-25-79]|7[0-9]|" . "8[013-9]|9[013-8]))|" . "6(?:0(?:0[0-8]|1[127-9]|2[0-24-689]|3[0-35-9]|4[0-79]|" . "5[0-9]|6[0-9]|7[0-249]|8[03-7]|9[2-9])|1(?:0[017-9]|" . "1[013679]|2[0-579]|3[0-9]|4[0-4]|5[0-359]|6[014]|" . "7[0-9]|8[135-9]|9[0-7])|2(?:0[0-9]|10|20|3[0-35-9]|40|" . "50|60|70|80|90)|3(?:0[0-68]|10|20|30|40|50|60|7[09]|" . "80|90)|4(?:0[0-59]|1[089]|20|30|40|50|60|70|80|90)|" . "5(?:0[0-49]|10|20|30|40|50|60|70|80|90)|6(?:00|10|20|" . "30|40|50|60|80|90)|7(?:00|10|2[013]|30|40|50|60|70|80|" . "90)|8(?:0[0-9]|10|2[13-5]|40|50|60|70|8[0-57]|90)|" . "9(?:0[02]|1[0457]|2[05-79]|3[045]|4[05]|50|60|70|80))|" . "7(?:0(?:0[0-9]|1[0-9]|2[013-8]|39|4[0-3]|5[0-2]|90)|" . "1(?:0[0-9]|1[0-58]|2[02-467]|3[013-589]|4[01458]|" . "5[0147]|6[03-79]|7[01346-8]|8[13-7]|9[0-9])|" . "2(?:0[0-9]|1[0-9]|2[0-59]|3[0-249]|4[0-36-9]|5[0-579]|" . "6[0-46]|7[0-2]|8[0-2]|9[0-9])|3(?:0[0-57-9]|1[0-689]|" . "2[07]|3[0-57]|4[0-46-9]|5[0-3]|60|70|8[0-24589]|90)|" . "4(?:0[0-579]|1[0-79]|2[0-79]|3[0-79]|4[0-8]|5[0-58]|" . "6[02-57-9]|70|8[0-46-9])|5(?:0[0-9]|1[05]|2[0-9]|" . "4[0-9]|5[0-9]|6[0-9]|70|8[0-35]|90)|6(?:0[0-9]|" . "1[0-24-7]|20|30|4[01569]|50|60|70|80|90)|7(?:0[0-689]|" . "1[014-7]|2[0-3]|30|50|60|7[126-9]|80|9[1-689])|" . "8(?:1[013-9]|20|3[0-57-9]|40|50|60|7[0-3569]|80|90)|" . "9(?:10|2[03]|3[0-39]|40|5[01]|61|70|8[1-369]|90))|" . "8(?:0(?:0[0-9]|1[0-57-9]|2[0-246-9]|3[02-5]|4[1-9]|" . "5[1-79]|6[0-24-7]|7[189]|8[1-9]|9[1-69])|" . "1(?:0[0-24-689]|1[0-9]|2[0-24-69]|3[0-59]|4[0-35-9]|" . "5[0-57-9]|6[02-79]|7[0-479]|8[0-689]|9[0-9])|" . "2(?:0[0-9]|1[0249]|2[0-39]|3[0-49]|4[0-49]|50|60|70|" . "8[0-9]|9[0-49])|3(?:0[0-46-9]|1[0-79]|2[0-2]|3[019]|" . "4[0-24-69]|5[0-69]|6[0-48]|7[0-9]|80|9[015])|" . "4(?:0[0-49]|1[0-35-79]|2[0-49]|3[019]|40|5[0178]|60|" . "7[0-29]|80|90)|5(?:0[0-79]|1[0-59]|20|3[0-69]|40|50|" . "60|70|80|9[0-29])|6(?:0[0-69]|1[029]|20|30|40|50|60|" . "70|80|90)|7(?:0[0-359]|1[0-58]|20|30|40|50|60|7[0189]|" . "80|90)|8(?:0[0-69]|10|20|30|40|5[0-249]|60|70|8[1-6]|" . "9[07])|9(?:1[05]|2[0-9]|3[01]|4[0-689]|5[05]|60|70|80|" . "9[05-7]))|" . "9(?:0(?:0[0-9]|1[0-8]|2[1-9]|3[0-9]|4[1-69]|5[0-69]|" . "6[0189]|7[0-79]|8[0-8]|9[1-389])|1(?:0[0-69]|10|20|30|" . "4[0-5]|50|60|70|8[0-2459]|90)|2(?:0[0-689]|10|20|" . "3[0-4]|40|50|60|70|90)|3(?:0[0-9]|10|20|30|40|50|60|" . "70|80|90)|4(?:0[0-49]|10|20|30|40|50|60)|5(?:00|10)|" . "600|700|800|9(?:39|5[03])))" . "|8(?:0(?:0(?:0[0-9]|1[0-79]|2[0-35-9]|3[0-46-9]|4[0-46-9]|" . "5[014-7]|6[0-489]|75|8[0-9]|9[0-79])|1(?:0[0-9]|" . "1[058]|2[02]|3[0-24-6]|4[02-6]|50|60|70|90)|" . "2(?:0[0-689]|10|20|30|40|50|60|70|90)|3(?:0[0-39]|10|" . "20|3[0-69]|40|50|60|70|90)|4(?:00|10|20|30|40|50|60|" . "70|80|90)|5(?:00|10|20|3[1-59]|40|50|60|70|80)|6(?:00|" . "10|20|30|40|50|70|80|90)|7(?:00|10|40|50|70|80)|" . "8(?:00|20|30|50|60|70|80|9[01])|9(?:1[09]|60|70|80))|" . "1(?:0(?:0[0-7]|1[1-9]|2[0-35-8]|3[014-9]|90)|1(?:0[0-9]|" . "1[056]|20|30|40|50|60|70|90)|2(?:0[0-9]|1[05]|20|30|" . "40|50|60|70|90)|3(?:0[0-5]|10|20|30|40|50|60|70|80|" . "90)|4(?:00|30|40|50|70|90)|5(?:0[0-369]|30|40|70|80)|" . "6(?:0[0-59]|30|40|60)|7(?:00|10)|800|990)|" . "2(?:0(?:0[0-689]|1[3-579]|2[47]|3[0237]|4[078]|5[347]|" . "6[057]|7[07]|8[07])|1(?:0[0-49]|10|20|30|40|50|60|70|" . "90)|2(?:0[0-28]|10|20|30|40|50|70|90)|3(?:0[0-3]|30|" . "40|50|60|70|90)|4(?:0[0-3]|10|40)|500|600|7(?:00|10)|" . "800)|" . "3(?:0(?:0[0-8]|1[2-69]|3[068]|4[0-289]|5[0-9]|6[0-59]|" . "7[016-9]|8[0-9]|9[0-57-9])|1(?:0[078]|1[019]|20|" . "3[016]|4[039]|50|6[0-467]|7[0-79]|8[013-57-9]|" . "9[0-269])|2(?:00|10|20|3[016-8]|40|50|60|70)|3(?:00|" . "1[0-7]|20|30|40|50|7[0-29]|80|90)|4(?:0[0-9]|1[128]|" . "20|30|40|60|70|8[0-9]|90)|5(?:0[0-479]|1[0-248]|20|30|" . "50|60|70|80|90)|6(?:0[0-4689]|1[03-68]|30|40|60|70|80|" . "90)|7(?:0[0-57]|20|40|80|90)|8(?:00|20|30|40|60|70|" . "90)|9(?:10|20|5[1-47]|80|9[0-8]))|" . "4(?:0(?:0[04-9]|1[013-689]|2[1-579]|3[1-6]|4[1-9]|" . "5[014689]|7[1278]|8[1-5]|9[0-9])|1(?:0[0-9]|10|2[0-4]|" . "3[0-59]|4[0-479]|50|60|70|90)|2(?:0[0-9]|10|20|3[0-2]|" . "40|50|60|7[0-9]|90)|3(?:0[0-9]|10|20|30|40|50|60|70|" . "80|90)|4(?:0[0-5]|10|20|30|40|50|60|70|80|90)|" . "5(?:0[0-57]|10|30|50|60|70|80)|6(?:0[0-39]|60)|" . "7(?:0[0-6]|40|50|60)|8(?:0[0-58]|10|20|30|40|50|60|" . "7[0-48])|9(?:0[1259]|1[1-9]|5[1-46]|6[13-57-9]|" . "7[1-367]))|" . "5(?:0(?:0[0-9]|1[0235-9]|2[01346]|3[356])|1(?:0[0-9]|" . "1[013489]|20|3[0-39]|40|50|6[0-579]|70|80|90)|" . "2(?:0[0-689]|10|20|30|40|50|60|70|80|9[0-29])|" . "3(?:0[0-79]|10|20|30|4[0-2]|50|60|70|90)|" . "4(?:0[0-4679]|10|20|30|40|50|60|70|80|90)|5(?:0[0-69]|" . "10|20|30|40|50|60|70|80|90)|6(?:0[0-479]|1[02-6]|20|" . "30|40|60|70|80|90)|7(?:0[0237-9]|10|40|50|70)|" . "80[03-69]|9(?:19|2[1-8]|3[0-4]))|" . "6(?:0(?:0[0-9]|1[0-3]|2[0-39]|3[04-68]|4[2-7]|5[0-6]|" . "6[0-35-9]|7[1-46]|8[0-9]|9[0-8])|1(?:0[0-9]|1[07]|20|" . "3[0-57-9]|40|50|60|70|80|90)|2(?:0[0-2469]|10|20|30|" . "40|50|60|70|8[0-29]|90)|3(?:00|10|20|30|40|50|6[0-29]|" . "70|80|90)|4(?:00|10|20|30|40|50|60|70|80|90)|" . "5(?:0[0-289]|10|30|40|50|80)|6(?:00|10)|700|800|" . "9(?:05|10|6[0-49]|8[0-4]))|" . "7(?:0(?:0[0-9]|1[0-35-8]|2[0-356]|3[0-46-9]|4[0-9]|" . "5[0-589]|6[015-9]|7[013-9]|8[0-59]|90)|1(?:00|10|20|" . "30|40|50|60|70|90)|2(?:0[0-356]|10|2[0-3]|30|40|50|60|" . "70|80|90)|3(?:00|10|20|30|40|50|60|70|80)|4(?:00|10|" . "20|30|40|60|70|80)|5(?:00|10|20|70|90)|6(?:00|20|40)|" . "7(?:00|20)|8(?:00|90)|9(?:00|19|20|30|50))|" . "8(?:0(?:0[0-9]|1[0-8]|2[015-79]|33|5[01]|60|8[4-689]|99)|" . "1(?:0[0-9]|10|2[0-3579]|3[0-39]|4[0-39]|5[0-6]|" . "6[0-259]|70|87|9[0-589])|2(?:0[0-79]|1[0-4]|20|30|40|" . "50|60|70|90)|3(?:0[0-7]|10|20|30|40|50|60|70|80|90)|" . "4(?:0[0-35-9]|10|20|30|40|50|60|70|80|90)|" . "5(?:0[0-479]|10|20|30|40|50|60|80)|6(?:00|30|40|50)|" . "700|80[0-59])|" . "9(?:0(?:0[0-79]|1[0-2569]|2[0-9]|30|89|9[0-59])|" . "1(?:0[0-9]|1[036]|20|30|4[04]|50|60|70|90)|" . "2(?:0[0-79]|10|20|30|40|50|60|70|90)|3(?:0[0-79]|10|" . "20|3[01]|40|50|60|80|90)|4(?:00|10|20|30|40|50|60|70|" . "80)|5(?:00|1[05]|2[05]|30|50|60|70|80)|6(?:00|30|60|" . "90)|7(?:00|10|40|7[0-2])|800))" . "|9(?:0(?:0(?:0[0-9]|1[0-689]|2[0-35]|40)|1(?:0[01]|10|20|30|40|" . "50|60|70)|200|3(?:00|30|40|50|60|70|80)|400|500|600|" . "700|8(?:00|50))|" . "1(?:0(?:0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|" . "7[0-247-9]|80|9[07])|1(?:0[0-9]|2[0-9]|3[0-35-7]|" . "4[0-269]|5[0-46-9]|6[0-9]|7[0-47-9]|80|9[0-9])|" . "2(?:0[014579]|1[0134]|2[0-9]|30|4[01]|50|6[0-35-9]|70|" . "80|9[0-24-9])|3(?:0[0-9]|1[0-245]|2[0-589]|3[0-59]|" . "4[0-9]|5[013-59]|60|7[014]|8[0-9]|90)|4(?:0[0-79]|" . "1[024-8]|2[0-9]|30|40|50|6[0-3]|70|80|90)|5(?:10|20|" . "30|4[0-29]|5[01]|60|7[0-489]|80|90)|6(?:0[0-359]|" . "1[0239]|2[05]|30|40|50|60|70|80|9[0-9])|7(?:0[0-9]|" . "1[0-3]|20|30|4[0-9]|50|6[0-47]|70|8[013]|9[0-2])|" . "8(?:0[0-79]|1[0-5]|2[01]|30|4[019]|5[0-25]|6[01]|" . "7[0-9]|8[0-79]|9[0-689])|9(?:1[0-79]|2[1-4]|30|4[0-9]|" . "5[1-9]|6[1-9]|7[1-9]|8[1-68]))|" . "2(?:0(?:0[0-9]|1[0-9]|2[0-9]|3[3-9]|4[0-9]|5[0-9]|" . "6[013-9]|7[0-9]|8[1-9]|9[235-9])|1(?:0[0-689]|1[0-9]|" . "2[0-9]|3[0-9]|4[0-9]|5[0-9]|6[0-9]|7[0-9]|8[1-689]|" . "9[013-69])|2(?:0[0-689]|1[0-69]|2[0-9]|3[0-57-9]|" . "4[0-79]|5[0-46-9]|6[0-369]|7[0-59]|8[0-246-8]|" . "9[0-35-8])|3(?:0[0-9]|1[0-46-9]|2[0-9]|3[0-379]|" . "4[0-2]|5[0-79]|6[0-69]|7[029]|8[08]|9[0-9])|" . "4(?:0[0-9]|1[0-9]|2[03]|3[08]|4[1-578]|54|99)|" . "5(?:0[0-9]|1[1346-9]|2[1-57-9]|3[1-8]|4[1-6]|5[235]|" . "6[1-79]|7[13-8]|8[1-8]|9[1-9])|6(?:0[0-79]|1[13-6]|" . "2[24]|3[1-8]|4[1-359]|5[013-689]|6[05]|7[12579]|" . "8[2-689]|9[1358])|7(?:0[0-9]|1[1-5]|2[125-9]|3[05-9]|" . "4[1-578]|5[12568]|6[1-46-8]|7[2-469]|8[1-9]|9[1-9])|" . "8(?:0[0-9]|1[135-9]|2[0-4]|4[2-8]|5[1-69]|6[1-7]|" . "8[1-79]|9[1-8])|9(?:0[1-46-9]|1[1-9]|2[0-9]|3[0-9]|59|" . "7[0-57-9]|8[013-9]|99))|" . "3(?:0(?:0[0-35-9]|1[1-46-8]|2[124])|1(?:0[0-8]|1[0-24-8]|" . "2[0-367]|3[013-6]|4[0-9]|5[0-8]|6[0-9]|7[0-24-7]|" . "8[1-46-9]|9[0-79])|2(?:0[0-9]|1[0-46-9]|2[0-2]|" . "3[0135]|4[015]|50|6[01]|7[0145]|8[2-6]|9[047])|" . "3(?:0[0-8]|1[015]|2[0-5]|3[0-24-7]|4[0-689]|5[0-2]|" . "6[0-6]|70|8[0-2]|90)|4(?:0[0-8]|1[0-2]|2[0-4]|3[0167]|" . "4[01]|5[013-8]|6[0-5]|7[0239]|8[1-79]|93)|5(?:0[0-8]|" . "1[1-7]|2[1-46-8]|3[1-9]|4[1457]|5[4-68]|6[1-4]|" . "7[14-8]|8[1-9]|9[13])|6(?:0[0-689]|1[1-9]|2[1-37]|31|" . "9[1-9])|7(?:0[015]|1[129]|3[1346-8]|61)|8(?:0[0-267]|" . "1[2-6]|8[13-57]|9[19])|90[17-9])|" . "4(?:0(?:0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[1-5]|94)|" . "1(?:0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|6[0-69]|" . "7[0-5]|9[0-79])|2(?:0[0-9]|1[0149]|2[0-9]|3[0-9]|" . "4[0-4679]|5[0-9]|6[0-9]|7[0-9]|81|90)|3(?:0[0-9]|" . "1[0-29]|2[0-247]|4[0-59]|5[013-79]|6[0-689]|7[0-9]|" . "8[0-9]|9[0-689])|4(?:0[0-9]|1[0-579]|20|3[0-9]|40|" . "5[0-79]|60|7[0-9]|80|90)|5(?:0[0-9]|1[0-9]|2[0-8]|" . "3[1-9]|4[1-46-9]|5[0-3]|6[1-9]|7[1-9]|8[1-9]|9[1-9])|" . "6(?:0[0-4679]|1[1-46-9]|2[1-36-8]|3[1-9]|4[1-578]|" . "5[1346-9]|6[13479]|7[1-9]|8[1-8])|7(?:0[0-4679]|" . "1[0-59]|2[1-9]|3[1-9]|4[1-589]|6[1-8]|8[1-59])|" . "8(?:0[0-9]|1[1-9]|3[1-39]|5[1-9]|6[1-79]|80|9[1-4])|" . "9(?:4[125-9]|5[1-689]|6[1-68]|7[1-8]))|" . "5(?:0(?:0[0-8]|1[0-9]|2[0-57-9]|3[0-8]|4[0-26]|5[0-69]|" . "6[0-79]|7[0-9]|9[0-8])|1(?:0[0-9]|1[0-27-9]|2[0-79]|" . "3[0-579]|4[0-6]|5[0-57-9]|6[0-259]|70|80|9[0-9])|" . "2(?:0[0-79]|1[0-9]|2[0-4689]|3[0-49]|40|5[0-29]|60|70|" . "80|90)|3(?:0[0-469]|1[0-689]|2[0-489]|3[0-5]|40|" . "5[015]|60|7[09]|80|90)|4(?:00|1[0-29]|20|30|4[015]|50|" . "6[01]|7[0-9]|80|90)|5(?:0[0-9]|10|2[0-9]|30|40|5[019]|" . "60|7[013]|80|90)|6(?:0[0-59]|1[0-9]|20|30|40|5[0-29]|" . "60|70|80|9[0-367])|7(?:0[0-9]|1[0-3569]|2[0-7]|3[1-4]|" . "4[0-27]|50|6[019]|70|80)|8(?:0[0-9]|1[0-6]|20|30|" . "4[02-4]|50|6[1-68]|7[0-79]|80|9[127])|9(?:0[12578]|" . "1[1-3569]|2[0-8]|3[0-4]|4[0-9]|5[0-46-9]|7[0-8]))|" . "8799)" . ")", # # 5 Digit postal code, with leading 0s. # # Data from: http://download.geonames.org/export/zip/DE.zip # Germany => "(?k:0(?:1(?:0(?:6[79]|9[79])|1(?:0[89]|2[79]|39|5[679]|69|8[79])|" . "2(?:1[79]|3[79]|5[79]|7[79])|3(?:0[79]|14|2[468])|" . "4(?:45|5[48]|6[258]|7[178])|5(?:58|61|8[79]|9[14])|" . "6(?:09|1[269]|23|40|6[25]|8[39])|7(?:05|2[38]|3[1478]|" . "44|6[28]|7[3468]|96)|8(?:09|1[469]|2[459]|33|4[478]|" . "55|77|96)|9(?:0[0469]|17|20|36|45|68|79|8[37]|" . "9[03468]))|" . "2(?:6(?:2[57]|33|4[03]|8[19]|9[249])|7(?:08|27|3[0369]|" . "4[278]|63|79|8[258]|9[14679])|8(?:2[6-9]|9[49])|" . "9(?:06|2[39]|43|5[3679]|7[79]|9[1479]))|" . "3(?:0(?:4[2468]|5[0-58]|9[69])|1(?:03|1[69]|3[09]|49|59|" . "72|85|97)|2(?:0[25]|2[269]|38|4[69]|53))|" . "4(?:1(?:0[3579]|29|5[57-9]|7[7-9])|2(?:0[579]|29|49|" . "7[579]|8[89]|99)|3(?:1[5-9]|2[89]|4[79]|5[67])|4(?:16|" . "2[05]|35|42|51|6[03])|5(?:09|19|23|39|52|6[457]|" . "7[1459])|6(?:0[03]|1[0378]|26|39|43|5[1457]|68|" . "8[03578])|7(?:03|20|36|4[169]|58|69|7[49])|8(?:08|" . "2[1478]|38|49|6[02]|74|8[069]|95)|9(?:1[06]|2[48]|" . "3[12468]))|" . "6(?:1(?:08|1[02468]|2[02468]|3[02]|79|8[48]|9[38])|2(?:17|" . "3[17]|4[269]|5[4589]|68|79|95)|3(?:08|1[1378]|33|" . "4[378]|6[69]|8[568])|4(?:0[68]|2[059]|49|5[68]|" . "6[34679]|84|93)|5(?:0[27]|2[68]|3[67]|4[2378]|56|67|" . "7[178])|6(?:18|28|3[268]|4[278]|67|79|8[268])|7(?:12|" . "2[124579]|31|49|66|7[349]|8[056]|9[1246])|" . "8(?:0[03489]|4[24679]|6[129]|8[689]|9[56])|9(?:0[159]|" . "1[78]|2[2568]))|" . "7(?:3(?:18|3[03468]|4[39]|56|6[68]|8[179])|4(?:07|" . "2[2679])|5(?:4[5689]|5[1247]|70|8[069])|6(?:07|1[369]|" . "29|39|46)|7(?:4[3579]|51|68|7[48])|8(?:06|19)|9(?:07|" . "19|2[24679]|37|5[02578]|73|8[0579]))|" . "8(?:0(?:5[68]|6[0246])|1(?:07|1[258]|3[24]|4[147])|2(?:09|" . "2[38]|3[3679]|48|58|6[12579]|8[09]|9[47])|3(?:0[149]|" . "1[258]|2[14-68]|4[049]|5[259]|7[13]|9[36])|4(?:12|" . "2[78]|3[29]|5[19]|68|85|9[169])|5(?:2[3579]|3[89]|" . "4[1378])|6(?:06|26|4[58]))|" . "9(?:0(?:28|30)|1(?:1[1-4679]|2[0235-8]|3[01])|2(?:1[27]|" . "2[1478]|3[256]|4[1349])|3(?:06|2[268]|37|5[0356]|66|" . "76|8[057]|9[02459])|4(?:05|19|2[379]|3[02579]|56|" . "6[58]|7[147]|8[1478]|96)|5(?:09|1[478]|26|4[48]|57|69|" . "7[3579]|99)|6(?:0[03]|1[89]|2[379]|3[348]|48|6[19])))" . "|1(?:0(?:1(?:1[579]|7[89])|24[3579]|3(?:1[57-9]|6[579])|" . "4(?:0[579]|3[579])|5(?:5[13579]|8[579])|62[3579]|" . "7(?:0[79]|1[13579]|7[79]|8[13579])|82[3579]|" . "9(?:6[13579]|9[79]))|" . "1011|2(?:0(?:4[3579]|5[13579]|99)|1(?:0[13579]|5[79]|" . "6[13579])|2(?:0[3579]|4[79]|7[79])|3(?:0[579]|4[79]|" . "5[13579])|4(?:3[579]|59|8[79])|5(?:2[4679]|5[579]|" . "8[79])|6(?:19|2[1379]|79|8[13579]))|" . "3(?:0(?:47|5[13579]|8[689])|1(?:2[579]|5[689]|8[79])|" . "3(?:4[79]|5[13579])|4(?:0[3579]|3[579]|6[579])|" . "5(?:0[3579]|8[13579]|9[13579])|62[79])|" . "4(?:0(?:5[023579]|89)|1(?:09|29|31|6[3579]|9[3579])|" . "4(?:6[179]|7[1368]|8[02])|5(?:13|32|4[278]|5[02478])|" . "6(?:12|2[147]|41|56|6[29])|7(?:1[25]|2[78]|7[02468]|" . "89|9[378])|8(?:06|2[2378])|9(?:13|29|4[37]|59|7[49]))|" . "5(?:2(?:3[0246]|9[59])|3(?:06|2[0468]|4[45]|66|7[02478])|" . "5(?:1[78]|2[68]|37|6[269])|7(?:11|3[28]|4[15689]|" . "5[124578])|8(?:06|27|3[1478]|48|59|6[48]|9[08])|" . "9(?:07|1[03]|26|3[68]))|" . "6(?:2(?:2[57]|30|4[478]|59|69|78)|3(?:0[367]|21|4[18]|" . "5[269])|5(?:15|4[078]|5[269]|6[257])|7(?:27|6[167]|75|" . "9[28])|8(?:1[68]|27|3[1357]|45|6[68])|9(?:09|18|2[18]|" . "4[59]))|" . "7(?:0(?:3[3469]|8[79]|9[1489])|1(?:09|11|2[169]|39|5[349]|" . "6[68]|79|9[24])|2(?:0[79]|1[3479]|3[57]|48|5[2589]|68|" . "79|91)|3(?:09|2[12689]|3[57]|4[89]|58|67|7[359]|89|" . "9[0-28])|4(?:06|19|2[49]|38|4[09]|5[49]|89|9[1358])|" . "50[69])|" . "8(?:0(?:5[579]|69)|1(?:0[679]|19|4[67]|8[124]|9[0568])|" . "2(?:09|11|25|3[01369]|4[69]|58|7[369]|9[29])|" . "3(?:1[147]|20|3[47]|47|56|7[45])|4(?:3[579]|4[25]|" . "6[159])|5(?:07|1[0369]|28|46|5[16]|6[59]|7[34]|8[16])|" . "609)|" . "9(?:0(?:5[3579]|6[13579]|7[13579]|8[69])|2(?:0[59]|17|30|" . "4[369]|58|60|73|88|94)|3(?:0[0369]|22|3[69]|48|57|" . "7[0246]|86|9[59])|4(?:06|1[27])))" . "|2(?:0(?:0(?:38|88|9[579])|14[4689]|2(?:49|5[13579])|35[04579]|" . "45[79]|53[579])|" . "1(?:0(?:29|3[13579]|7[3579])|1(?:0[79]|29|4[79])|" . "2(?:1[78]|2[0478]|44|5[5689]|6[16]|7[1249])|" . "3(?:3[579]|5[478]|6[0589]|7[169]|8[02568]|9[14578])|" . "4(?:0[013679]|23|3[5689]|4[124579]|65|8[13]|93)|" . "5(?:0[29]|1[46]|2[124679])|6(?:14|29|35|4[0134679]|" . "8[02-4]|98)|7(?:0[269]|1[0247]|2[03679]|3[02479]|45|" . "5[56]|6[2359]|7[0256]|8[124579]))|" . "2(?:0(?:4[13579]|8[13579])|1(?:1[13579]|4[3579]|59|" . "7[579])|29[79]|3(?:0[13579]|3[579]|59|9[13579])|" . "4(?:1[579]|5[3579])|5(?:2[3579]|4[79]|59|8[79])|" . "60[579]|76[13579]|8(?:4[468]|5[01]|69|8[059])|" . "9(?:2[679]|4[169]|5[25689]|6[24579]))|" . "3(?:5(?:39|5[2468]|6[024689]|70)|6(?:1[179]|2[36-9]|69|" . "8[349])|7(?:01|1[4579]|3[08]|4[34679]|58|69|7[4579]|" . "95)|8(?:1[23568]|2[0134679]|4[357]|58|6[03679]|79|" . "8[13]|9[689])|9(?:09|1[19]|23|36|4[2468]|52|6[68]|" . "7[024]|9[269]))|" . "4(?:1(?:0[35-79]|1[134689]|4[35-9]|59|61)|2(?:1[147]|" . "2[02369]|3[2589]|4[124578]|5[0134679])|3(?:06|2[1679]|" . "40|5[1478]|6[0134679]|76|9[2589])|40[124579]|" . "5(?:3[4679]|58|68|76|8[29]|9[48])|6(?:01|1[0369]|" . "2[0235689]|3[124578]|4[0134679])|7(?:68|8[2-47]|" . "9[0134679])|8(?:0[0235689]|1[134679]|37|48|5[0257]|" . "6[0134679]|7[0235689]|8[124578]|9[0134679])|9(?:3[79]|" . "4[134]|55|6[0369]|7[25-7]|8[03689]|9[124679]))|" . "5(?:3(?:3[5-7]|48|5[58]|6[1458]|7[013679])|4(?:04|2[19]|" . "3[67]|51|6[29]|7[49]|8[25689]|9[124579])|5(?:24|4[18]|" . "5[147]|6[0369]|7[235689]|8[124578]|9[0134679])|693|" . "7(?:0[49]|1[2589]|2[14579]|46|6[147]|7[0469]|8[2568]|" . "9[124579])|8(?:13|2[16]|3[26]|4[0259]|5[0235689]|" . "6[02-4689]|7[0235689]|8[124579]|99)|9(?:17|2[03467]|" . "38|46|80|9[2679]))|" . "6(?:1(?:2[1-3579]|3[135]|6[09]|8[08]|97)|2(?:0[39]|1[59])|" . "3(?:16|4[059]|8[24689])|4(?:09|19|27|34|4[16]|52|65|" . "74|8[679])|5(?:06|2[49]|32|48|5[36]|7[19])|6(?:0[357]|" . "2[49]|3[29]|55|7[06]|8[39])|7(?:2[135]|36|5[79]|89)|" . "8(?:02|1[07]|26|3[15]|4[24579]|71|9[279])|" . "9(?:0[134679]|19|3[15-79]|54|69))|" . "7(?:2(?:11|3[29]|4[35689]|5[12479]|83|99)|3(?:0[58]|1[38]|" . "2[147]|3[03679]|56|67|74|8[369])|4(?:04|1[29]|32|" . "4[269]|7[2468]|9[89])|5(?:68|7[02468]|80)|6(?:07|" . "1[269]|2[48]|3[278])|7(?:11|2[169]|49|5[135]|77|" . "9[38])|80[149])|" . "8(?:19[579]|2(?:0[13579]|1[13579]|3[79]|59|7[79])|" . "3(?:0[79]|2[579]|35|5[579])|7(?:1[79]|5[579]|7[79]|" . "90)|8(?:16|32|44|57|65|7[069]))|" . "9(?:22[13579]|3(?:0[38]|13|2[038]|3[169]|4[258]|" . "5[1-35689]|6[124579]|7[89]|8[69]|9[2-469])|4(?:1[036]|" . "39|5[169]|6[258]|7[1-35689]|8[124578]|9[0134679])|" . "5(?:25|49|5[369]|6[258]|7[14-689]|8[124578]|" . "9[0134679])|6(?:14|33|4[0369]|64|83|9[039])))" . "|3(?:0(?:1(?:59|6[13579]|7[13579])|4(?:19|49|5[13579])|5(?:19|" . "21|39|59)|6(?:2[579]|5[579]|69)|8(?:2[367]|5[135]|80|" . "90)|9(?:00|16|26|38|52|66|74|8[29]))|" . "1(?:0(?:08|2[089]|3[23569]|61|7[39]|8[457-9]|9[134679])|" . "1(?:3[4579]|41|57|6[27]|7[147]|8[058]|9[1569])|" . "2(?:2[468]|34|4[169]|75)|3(?:03|1[19])|5(?:15|35|" . "4[27]|5[235689]|82|9[25])|6(?:0[034689]|1[389]|" . "2[1-36-9]|3[2-46-8]|55|75|8[38]|9[1389])|7(?:0[0278]|" . "1[0-2457-9]|37|49|8[579])|8(?:12|32|4[08]|55|6[0378]))|" . "2(?:0(?:49|5[12])|1(?:0[578]|20|3[09])|2(?:57|78|89)|" . "3(?:12|39|51|6[19])|4(?:2[3579]|57|69|79)|5(?:4[579]|" . "84)|6(?:0[29]|57|76|8[39]|9[49])|7(?:5[68]|60|91)|" . "8(?:05|16|25|3[29]))|" . "3(?:0(?:14|3[49]|98)|1(?:0[0246]|29|42|54|6[15]|7[58]|" . "8[149])|3(?:11|3[0245]|78|97)|4(?:15|28|4[29])|519|" . "6(?:0[24579]|1[13579]|4[79]|59|89|99)|7(?:19|29|39|58|" . "75|90)|8(?:03|1[38]|2[49]))|" . "4(?:1(?:1[79]|2[13578]|3[0-24])|2(?:12|25|33|46|53|6[06]|" . "7[07]|8[169]|9[258])|3(?:0[258]|1[147]|2[03679]|46|" . "5[59]|69|7[69]|8[58]|9[369])|4(?:14|3[149]|54|66|" . "7[1479]|97)|5(?:08|1[369]|37|49|60|76|8[27]|9[0369])|" . "6(?:13|2[168]|3[02379]))|" . "5(?:0(?:3[79]|4[13]|66|75|8[0358]|9[1469])|1(?:0[248]|" . "1[024679])|2(?:16|3[269]|60|7[49]|8[2578])|3(?:05|15|" . "2[1579]|9[02468])|4(?:1[058]|2[38]|35|4[047]|5[27]|" . "6[0369])|5(?:1[069]|7[689]|8[0-6])|6(?:06|1[49]|25|" . "3[038]|4[1479]|8[3-9]|90)|7(?:08|1[369]|45|5[369]|" . "6[478]|8[19]|9[2469]))|" . "6(?:0(?:3[79]|4[13]|88|93)|1(?:0[03]|1[059]|2[49]|3[27]|" . "4[258]|5[147]|6[03679]|79|99)|2(?:0[58]|1[1479]|51|" . "6[69]|7[257]|8[024679])|3(?:04|18|2[03569]|41|5[58]|" . "6[479]|81|9[169])|4(?:04|1[49]|33|48|5[267]|6[069]))|" . "7(?:0(?:7[3579]|8[135])|1(?:15|2[047]|3[0369]|54|7[06]|" . "8[16]|9[1479])|2(?:1[3-8]|35|4[279]|69|76|8[147]|" . "9[03679])|3(?:08|18|27|39|45|5[159])|4(?:12|3[14]|" . "4[14579])|5(?:20|3[49]|47|74|8[169])|6(?:03|19|2[07]|" . "3[2359]|4[02379]|71|88|9[1679]))|" . "8(?:023|1(?:0[02468]|1[02468]|2[0246]|5[49]|6[25]|" . "7[0369])|2(?:2[689]|39|59|68|7[124579]|81)|3(?:0[024]|" . "1[259]|2[124579]|50|6[48]|7[235689]|8[124578])|" . "4(?:4[02468]|5[89]|6[124578]|7[0134679]|8[69])|5(?:18|" . "2[478]|3[01369]|4[237]|5[0134679])|6(?:4[024]|67|78|" . "85|90)|7(?:0[0479]|2[39])|8(?:2[0289]|3[568]|55|" . "7[1579]|89|9[59]))|" . "9(?:014|1(?:0[468]|1[02468]|2[02468]|30|6[47]|7[159])|" . "2(?:18|21|4[059]|6[14]|79|88|91)|3(?:07|1[79]|26|" . "4[035]|5[69]|65|87|9[378])|4(?:18|3[459]|4[3468])|" . "5(?:17|24|39|7[69]|9[069])|6(?:06|1[59]|2[49]|38|" . "4[69])))" . "|4(?:0(?:2(?:1[0-3579]|2[13579]|3[13579])|4(?:68|7[024679]|89)|" . "5(?:4[579]|89|9[13579])|6(?:2[579]|6[78]|70|99)|" . "7(?:2[134]|64|89)|8(?:22|32|78|8[0235]))|" . "1(?:06[135689]|1(?:69|79|89|99)|23[689]|3(?:34|52|6[36]|" . "7[29])|4(?:6[024689]|7[02])|5(?:1[5-7]|39|4[0-2]|" . "6[49])|7(?:4[7-9]|51)|8(?:12|36|4[49]))|" . "2(?:1(?:0[3579]|1[13579])|2(?:7[579]|8[13579])|3(?:2[79]|" . "49|69|89|99)|4(?:77|89|99)|5(?:49|5[135]|79)|" . "6(?:5[13579]|9[79])|7(?:19|81|99)|8(?:5[3579]|9[79])|" . "929)|" . "4(?:1(?:3[579]|4[13579])|2(?:2[579]|6[3579]|8[79])|3(?:09|" . "19|2[89]|39|5[79]|69|79|88)|5(?:3[246]|7[579]|81)|" . "6(?:2[357-9]|49|5[1-3])|7(?:8[79]|9[13579])|" . "8(?:0[13579]|6[679]|79|9[24]))|" . "5(?:1(?:2[78]|3[0134689]|4[13-579])|2(?:19|39|5[79]|" . "7[679]|89)|3(?:0[79]|2[679]|5[5-79])|4(?:03|68|" . "7[0235689]|81)|5(?:2[579]|49)|6(?:5[79]|6[135]|99)|" . "7(?:01|11|21|3[19]|68|7[02])|8(?:79|8[134689]|" . "9[124679])|96[468])|" . "6(?:04[579]|1(?:1[79]|4[579])|2(?:3[68]|4[024]|8[246])|" . "3(?:25|4[28]|5[49]|9[579])|4(?:1[49]|46|59|8[357]|99)|" . "5(?:09|1[49]|3[579]|6[29]))|" . "7(?:05[1357-9]|1(?:19|3[7-9]|6[679]|7[89]|9[89])|" . "2(?:2[689]|39|49|59|69|79)|4(?:4[1357]|75|95)|" . "5(?:0[69]|33|46|5[19]|74|89)|6(?:08|2[3-7]|38|47|52|" . "6[159])|79[89]|8(?:0[02-579]|29|39|77)|9(?:06|18|29))|" . "8(?:079|1(?:4[3579]|5[13579]|6[1357])|2(?:31|49|68|82|91)|" . "3(?:0[18]|17|2[49]|36|4[16]|5[16]|6[169])|4(?:29|" . "3[12]|55|65|77|8[058]|9[369])|5(?:2[79]|31|65|99)|" . "6(?:07|1[29]|2[49]|53|83|91)|7(?:03|12|2[07]|3[49]))|" . "9(?:0(?:7[468]|8[02468]|90)|1(?:24|34|43|52|63|7[069]|86|" . "9[16])|2(?:0[15]|1[49])|3(?:2[468]|56|77|93)|" . "4(?:0[16]|1[39]|2[49]|3[49]|48|5[13679]|7[79]|9[27])|" . "5(?:0[49]|25|36|4[59]|65|77|8[46]|9[34679])|6(?:10|" . "2[46]|3[2578]|61|8[158]|9[269])|7(?:16|33|4[04]|5[17]|" . "6[27]|7[0479])|8(?:0[89]|11|2[48]|3[258]|4[34679])))" . "|5(?:0(?:1(?:2[679]|69|7[01]|8[19])|2(?:26|59)|3(?:21|54|74|" . "89)|6(?:6[78]|7[0246-9])|7(?:3[3579]|6[579])|" . "8(?:2[3579]|5[89])|9(?:3[13579]|6[89]|9[679]))|" . "1(?:06[13579]|1(?:0[3579]|4[3579])|3(?:7[13579]|81|99)|" . "4(?:2[79]|6[579]|91)|5(?:03|1[59]|45|70|8[08]|9[78])|" . "6(?:4[357]|74|88)|7(?:0[29]|66|89))|" . "2(?:0(?:6[2468]|7[02468]|80)|1(?:34|46|5[269])|2(?:2[2-4]|" . "49)|3(?:49|5[135]|7[29]|8[258]|9[1369])|4(?:28|4[15]|" . "5[79]|77|99)|5(?:11|25|3[18]))|" . "3(?:1(?:1[13579]|2[13579]|7[3579])|22[579]|3(?:32|4[037]|" . "59)|4(?:2[46]|74|89|98)|5(?:0[15-8]|18|20|3[349]|" . "4[57]|57|6[027]|7[27-9])|6(?:04|19|39)|7(?:21|57|73|" . "83|97)|8(?:0[49]|19|4[024]|59|79|81|94)|9(?:0[29]|" . "1[39]|25|37|4[0579]))|" . "4(?:29[02-68]|3(?:0[689]|1[01346-8]|2[09]|3[128]|" . "4[0134679])|4(?:1[13]|2[124679]|39|41|5[0135-79]|" . "7[02]|8[3467]|9[278])|5(?:1[68]|2[34689]|3[134689]|" . "5[028]|68|7[04689]|8[4-79]|9[57])|6(?:08|1[0-24679]|" . "3[46]|4[679]|5[57]|6[24689]|7[35]|8[79]))|" . "5(?:1(?:1[68]|2[0246-9]|3[01])|2(?:18|3[2479]|46|5[27]|" . "6[238]|7[0168]|8[368]|9[1469])|4(?:1[13]|2[245]|" . "3[0257]|4[24]|5[0279]|69|71|8[137]|9[014679])|" . "5(?:4[356]|59|6[689]|7[168]|8[35]|9[0235-79])|" . "6(?:0[68]|1[89]|2[14679])|7(?:43|5[68]|6[578]|" . "7[4679]))|" . "6(?:0(?:68|7[0235-7])|1(?:12|3[023]|54|7[09]|82|91)|" . "2(?:0[346]|18|20|3[57]|4[249]|5[34]|69|7[16]|8[138]|" . "9[01459])|3(?:0[57]|1[67]|2[1-39]|3[023578]|4[01689]|" . "5[57]|68|7[079])|4(?:1[024]|2[2478]|5[79]|62|7[0279])|" . "5(?:6[467]|7[59]|8[147-9]|9[3489])|6(?:26|3[07]|" . "4[258]|5[1369])|7(?:2[79]|36|4[356]|5[1349]|6[1679])|" . "8(?:1[248]|2[0135689]|4[13]|5[0689]|6[124579]))|" . "7(?:0(?:7[2468]|80)|2(?:23|34|5[08]|71|9[09])|3(?:19|" . "3[49]|68|9[29])|4(?:13|39|62|8[29])|5(?:18|20|3[79]|" . "48|55|6[27]|7[278]|8[0134679])|6(?:1[024]|2[79]|" . "3[25689]|4[124578]))|" . "8(?:0(?:89|9[13579])|1(?:19|35)|2(?:39|56|85)|3(?:00|13|" . "3[29])|45[2-6]|5(?:0[79]|1[135]|40|53|66|79)|" . "6(?:3[68]|4[024]|75)|7(?:0[68]|10|3[09]|6[29]|91)|" . "8(?:0[29]|4[09]))|" . "9(?:0(?:6[3579]|7[1357])|1(?:74|9[29])|2(?:2[79]|69)|" . "3(?:02|2[09]|48|68|79|87|9[49])|4(?:2[357]|39|57|69|" . "94)|5(?:05|1[049]|5[5-8]|81|9[07])|60[29]|75[579]|" . "8(?:2[13]|46|72|89)|9(?:09|29|39|55|6[49])))" . "|6(?:0(?:3(?:08|1[13468]|2[0235-79]|8[5689])|4(?:3[1357-9]|" . "8[6-9])|5(?:2[89]|49|9[4689]))|" . "1(?:1(?:18|3[078]|69|84|9[147])|2(?:0[0369]|3[19]|50|67|" . "7[369])|3(?:48|5[02]|8[19])|4(?:4[09]|62|7[69]))|" . "3(?:0(?:6[579]|7[135])|1(?:10|28|50|65|79)|2(?:25|63)|" . "3(?:03|2[29])|4(?:05|5[02467]|77|86)|5(?:0[05]|1[27]|" . "26|3[38]|4[369]|7[19]|8[49]|9[49])|6(?:07|19|28|" . "3[3679]|54|67|7[49]|8[38]|9[14579])|7(?:39|4[13]|55|" . "6[28]|7[36]|85|9[16])|8(?:0[18]|1[14]|2[05689]|3[149]|" . "4[0369]|5[367]|6[0347-9]|7[124579]|97)|9(?:06|1[16]|" . "2[04578]|3[0134679]))|" . "4(?:2(?:8[3579]|9[1357])|3(?:19|31|4[27]|54|67|72|8[05]|" . "9[057])|40[14579]|5(?:21|46|6[09]|7[29]|8[49])|6(?:25|" . "46|5[38]|6[58]|7[38]|8[369])|7(?:11|20|3[29]|4[37]|" . "5[034679])|8(?:07|23|3[29]|46|5[039]))|" . "5(?:1(?:8[3579]|9[13579])|2(?:0[1357]|19|2[0-4]|3[29])|" . "3(?:07|2[169]|4[3-7]|66|75|8[58]|9[169])|4(?:28|39|51|" . "6[28]|7[49])|5(?:10|2[079]|49|5[0-68]|8[29]|9[479])|" . "6(?:0[46]|1[148]|2[034679])|7(?:19|60|79|95)|" . "8(?:1[27]|24|3[05]|43)|9(?:29|3[1346]))|" . "6(?:1(?:1[13579]|2[135-9]|3[0-3])|2(?:65|71|8[07]|9[29])|" . "3(?:33|46|5[29]|86|99)|4(?:24|40|5[039]|8[24]|97)|" . "5(?:0[0134679]|3[89]|40|57|64|7[18]|8[39])|6(?:06|" . "2[059]|36|4[069]|63|79|87|93)|7(?:0[169]|40|63|73|" . "8[07]|9[38])|8(?:0[269]|22|39|49|51|6[29]|7[179]|" . "8[257]|9[24])|9(?:0[13479]|1[4679]|5[3-57]|69|7[68]|" . "8[179]|9[469]))|" . "7(?:0(?:59|6[13579]|71|98)|1(?:05|1[27]|2[25-7]|3[346]|" . "4[1679]|5[027-9]|6[15-79])|2(?:2[79]|4[056]|5[1689]|" . "69|7[138]|8[013]|9[2457])|3(?:0[4578]|1[01679]|46|54|" . "6[013568]|7[346-8])|4(?:3[3-5]|5[49]|6[68]|7[1-35]|" . "8[02379])|5(?:4[79]|5[01]|7[4578]|8[0235-7]|" . "9[0-35689])|6(?:5[3579]|6[13]|7[78]|8[01568]|9[1379])|" . "7(?:0[015-7]|1[4-68]|2[2457-9]|3[12457]|4[24-689]|" . "5[2-4679])|8(?:0[68]|1[134679]|2[1-4679]))|" . "8(?:1(?:59|6[13579]|99)|2(?:19|29|39|59)|30[579]|5(?:19|" . "26|35|4[29])|6(?:23|4[279])|7(?:23|53|66|75|8[29]|" . "9[49])|80[49])|" . "9(?:1(?:1[578]|2[01346]|51|68|81|9[08])|2(?:07|14|2[16]|" . "3[149]|4[25]|5[0134679])|4(?:12|2[79]|3[4679]|69|" . "8[38]|93)|5(?:0[29]|1[478])))" . "|7(?:0(?:1(?:7[3468]|8[02468]|9[0-3579])|3(?:2[79]|7[2468])|" . "4(?:3[579]|69|99)|5(?:6[3579]|9[79])|6(?:19|29)|" . "7(?:3[46]|71|94)|8(?:06|25|39))|" . "1(?:0(?:3[24]|6[3579]|8[38]|93)|1(?:0[16]|1[16]|2[06]|" . "3[149]|4[49]|5[4579])|2(?:29|54|63|7[27]|8[27]|" . "9[2679])|3(?:3[246]|64|84|9[47])|40[49]|5(?:22|" . "4[0369]|54|6[036]|7[03679])|6(?:3[468]|4[02]|65|7[29]|" . "86|9[16])|7(?:0[16]|1[178]|2[0369]|3[2579]))|" . "2(?:07[0246]|1(?:08|1[69]|2[47]|3[158]|4[14579]|60|7[258]|" . "8[1469])|2(?:02|1[38]|2[14679]|50|7[05]|8[05]|" . "9[0134679])|3(?:36|48|5[15689]|6[124579]|79|93)|" . "4(?:0[16]|1[14579]|5[89]|6[19]|7[4579]|88)|5(?:0[15]|" . "1[0134679]|25|3[124579]|55|74|8[124579])|6(?:22|" . "3[169]|4[49]|5[4578]|6[0134679])|7(?:6[02468]|70|93)|" . "8(?:0[05]|1[038]|2[079]))|" . "3(?:0(?:3[357]|54|6[16]|7[29]|8[47]|9[2589])|" . "1(?:0[124578]|1[0134679])|2(?:07|3[05]|4[09]|5[27]|" . "6[25689]|7[124578])|3(?:12|2[69]|3[37]|4[024579])|" . "4(?:3[0-4]|4[17]|5[037]|6[03679]|79|8[5689]|" . "9[124579])|5(?:2[579]|4[07]|5[037]|6[035689]|" . "7[124579])|6(?:14|3[05]|42|5[05]|6[03679])|7(?:28|" . "3[02-4]|6[05]|7[0369]))|" . "4(?:0(?:7[2468]|8[01])|1(?:7[27]|8[29]|9[369])|2(?:06|" . "1[149]|2[369]|3[2589]|4[35689]|5[124579])|3(?:21|" . "3[67]|4[38]|5[47]|6[0369]|7[2469]|8[2589]|9[124579])|" . "4(?:05|17|2[034679])|5(?:23|3[258]|4[124579]|64|" . "7[259]|8[2569]|9[24579])|6(?:13|2[69]|3[2589]|53|" . "7[03679])|7(?:06|22|3[16]|4[034679])|8(?:21|3[1248]|" . "4[27]|5[058]|6[124579]|89)|9(?:0[69]|1[258]|2[14578]|" . "3[0134679]))|" . "5(?:0(?:15|3[18]|45|5[03679])|1(?:7[23579]|8[01]|96)|" . "2(?:03|1[07]|2[38]|3[369]|4[2589])|3(?:05|2[38]|" . "3[14579]|65|78|8[2579]|9[124579])|4(?:17|28|3[38]|" . "4[3679]))|" . "6(?:006|1(?:3[13579]|49|8[579]|99)|2(?:2[7-9]|75|87|97)|" . "3(?:07|16|27|3[27]|44|5[169])|4(?:37|48|56|6[17]|" . "7[034679])|5(?:3[024]|4[79]|71|9[3679])|6(?:46|6[19]|" . "76|8[49]|9[48])|7(?:0[3679]|26|44|5[16]|6[1478]|" . "7[0134679])|8(?:29|3[135]|4[68]|5[57]|6[35]|7[0279]|" . "8[79]|91))|" . "7(?:6(?:5[246]|94)|7(?:0[49]|16|2[38]|3[16]|4[0369]|56|" . "6[17]|7[036]|8[147]|9[0134679])|8(?:15|3[0369]|55|66|" . "7[16]|8[03679])|9(?:33|4[48]|55|6[036]|7[124578]))|" . "8(?:0(?:48|5[0246]|7[38]|8[3679]|98)|1(?:12|2[06]|3[26]|" . "4[1478]|66|76|8[37]|9[49])|2(?:24|3[49]|4[47]|5[0369]|" . "6[2679])|3(?:15|3[37]|4[35]|5[14579])|4(?:6[2457]|" . "7[69])|5(?:32|49|5[49]|6[47]|7[0369]|8[0235689]|" . "9[124578])|6(?:0[0134679]|28|47|5[258]|6[124579])|" . "7(?:13|27|3[03679]))|" . "9(?:098|1(?:0[02468]|1[0-2457]|8[39]|9[49])|2(?:06|1[159]|" . "2[47]|3[258]|4[149]|5[2468]|6[138]|7[1469]|8[0235689]|" . "9[124579])|3(?:12|3[16]|4[168]|5[0369]|6[124579]|79|" . "95)|4(?:00|1[058]|2[34679])|5(?:13|39|4[01]|7[68]|" . "8[589]|9[124579])|6(?:18|39|50|6[49]|7[47]|8[235689]|" . "9[124579])|7(?:13|25|3[03679]|61|7[147]|8[07]|9[038])|" . "8(?:0[124579]|22|37|4[38]|5[369]|6[258]|7[124579])))" . "|8(?:0(?:33[135-79]|469|53[89]|6(?:3[46-9]|8[679])|79[6-9]|" . "80[1-579]|9(?:3[3579]|9[23579]))|" . "1(?:24[13579]|3(?:69|7[13579])|47[5-79]|5(?:39|4[13579])|" . "6(?:6[79]|7[13579])|73[579]|82[579]|92[579])|" . "2(?:0(?:08|24|3[12]|4[19]|5[47]|6[14579])|1(?:10|31|40|52|" . "66|78|94)|2(?:05|1[16]|2[39]|3[479]|56|6[69]|7[25689]|" . "8[124578]|9[0134679])|3(?:19|27|35|4[03679]|62|77|" . "8[03679]|9[0235689])|4(?:0[124579]|18|3[1-35689]|" . "4[124579]|67|8[178]|9[0134679])|5(?:15|38|4[1479]))|" . "3(?:0(?:2[246]|43|5[29]|64|7[15]|8[038]|9[38])|1(?:0[149]|" . "1[259]|2[235689]|3[124579])|2(?:09|2[49]|3[36]|4[26]|" . "5[034679]|78)|3(?:0[18]|1[37]|2[49]|3[49]|4[2469]|" . "5[2589]|6[124578]|7[0134679]|95)|4(?:04|1[0367]|35|" . "5[1478]|71|8[3679])|5(?:12|27|3[0369]|4[34679]|" . "5[0235689]|6[124579])|6(?:07|2[034679]|46|6[16]|" . "7[0134679]|84)|7(?:0[0378]|14|27|3[04579]))|" . "4(?:0(?:28|3[0246]|48|5[16]|6[169]|7[269]|8[2589]|" . "9[124578])|1(?:0[0134679]|3[07]|4[049]|5[25]|" . "6[034689]|7[124578]|8[0134679])|3(?:07|2[369]|" . "3[23579]|47|59|6[47]|7[158]|8[14579])|4(?:05|1[69]|" . "2[478]|3[124579]|53|78|89|94)|5(?:0[38]|1[38]|2[49]|" . "3[39]|4[34679]|5[0235689]|6[124578]|7[0134679]))|" . "5(?:0(?:49|5[1357]|7[27]|8[048]|9[258])|1(?:0[147]|" . "1[0134679]|2[0235689]|3[124579])|2(?:2[19]|3[258]|" . "4[147]|5[034689]|76|83|9[0368])|3(?:0[124579]|5[46]|" . "68|7[56]|86|9[159])|4(?:0[2568]|1[0134679]|35|4[57]|" . "5[2679]|6[124579])|5(?:21|40|51|6[07]|7[09]|86|" . "9[189])|6(?:0[49]|1[47]|2[25]|3[05]|4[0369]|5[235689]|" . "6[124579])|7(?:16|37|48|57|64|7[478]))|" . "6(?:1(?:5[02-4679]|6[13579]|79|99)|3(?:16|43|56|68|81|" . "9[19])|4(?:05|15|2[04]|38|4[147]|5[0369]|6[25]|" . "7[03679]|8[0235689]|9[124578])|5(?:0[024578]|" . "1[013479]|29|5[14689]|6[124578]|7[0134679])|6(?:09|" . "3[37]|4[137]|5[0357]|6[03689]|7[2-689]|8[124578]|" . "9[024578])|7(?:0[0134679]|20|3[235689]|4[124578]|" . "5[0134679])|8(?:07|25|3[036]|4[25]|5[034679]|" . "6[0235689]|7[124579]|99)|9(?:1[169]|2[0235689]|" . "3[124578]|4[0134679]|56|7[124578]|8[0134679]))|" . "7(?:4(?:3[579]|48|5[29]|6[36]|7[147]|8[0478]|9[034679])|" . "5(?:09|27|3[48]|4[14579]|61)|6(?:00|16|29|3[47]|" . "4[02578]|5[0134679]|6[0235689]|7[124579])|7(?:00|19|" . "2[47]|3[034679]|4[0235689]|5[124578]|6[0134679]|" . "7[0235689]|8[124579]))|" . "8(?:0(?:4[568]|69|7[49]|8[56]|9[0479])|1(?:3[18]|4[2579]|" . "6[17]|7[1589])|2(?:1[2-4]|39|5[05]|6[037]|7[1369]|" . "8[14579]|99)|3(?:1[679]|26|39|48|5[36]|6[1478]|" . "7[0134679])|4(?:00|1[06]|2[27]|3[0367]|4[1478]|" . "5[0134679]|7[17]|8[0134679]|99)|5(?:1[258]|2[14579])|" . "6(?:05|3[0134679]|62|77|82|9[03679])|7(?:09|1[89]))|" . "9(?:0(?:40|7[3579]|81)|1(?:29|34|43|5[05]|6[058]|" . "7[134679]|8[0235689]|9[124578])|2(?:3[13]|5[07]|6[49]|" . "7[58]|8[147]|9[0134679])|3(?:12|3[15]|4[034679]|" . "5[0235689]|6[124578])|4(?:07|15|2[03689]|3[124578]|" . "4[0134679])|5(?:18|2[02]|37|4[27]|5[158]|6[1478]|84|" . "97)|6(?:0[14578]|1[0134679])))" . "|9(?:0(?:4(?:0[2389]|1[19]|2[579]|3[19]|4[139]|5[13579]|6[19]|" . "7[1358]|8[029]|91)|5(?:1[38]|22|3[07]|4[27]|5[269]|62|" . "7[149]|8[47]|9[269])|6(?:0[27]|1[034679])|76[23568])|" . "1(?:0(?:5[2468]|7[47]|8[03568]|9[0134679])|1(?:26|54|" . "6[16]|7[147]|8[03679])|2(?:07|17|2[047]|3[035689]|" . "4[124579]|57|7[58]|8[124679])|3(?:01|15|2[0257]|" . "3[02468]|4[14679]|5[0235689]|6[124579])|4(?:13|38|" . "4[38]|5[269]|6[0235689]|7[124578]|8[0134679])|5(?:22|" . "41|5[05]|6[047]|7[258]|8[03679]|9[0235689])|" . "6(?:0[124578]|1[0134679]|2[0235689]|3[124579])|" . "7(?:1[079]|2[0235689]|3[124578]|4[0134679]|57|8[158]|" . "9[0235689])|80[124579])|" . "2(?:2(?:24|37|4[259]|5[369]|6[0235689]|7[124578]|" . "8[0134679])|3(?:18|3[149]|4[258]|5[358]|6[0134679])|" . "4(?:21|3[169]|4[24579])|5(?:07|2[16]|3[369]|" . "4[0235689]|5[124579])|6(?:37|48|55|6[05]|7[06]|8[15]|" . "9[034679])|7(?:0[0235689]|1[124578]|2[0134679]))|" . "3(?:0(?:4[79]|5[13579]|7[37]|8[03679]|9[0235689])|" . "1(?:0[124579]|28|3[38]|4[29]|5[258]|6[147]|7[03679]|" . "8[0235689]|9[124579])|3(?:09|26|3[369]|4[235689]|" . "5[124689])|4(?:13|26|37|4[49]|5[358]|6[2468]|" . "7[0134679]|8[0235689]|9[124579]))|" . "4(?:0(?:3[246]|51|6[05]|7[28]|8[169]|9[49])|1(?:0[47]|" . "1[0368]|2[147]|3[03679]|4[0235689]|5[124578]|" . "6[0134679])|2(?:09|27|3[49]|4[49]|5[0235689]|" . "6[124579])|3(?:15|27|3[0369]|4[24578]|5[0134679]|" . "6[0235689]|7[124579])|4(?:05|19|2[48]|3[1679]|47|69|" . "74|8[16]|9[16])|5(?:0[158]|1[38]|2[2679]|3[0235689]|" . "4[124578]|5[0134679]|6[0235689]|7[124579]))|" . "5(?:0(?:28|3[02])|1(?:00|1[19]|26|3[18]|45|5[28]|6[38]|" . "7[369]|8[0235689]|9[124579])|2(?:13|3[34679])|3(?:26|" . "3[69]|4[69]|5[25689]|6[124579])|4(?:4[4578]|6[0369]|" . "7[38]|8[258]|9[0134679])|5(?:0[0235689]|1[124579])|" . "6(?:15|32|43|5[29]|66|7[169]|8[0235689]|9[124578])|" . "70[0134679])|" . "6(?:0(?:4[79]|5[02])|1(?:0[36]|1[047]|2[0369]|3[258]|" . "4[25689]|5[124578]|6[0134679]|7[0235689]|8[124578]|" . "9[0134679])|2(?:15|24|3[17]|4[27]|5[037]|6[0489]|" . "7[124579])|3(?:17|28|3[27]|4[269]|5[258]|6[14579])|" . "4(?:50|65|7[269]|8[24679])|5(?:15|2[348]))|" . "7(?:0(?:7[02468]|8[024])|199|2(?:0[49]|1[58]|2[258]|" . "3[024679]|4[134679]|5[0235689]|6[124578]|7[0134679]|" . "8[0235689]|9[124579])|3(?:18|20|3[247]|4[0268]|" . "5[03579])|4(?:12|2[124]|37|4[07]|5[036]|6[149]|7[58]|" . "8[368]|9[0134679])|5(?:0[0235689]|1[134679]|" . "2[0235689]|3[124579])|6(?:1[68]|3[138]|4[057]|" . "5[034679]|88)|7(?:0[258]|1[147]|2[03-579]|37|53|6[29]|" . "7[235689]|8[0235689]|9[124579])|8(?:16|28|3[34679]|" . "4[0235689]|5[124579]|77|9[26])|9(?:0[0134679]|22|" . "4[147]|5[03679]|80|9[0369]))|" . "8(?:5(?:2[7-9]|30|4[47]|5[349]|74|87|9[03679])|6(?:17|" . "3[149]|46|6[03679]|7[38]|93)|7(?:0[148]|1[146]|24|39|" . "4[3469]))|" . "9(?:0(?:8[4-79]|9[1246-9])|1(?:0[02]|30|89|9[258])|3(?:10|" . "26|3[048])|4(?:2[3578]|3[89]|4[148])|51[08]|6(?:10|" . "2[58]|3[1468])|7(?:06|1[38]|3[45]|5[259]|6[258])|" . "8(?:1[79]|26|3[0147]|4[268]|6[79]|8[057]|9[1478])|" . "9(?:47|5[58]|7[46]|8[68]|9[1468])))" . ")", # # Postal codes of Greenland use a slice of the Danish postal code system. # Greenlands postal code consist of 4 digits, the first two being 39. # Except Santas postal code. He uses 2412. # # Data from: http://download.geonames.org/export/zip/GL.zip # Greenland => "(?k:2412" . "|39(?:0[05]|1[0-359]|2[0-4]|3[02]|40|5[0-35]|6[124]|" . "7[0-2]|8[0245]|92)" . ")", # # Postal codes for Italy use 5 digits, with leading 0s. Codes starting # with 4789 belong to San Marino. # # Data from: http://download.geonames.org/export/zip/IT.zip # Italy => "(?k:0(?:0(?:0(?:1[0-357-9]|2[0-9]|3[0-9]|4[0-9]|5[0-57-9]|" . "6[0-35-9])|1(?:19|2[0-8]|3[1-9]|4[1-9]|5[1-9]|6[1-9]|" . "7[1-9]|8[1-9]|9[1-9]))|" . "1(?:0(?:1[0-24-9]|2[0-8]|3[02-9])|100)|" . "2(?:0(?:1[0-689]|2[0-68]|3[0-57-9]|4[0-9])|100)|" . "3(?:0(?:1[0-46-9]|2[0-9]|3[0-9]|4[0-9])|100)|" . "4(?:0(?:1[0-9]|2[0-9])|100)|" . "5(?:0(?:1[0-8]|2[0-689]|3[0-2459])|100)|" . "6(?:0(?:1[024689]|2[0-9]|3[013-689]|4[0-79]|5[013-79]|" . "6[0-689]|7[023]|8[1349])|1(?:00|2[1-9]|3[124]))|" . "7(?:0(?:1[0-9]|2[0-9]|3[0-9]|4[013-9])|100)|" . "8(?:0(?:1[0-35-9]|2[0-9]|3[0-9]|4[02-9])|100)|" . "9(?:0(?:1[0-9]|2[0-9]|3[0-9]|4[0-57-9]|7[0-9]|8[0-68]|" . "9[0-9])|1(?:00|2[1-9]|3[14]|70)))" . "|1(?:0(?:0(?:1[0-9]|2[02-689]|3[0-24-8]|4[0-68]|5[0-9]|6[0-9]|" . "7[0-8]|8[0-8]|9[0-589])|1(?:00|2[1-9]|3[1-9]|4[1-9]|" . "5[1-6]))|" . "1(?:0(?:1[0-8]|2[0-9])|100)|" . "2(?:0(?:1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-68]|6[0-689]|" . "7[0-9]|8[0-47-9])|100)|" . "3(?:0(?:1[0-27-9]|2[0-8]|3[0-9]|4[013-9]|60)|100|" . "8(?:1[124-8]|2[1-5]|3[13-6]|4[13-578]|5[1-6]|6[1-8]|" . "7[1-8]|8[1-8]|9[13-9])|900)|" . "4(?:0(?:1[0-9]|2[0-6]|3[0-79]|4[0-9]|5[0-57-9])|100)|" . "5(?:0(?:1[0-9]|2[0-9]|3[0-689]|4[0-689]|5[0-9]|6[0-9]|" . "7[0-9])|100)|" . "6(?:0(?:1[0-9]|2[0-9]|3[0-689]|4[0-9])|1(?:00|2[1-9]|" . "3[1-9]|4[1-9]|5[1-9]|6[1-7]))|" . "7(?:0(?:1[0-579]|2[0-8]|3[0-57-9]|4[0-8]|5[1-8])|100)|" . "8(?:0(?:1[0-9]|2[0-7]|3[0-9])|100)|" . "9(?:0(?:1[0-8]|2[0158]|3[0-478])|1(?:00|2[1-6]|3[1-9])))" . "|2(?:0(?:0(?:1[0-9]|2[0-9]|3[027]|40|56|6[0-9]|7[078]|8[0-9]|" . "9[0-9])|1(?:2[1-9]|3[1-9]|4[1-9]|5[1-9]|6[12])|" . "8(?:1[1-6]|2[1-6]|3[1-8]|4[1-7]|5[1-7]|6[1-7]|7[1-7]|" . "8[1-6])|900)|" . "1(?:0(?:1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9])|100)|" . "2(?:0(?:1[0-9]|2[0-9]|3[0-9]|4[04-6]|6[0369]|7[0-9])|100)|" . "3(?:0(?:1[0-9]|2[0-79]|3[0-8])|100|8(?:0[124-8]|1[13-9]|" . "2[1-9]|3[1-8]|4[1-9]|5[12457]|6[124578]|7[013-9]|" . "8[013-9]|9[0-9])|900)|" . "4(?:0(?:1[0-9]|2[0-9]|3[013-9]|4[0-9]|5[0-9]|6[0-9])|" . "1(?:00|2[1-9]))|" . "5(?:0(?:1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|6[0-589]|" . "7[0-9]|8[0-9])|1(?:00|2[1-9]|3[1-6]))|" . "6(?:0(?:1[0-9]|2[0-9]|3[0-9]|4[0-9])|100|8(?:1[1-8]|" . "2[1-8]|3[1-9]|4[1-9]|5[1-9]|6[1-7])|900)|" . "7(?:0(?:1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-57-9])|100)|" . "8(?:0(?:1[0-79]|2[148]|4[0135-7]|5[03]|6[0-24-689]|" . "7[0-9])|100|8(?:0[1-5]|1[1-9]|2[1-8]|3[1-368]|4[1-5]|" . "5[1-9]|6[1-68]|7[135-79]|8[13-7]|9[13-9])|922)|" . "9(?:0(?:1[0-9]|2[0-9])|100))" . "|3(?:0(?:0(?:1[03-6]|2[0-9]|3[0-9])|1(?:00|2[1-6]|3[1-35]|" . "4[12]|7[0-5]))|" . "1(?:0(?:1[0-8]|2[0-9]|3[0-9]|4[0-9]|5[0-9])|100)|" . "2(?:0(?:1[02-6]|2[0-26-8]|3[0-7]|4[0-7])|100)|" . "3(?:0(?:1[0135-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|7[024-9]|" . "8[0-7]|9[02457-9])|1(?:00|70))|" . "4(?:0(?:1[0-24-8]|7[0-9])|1(?:00|2[1-9]|3[1-9]|4[1-9]|51|" . "70))|" . "5(?:0(?:1[0-9]|2[0-9]|3[0-24-8]|4[0-8])|1(?:00|2[1-9]|" . "3[1-9]|4[1-3]))|" . "6(?:0(?:1[0-6]|2[0-8]|3[0-6]|4[0235-7]|5[0-7]|6[0-6]|" . "7[0-35-8])|100)|" . "7(?:0(?:1[0-9]|2[0-4689]|3[0-25689]|4[0-79]|5[0-9]|" . "6[02-46-9])|1(?:00|2[1-9]|3[1-9]|42))|" . "8(?:0(?:1[0-35-9]|2[0-9]|3[0-9]|4[0-35-9]|5[0-79]|6[0-9]|" . "7[0-9]|8[0-35-9])|100)|" . "9(?:0(?:1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-8])|100))" . "|4(?:0(?:0(?:1[0-9]|2[0-7]|3[02-8]|4[1-3568]|5[0-79]|6[0-9])|" . "1(?:00|2[1-9]|3[1-9]|41))|" . "1(?:0(?:1[0-9]|2[0-35-9]|3[0-9]|4[02-689]|5[1-9])|100)|" . "2(?:0(?:1[0-9]|2[0-8]|3[0-579]|4[0-9])|100)|" . "3(?:0(?:1[0-57-9]|2[0-24589]|3[025-9]|4[0-57-9]|" . "5[0-35689])|1(?:00|26))|" . "4(?:0(?:1[0-24-69]|2[0-35-9]|3[03-579]|4[1-357-9])|100)|" . "5(?:0(?:1[0-2457-9]|2[0-7]|3[0-9])|100)|" . "6(?:0(?:1[0-47-9]|2[02-9]|3[0-35-79]|4[0-9])|100)|" . "7(?:0(?:1[0-9]|2[013578]|3[02459]|4[23])|1(?:00|2[12])|" . "8(?:14|2[24-6]|3[2-8]|4[1-3]|5[3-5]|6[1-7])|900)|" . "8(?:0(?:1[0-578]|2[024-7])|100))" . "|5(?:0(?:0(?:1[02-489]|2[0-35-8]|3[1-9]|41|5[0-689]|6[0-8])|" . "1(?:00|2[1-79]|3[1-79]|4[1-5]))|" . "1(?:0(?:1[0-35-9]|2[0148]|3[014-79])|100)|" . "2(?:0(?:1[014-8]|2[0-24-9]|3[0-35-8]|4[13-8])|100)|" . "3(?:0(?:1[1-9]|2[0-7]|3[014-7]|4[0-357-9])|100)|" . "4(?:0(?:1[0-6]|2[136-9]|3[358])|100)|" . "5(?:0(?:1[0-689]|2[02357]|3[0-68]|4[0-2579]|5[14]|" . "6[0-24])|100)|" . "6(?:0(?:1[0-279]|2[0-589]|3[0-8]|4[013-68])|1(?:00|" . "2[1-8]))|" . "7(?:0(?:1[467]|2[0-3578]|3[0-46-9])|1(?:00|2[1-8]))|" . "8(?:0(?:1[0-2457-9]|2[02-7]|3[1346-8]|4[02-5]|5[13-5])|" . "100)|" . "9(?:0(?:1[1356]|2[14-6])|100))" . "|6(?:0(?:0(?:1[013589]|2[0-24-7]|3[013-9]|4[01348])|1(?:00|" . "2[1-9]|31))|" . "1(?:0(?:1[0-4]|2[0-689]|3[02-47-9]|4[0-9])|100)|" . "2(?:0(?:1[0-2457-9]|2[0-24-9]|3[24-689])|100)|" . "3(?:0(?:20|31|6[1-9]|7[1-9]|8[1-8]|9[1-6])|100|8(?:1[1-6]|" . "2[1-8]|3[1-9]|4[1-8]|5[1-8])|900)|" . "4(?:0(?:1[0-68]|2[013-8]|3[0-79]|4[0-79])|100)|" . "5(?:0(?:1[0-579]|2[02-9])|1(?:00|2[1-9]|3[12]))|" . "6(?:0(?:1[0-24-9]|2[0-36]|3[0-46-8]|4[0-7]|5[0-24])|100)|" . "7(?:0(?:1[02-579]|2[0-9]|3[0-9]|4[013-9]|5[0-9]|" . "6[0-46-9])|100))" . "|7(?:0(?:0(?:1[013-9]|2[0-9]|3[2378]|4[2-4]|5[46])|1(?:00|" . "2[1-9]|31))|" . "1(?:0(?:1[0-9]|2[0-9]|3[0-9]|4[0-3578])|100)|" . "2(?:0(?:1[02-9]|2[0-9])|100)|" . "3(?:0(?:1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9])|100)|" . "4(?:0(?:1[0-9]|2[0-8])|100)|" . "5(?:0(?:1[0-9]|2[0-9])|100)|" . "6(?:01[1-7]|12[135]))" . "|8(?:0(?:0(?:1[0-46-9]|2[0-9]|3[0-689]|4[0-24-9]|5[013-9]|" . "6[0-35-79]|7[013-9])|1(?:00|2[1-9]|3[1-9]|4[1-7]))|" . "1(?:0(?:1[0-467]|2[0-578]|3[0-9]|4[0-4679]|5[0-9])|100)|" . "2(?:0(?:1[0135-9]|2[0-9]|3[0-46-8])|100)|" . "3(?:0(?:1[0-8]|2[0-9]|3[0-24-9]|4[0-9]|5[0-9])|100)|" . "4(?:0(?:1[0-9]|2[0-9]|3[0-9]|4[02-9]|5[0-35-79]|6[0-25-9]|" . "7[03-9]|8[0-8]|9[0-25689])|1(?:00|2[1-9]|3[1-5]))|" . "5(?:0(?:1[0-8]|2[0-9]|3[0-9]|4[02-46-9]|5[0-9])|100)|" . "6(?:0(?:1[0-9]|2[0-9]|3[0-9]|4[0-9]|7[0-57-9]|8[0-9]|" . "9[0-7])|1(?:00|70))|" . "7(?:0(?:1[0-9]|2[0-46-9]|3[0-8]|4[0-8]|5[0-8]|6[0-24679]|" . "7[0-6])|100)|" . "8(?:0(?:2[0-245]|4[0-24-79]|5[014-6]|6[02457-9]|70)|100|" . "8(?:1[1-9]|2[1-5]|3[1-8]|4[12])|900)|" . "9(?:0(?:1[0-8]|2[0-9]|3[0-9]|4[0-9]|5[0246-8]|6[02-59])|" . "1(?:00|2[1-9]|3[1-5])|8(?:1[2-9]|2[1-4]|3[1-4]|4[1-4]|" . "5[1-3]|6[1-46-8])|900))" . "|9(?:0(?:0(?:1[0-9]|2[0-9]|3[0-9]|4[0-9])|1(?:00|2[1-9]|3[1-9]|" . "4[1-9]|51))|" . "1(?:0(?:1[0-9]|2[0-9])|100)|" . "2(?:0(?:1[0-9]|2[0-9])|100)|" . "3(?:01[0-9]|100)|" . "4(?:01[0-9]|100)|" . "5(?:0(?:1[0-9]|2[0-2457-9]|3[0-9]|4[0-9])|1(?:00|2[1-9]|" . "31))|" . "6(?:01[0-9]|100)|" . "7(?:01[0-9]|100)|" . "8(?:0(?:2[0-35-9]|3[0-9]|4[0-9]|5[013-9]|6[0-9]|7[0-9])|" . "1(?:00|2[1-9]|3[1-9]|4[1-9]|5[1-9]|6[1-8])))" . ")", # # The numbering system for postal codes of Liechtenstein is part of # the numbering system for Swiss postal codes. Four digits are used # and all postal codes in Liechtenstein start with 94, the third # digit an 8 or a 9. # # Data from: http://download.geonames.org/export/zip/LI.zip # # The file above does not include 9489 (instead, a different file # reports it to be in CH), but 9489 is the postal code for Schaan Log, # which is located in Liechtenstein. # # http://postal-codes.findthedata.com/l/57083/9489-Schaan-Log # Liechtenstein => "(?k:94(?:8[5-9]|9[0-8]))", # # https://www.post.lu/documents/10181/2314856/EptSggaCsv.csv/ # ee8fa0de-5e84-4e31-8cbd-b7b57679c21a?param=0.19755403072045696 # (http://bit.ly/1PeTVqY) # Luxembourg => "(?k:0(?:1(?:01|2[13-5]|3[12]|4[1-3]|61|7[13]|8[1-3]|9[12])|" . "2(?:02|11|31|41|51|6[23]|91)|" . "3(?:2[1-5]|32|42|6[12]|72|8[1-3]|91)|" . "4(?:0[1-3]|1[12]|2[12]|4[1-356]|5[13]|6[2-4]|7[12]|8[12]|" . "9[1-7])|" . "5(?:21|3[12]|5[1-4]|6[12]|8[1-4])|" . "6(?:1[12]|4[1-4]|6[1-4]|7[12]|9[12])|" . "7(?:2[1-3]|5[1-4]|6[13]|7[12])|" . "8(?:0[1-9]|1[1-4]|2[1-3]|3[1-4]|41|5[2-5]|61|81)|" . "9(?:0[134]|1[1-4]|2[12]|4[2-4]|5[1-4]|6[1-3]|7[1-3]|" . "8[1-3]|9[1-5]))" . "|1(?:0(?:09|1[0-9]|2[0-9]|30|50|60|90)|" . "1(?:1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-39]|6[01])|" . "2(?:0[89]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|6[0-9]|" . "7[0-9]|8[0-3])|" . "3(?:09|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|6[0-9]|7[0-6])|" . "4(?:09|1[1-9]|2[0-9]|3[0-4]|4[589]|5[0-9]|6[0-9]|7[0-9]|" . "8[0-4]|9[09])|" . "5(?:0[89]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-2])|" . "6(?:1[013-9]|2[0-9]|3[0-9]|4[0-9]|5[0-6]|6[01]|70)|" . "7(?:09|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-3])|" . "8(?:1[1-8]|2[0-2]|3[1-9]|4[0-356]|5[0-9]|6[0-8]|7[0-3]|" . "8[0-2]|9[6-9])|" . "9(?:1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-4]))" . "|2(?:0(?:1[0-9]|20|8[024-9]|9[013-9])|" . "1(?:1[1-9]|2[0-57-9]|3[0-57-9]|4[0-9]|5[0-9]|6[0-9]|" . "7[0-9]|8[0-4])|" . "2(?:1[0-5]|2[0-9]|3[0-4]|4[0-3]|6[1-35-9]|7[0-3])|" . "3(?:0[89]|1[0-9]|2[02-46-9]|3[0-9]|4[0-9]|5[0-9]|6[01]|70|" . "8[01])|" . "4(?:09|1[0-9]|2[02-9]|3[0-6]|4[0-9]|5[0-4])|" . "5(?:1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|6[0-7])|" . "6(?:09|1[0-79]|2[0-9]|3[0-7]|5[1-4]|6[1-9]|7[0-4]|8[01])|" . "7(?:1[1-9]|2[0-9]|3[0-46-9]|4[01]|6[1-4])|" . "8(?:50|60|8[07-9])|" . "9(?:00|1[0-689]|2[0-25689]|3[0-9]|4[0-269]|5[0-8]|" . "6[014-68]|7[14-9]|8[0-8]|9[0-24-9]))" . "|3(?:2(?:0[15689]|1[0-9]|2[0-59]|3[0-9]|4[0-39]|5[0-9]|" . "6[015-79]|7[0-9]|8[0-8]|90)|" . "3(?:1[13-8]|2[0-9]|3[02-7]|4[015-9]|5[0-9]|6[0-9]|7[0-8]|" . "8[02-69]|9[0-8])|" . "4(?:0[1-39]|1[0-9]|2[0-9]|3[0-3569]|4[0-9]|5[0-4]|6[0-9]|" . "7[0-6]|8[0-9]|9[0-3])|" . "5(?:0[1-9]|1[0-7]|2[0-69]|3[0-29]|4[0-9]|5[0-5]|6[0-9]|" . "7[0-6]|8[2-589]|9[0-8])|" . "6(?:01|1[1-7]|2[0-2]|3[015-8]|4[0-4]|5[0-8]|60|7[0-9]|" . "8[0-2])|" . "7(?:0[15]|1[0-9]|2[0-9]|3[013-9]|4[0-4]|5[0-5]|6[1-8]|" . "7[0-6]|8[0-246-9]|90)|" . "8(?:01|1[0-9]|2[0-6]|3[0-9]|4[0-4]|5[0-9]|6[0-4]|7[0-9]|" . "8[0-4]|9[5-9])|" . "9(?:0[19]|1[0-9]|2[0-9]|3[0-9]|4[013-5]|6[01]|8[05]))" . "|4(?:0(?:0[1-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|6[0-9]|" . "7[0-4]|8[0-68])|" . "1(?:0[0-35-9]|1[0-689]|2[0-356]|3[0-9]|4[0-39]|5[0-6]|" . "6[4-9]|7[0-9]|80)|" . "2(?:0[1-9]|1[013467]|2[0-2]|3[0-9]|4[0-9]|5[0-6]|6[0-8]|" . "7[0-25-9]|8[0-39])|" . "3(?:0[1-9]|1[04-9]|2[0-8]|3[0-7]|4[0-9]|5[0-5]|6[0-9]|" . "7[0-3]|8[0-5]|9[0-8])|" . "4(?:0[125-9]|1[0-9]|2[0-39]|3[0-9]|4[0-9]|5[019]|6[0-9]|" . "7[05-9]|8[0-9]|9[0-49])|" . "5(?:0[1-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|6[0-59]|" . "7[0-9]|8[0-3]|9[0-9])|" . "6(?:0[1-9]|1[0-3]|2[0-9]|3[0-689]|4[0-9]|5[0136-8]|6[0-9]|" . "7[0-26-9]|8[0-9]|9[0-36-8])|" . "7(?:0[126-9]|1[0-9]|2[0-2]|3[0-9]|4[0-5]|5[0-9]|6[0-3]|" . "7[0-9]|8[0-6]|9[5-8])|" . "8(?:0[124-9]|1[0-589]|2[02-69]|3[0-47-9]|4[02-9]|5[03]|" . "7[0-9]|8[0-9]|9[0-5])|" . "9(?:0[126-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-689]|6[0-9]|" . "7[0-9]|8[0-24-9]|9[0-9]))" . "|5(?:2(?:01|1[1-9]|2[0-2]|3[0-9]|4[0134]|5[0-6]|80|9[09])|" . "3(?:1[024-8]|2[02468]|3[0-79]|4[0-2]|5[1-359]|6[0-9]|" . "7[0-8]|80)|" . "4(?:0[1-578]|1[0-9]|2[1-79]|3[0-59]|4[0-7]|5[01]|6[056]|" . "7[01]|8[0-3589]|9[59])|" . "5(?:0[15-7]|1[1-9]|2[0-3]|3[0-9]|4[0489]|5[0-9]|6[01]|" . "7[0-7])|" . "6(?:0[125]|1[0-9]|2[06-9]|3[0-9]|40|5[0-9]|7[015]|8[0-7]|" . "9[0-358])|" . "7(?:01|1[0-46-9]|2[0-3]|30|4[01]|5[0-6]|6[0-2]|7[0-6])|" . "8(?:0[189]|1[0-9]|2[0-689]|3[0-9]|4[0-46]|5[02-69]|6[0-9]|" . "7[0-68]|8[04-9]|9[0-389])|" . "9(?:4[0-3]|5[0-9]|6[0-49]|7[0-8]))" . "|6(?:1(?:01|1[1-9]|2[0-59]|3[0-9]|4[0-9]|5[05]|6[0-3569]|" . "7[015]|8[0-9]|9[05-7])|" . "2(?:01|1[0-5]|25|3[01589]|4[0356]|5[0-25])|" . "3(?:01|1[0-5]|40|50|60|70|80)|" . "4(?:0[12689]|1[0-9]|2[0-3]|3[0-9]|4[0-35-9]|5[0-5]|6[0-9]|" . "7[0-9]|8[0-8]|9[0-79])|" . "5(?:5[0-357-9]|6[02]|7[0-29]|8[0-35-7]|90)|" . "6(?:01|1[0-9]|2[0-3]|3[0-8]|4[5-9]|5[01]|6[013569]|7[0-8]|" . "8[0-9]|9[0-35])|" . "7(?:01|1[1-9]|2[0-6]|3[0-9]|4[0-5]|5[0-9]|6[0-5]|7[0-9]|" . "8[0-6]|9[0-6])|" . "8(?:15|3[0-9]|4[0-2]|5[0-28]|6[89]|7[01]|80)|" . "9(?:0[156]|1[0-9]|2[1-356]|3[01349]|4[0-8]|5[0156]|" . "6[0-29]|7[0-9]|8[0-25-9]|9[0-25-9]))" . "|7(?:2(?:0[129]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|6[0-489]|" . "7[04])|" . "3(?:0[2-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|6[0-4]|" . "7[0-9]|8[0-4]|9[0-25-7])|" . "4(?:09|1[0-25-8]|2[013-5]|3[0-35]|4[0-9]|5[0-8]|6[0-5]|" . "7[0135]|8[0-2])|" . "5(?:0[125-8]|1[1-9]|2[0-6]|3[1-9]|4[0-7]|5[3-9]|6[0-9]|" . "7[0-2]|9[0-9])|" . "6(?:01|1[023589]|2[0-7]|3[3-69]|4[019]|5[0-3]|6[0-4]|" . "7[03]|8[01])|" . "7(?:0[13]|1[0-6]|2[0-467]|3[0-57-9]|4[01]|5[089]|6[0-9]|" . "7[0-47-9]|8[0-9]|9[0-5]))" . "|8(?:0(?:0[125-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|6[0-9]|" . "7[0-9]|8[0-9]|9[0-9])|" . "1(?:1[0-25-9]|2[013-9]|3[0-57-9]|4[0-25-79]|5[0-46-9]|" . "6[05-7]|79|8[0-9]|9[01])|" . "2(?:0[159]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-589]|6[0-9]|" . "7[0-47-9]|8[0-9]|9[0-5])|" . "3(?:0[1-3689]|1[0-9]|2[0-9]|3[0-9]|4[0-5]|5[0-9]|6[0-9]|" . "7[0-689]|8[013-8]|9[0-689])|" . "4(?:01|1[0-5]|2[0-4]|3[5-8]|4[0-57-9]|5[0-3]|6[0-9]|" . "7[0-9]|80)|" . "5(?:0[126-9]|1[01]|2[1-35-9]|3[0137-9]|4[0-6]|5[0-278]|" . "6[0-2])|" . "6(?:0[69]|1[0-5]|20)|" . "7(?:0[15-8]|1[015]|20)|" . "8(?:0[125689]|1[1-46-9]|2[0-6]|3[1-58]))" . "|9(?:0(?:0[1-46]|1[0-9]|2[0-9]|3[0-3]|4[0-8]|5[0-6]|6[0-9]|" . "7[0-2]|8[0-9]|9[0-489])|" . "1(?:1[5-9]|2[0-9]|3[0-7]|4[024-7]|5[013-8]|6[013-9]|" . "7[0-35-79]|8[0-4689]|9[01])|" . "2(?:0[1-9]|1[0-8]|2[014-9]|3[0-9]|4[0-59]|5[0-9]|6[0-8]|" . "7[35-9]|8[0-9]|9[0-4])|" . "3(?:30|40|5[0-79]|6[014-689]|7[0-35-8]|8[0-2]|9[0-25])|" . "4(?:0[15-9]|1[0-24-9]|2[0-6]|40|5[1-9]|6[1-6])|" . "5(?:0[126]|1[0-9]|2[0-3]|3[0-9]|4[0-5]|5[0-9]|60|7[0-9])|" . "6(?:3[1-35-9]|4[013-578]|5[013-79]|6[0235689]|7[0-468]|" . "8[12479]|9[06])|" . "7(?:0[16-9]|1[0-5]|3[78]|4[0-9]|5[1-9]|6[0-9]|7[0-69]|80)|" . "8(?:0[15-9]|3[013-9]|4[01])|" . "9(?:0[1-35-9]|1[0-3]|4[02-468]|5[0246]|6[02468]|7[0246]|" . "8[02]|9[0-39]))" . ")", # # Postal codes of Monaco are part of the system used for France. # Monaco uses postal codes starting with 980. 98000 is for all # physical addresses, while numbers ending in 01 - 99 are reserved # for special deliveries. # # http://www.upu.int/fileadmin/documentsFiles/activities/ # addressingUnit/mcoEn.pdf # Monaco => "(?k:980[0-9][0-9])", # # Postal codes in Norway use 4 digits. Leading 0s happen, but not all # combinations are used. # # Data from: http://download.geonames.org/export/zip/GL.zip # Norway => "(?k:0(?:0(?:01|1[058]|2[14-68]|3[0-47]|4[05-8]|5[015]|60|80)|" . "1(?:0[1-79]|1[0-9]|2[0-589]|3[0-9]|5[0-57-9]|6[0-24-9]|" . "7[0-9]|8[0-8]|9[0-68])|" . "2(?:0[1-478]|1[1-8]|30|4[047]|5[0-9]|6[02-8]|7[0-9]|" . "8[0-467])|" . "3(?:0[1-9]|1[13-9]|23|30|4[09]|5[0-9]|6[0-9]|7[0-9]|" . "8[0-3])|" . "4(?:0[1-689]|1[0-35]|2[1-4]|4[0-25]|5[0-24-9]|6[0-57-9]|" . "7[02-9]|8[0-9]|9[0-6])|" . "5(?:0[1-9]|1[0-35-8]|20|40|5[0-9]|6[0-9]|7[0-9]|8[0-9]|" . "9[0-8])|" . "6(?:0[1-9]|1[1-9]|2[0-46]|5[0-9]|6[0-9]|7[0-9]|8[0-9]|" . "9[0-4])|" . "7(?:0[125]|1[02]|5[0-8]|6[03-8]|7[0-9]|8[1-9]|9[01])|" . "8(?:0[15-7]|40|5[0-8]|6[0-4]|7[0-7]|8[0-4]|9[01])|" . "9(?:0[1-578]|1[3-5]|5[0-9]|6[02-489]|7[0-35-9]|8[0-8]))" . "|1(?:0(?:0[135-9]|11|5[1-6]|6[1-57-9]|71|8[1346-9])|" . "1(?:0[129]|12|5[0-8]|6[0-9]|7[026-9]|8[12457-9])|" . "2(?:0[1-57]|1[45]|5[0-9]|6[236]|7[0-589]|8[13-6]|9[0145])|" . "3(?:0[0-79]|1[1-46-9]|2[1-9]|3[0-9]|4[0-24689]|5[0-46-9]|" . "6[0-9]|7[1-35-9]|8[013-9]|9[0-79])|" . "4(?:0[0-9]|1[0-9]|2[019]|3[0-2]|4[0-9]|5[013-578]|6[89]|" . "7[0-9]|8[0-8])|" . "5(?:0[1-4689]|1[0-9]|2[0-689]|3[0-9]|4[015]|5[056]|60|70|" . "8[01]|9[0-36-9])|" . "6(?:0[1-9]|1[02-9]|2[014-689]|3[02-46-9]|4[0-2]|" . "5[013-57-9]|6[1-7]|7[0-35689]|8[02-4]|9[02])|" . "7(?:0[1-9]|1[0-589]|2[0-7]|3[03-589]|4[0235-7]|5[1-479]|" . "6[013-9]|7[126-9]|8[1-9]|9[0-4689])|" . "8(?:0[1-9]|1[1-6]|2[0357]|3[0-3]|5[019]|6[0167]|7[0158]|" . "80|9[0-3])|" . "9(?:0[013]|1[0-2467]|2[013-9]|3[01]|4[01]|5[04]|6[013]|" . "7[01]))" . "|2(?:0(?:0[013-9]|1[0-9]|2[0-8]|3[0-6]|4[01]|5[0-8]|6[0-26-9]|" . "7[0-46]|8[01]|9[0-3])|" . "1(?:0[01]|1[046]|2[03]|3[034]|5[01]|6[0-24-6]|70)|" . "2(?:0[1-689]|1[0-46-9]|2[03-6]|3[0235]|40|56|6[014-6]|" . "7[01]|8[03])|" . "3(?:0[1-9]|1[25-9]|2[0-6]|3[024-8]|4[0145]|5[035]|6[045]|" . "72|8[0-9]|9[01])|" . "4(?:0[1-35-9]|1[0-2568]|2[0-357-9]|3[025-8]|4[0368]|5[01]|" . "60|7[6-8]|8[015])|" . "5(?:0[01]|1[02]|4[024]|5[025]|6[01]|8[0-24])|" . "6(?:0[1-9]|1[0-9]|2[4-69]|3[0-79]|4[0235-9]|5[1-36-9]|" . "6[0-9]|7[02-7]|8[02-8]|9[03-5])|" . "7(?:1[1-8]|20|30|4[023]|50|60|70)|" . "8(?:0[1-9]|1[015-9]|2[0-257]|3[0-26-9]|4[036-9]|5[013478]|" . "6[0-2467]|7[09]|8[0-2]|9[03])|" . "9(?:0[017]|1[078]|2[039]|3[03679]|4[03]|5[02-49]|6[067]|" . "7[3-57]|85))" . "|3(?:0(?:0[1-9]|1[1-9]|2[1-9]|3[0-9]|4[0-8]|5[013-8]|6[01]|" . "7[015]|8[0-9]|9[025])|" . "1(?:0[13-9]|1[0-9]|2[0-8]|3[1-357-9]|4[0-58]|5[0-47-9]|" . "6[0-9]|7[0-9]|8[0-9]|9[1-69])|" . "2(?:0[1-9]|1[0-9]|2[0-9]|3[0-9]|4[0-69]|5[1-9]|6[0-57-9]|" . "7[014-7]|8[0-245]|9[0-24-7])|" . "3(?:0[01]|2[0-2]|3[01]|4[0-2]|5[01589]|6[01]|7[01])|" . "4(?:0[1-9]|1[0-4]|2[015-8]|3[01]|4[0-2]|7[0-24-8]|8[0-4]|" . "9[01])|" . "5(?:0[1-47]|1[0-9]|2[0-689]|3[013-9]|4[014]|5[01]|6[01]|" . "7[015-79]|8[018]|9[35])|" . "6(?:0[1-689]|1[0-9]|2[0-46-9]|3[0-2]|4[6-8]|5[0268]|" . "6[0156]|7[1-9]|8[0134]|9[0-27])|" . "7(?:0[1-578]|1[0-9]|2[0-9]|3[0-9]|4[0-46-9]|5[03]|6[06]|" . "70|8[01357-9]|9[0-68])|" . "8(?:0[0-5]|1[0-2]|2[05]|3[0-6]|4[01489]|5[03-5]|64|70|" . "8[02-8]|9[0135])|" . "9(?:0[1-6]|1[0-9]|2[0-24589]|3[013679]|4[0-46-9]|50|" . "6[05-7]|70|9[13-9]))" . "|4(?:0(?:0[1-9]|1[0-9]|2[0-9]|3[1-6]|4[1-9]|5[0-9]|6[4-9]|" . "7[06-9]|8[1-9]|9[0-9])|" . "1(?:0[02]|1[09]|2[0346-9]|3[0479]|4[68]|5[02-4689]|" . "6[01347-9]|7[034]|8[027]|98)|" . "2(?:0[0189]|3[03-579]|4[04]|50|6[0245]|7[024-6]|80|" . "9[14-9])|" . "3(?:0[1-9]|1[0-9]|2[1-9]|3[02359]|4[0-9]|5[2-8]|" . "6[02-57-9]|7[0-689]|8[0179]|9[1-8])|" . "4(?:0[0-3]|20|3[2468]|4[013]|6[0235]|73|8[045]|9[0-2])|" . "5(?:0[1-69]|1[3-79]|2[0-589]|3[246]|4[04]|5[0-478]|6[03]|" . "7[5-79]|8[068]|9[056])|" . "6(?:0[4-689]|1[0-9]|2[0-689]|3[0-9]|4[05-7]|5[16-9]|" . "6[1-6]|7[0-9]|8[1-9]|9[13-9])|" . "7(?:0[0-35]|15|2[04]|3[03-57]|4[12578]|5[4-6]|6[068]|70|" . "80|9[0-5])|" . "8(?:0[1-489]|1[025-8]|2[013-578]|3[024689]|4[1-46-9]|" . "5[1-9]|6[1-589]|7[06-9]|8[4-9]|9[1-468])|" . "9(?:0[0-29]|1[0256]|20|34|5[0-35]|7[1-4]|8[05]|9[034]))" . "|5(?:0(?:0[3-9]|1[0-9]|2[0-2]|3[1-9]|4[1-35]|5[2-9]|6[378]|" . "7[235]|8[129]|9[346-9])|" . "1(?:0[14-9]|1[13-9]|2[124]|3[0-24-7]|4[1-8]|5[1-5]|6[0-5]|" . "7[0-46-9]|8[34])|" . "2(?:0[0-36-9]|1[0-25-8]|2[1-9]|3[0-25-9]|4[34]|5[1-47-9]|" . "6[0-578]|8[1-6]|9[139])|" . "3(?:0[0-9]|1[04589]|2[1-35-79]|3[13-7]|4[1-35-7]|" . "5[03-578]|6[0356]|7[1489]|8[0-24578]|9[2-46-9])|" . "4(?:0[1-46-9]|1[0-9]|2[0378]|3[07]|4[03-579]|5[0-57-9]|" . "6[02-5]|7[02-6]|8[046]|9[89])|" . "5(?:0[1-9]|1[124-9]|2[1-357-9]|3[1-8]|4[124-9]|5[01459]|" . "6[0135-8]|7[04-68]|8[02-689]|9[013-68])|" . "6(?:0[0-245]|1[024]|2[06-9]|3[025-7]|4[0-35-79]|5[023]|" . "8[0357]|9[03-6])|" . "7(?:0[0-9]|1[0-589]|2[1-9]|3[01346]|4[1-35-9]|5[0-2]|" . "6[03]|7[036-9]|8[0-8])|" . "8(?:0[3-9]|1[0-9]|2[0-24589]|3[1568]|4[157-9]|5[1-47-9]|" . "6[1-489]|7[1-36-9]|8[1246-9]|9[23569])|" . "9(?:0[2-46-8]|1[1-8]|3[16-9]|4[1378]|5[1-7]|6[0-267]|" . "7[07-9]|8[13467]|9[134]))" . "|6(?:0(?:0[1-9]|1[0-9]|2[0-68]|3[05-9]|4[03-8]|5[0-257-9]|" . "6[02-57-9]|7[06]|8[02-579]|9[0-24-689])|" . "1(?:0[0-6]|10|20|3[39]|4[0-469]|5[0-6]|6[0156]|7[04]|" . "8[34]|9[06])|" . "2(?:0[01]|1[0-68]|2[024]|3[089]|4[09]|5[09]|6[03-5]|7[02]|" . "8[0-35]|9[02-4])|" . "3(?:0[01]|1[05]|20|3[09]|50|6[034]|8[67]|9[0-9])|" . "4(?:0[1-57-9]|1[0-689]|2[1-359]|3[013-6]|4[03-57]|5[03-7]|" . "6[0-2]|7[0256]|8[01346-8]|9[0349])|" . "5(?:0[1-46-9]|1[0-24-8]|2[0-59]|3[089]|7[01]|90)|" . "6(?:0[01]|1[0-3]|2[0289]|3[0136-9]|4[02-5]|5[0235-9]|" . "7[04]|8[036-9]|9[0347-9])|" . "7(?:0[0-478]|1[013-9]|2[136-9]|3[0147]|4[01]|5[01]|6[13]|" . "7[0-26-9]|8[1-489]|9[1-35-9])|" . "8(?:0[0-9]|1[0-57-9]|2[1-36-9]|4[1378]|5[1-689]|6[13689]|" . "7[0-35-9]|8[124-8]|9[13-689])|" . "9(?:0[0-39]|1[24-9]|2[146-9]|4[0-2467]|5[1378]|6[1346-9]|" . "7[13578]|8[0-8]|9[1356]))" . "|7(?:0(?:0[3-6]|1[0-689]|2[0-9]|3[0-46-9]|4[0-9]|5[0-46-9]|" . "7[024589]|8[0-389]|9[127-9])|" . "1(?:0[015]|1[02-49]|2[015-79]|30|4[02]|5[02369]|6[05-9]|" . "7[06-8]|80|9[04])|" . "2(?:0[0136]|1[1-3]|2[13478]|3[124-689]|4[0-367]|5[025-79]|" . "6[013468]|7[03]|8[024-9]|9[0158])|" . "3(?:0[0-2]|1[05689]|2[0179]|3[1-68]|4[0-35]|5[013-578]|61|" . "7[024]|8[03467]|9[1-37-9])|" . "4(?:0[0-9]|1[0-9]|2[0-24-9]|3[0-9]|4[0-9]|5[0-9]|" . "6[1-35-9]|7[0-9]|8[0-9]|9[0-7])|" . "5(?:0[0-9]|1[02-479]|2[059]|3[013]|4[019]|5[01]|6[0236]|" . "70|8[0134]|9[016])|" . "6(?:0[0-9]|1[09]|2[02-49]|3[0-4]|5[0-8]|60|7[01]|90)|" . "7(?:0[1-57-9]|1[0-8]|2[4-69]|3[024-9]|4[024-68]|5[01]|" . "6[01]|7[017]|9[0167])|" . "8(?:0[0-58]|1[07-9]|2[02]|56|6[0349]|7[013]|8[24]|" . "9[02368])|" . "9(?:0[01]|4[04]|50|60|7[01367]|8[0-25]|9[034]))" . "|8(?:0(?:0[1-9]|1[0-69]|2[0-36-9]|3[0-278]|4[17-9]|5[068]|" . "6[34]|7[0-69]|8[46-9]|9[1-8])|" . "1(?:0[0238]|1[048]|2[08]|3[0568]|4[0569]|5[017-9]|6[018]|" . "7[08]|8[124-9]|9[035-8])|" . "2(?:0[0-35-9]|1[014589]|2[06]|3[0-3]|5[0156]|6[0146]|" . "7[013-68]|8[135689]|9[01478])|" . "3(?:0[0159]|1[0-7]|2[02-68]|40|5[27]|60|7[0236-8]|" . "8[02478]|9[0238])|" . "4(?:0[0-9]|1[0-6]|2[68]|3[0289]|4[57]|5[059]|6[59]|7[05]|" . "8[013-589]|93)|" . "5(?:0[1-9]|1[02-8]|2[023]|3[013-69]|4[036]|9[01])|" . "6(?:0[1-478]|1[03-8]|2[246]|3[048]|4[0-36-8]|5[124-9]|" . "6[013-6]|72|8[01]|9[01])|" . "7(?:0[01]|2[03-5]|3[0235]|4[023]|5[02-4]|6[12467]|70)|" . "8(?:0[0-59]|13|2[07]|30|4[24]|5[0-24]|6[015]|70|80|" . "9[0-27])|" . "9(?:0[0-24-9]|10|2[0-2]|6[01]|76|8[015]))" . "|9(?:0(?:0[6-9]|1[0-9]|2[02479]|3[0478]|4[02369]|5[05-79]|" . "6[02489])|" . "1(?:0[0-8]|1[089]|2[08]|3[0-24-8]|4[0-46-8]|5[1-369]|" . "6[1-39]|8[0-24-79]|9[02-57])|" . "2(?:40|5[1-9]|6[0-35-9]|7[0-9]|8[0-8]|9[0-4689])|" . "3(?:0[02-6]|1[0156]|2[12569]|3[4-6]|5[0578]|6[05]|" . "7[02369]|8[0-24-9]|9[1-35])|" . "4(?:0[2-9]|1[1459]|2[03-7]|3[069]|4[0-8]|5[013-5]|" . "7[01569]|8[0-9]|9[6-8])|" . "5(?:0[1-9]|1[0-9]|2[015]|3[1-36]|4[05]|5[01]|8[02-7]|" . "9[035])|" . "6(?:0[09]|1[056]|2[014]|5[07]|64|7[02]|9[0-2])|" . "7(?:0[09]|1[0-7]|22|3[05]|4[02]|5[01]|6[03-58]|7[0-35]|82|" . "90)|" . "8(?:0[02]|1[015]|2[06]|4[056])|" . "9(?:00|1[024-7]|25|3[05]|5[01]|60|8[0-2]|9[01]))" . ")", # # San Marino uses a slice of the postal codes for Italy. # Any postal code starting with 4789, followed by another # digit is from San Marino # # Data: http://download.geonames.org/export/zip/SM.zip # 'San Marino' => "(?k:4789[0-9])", Spain => "(?k:(?k:0[1-9]|[1-4][0-9]|5[0-2])(?k:[0-9])(?k:[0-9]{2}))", # Five digits, first two indicate the province. # Third digit: large town, main delivery rounds. # Last 2 digits: delivery area, secondary delivery route # or link to rural areas. # # Switzerland uses four digit postal codes; leading 0s are not used. # Not every combination is in use. Postal codes starting with 948 and # 949 are used by Liechtenstein, and will not be recognized by the # pattern below. # # Data from: http://download.geonames.org/export/zip/CH.zip # Switzerland => "(?k:1(?:0(?:0[0-9]|1[0-2457-9]|2[02-9]|3[0-9]|4[0-7]|5[2-589]|" . "6[1-368]|7[0-36-8]|8[0-58]|9[0-8])|" . "1(?:1[02-7]|2[1-8]|3[124-6]|4[1-9]|6[2-9]|7[02-6]|8[02-9]|" . "9[5-7])|" . "2(?:0[0-9]|1[1-9]|2[02-8]|3[1-4679]|4[0-8]|5[1-8]|6[0-9]|" . "7[0-9]|8[13-9]|9[0-9])|" . "3(?:0[02-8]|1[0-35-8]|2[0-69]|3[078]|4[1-8]|5[02-8]|" . "7[2-7])|" . "4(?:0[014-9]|1[0235-8]|2[0-9]|3[0-9]|4[0-356]|5[02-4]|" . "6[2-48]|7[03-5]|8[2-69])|" . "5(?:09|1[02-5]|2[1-9]|3[02-8]|4[1-5]|5[1-5]|6[2-8]|" . "8[02-9]|95)|" . "6(?:0[7-9]|1[0-9]|2[3-8]|3[0-8]|4[2-9]|5[1-46-9]|" . "6[0135-79]|7[03-9]|8[0-9]|9[0-24-79])|" . "7(?:0[0-2457-9]|1[2-9]|2[0-8]|3[0-8]|4[0-24-9]|5[2-467]|" . "6[23]|7[2-6]|8[2-9]|9[1-7])|" . "8(?:0[0-9]|1[14-8]|2[02-4]|3[23]|4[4-7]|5[2-46]|6[02-9]|" . "7[0-5]|8[0245]|9[0-35-9])|" . "9(?:0[2-8]|1[1-489]|2[0-35-9]|3[2-46-8]|4[1-8]|5[013578]|" . "6[1-9]|7[1-8]|8[1-8]|9[1-467]))" . "|2(?:0(?:0[0-46-9]|1[02-79]|2[2-578]|3[4-7]|4[236]|5[2-46-8]|" . "6[3578]|7[2-5]|8[78])|" . "1(?:0[358]|1[2-7]|2[3467]|49)|" . "20[6-8]|3(?:0[0-46]|1[468]|2[25]|3[368]|4[05]|5[034]|" . "6[02-4])|" . "4(?:0[056]|1[46])|" . "5(?:0[0-5]|1[02-8]|2[035]|3[2-8]|4[02-5]|5[2-8]|6[02-5]|" . "7[25-7])|" . "6(?:0[3-8]|1[02356])|" . "7(?:1[02-8]|2[023]|3[23568]|4[02-8]|62)|" . "8(?:0[0235-7]|1[2-4]|2[2-9]|3[02]|4[23]|5[2-7]|6[34]|73|" . "8[2-9])|" . "9(?:0[02-8]|1[24-6]|2[2-6]|3[235]|4[2-467]|5[02-4]))" . "|3(?:0(?:0[0-8]|1[0-57-9]|2[0479]|3[02-9]|4[0-9]|5[02-4]|" . "6[35-8]|7[0-8]|8[2-9]|9[5-9])|" . "1(?:1[0-6]|2[2-8]|32|4[4578]|5[02-9]|7[2-9]|8[2-6])|" . "2(?:0[2-8]|1[02-6]|2[56]|3[2-8]|5[0-7]|6[2-46-8]|7[0-4]|" . "8[02-6]|9[2-8])|" . "3(?:0[235-9]|1[2-57]|2[1-6]|6[0235-8]|7[2-7]|80)|" . "4(?:0[0-2]|1[2-9]|2[1-9]|3[2-9]|5[2-7]|6[2-5]|7[2-6])|" . "5(?:0[346-8]|1[023]|3[1-8]|43|5[0-35-7])|" . "6(?:0[0-57-9]|1[2-9]|2[2-9]|3[1-68]|4[5-7]|5[2-8]|6[1-5]|" . "7[1-4])|" . "7(?:0[02-7]|1[13-8]|2[2-5]|5[2-8]|6[2-6]|7[0-35-8]|8[0-5]|" . "92)|" . "8(?:0[013-7]|1[2-68]|2[2-6]|5[2-8]|6[02-4])|" . "9(?:0[0-8]|1[0-46-9]|2[02-9]|3[0-57-9]|4[02-9]|5[1-7]|" . "6[0135-8]|7[0-9]|8[2-9]|9[1-9]))" . "|4(?:0(?:0[0-57-9]|1[0-35-9]|2[03-5]|3[0-59]|4[0-2]|5[1-9]|65|" . "7[058]|8[0-9]|9[1-6])|" . "1(?:0[1-8]|1[24-8]|2[3-7]|3[23]|4[2-8]|53)|" . "2(?:0[2-46-8]|2[2-9]|3[2-4]|4[2-7]|5[2-4])|" . "3(?:0[2-5]|1[02-7]|2[2-5]|3[2-4])|" . "4(?:02|1[0-9]|2[1-6]|3[1-8]|4[1-8]|5[0-35-8]|6[0-9]|" . "9[2-7])|" . "5(?:0[0-39]|1[2-5]|2[2-58]|3[2-9]|4[23]|5[1-46-8]|6[2-6]|" . "7[1346-9]|8[1-8])|" . "6(?:0[0139]|1[1-8]|2[0-689]|3[02-4]|40|5[2-8]|6[35])|" . "7(?:0[2-4]|1[02-9])|" . "8(?:0[0-35-9]|1[2-4]|5[236])|" . "9(?:0[0-2]|1[1-79]|2[2-4]|3[2-8]|4[2-4]|5[02-5]))" . "|5(?:0(?:0[014]|1[02-578]|2[2-8]|3[2-7]|4[02-46]|5[346-8]|" . "6[2-4]|7[02-9]|8[02-5])|" . "1(?:0[235-8]|1[236])|" . "2(?:0[01]|1[023]|2[2-5]|3[2-7]|4[2-6]|7[2-7])|" . "3(?:0[013-6]|1[2-8]|2[2-6]|3[02-4])|" . "4(?:0[0-24-68]|1[235-7]|2[0356]|3[0-26]|4[2-5]|5[2-4]|" . "6[2-7])|" . "5(?:0[2-7]|12|2[245])|" . "6(?:0[013-8]|1[0-9]|2[0-8]|3[02467]|4[2-7])|" . "7(?:0[2-8]|12|2[2-8]|3[2-7]|4[256]))" . "|6(?:0(?:0[02-9]|1[0-9]|2[0-8]|3[0-9]|4[2-578]|5[2356]|" . "6[0-46-8]|7[2-48]|8[3-6])|" . "1(?:0[2356]|1[02-4]|2[2356]|3[023]|4[2-7]|5[2-46]|" . "6[0-367]|7[034]|82|9[267])|" . "2(?:0[3-8]|1[0-8]|2[12]|3[1-6]|4[2-8]|5[23]|6[02-5]|" . "7[4-7]|8[013-9]|9[45])|" . "3(?:0[0-4]|1[02-57-9]|3[0-3]|4[0-69]|5[346]|6[235]|7[0-7]|" . "8[236-8]|9[01])|" . "4(?:0[2-5]|1[04-8]|2[2-4]|3[0-468]|4[0-3]|5[24]|6[0-9]|" . "7[2-6]|8[2457]|9[013])|" . "5(?:0[0136]|1[1-8]|2[3-8]|3[2-578]|4[0-9]|5[6-8]|6[235]|" . "7[1-9]|8[2-4]|9[02-9])|" . "6(?:0[0-245]|1[1-468]|22|3[1-7]|4[4-8]|5[2-9]|6[1-4]|" . "7[02-8]|8[2-5]|9[02-6])|" . "7(?:0[2357]|1[03-9]|2[0-4]|4[2-9]|6[034]|7[2-7]|8[01])|" . "8(?:0[2-9]|1[04-8]|2[1-35-8]|3[02-9]|5[02-5]|6[2-7]|" . "7[2-57]|83)|" . "9(?:0[0-8]|1[1-9]|2[124-9]|3[02-9]|4[2-9]|5[0-9]|6[2-8]|" . "7[46-9]|8[0-46-9]|9[0-9]))" . "|7(?:0(?:0[0-467]|1[2-9]|2[36-9]|3[12]|5[06-8]|6[2-4]|7[4-8]|" . "8[2-4])|" . "1(?:0[4679]|1[0-6]|2[26-8]|3[02-8]|4[1-9]|5[1-9]|6[2-8]|" . "7[2-6]|8[02-9])|" . "2(?:0[1-68]|1[2-5]|2[02-468]|3[1-35]|4[0-79]|5[02]|6[05]|" . "7[026-8])|" . "3(?:0[2-467]|1[02-57]|2[03-6])|" . "4(?:0[2-578]|1[1-9]|2[1-8]|3[0-8]|4[02-8]|5[0-9]|6[02-4]|" . "7[237]|8[24]|9[2-4])|" . "5(?:0[02-5]|1[2-7]|2[2-7]|3[02-7]|4[2356]|5[0-46-9]|" . "6[023])|" . "6(?:0[2-68]|10)|" . "7(?:10|4[1-8]))" . "|8(?:0(?:0[0-68]|1[0-256]|2[0-467]|3[0-46-9]|4[0-24-9]|" . "5[0-357-9]|6[013-68]|7[0145]|8[015-8]|9[0-3689])|" . "1(?:0[2-9]|1[2-578]|2[1-7]|3[02-6]|4[23]|5[2-8]|6[24-6]|" . "7[2-5]|8[0-57]|9[2-7])|" . "2(?:0[0-578]|1[02-9]|2[2-68]|3[1-689]|4[0-35-8]|5[2-59]|" . "6[0-9]|7[2-4]|8[05])|" . "3(?:0[1-9]|1[0-2457]|2[025]|3[0-25]|4[02-5]|5[2-7]|6[023]|" . "7[0-246])|" . "4(?:0[0-24-689]|1[0-68]|2[1-8]|4[247]|5[0-57-9]|6[0-8]|" . "7[124-9]|8[2-46-9]|9[2-9])|" . "5(?:0[0-35-8]|1[024]|2[02-6]|3[025-7]|4[02-8]|5[2-68]|" . "6[014-6]|7[02-7]|8[0-9]|9[02-9])|" . "6(?:0[02-8]|1[02-8]|2[0-7]|3[02-9]|4[056])|" . "7(?:0[02-46-8]|1[2-8]|2[235-7]|3[02-57-9]|40|5[0-9]|" . "6[25-7]|7[2-57]|8[2-4])|" . "8(?:0[0-8]|1[02356]|2[045]|3[2-6]|4[0-79]|5[2-8]|6[2-8]|" . "7[2-47-9]|8[0-9]|9[02-8])|" . "9(?:0[1-9]|1[0-9]|2[56]|3[2-4]|42|5[1-7]|6[24-7]|70))" . "|9(?:0(?:0[0146-9]|1[0-6]|2[02-9]|3[02-8]|4[2-4]|5[02-8]|" . "6[2-4])|" . "1(?:0[0-578]|1[2-6]|2[235-7])|" . "2(?:0[013-5]|1[2-7]|2[035]|3[01]|4[02-9])|" . "3(?:0[014-68]|1[2-5]|2[0235-7])|" . "4(?:0[0-5]|1[0134]|2[2-8]|3[04-7]|4[2-5]|5[0-3]|6[2-9]|" . "7[0-35-9])|" . "5(?:0[0-46-8]|1[02457]|2[3-7]|3[2-6]|4[235-8]|5[2-6]|" . "6[25]|73)|" . "6(?:0[1246-8]|1[2-5]|2[0-2]|3[013]|4[23]|5[0-25-8]))" . ")", # # Vatican City uses a single postal code, taken from the Italian # system for postal codes; and this code is shared with parts of Rome. # # Data from: http://download.geonames.org/export/zip/CH.zip # 'Vatican City' => "(?k:00120)", ); my %alternatives = ( Australia => [qw /Australian/], France => [qw /French/], Germany => [qw /German/], ); while (my ($country, $zip) = each %zip) { my @names = ($country); push @names => @{$alternatives {$country}} if $alternatives {$country}; foreach my $name (@names) { my $pat_name = $name eq "Denmark" && $] < 5.00503 ? [zip => $name, qw /-country=/] : [zip => $name, qw /-prefix= -country=/]; pattern name => $pat_name, create => sub { my $pt = _t $_ [1] {-prefix}; my $cn = _c $country => $_ [1] {-country}; my $pfx = "(?:(?k:$cn)-)"; "(?k:$pfx$pt$zip)"; }, ; } } # Postal codes of the form 'DDDD LL', with F, I, O, Q, U and Y not # used, SA, SD and SS unused combinations, and the first digit # cannot be 0. No specific meaning to the letters or digits. foreach my $country (qw /Netherlands Dutch/) { pattern name => ['zip', $country => qw /-prefix= -country=/, "-sep= "], create => sub { my $pt = _t $_ [1] {-prefix}; # Unused letters: F, I, O, Q, U, Y. # Unused combinations: SA, SD, SS. my $num = '[1-9][0-9]{3}'; my $let = '[A-EGHJ-NPRTVWXZ][A-EGHJ-NPRSTVWXZ]|' . 'S[BCEGHJ-NPRTVWXZ]'; my $sep = __ $_ [1] {-sep}; my $cn = _c Netherlands => $_ [1] {-country}; my $pfx = "(?:(?k:$cn)-)"; "(?k:$pfx$pt(?k:(?k:$num)(?k:$sep)(?k:$let)))"; }, ; } # Postal codes of the form 'DDDDD' or 'DDDDD-DDDD'. All digits are used, # none carry any specific meaning. pattern name => [qw /zip US -prefix= -country= -extended= -sep=-/], create => sub { my $pt = _t $_ [1] {-prefix}; my $et = _t $_ [1] {-extended}; my $sep = __ $_ [1] {-sep}; my $cn = _c USA => $_ [1] {-country}; my $pfx = "(?:(?k:$cn)-)"; # my $zip = "(?k:[0-9]{5})"; # my $ext = "(?:(?k:$sep)(?k:[0-9]{4}))"; my $zip = "(?k:(?k:[0-9]{3})(?k:[0-9]{2}))"; my $ext = "(?:(?k:$sep)(?k:(?k:[0-9]{2})(?k:[0-9]{2})))"; "(?k:$pfx$pt(?k:$zip$ext$et))"; }, ; # # Postal codes are four digits, but not all combinations are used. # # Valid codes from: # https://postcode.auspost.com.au/free_display.html?id=1 # pattern name => ['zip', 'Australia' => qw /-prefix= -country= -lax=/], create => sub { my $pt = _t $_ [1] {-prefix}; my $cn = _c Australia => $_ [1] {-country}; my $pfx = "(?:(?k:$cn)-)"; my $lax = !defined $_ [1] {-lax} || $_ [1] {-lax}; my $l0 = $lax ? "0?" : "0"; # Leading zero my $pat = "(?|" . "(?|1(?:2(?:15|2[05]|3[05]|40)|" . "3(?:00|35|40|5[05]|60)|" . "4(?:35|45|5[05]|6[056]|7[05]|8[015]|9[059])|" . "5(?:15|6[05]|70|85|9[05])|" . "6(?:3[05]|40|55|60|7[05]|8[05])|" . "7(?:0[01]|1[05]|30|5[05]|65|90)|" . "8(?:0[05]|11|25|35|51|60|7[15]|85|90))" . "|2(?:0(?:0[0-246-9]|1[0-25-9]|[2-4][0-9]|5[0279]|" . "6[0-9]|7[0-79]|8[0-9]|9[02-79])|" . "1(?:[0-2][0-9]|3[0-8]|4[0-8]|5[0-9]|6[0-8]|" . "7[0-9]|9[0-9])|" . "2(?:0[03-9]|1[0-46-9]|2[0-9]|3[0-4]|5[016-9]|" . "6[0-57]|78|8[0-79]|9[0-9])|" . "3(?:0[02-9]|1[0-24-9]|2[0-9]|3[03-9]|4[0-8]|" . "5[0-9]|6[0159]|7[0-29]|8[0-26-8]|9[05-9])|" . "4(?:0[0-689]|1[015]|2[0-9]|3[019]|4[013-9]|" . "5[02-6]|6[02-69]|[78][0-9]|90)|" . "5(?:0[02568]|1[5-9]|2[025-9]|3[03-9]|4[015689]|" . "5[015-9]|6[03-9]|7[0-9]|8[0-8]|9[04])|" . "6(?:0[0-9]|1[0-24-9]|2[0-9]|3[0-3]|4[0-9]|" . "5[0-35689]|6[0135689]|7[1258]|8[01])|" . "7(?:0[0-35-8]|1[0-7]|2[0-25-79]|3[0-9]|4[57-9]|" . "5[0-46-9]|6[0-35-9]|7[03-9]|8[02-7]|9[0-57-9])|" . "8(?:0[03-9]|1[078]|2[0-9]|3[0-689]|4[02-9]|5[02]|" . "6[4-9]|7[013-9]|80|9[089])|" . "9(?:0[0-6]|1[1-4]))" . "|3(?:0(?:0[0-468]|1[0-35689]|2[0-9]|3[0-46-9]|[45][0-9]|" . "6[0-8]|7[0-689]|8[1-57-9]|9[013-79])|" . "1(?:0[1-9]|1[13-6]|2[1-9]|[34][0-9]|5[0-689]|" . "[6-9][0-9])|" . "2(?:0[0-24-7]|1[1-9]|2[0-8]|3[0-9]|4[0-39]|5[014]|" . "6[04-9]|7[0-9]|8[0-79]|9[2-4])|" . "3(?:0[0-59]|1[0-2457-9]|2[1-589]|3[0-578]|4[0-25]|" . "5[0-7]|6[0134]|7[013-57-9]|8[014578]|9[0-356])|" . "4(?:0[0-279]|1[2-589]|2[0347-9]|3[0-578]|4[0-246-8]|" . "5[0138]|6[0-57-9]|7[2578]|8[02357-9]|9[01468])|" . "5(?:0[0-25-79]|1[25-8]|2[0-3579]|3[0137]|4[02469]|" . "5[0-24-9]|6[1-8]|7[0-3569]|8[013-689]|9[014-79])|" . "6(?:0[78]|1[0246-9]|2[0-49]|3[0-9]|4[0134679]|" . "5[89]|6[0-69]|7[0-35-8]|8[2357-9]|9[01457-9])|" . "7(?:0[01457-9]|1[1-57-9]|2[02-8]|3[0235-9]|4[014679]|" . "5[0-9]|6[0-7]|7[057-9]|8[1-35-9]|9[1-35-79])|" . "8(?:0[02-9]|1[02-68]|2[0-5]|3[1-35]|4[0-247]|" . "5[0-46-9]|6[02459]|7[013-58]|8[025-9]|9[0-3568])|" . "9(?:0[02-49]|1[0-35689]|2[0-35-9]|3[01346-9]|4[0-6]|" . "5[01346-9]|6[024-7]|7[15-9]|8[01478]|9[0-256]))" . "|4(?:0(?:0[0-9]|1[0-47-9]|2[0-259]|3[0-24-7]|5[13-59]|" . "6[014-9]|7[02-8])|" . "1(?:0[1-9]|1[0-9]|2[0-57-9]|3[0-3]|5[1-9]|6[013-59]|" . "7[0-489]|8[34])|" . "2(?:0[57-9]|[12][0-9]|30|7[0-25]|8[057])|" . "3(?:0[013-79]|1[0-3]|4[0-7]|5[02-9]|6[0-5]|7[0-8]|" . "8[0-578]|90)|" . "4(?:0[0-8]|1[0-35-9]|2[0-8]|5[45]|6[12578]|" . "7[0-2457-9]|8[0-26-9]|9[0-46-8])|" . "5(?:0[0-9]|1[0-24-9]|2[01]|[56][0-9]|7[0-5]|8[01])|" . "6(?:0[01568]|1[0-5]|2[015-7]|30|5[059]|6[02]|" . "7[01346-8]|80|9[4579])|" . "7(?:0[0-79]|1[0-9]|2[0-8]|3[0-35-9]|4[0-6]|5[013467]|" . "9[89])|" . "8(?:0[02-9]|1[0-9]|2[0-589]|30|49|5[024-9]|" . "6[01589]|7[0-9]|8[0-8]|9[0-25]))" . "|5(?:0(?:0[016-9]|1[0-9]|2[0-5]|3[1-57-9]|4[0-9]|5[0-2]|" . "6[1-9]|7[0-6]|8[1-9]|9[0-8])|" . "1(?:0[6-9]|1[0-8]|2[015-7]|3[1-46-9]|4[0-24]|" . "[56][0-9]|7[0-4])|" . "2(?:0[1-4]|1[0-4]|2[0-3]|3[1-8]|4[0-5]|5[0-69]|" . "6[0-9]|7[0-35-9]|80|9[01])|" . "3(?:0[1-46-9]|1[01]|2[0-2]|3[0-3]|4[0-6]|5[0-7]|" . "60|7[1-4]|81)|" . "4(?:0[01]|1[0-9]|2[0-2]|3[1-4]|40|5[1-5]|6[0-24]|" . "7[0-3]|8[0-35]|9[0135])|" . "5(?:0[12]|10|2[0-3]|40|5[024-68]|60|7[0-35-7]|" . "8[0-3])|" . "6(?:0[0-9]|3[0-3]|4[0-2]|5[0-5]|6[01]|7[01]|80|90)|" . "7(?:0[01]|1[09]|2[02-5]|3[0-4])|" . "9(?:42|50))" . "|6(?:0(?:0[013-9]|1[0-24-9]|2[0-9]|3[0-8]|4[1-4]|" . "[56][0-9]|7[0-46-9]|8[1-4]|90)|" . "1(?:0[0-9]|1[0-2]|2[1-6]|4[7-9]|[56][0-9]|" . "7[0-6]|8[0-2])|" . "2(?:0[7-9]|1[013-58]|2[013-9]|3[0-36769]|4[034]|" . "5[1-68]|6[02]|7[15]|8[0-24-68]|90)|" . "3(?:0[24689]|1[1-35-8]|2[0-46-8]|3[0-35-8]|4[1368]|" . "5[0-35-9]|6[1357-9]|7[0235]|8[3-6]|9[0-8])|" . "4(?:0[13579]|1[0-589]|2[0-9]|3[0-46-8]|4[0235-8]|" . "5[02]|6[0-35-8]|7[0235-79]|8[0457-9]|90)|" . "5(?:0[1-79]|1[0-9]|2[1258]|3[0-25-7]|5[68]|" . "6[0246-9]|7[1245])|" . "6(?:0[35689]|1[2-46]|2[03578]|3[0-2589]|4[026])|" . "7(?:0[157]|1[0-468]|2[0-2568]|3[13]|4[03]|5[1348]|" . "6[025]|70|9[89])|" . "8(?:3[17-9]|4[0-9]|50|65|72|92)|" . "9(?:0[1-79]|1[0-9]|2[0-69]|3[1-69]|4[1-7]|5[1-9]|" . "6[013-9]|7[09]|8[1-9]|9[0-27]))" . "|7(?:0(?:0[0-24-9]|1[0-25-9]|2[0-7]|30|5[0-5])|" . "1(?:09|1[23679]|20|39|40|5[015]|6[23]|7[0-9]|" . "8[02-7]|90)|" . "2(?:09|1[0-6]|4[89]|5[02-9]|6[0-578]|7[05-7]|9[0-2])|" . "3(?:0[0-7]|1[056]|2[0-25]|3[01])|" . "4(?:6[6-9]|70))" . "|8(?:0(?:0[1-9]|1[0-2]))" . "|9726" . # # Place this last, in case the leading 0 is optional; if # not, matching against "2001" would find "200". # "|$l0(?:200|8(?:0[014]|1[0-5]|2[0-289]|3[0-24-9]|4[05-7]|" . "5[0-4]|6[0-2]|7[0-5]|8[0156])|909)" . "))"; "(?k:$pfx$pt(?k:$pat))"; } ; # pattern name => [qw /zip British/, "-sep= "], # create => sub { # my $sep = $_ [1] -> {-sep}; # # my $london = '(?:EC[1-4]|WC[12]|S?W1)[A-Z]'; # my $single = '[BGLMS][0-9]{1,2}'; # my $double = '[A-Z]{2}[0-9]{1,2}'; # # my $left = "(?:$london|$single|$double)"; # my $right = '[0-9][ABD-HJLNP-UW-Z]{2}'; # # "(?k:(?k:$left)(?k:$sep)(?k:$right))"; # }, # ; # # pattern name => [qw /zip Canadian/, "-sep= "], # create => sub { # my $sep = $_ [1] -> {-sep}; # # my $left = '[A-Z][0-9][A-Z]'; # my $right = '[0-9][A-Z][0-9]'; # # "(?k:(?k:$left)(?k:$sep)(?k:$right))"; # }, # ; 1; __END__ =pod =head1 NAME Regexp::Common::zip -- provide regexes for postal codes. =head1 SYNOPSIS use Regexp::Common qw /zip/; while (<>) { /^$RE{zip}{Netherlands}$/ and print "Dutch postal code\n"; } =head1 DESCRIPTION Please consult the manual of L for a general description of the works of this interface. Do not use this module directly, but load it via I. This module offers patterns for zip or postal codes of many different countries. They all have the form C<$RE{zip}{Country}[{options}]>. The following common options are used: =head2 C<{-prefix=[yes|no|allow]}> and C<{-country=PAT}>. Postal codes can be prefixed with a country abbreviation. That is, a Dutch postal code of B<1234 AB> can also be written as B. By default, all the patterns will allow the prefixes. But this can be changed with the C<-prefix> option. With C<-prefix=yes>, the returned pattern requires a country prefix, while C<-prefix=no> disallows a prefix. Any argument that doesn't start with a C or a C allows a country prefix, but doesn't require them. The prefixes used are, unfortunately, not always the same. Officially, ISO country codes need to be used, but the usage of I codes (the same ones as used on cars) is common too. By default, each postal code will recognize a country prefix that's either the ISO standard or the CEPT code. That is, German postal codes may prefixed with either C or C. The recognized prefix can be changed with the C<-country> option, which takes a (sub)pattern as argument. The arguments C and C are special, and indicate the language prefix should be the ISO country code, or the CEPT code. Examples: /$RE{zip}{Netherlands}/; # Matches '1234 AB' and 'NL-1234 AB'. /$RE{zip}{Netherlands}{-prefix => 'no'}/; # Matches '1234 AB' but not 'NL-1234 AB'. /$RE{zip}{Netherlands}{-prefix => 'yes'}/; # Matches 'NL-1234 AB' but not '1234 AB'. /$RE{zip}{Germany}/; # Matches 'DE-12345' and 'D-12345'. /$RE{zip}{Germany}{-country => 'iso'}/; # Matches 'DE-12345' but not 'D-12345'. /$RE{zip}{Germany}{-country => 'cept'}/; # Matches 'D-12345' but not 'DE-12345'. /$RE{zip}{Germany}{-country => 'GER'}/; # Matches 'GER-12345'. =head2 C<{-sep=PAT}> Some countries have postal codes that consist of two parts. Typically there is an official way of separating those parts; but in practise people tend to use different separators. For instance, if the official way to separate parts is to use a space, it happens that the space is left off. The C<-sep> option can be given a pattern as argument which indicates what to use as a separator between the parts. Examples: /$RE{zip}{Netherlands}/; # Matches '1234 AB' but not '1234AB'. /$RE{zip}{Netherlands}{-sep => '\s*'}/; # Matches '1234 AB' and '1234AB'. =head2 C<$RE{zip}{Australia}{-lax}> Returns a pattern that recognizes Australian postal codes. Australian postal codes consist of four digits; the first two digits, which range from '10' to '97', indicate the state, although there are exceptions. Territories use '02' or '08' as starting digits. '0909' is the only postal code starting with '09' - this is the postal code for the Northern Territory University). The (optional) country prefixes are I (ISO country code) and I (CEPT code). It the past, it was claimed that for postal codes starting with a 0, the leading 0 may be omitted, and up to (and including) version 2016060201, the leading 0 was optional. But there doesn't seem be solid evidence the leading 0 is optional. So, we now require there always to be four digit -- unless the C<< {-lax} >> option is given, then a possibly leading 0 is optional. Regexp::Common 2.107 and before used C<$RE{zip}{Australian}>. This is still supported. If C<{-keep}> is used, the following variables will be set: =over 4 =item $1 The entire postal code. =item $2 The country code prefix. =item $3 The postal code without the country prefix. =back As of version 2016060201, no C<< $4 >> or C<< $5 >> will be set. =head2 C<< $RE {zip} {Austria} >> Returns a pattern which recognizes Austrian postal codes. Austrian postal codes consists of 4 digits, but not all possibilities are used. This pattern matches the postal codes in use. The (optional) country prefixes are I (ISO country code) and I (CEPT code). If C<< {-keep} >> is used, the following variables will be set: =over 4 =item $1 The entire postal code. =item $2 The country code prefix. =item $3 The postal code without the country code prefix. =back =head2 C<$RE{zip}{Belgium}> Returns a pattern than recognizes Belgian postal codes. Belgian postal codes consist of 4 digits, of which the first indicates the province. The (optional) country prefixes are I (ISO country code) and I (CEPT code). If C<{-keep}> is used, the following variables will be set: =over 4 =item $1 The entire postal code. =item $2 The country code prefix. =item $3 The postal code without the country prefix. =back =head2 C<$RE{zip}{Denmark}> Returns a pattern that recognizes Danish postal codes. Danish postal codes consist of four numbers; the first digit indicates the distribution region, the second the distribution district. The (optional) country prefix is I, which is both the ISO country code and the CEPT code. If C<{-keep}> is used, the following variables will be set: =over 4 =item $1 The entire postal code. =item $2 The country code prefix. =item $3 The postal code without the country prefix. =back Danish postal codes will not start with 39. Postal codes of the form 39XX are reserved from Greenland; the pattern for Danish postal codes will not recognize them. =head2 C<$RE{zip}{France}> Returns a pattern that recognizes French postal codes. French postal codes consist of five numbers; the first two numbers, which range from '01' to '98', indicate the department. The (optional) country prefixes are I (ISO country code) and I (CEPT code). Regexp::Common 2.107 and before used C<$RE{zip}{French}>. This is still supported. Monaco uses postal codes which are part of the numbering system used by the French postal code system; their numbers start with 980. These numbers are C<< not >> recognized by this pattern. If C<{-keep}> is used, the following variables will be set: =over 4 =item $1 The entire postal code. =item $2 The country code prefix. =item $3 The postal code without the country prefix. =back =head2 C<$RE{zip}{Germany}> Returns a pattern that recognizes German postal codes. German postal codes consist of five numbers; the first two numbers indicating a wider postal area, the last three digits a postal district. The (optional) country prefixes are I (ISO country code) and I (CEPT code). Regexp::Common 2.107 and before used C<$RE{zip}{German}>. This is still supported. If C<{-keep}> is used, the following variables will be set: =over 4 =item $1 The entire postal code. =item $2 The country code prefix. =item $3 The postal code without the country prefix. =back =head2 C<$RE{zip}{Greenland}> Returns a pattern that recognizes postal codes from Greenland. Greenland, uses the Danish postal codes system. Postal codes starting with 39 are reserved for Greenland, and all Greenlandic postal codes start with 39. Except the postal code for Santa. He uses 2412. The (optional) country prefix is I, which is use both as the ISO country code and the CEPT code. Earlier versions used I as the prefix. If C<{-keep}> is used, the following variables will be set: =over 4 =item $1 The entire postal code. =item $2 The country code prefix. =item $3 The postal code without the country prefix. =back =head2 C<$RE{zip}{Italy}> Returns a pattern recognizing Italian postal codes. Italian postal codes consist of 5 digits. The first digit indicates the region, the second the province. The third digit is odd for province capitals, and even for the province itself. The fourth digit indicates the route, and the fifth a place on the route (0 for small places, alphabetically for the rest). Codes starting with 4789 are postal codes for San Marino; they are not recognized by the pattern. Use C<< $RE {zip} {'San Marino'} >> instead. The country prefix is either I (the ISO country code), or I (the CEPT code). If C<{-keep}> is used, the following variables will be set: =over 4 =item $1 The entire postal code. =item $2 The country code prefix. =item $3 The postal code without the country prefix. =back =head2 C<< $RE {zip} {Liechtenstein} >> Returns a pattern which recognizes postal codes used in Liechtenstein. Liechtenstein uses postal codes from the Swiss postal code system. This system uses four digits. Postal codes which start with 94, and use 8 or 9 as a third digit are postal codes for Liechtenstein. If C<{-keep}> is used, the following variables will be set: =over 4 =item $1 The entire postal code. =item $2 The country code prefix. =item $3 The postal code without the country prefix. =back The ISO country prefix is I<< LI >>, the CEPT country prefix is I<< LIE >>. =head2 C<< $RE {zip {Monaco} >> Returns a pattern for postal codes used in Monaco. Monaco uses a range from the system used in France. They are 5 digits, starting with I<< 980 >>. The number I<< 98000 >> is used for physical addresses. Numbers ending in C<< 01 >> to C<< 99 >> are used for special deliveries. The ISO country code is I<< MC >>. If C<{-keep}> is used, the following variables will be set: =over 4 =item $1 The entire postal code. =item $2 The country code prefix. =item $3 The postal code without the country prefix. =back =head2 C<$RE{zip}{Netherlands}> Returns a pattern that recognizes Dutch postal codes. Dutch postal codes consist of 4 digits and 2 letters, separated by a space. The separator can be changed using the C<{-sep}> option, as discussed above. The (optional) country prefix is I, which is both the ISO country code and the CEPT code. Regexp::Common 2.107 and earlier used C<$RE{zip}{Dutch}>. This is still supported. If C<{-keep}> is used, the following variables will be set: =over 4 =item $1 The entire postal code. =item $2 The country code prefix. =item $3 The postal code without the country prefix. =item $4 The digits part of the postal code. =item $5 The separator between the digits and the letters. =item $6 The letters part of the postal code. =back =head2 C<< $RE{zip}{Norway} >> Returns a pattern that recognizes Norwegian postal codes. Norwegian postal codes consist of four digits. The country prefix is either I (the ISO country code), or I (the CEPT code). If C<{-keep}> is used, the following variables will be set: =over 4 =item $1 The entire postal code. =item $2 The country code prefix. =item $3 The postal code without the country prefix. =back =head2 C<< $RE {zip} {'San Marino'} >> Postal codes of San Marino use a slice from the Italian postal codes. Any code starting 4789, followed by another digit belongs to San Marino. The country prefix for San Marino is I<< SM >>. If C<{-keep}> is used, the following variables will be set: =over 4 =item $1 The entire postal code. =item $2 The country code prefix. =item $3 The postal code without the country prefix. =back =head2 C<< $RE{zip}{Spain} >> Returns a pattern that recognizes Spanish postal codes. Spanish postal codes consist of 5 digits. The first 2 indicate one of Spain's fifties provinces (in alphabetical order), starting with C<00>. The third digit indicates a main city or the main delivery rounds. The last two digits are the delivery area, secondary delivery route or a link to rural areas. The country prefix is either I (the ISO country code), or I (the CEPT code). If C<{-keep}> is used, the following variables will be set: =over 4 =item $1 The entire postal code. =item $2 The country code prefix. =item $3 The postal code without the country prefix. =item $4 The two digits indicating the province. =item $5 The digit indicating the main city or main delivery route. =item $6 The digits indicating the delivery area, secondary delivery route or a link to rural areas. =back =head2 C<< $RE {zip} {Switzerland} >> Returns a pattern that recognizes Swiss postal codes. Swiss postal codes consist of 4 digits, but not all combinations are used. Postal codes starting with 948 and 949 are for location in Liechtenstein, and will not be recognized by the pattern for Swiss postal codes. Use C<< $RE {zip} {Liechtenstein} >> for those. If C<{-keep}> is used, the following variables will be set: =over 4 =item $1 The entire postal code. =item $2 The country code prefix. =item $3 The postal code without the country prefix. =back The country prefix is I, for both the ISO and CEPT prefixes. =head2 C<< $RE{zip}{US}{-extended => [yes|no|allow]} >> Returns a pattern that recognizes US zip codes. US zip codes consist of 5 digits, with an optional 4 digit extension. By default, extensions are allowed, but not required. This can be influenced by the C<-extended> option. If its argument starts with a C, extensions are required; if the argument starts with a C, extensions will not be recognized. If an extension is used, a dash is used to separate the main part from the extension, but this can be changed with the C<-sep> option. The country prefix is either I (the ISO country code), or I (the CEPT code). If C<{-keep}> is being used, the following variables will be set: =over 4 =item $1 The entire postal code. =item $2 The country code prefix. =item $3 The postal code without the country prefix. =item $4 The first 5 digits of the postal code. =item $5 The first three digits of the postal code, indicating a sectional center or a large city. New in Regexp::Common 2.119. =item $6 The last 2 digits of the 5 digit part of the postal code, indicating a post office facility or delivery area. New in Regexp::Common 2.119. =item $7 The separator between the 5 digit part and the 4 digit part. Up to Regexp::Common 2.118, this used to be $5. =item $8 The 4 digit part of the postal code (if any). Up to Regexp::Common 2.118, this used to be $6. =item $9 The first two digits of the 4 digit part of the postal code, indicating a sector, or several blocks. New in Regexp::Common 2.119. =item $10 The last two digits of the 4 digit part of the postal code, indicating a segment or one side of a street. New in Regexp::Common 2.119. =back =head3 Questions =over 4 =item Can the 5 digit part of the zip code (in theory) start with 000? =item Can the 5 digit part of the zip code (in theory) end with 00? =item Can the 4 digit part of the zip code (in theory) start with 00? =item Can the 4 digit part of the zip code (in theory) end with 00? =back =head2 C<< $RE {zip} {'Vatican City'} >> Vatican City uses a single postal code; taken from the Italian system of postal codes, and sharing the single code with a part of Rome. If C<{-keep}> is used, the following variables will be set: =over 4 =item $1 The entire postal code. =item $2 The country code prefix. =item $3 The postal code without the country prefix. =back The country prefix for Vatican City is C<< VA >>. =head1 SEE ALSO L for a general description of how to use this interface. =over 4 =item L Frank's compulsive guide to postal addresses. =item L Postal addressing systems. =item L Postal code information. =item L Links to Postcode Pages. =item L All Australian postal codes in use. =item L Information about US postal codes. =item L =item L Lots of zip files with active postal codes. =item L Find postal codes. =back =head1 AUTHORS Damian Conway S<(I)> and Abigail S<(I)>. =head1 MAINTENANCE This package is maintained by Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Zip codes for most countries are missing. Send them in to I. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/URI/fax.pm000644 000765 000024 00000005323 13114356476 022351 0ustar00abigailstaff000000 000000 package Regexp::Common::URI::fax; use Regexp::Common qw /pattern clean no_defaults/; use Regexp::Common::URI qw /register_uri/; use Regexp::Common::URI::RFC2806 qw /$fax_subscriber $fax_subscriber_no_future/; use strict; use warnings; use vars qw /$VERSION/; $VERSION = '2017060201'; my $fax_scheme = 'fax'; my $fax_uri = "(?k:(?k:$fax_scheme):(?k:$fax_subscriber))"; my $fax_uri_nf = "(?k:(?k:$fax_scheme):(?k:$fax_subscriber_no_future))"; register_uri $fax_scheme => $fax_uri; pattern name => [qw (URI fax)], create => $fax_uri ; pattern name => [qw (URI fax nofuture)], create => $fax_uri_nf ; 1; __END__ =pod =head1 NAME Regexp::Common::URI::fax -- Returns a pattern for fax URIs. =head1 SYNOPSIS use Regexp::Common qw /URI/; while (<>) { /$RE{URI}{fax}/ and print "Contains a fax URI.\n"; } =head1 DESCRIPTION =head2 $RE{URI}{fax} Returns a pattern that matches I URIs, as defined by RFC 2806. Under C<{-keep}>, the following are returned: =over 4 =item $1 The complete URI. =item $2 The scheme. =item $3 The phone number, including any possible add-ons like ISDN subaddress, a post dial part, area specifier, service provider, etc. =back =head2 C<$RE{URI}{fax}{nofuture}> As above (including what's returned by C<{-keep}>), with the exception that I are not allowed. Without allowing those I, it becomes much easier to check a URI if the correct syntax for post dial, service provider, phone context, etc has been used - otherwise the regex could always classify them as a I. =head1 REFERENCES =over 4 =item B<[RFC 1035]> Mockapetris, P.: I. November 1987. =item B<[RFC 2396]> Berners-Lee, Tim, Fielding, R., and Masinter, L.: I. August 1998. =item B<[RFC 2806]> Vaha-Sipila, A.: I. April 2000. =back =head1 SEE ALSO L for other supported URIs. =head1 AUTHOR Damian Conway (damian@conway.org) =head1 MAINTENANCE This package is maintained by Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Bound to be plenty. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/URI/file.pm000644 000765 000024 00000004056 13114356476 022514 0ustar00abigailstaff000000 000000 package Regexp::Common::URI::file; use Regexp::Common qw /pattern clean no_defaults/; use Regexp::Common::URI qw /register_uri/; use Regexp::Common::URI::RFC1738 qw /$host $fpath/; use strict; use warnings; use vars qw /$VERSION/; $VERSION = '2017060201'; my $scheme = 'file'; my $uri = "(?k:(?k:$scheme)://(?k:(?k:(?:$host|localhost)?)" . "(?k:/(?k:$fpath))))"; register_uri $scheme => $uri; pattern name => [qw (URI file)], create => $uri, ; 1; __END__ =pod =head1 NAME Regexp::Common::URI::file -- Returns a pattern for file URIs. =head1 SYNOPSIS use Regexp::Common qw /URI/; while (<>) { /$RE{URI}{file}/ and print "Contains a file URI.\n"; } =head1 DESCRIPTION =head2 $RE{URI}{file} Returns a pattern that matches I URIs, as defined by RFC 1738. File URIs have the form: "file:" "//" [ host | "localhost" ] "/" fpath Under C<{-keep}>, the following are returned: =over 4 =item $1 The complete URI. =item $2 The scheme. =item $3 The part of the URI following "file://". =item $4 The hostname. =item $5 The path name, including the leading slash. =item $6 The path name, without the leading slash. =back =head1 REFERENCES =over 4 =item B<[RFC 1738]> Berners-Lee, Tim, Masinter, L., McCahill, M.: I. December 1994. =back =head1 SEE ALSO L for other supported URIs. =head1 AUTHOR Damian Conway (damian@conway.org) =head1 MAINTENANCE This package is maintained by Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Bound to be plenty. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/URI/ftp.pm000644 000765 000024 00000012603 13114356476 022363 0ustar00abigailstaff000000 000000 package Regexp::Common::URI::ftp; use Regexp::Common qw /pattern clean no_defaults/; use Regexp::Common::URI qw /register_uri/; use Regexp::Common::URI::RFC2396 qw /$host $port $ftp_segments $userinfo $userinfo_no_colon/; use strict; use warnings; use vars qw /$VERSION/; $VERSION = '2017060201'; my $ftp_uri = "(?k:(?k:ftp)://(?:(?k:$userinfo)(?k:)\@)?(?k:$host)" . "(?::(?k:$port))?(?k:/(?k:(?k:$ftp_segments)" . "(?:;type=(?k:[AIai]))?))?)"; my $ftp_uri_password = "(?k:(?k:ftp)://(?:(?k:$userinfo_no_colon)" . "(?::(?k:$userinfo_no_colon))?\@)?(?k:$host)" . "(?::(?k:$port))?(?k:/(?k:(?k:$ftp_segments)" . "(?:;type=(?k:[AIai]))?))?)"; register_uri FTP => $ftp_uri; pattern name => [qw (URI FTP), "-type=[AIai]", "-password="], create => sub { my $uri = exists $_ [1] -> {-password} && !defined $_ [1] -> {-password} ? $ftp_uri_password : $ftp_uri; my $type = $_ [1] -> {-type}; $uri =~ s/\[AIai\]/$type/; $uri; } ; 1; __END__ =pod =head1 NAME Regexp::Common::URI::ftp -- Returns a pattern for FTP URIs. =head1 SYNOPSIS use Regexp::Common qw /URI/; while (<>) { /$RE{URI}{FTP}/ and print "Contains an FTP URI.\n"; } =head1 DESCRIPTION =head2 $RE{URI}{FTP}{-type}{-password}; Returns a regex for FTP URIs. Note: FTP URIs are not formally defined. RFC 1738 defines FTP URLs, but parts of that RFC have been obsoleted by RFC 2396. However, the differences between RFC 1738 and RFC 2396 are such that they aren't applicable straightforwardly to FTP URIs. There are two main problems: =over 4 =item Passwords. RFC 1738 allowed an optional username and an optional password (separated by a colon) in the FTP URL. Hence, colons were not allowed in either the username or the password. RFC 2396 strongly recommends passwords should not be used in URIs. It does allow for I instead. This userinfo part may contain colons, and hence contain more than one colon. The regexp returned follows the RFC 2396 specification, unless the I<{-password}> option is given; then the regex allows for an optional username and password, separated by a colon. =item The ;type specifier. RFC 1738 does not allow semi-colons in FTP path names, because a semi-colon is a reserved character for FTP URIs. The semi-colon is used to separate the path from the option I specifier. However, in RFC 2396, paths consist of slash separated segments, and each segment is a semi-colon separated group of parameters. Straigthforward application of RFC 2396 would mean that a trailing I specifier couldn't be distinguished from the last segment of the path having a two parameters, the last one starting with I. Therefore we have opted to disallow a semi-colon in the path part of an FTP URI. Furthermore, RFC 1738 allows three values for the type specifier, I, I and I (either upper case or lower case). However, the internet draft about FTP URIs B<[DRAFT-FTP-URL]> (which expired in May 1997) notes the lack of consistent implementation of the I parameter and drops I from the set of possible values. We follow this practise; however, RFC 1738 behaviour can be archieved by using the I<-type => "[ADIadi]"> parameter. =back FTP URIs have the following syntax: "ftp:" "//" [ userinfo "@" ] host [ ":" port ] [ "/" path [ ";type=" value ]] When using I<{-password}>, we have the syntax: "ftp:" "//" [ user [ ":" password ] "@" ] host [ ":" port ] [ "/" path [ ";type=" value ]] Under C<{-keep}>, the following are returned: =over 4 =item $1 The complete URI. =item $2 The scheme. =item $3 The userinfo, or if I<{-password}> is used, the username. =item $4 If I<{-password}> is used, the password, else C. =item $5 The hostname or IP address. =item $6 The port number. =item $7 The full path and type specification, including the leading slash. =item $8 The full path and type specification, without the leading slash. =item $9 The full path, without the type specification nor the leading slash. =item $10 The value of the type specification. =back =head1 REFERENCES =over 4 =item B<[DRAFT-URL-FTP]> Casey, James: I. November 1996. =item B<[RFC 1738]> Berners-Lee, Tim, Masinter, L., McCahill, M.: I. December 1994. =item B<[RFC 2396]> Berners-Lee, Tim, Fielding, R., and Masinter, L.: I. August 1998. =back =head1 SEE ALSO L for other supported URIs. =head1 AUTHOR Damian Conway (damian@conway.org) =head1 MAINTENANCE This package is maintained by Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Bound to be plenty. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/URI/gopher.pm000644 000765 000024 00000010700 13114356476 023052 0ustar00abigailstaff000000 000000 package Regexp::Common::URI::gopher; use Regexp::Common qw /pattern clean no_defaults/; use Regexp::Common::URI qw /register_uri/; use Regexp::Common::URI::RFC1738 qw /$host $port $uchars/; use Regexp::Common::URI::RFC1808 qw /$pchars $pchar_range/; use strict; use warnings; use vars qw /$VERSION/; $VERSION = '2017060201'; my $pchars_notab = "(?:(?:[$pchar_range]+|" . "%(?:[1-9a-fA-F][0-9a-fA-F]|0[0-8a-fA-F]))*)"; my $gopherplus_string = $pchars; my $search = $pchars; my $search_notab = $pchars_notab; my $selector = $pchars; my $selector_notab = $pchars_notab; my $gopher_type = "(?:[0-9+IgT])"; my $scheme = "gopher"; my $uri = "(?k:(?k:$scheme)://(?k:$host)(?::(?k:$port))?" . "/(?k:(?k:$gopher_type)(?k:$selector)))"; my $uri_notab = "(?k:(?k:$scheme)://(?k:$host)(?::(?k:$port))?" . "/(?k:(?k:$gopher_type)(?k:$selector_notab)" . "(?:%09(?k:$search_notab)(?:%09(?k:$gopherplus_string))?)?))"; register_uri $scheme => $uri; pattern name => [qw (URI gopher -notab=)], create => sub { exists $_ [1] {-notab} && !defined $_ [1] {-notab} ? $uri_notab : $uri}, ; 1; __END__ =pod =head1 NAME Regexp::Common::URI::gopher -- Returns a pattern for gopher URIs. =head1 SYNOPSIS use Regexp::Common qw /URI/; while (<>) { /$RE{URI}{gopher}/ and print "Contains a gopher URI.\n"; } =head1 DESCRIPTION =head2 $RE{URI}{gopher}{-notab} Gopher URIs are poorly defined. Originally, RFC 1738 defined gopher URIs, but they were later redefined in an internet draft. One that was expired in June 1997. The internet draft for gopher URIs defines them as follows: "gopher:" "//" host [ ":" port ] "/" gopher-type selector [ "%09" search [ "%09" gopherplus_string ]] Unfortunally, a I is defined in such a way that characters may be escaped using the URI escape mechanism. This includes tabs, which escaped are C<%09>. Hence, the syntax cannot distinguish between a URI that has both a I and a I part, and an URI where the I includes an escaped tab. (The text of the draft forbids tabs to be present in the I though). C<$RE{URI}{gopher}> follows the defined syntax. To disallow escaped tabs in the I and I parts, use C<$RE{URI}{gopher}{-notab}>. There are other differences between the text and the given syntax. According to the text, selector strings cannot have tabs, linefeeds or carriage returns in them. The text also allows the entire I, (the part after the slash following the hostport) to be empty; if this is empty the slash may be omitted as well. However, this isn't reflected in the syntax. Under C<{-keep}>, the following are returned: =over 4 =item $1 The entire URI. =item $2 The scheme. =item $3 The host (name or address). =item $4 The port (if any). =item $5 The "gopher-path", the part after the / following the host and port. =item $6 The gopher-type. =item $7 The selector. (When no C<{-notab}> is used, this includes the search and gopherplus_string, including the separating escaped tabs). =item $8 The search, if given. (Only when C<{-notab}> is given). =item $9 The gopherplus_string, if given. (Only when C<{-notab}> is given). =back head1 REFERENCES =over 4 =item B<[RFC 1738]> Berners-Lee, Tim, Masinter, L., McCahill, M.: I. December 1994. =item B<[RFC 1808]> Fielding, R.: I. June 1995. =item B<[GOPHER URL]> Krishnan, Murali R., Casey, James: "A Gopher URL Format". Expired Internet draft I. December 1996. =back =head1 SEE ALSO L for other supported URIs. =head1 AUTHOR Damian Conway (damian@conway.org) =head1 MAINTENANCE This package is maintained by Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Bound to be plenty. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/URI/http.pm000644 000765 000024 00000005552 13114356476 022556 0ustar00abigailstaff000000 000000 package Regexp::Common::URI::http; use Regexp::Common qw /pattern clean no_defaults/; use Regexp::Common::URI qw /register_uri/; use Regexp::Common::URI::RFC2396 qw /$host $port $path_segments $query/; use strict; use warnings; use vars qw /$VERSION/; $VERSION = '2017060201'; my $http_uri = "(?k:(?k:http)://(?k:$host)(?::(?k:$port))?" . "(?k:/(?k:(?k:$path_segments)(?:[?](?k:$query))?))?)"; my $https_uri = $http_uri; $https_uri =~ s/http/https?/; register_uri HTTP => $https_uri; pattern name => [qw (URI HTTP), "-scheme=http"], create => sub { my $scheme = $_ [1] -> {-scheme}; my $uri = $http_uri; $uri =~ s/http/$scheme/; $uri; } ; 1; __END__ =pod =head1 NAME Regexp::Common::URI::http -- Returns a pattern for HTTP URIs. =head1 SYNOPSIS use Regexp::Common qw /URI/; while (<>) { /$RE{URI}{HTTP}/ and print "Contains an HTTP URI.\n"; } =head1 DESCRIPTION =head2 $RE{URI}{HTTP}{-scheme} Provides a regex for an HTTP URI as defined by RFC 2396 (generic syntax) and RFC 2616 (HTTP). If C<< -scheme => I

>> is specified the pattern I

is used as the scheme. By default I

is C. C and C are reasonable alternatives. The syntax for an HTTP URI is: "http:" "//" host [ ":" port ] [ "/" path [ "?" query ]] Under C<{-keep}>, the following are returned: =over 4 =item $1 The entire URI. =item $2 The scheme. =item $3 The host (name or address). =item $4 The port (if any). =item $5 The absolute path, including the query and leading slash. =item $6 The absolute path, including the query, without the leading slash. =item $7 The absolute path, without the query or leading slash. =item $8 The query, without the question mark. =back =head1 REFERENCES =over 4 =item B<[RFC 2396]> Berners-Lee, Tim, Fielding, R., and Masinter, L.: I. August 1998. =item B<[RFC 2616]> Fielding, R., Gettys, J., Mogul, J., Frystyk, H., Masinter, L., Leach, P. and Berners-Lee, Tim: I. June 1999. =back =head1 SEE ALSO L for other supported URIs. =head1 AUTHOR Damian Conway (damian@conway.org) =head1 MAINTENANCE This package is maintained by Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Bound to be plenty. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/URI/news.pm000644 000765 000024 00000005411 13114356476 022545 0ustar00abigailstaff000000 000000 package Regexp::Common::URI::news; use Regexp::Common qw /pattern clean no_defaults/; use Regexp::Common::URI qw /register_uri/; use Regexp::Common::URI::RFC1738 qw /$grouppart $group $article $host $port $digits/; use strict; use warnings; use vars qw /$VERSION/; $VERSION = '2017060201'; my $news_scheme = 'news'; my $news_uri = "(?k:(?k:$news_scheme):(?k:$grouppart))"; my $nntp_scheme = 'nntp'; my $nntp_uri = "(?k:(?k:$nntp_scheme)://(?k:(?k:(?k:$host)(?::(?k:$port))?)" . "/(?k:$group)(?:/(?k:$digits))?))"; register_uri $news_scheme => $news_uri; register_uri $nntp_scheme => $nntp_uri; pattern name => [qw (URI news)], create => $news_uri, ; pattern name => [qw (URI NNTP)], create => $nntp_uri, ; 1; __END__ =pod =head1 NAME Regexp::Common::URI::news -- Returns a pattern for file URIs. =head1 SYNOPSIS use Regexp::Common qw /URI/; while (<>) { /$RE{URI}{news}/ and print "Contains a news URI.\n"; } =head1 DESCRIPTION =head2 $RE{URI}{news} Returns a pattern that matches I URIs, as defined by RFC 1738. News URIs have the form: "news:" ( "*" | group | article "@" host ) Under C<{-keep}>, the following are returned: =over 4 =item $1 The complete URI. =item $2 The scheme. =item $3 The part of the URI following "news://". =back =head2 $RE{URI}{NNTP} Returns a pattern that matches I URIs, as defined by RFC 1738. NNTP URIs have the form: "nntp://" host [ ":" port ] "/" group [ "/" digits ] Under C<{-keep}>, the following are returned: =over 4 =item $1 The complete URI. =item $2 The scheme. =item $3 The part of the URI following "nntp://". =item $4 The host and port, separated by a colon. If no port was given, just the host. =item $5 The host. =item $6 The port, if given. =item $7 The group. =item $8 The digits, if given. =back =head1 REFERENCES =over 4 =item B<[RFC 1738]> Berners-Lee, Tim, Masinter, L., McCahill, M.: I. December 1994. =back =head1 SEE ALSO L for other supported URIs. =head1 AUTHOR Damian Conway (damian@conway.org) =head1 MAINTENANCE This package is maintained by Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Bound to be plenty. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/URI/pop.pm000644 000765 000024 00000004054 13114356476 022371 0ustar00abigailstaff000000 000000 package Regexp::Common::URI::pop; use Regexp::Common qw /pattern clean no_defaults/; use Regexp::Common::URI qw /register_uri/; use Regexp::Common::URI::RFC1738 qw /$host $port/; use Regexp::Common::URI::RFC2384 qw /$enc_user $enc_auth_type/; use strict; use warnings; use vars qw /$VERSION/; $VERSION = '2017060201'; my $scheme = "pop"; my $uri = "(?k:(?k:$scheme)://(?:(?k:$enc_user)" . "(?:;AUTH=(?k:[*]|$enc_auth_type))?\@)?" . "(?k:$host)(?::(?k:$port))?)"; register_uri $scheme => $uri; pattern name => [qw (URI POP)], create => $uri, ; 1; __END__ =pod =head1 NAME Regexp::Common::URI::pop -- Returns a pattern for POP URIs. =head1 SYNOPSIS use Regexp::Common qw /URI/; while (<>) { /$RE{URI}{POP}/ and print "Contains a POP URI.\n"; } =head1 DESCRIPTION =head2 $RE{URI}{POP} Returns a pattern that matches I URIs, as defined by RFC 2384. POP URIs have the form: "pop:" "//" [ user [ ";AUTH" ( "*" | auth_type ) ] "@" ] host [ ":" port ] Under C<{-keep}>, the following are returned: =over 4 =item $1 The complete URI. =item $2 The I. =item $3 The I, if given. =item $4 The I, if given (could be a I<*>). =item $5 The I. =item $6 The I, if given. =back =head1 REFERENCES =over 4 =item B<[RFC 2384]> Gellens, R.: I. August 1998. =back =head1 SEE ALSO L for other supported URIs. =head1 AUTHOR Abigail. (I). =head1 BUGS AND IRRITATIONS Bound to be plenty. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/URI/prospero.pm000644 000765 000024 00000004172 13114356476 023445 0ustar00abigailstaff000000 000000 package Regexp::Common::URI::prospero; use Regexp::Common qw /pattern clean no_defaults/; use Regexp::Common::URI qw /register_uri/; use Regexp::Common::URI::RFC1738 qw /$host $port $ppath $fieldname $fieldvalue $fieldspec/; use strict; use warnings; use vars qw /$VERSION/; $VERSION = '2017060201'; my $scheme = 'prospero'; my $uri = "(?k:(?k:$scheme)://(?k:$host)(?::(?k:$port))?" . "/(?k:$ppath)(?k:$fieldspec*))"; register_uri $scheme => $uri; pattern name => [qw (URI prospero)], create => $uri, ; 1; __END__ =pod =head1 NAME Regexp::Common::URI::prospero -- Returns a pattern for prospero URIs. =head1 SYNOPSIS use Regexp::Common qw /URI/; while (<>) { /$RE{URI}{prospero}/ and print "Contains a prospero URI.\n"; } =head1 DESCRIPTION =head2 $RE{URI}{prospero} Returns a pattern that matches I URIs, as defined by RFC 1738. prospero URIs have the form: "prospero:" "//" host [ ":" port ] "/" path [ fieldspec ] * Under C<{-keep}>, the following are returned: =over 4 =item $1 The complete URI. =item $2 The I. =item $3 The I. =item $4 The I, if given. =item $5 The propero path. =item $6 The field specifications, if given. There can be more field specifications; they will all be returned in C<$6>. =back =head1 REFERENCES =over 4 =item B<[RFC 1738]> Berners-Lee, Tim, Masinter, L., McCahill, M.: I. December 1994. =back =head1 SEE ALSO L for other supported URIs. =head1 AUTHOR Abigail. (I). =head1 BUGS AND IRRITATIONS Bound to be plenty. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/URI/RFC1035.pm000644 000765 000024 00000004004 13114356476 022511 0ustar00abigailstaff000000 000000 package Regexp::Common::URI::RFC1035; use Regexp::Common qw /pattern clean no_defaults/; use strict; use warnings; use vars qw /$VERSION/; $VERSION = '2017060201'; use vars qw /@EXPORT @EXPORT_OK %EXPORT_TAGS @ISA/; use Exporter (); @ISA = qw /Exporter/; my %vars; BEGIN { $vars {low} = [qw /$digit $letter $let_dig $let_dig_hyp $ldh_str/]; $vars {parts} = [qw /$label $subdomain/]; $vars {domain} = [qw /$domain/]; } use vars map {@$_} values %vars; @EXPORT = qw /$host/; @EXPORT_OK = map {@$_} values %vars; %EXPORT_TAGS = (%vars, ALL => [@EXPORT_OK]); # RFC 1035. $digit = "[0-9]"; $letter = "[A-Za-z]"; $let_dig = "[A-Za-z0-9]"; $let_dig_hyp = "[-A-Za-z0-9]"; $ldh_str = "(?:[-A-Za-z0-9]+)"; $label = "(?:$letter(?:(?:$ldh_str){0,61}$let_dig)?)"; $subdomain = "(?:$label(?:[.]$label)*)"; $domain = "(?: |(?:$subdomain))"; 1; __END__ =pod =head1 NAME Regexp::Common::URI::RFC1035 -- Definitions from RFC1035; =head1 SYNOPSIS use Regexp::Common::URI::RFC1035 qw /:ALL/; =head1 DESCRIPTION This package exports definitions from RFC1035. It's intended usage is for Regexp::Common::URI submodules only. Its interface might change without notice. =head1 REFERENCES =over 4 =item B<[RFC 1035]> Mockapetris, P.: I. November 1987. =back =head1 AUTHOR Damian Conway (damian@conway.org) =head1 MAINTENANCE This package is maintained by Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Bound to be plenty. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/URI/RFC1738.pm000644 000765 000024 00000011345 13114356476 022531 0ustar00abigailstaff000000 000000 package Regexp::Common::URI::RFC1738; use Regexp::Common qw /pattern clean no_defaults/; use strict; use warnings; use vars qw /$VERSION/; $VERSION = '2017060201'; use vars qw /@EXPORT @EXPORT_OK %EXPORT_TAGS @ISA/; use Exporter (); @ISA = qw /Exporter/; my %vars; BEGIN { $vars {low} = [qw /$digit $digits $hialpha $lowalpha $alpha $alphadigit $safe $extra $national $punctuation $unreserved $unreserved_range $reserved $uchar $uchars $xchar $xchars $hex $escape/]; $vars {connect} = [qw /$port $hostnumber $toplabel $domainlabel $hostname $host $hostport $user $password $login/]; $vars {parts} = [qw /$fsegment $fpath $group $article $grouppart $search $database $wtype $wpath $psegment $fieldname $fieldvalue $fieldspec $ppath/]; } use vars map {@$_} values %vars; @EXPORT = qw /$host/; @EXPORT_OK = map {@$_} values %vars; %EXPORT_TAGS = (%vars, ALL => [@EXPORT_OK]); # RFC 1738, base definitions. # Lowlevel definitions. $digit = '[0-9]'; $digits = '[0-9]+'; $hialpha = '[A-Z]'; $lowalpha = '[a-z]'; $alpha = '[a-zA-Z]'; # lowalpha | hialpha $alphadigit = '[a-zA-Z0-9]'; # alpha | digit $safe = '[-$_.+]'; $extra = "[!*'(),]"; $national = '[][{}|\\^~`]'; $punctuation = '[<>#%"]'; $unreserved_range = q [-a-zA-Z0-9$_.+!*'(),]; # alphadigit | safe | extra $unreserved = "[$unreserved_range]"; $reserved = '[;/?:@&=]'; $hex = '[a-fA-F0-9]'; $escape = "(?:%$hex$hex)"; $uchar = "(?:$unreserved|$escape)"; $uchars = "(?:(?:$unreserved|$escape)*)"; $xchar = "(?:[$unreserved_range;/?:\@&=]|$escape)"; $xchars = "(?:(?:[$unreserved_range;/?:\@&=]|$escape)*)"; # Connection related stuff. $port = "(?:$digits)"; $hostnumber = "(?:$digits\[.]$digits\[.]$digits\[.]$digits)"; $toplabel = "(?:$alpha\[-a-zA-Z0-9]*$alphadigit|$alpha)"; $domainlabel = "(?:(?:$alphadigit\[-a-zA-Z0-9]*)?$alphadigit)"; $hostname = "(?:(?:$domainlabel\[.])*$toplabel)"; $host = "(?:$hostname|$hostnumber)"; $hostport = "(?:$host(?::$port)?)"; $user = "(?:(?:[$unreserved_range;?&=]|$escape)*)"; $password = "(?:(?:[$unreserved_range;?&=]|$escape)*)"; $login = "(?:(?:$user(?::$password)?\@)?$hostport)"; # Parts (might require more if we add more URIs). # FTP/file $fsegment = "(?:(?:[$unreserved_range:\@&=]|$escape)*)"; $fpath = "(?:$fsegment(?:/$fsegment)*)"; # NNTP/news. $group = "(?:$alpha\[-A-Za-z0-9.+_]*)"; $article = "(?:(?:[$unreserved_range;/?:&=]|$escape)+" . '@' . "$host)"; $grouppart = "(?:[*]|$article|$group)"; # It's important that # $article goes before # $group. # WAIS. $search = "(?:(?:[$unreserved_range;:\@&=]|$escape)*)"; $database = $uchars; $wtype = $uchars; $wpath = $uchars; # prospero $psegment = "(?:(?:[$unreserved_range?:\@&=]|$escape)*)"; $fieldname = "(?:(?:[$unreserved_range?:\@&]|$escape)*)"; $fieldvalue = "(?:(?:[$unreserved_range?:\@&]|$escape)*)"; $fieldspec = "(?:;$fieldname=$fieldvalue)"; $ppath = "(?:$psegment(?:/$psegment)*)"; # # The various '(?:(?:[$unreserved_range ...]|$escape)*)' above need # some loop unrolling to speed up the match. # 1; __END__ =pod =head1 NAME Regexp::Common::URI::RFC1738 -- Definitions from RFC1738; =head1 SYNOPSIS use Regexp::Common::URI::RFC1738 qw /:ALL/; =head1 DESCRIPTION This package exports definitions from RFC1738. It's intended usage is for Regexp::Common::URI submodules only. Its interface might change without notice. =head1 REFERENCES =over 4 =item B<[RFC 1738]> Berners-Lee, Tim, Masinter, L., McCahill, M.: I. December 1994. =back =head1 AUTHOR Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Bound to be plenty. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/URI/RFC1808.pm000644 000765 000024 00000010454 13114356476 022527 0ustar00abigailstaff000000 000000 package Regexp::Common::URI::RFC1808; BEGIN { # This makes sure 'use warnings' doesn't bomb out on 5.005_*; # warnings won't be enabled on those old versions though. if ($] < 5.006 && !exists $INC {"warnings.pm"}) { $INC {"warnings.pm"} = 1; no strict 'refs'; *{"warnings::unimport"} = sub {0}; } } use strict; use warnings; use vars qw /$VERSION/; $VERSION = '2017060201'; use vars qw /@EXPORT @EXPORT_OK %EXPORT_TAGS @ISA/; use Exporter (); @ISA = qw /Exporter/; my %vars; BEGIN { $vars {low} = [qw /$punctuation $reserved_range $reserved $national $extra $safe $digit $digits $hialpha $lowalpha $alpha $alphadigit $hex $escape $unreserved_range $unreserved $uchar $uchars $pchar_range $pchar $pchars/], $vars {parts} = [qw /$fragment $query $param $params $segment $fsegment $path $net_loc $scheme $rel_path $abs_path $net_path $relativeURL $generic_RL $absoluteURL $URL/], } use vars map {@$_} values %vars; @EXPORT = qw /$host/; @EXPORT_OK = map {@$_} values %vars; %EXPORT_TAGS = (%vars, ALL => [@EXPORT_OK]); # RFC 1808, base definitions. # Lowlevel definitions. $punctuation = '[<>#%"]'; $reserved_range = q [;/?:@&=]; $reserved = "[$reserved_range]"; $national = '[][{}|\\^~`]'; $extra = "[!*'(),]"; $safe = '[-$_.+]'; $digit = '[0-9]'; $digits = '[0-9]+'; $hialpha = '[A-Z]'; $lowalpha = '[a-z]'; $alpha = '[a-zA-Z]'; # lowalpha | hialpha $alphadigit = '[a-zA-Z0-9]'; # alpha | digit $hex = '[a-fA-F0-9]'; $escape = "(?:%$hex$hex)"; $unreserved_range = q [-a-zA-Z0-9$_.+!*'(),]; # alphadigit | safe | extra $unreserved = "[$unreserved_range]"; $uchar = "(?:$unreserved|$escape)"; $uchars = "(?:(?:$unreserved+|$escape)*)"; $pchar_range = qq [$unreserved_range:\@&=]; $pchar = "(?:[$pchar_range]|$escape)"; $pchars = "(?:(?:[$pchar_range]+|$escape)*)"; # Parts $fragment = "(?:(?:[$unreserved_range$reserved_range]+|$escape)*)"; $query = "(?:(?:[$unreserved_range$reserved_range]+|$escape)*)"; $param = "(?:(?:[$pchar_range/]+|$escape)*)"; $params = "(?:$param(?:;$param)*)"; $segment = "(?:(?:[$pchar_range]+|$escape)*)"; $fsegment = "(?:(?:[$pchar_range]+|$escape)+)"; $path = "(?:$fsegment(?:/$segment)*)"; $net_loc = "(?:(?:[$pchar_range;?]+|$escape)*)"; $scheme = "(?:(?:[-a-zA-Z0-9+.]+|$escape)+)"; $rel_path = "(?:$path?(?:;$params)?(?:?$query)?)"; $abs_path = "(?:/$rel_path)"; $net_path = "(?://$net_loc$abs_path?)"; $relativeURL = "(?:$net_path|$abs_path|$rel_path)"; $generic_RL = "(?:$scheme:$relativeURL)"; $absoluteURL = "(?:$generic_RL|" . "(?:$scheme:(?:[$unreserved_range$reserved_range]+|$escape)*))"; $URL = "(?:(?:$absoluteURL|$relativeURL)(?:#$fragment)?)"; 1; __END__ =pod =head1 NAME Regexp::Common::URI::RFC1808 -- Definitions from RFC1808; =head1 SYNOPSIS use Regexp::Common::URI::RFC1808 qw /:ALL/; =head1 DESCRIPTION This package exports definitions from RFC1808. It's intended usage is for Regexp::Common::URI submodules only. Its interface might change without notice. =head1 REFERENCES =over 4 =item B<[RFC 1808]> Fielding, R.: I. June 1995. =back =head1 AUTHOR Damian Conway (damian@conway.org) =head1 MAINTENANCE This package is maintained by Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Bound to be plenty. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/URI/RFC2384.pm000644 000765 000024 00000004464 13114356476 022533 0ustar00abigailstaff000000 000000 package Regexp::Common::URI::RFC2384; use Regexp::Common qw /pattern clean no_defaults/; use Regexp::Common::URI::RFC1738 qw /$unreserved_range $escape $hostport/; use strict; use warnings; use vars qw /$VERSION/; $VERSION = '2017060201'; use vars qw /@EXPORT @EXPORT_OK %EXPORT_TAGS @ISA/; use Exporter (); @ISA = qw /Exporter/; my %vars; BEGIN { $vars {low} = [qw /$achar_range $achar $achars $achar_more/]; $vars {connect} = [qw /$enc_sasl $enc_user $enc_ext $enc_auth_type $auth $user_auth $server/]; $vars {parts} = [qw /$pop_url/]; } use vars map {@$_} values %vars; @EXPORT = qw /$host/; @EXPORT_OK = map {@$_} values %vars; %EXPORT_TAGS = (%vars, ALL => [@EXPORT_OK]); # RFC 2384, POP3. # Lowlevel definitions. $achar_range = "$unreserved_range&=~"; $achar = "(?:[$achar_range]|$escape)"; $achars = "(?:(?:[$achar_range]+|$escape)*)"; $achar_more = "(?:(?:[$achar_range]+|$escape)+)"; $enc_sasl = $achar_more; $enc_user = $achar_more; $enc_ext = "(?:[+](?:APOP|$achar_more))"; $enc_auth_type = "(?:$enc_sasl|$enc_ext)"; $auth = "(?:;AUTH=(?:[*]|$enc_auth_type))"; $user_auth = "(?:$enc_user$auth?)"; $server = "(?:(?:$user_auth\@)?$hostport)"; $pop_url = "(?:pop://$server)"; 1; __END__ =pod =head1 NAME Regexp::Common::URI::RFC2384 -- Definitions from RFC2384; =head1 SYNOPSIS use Regexp::Common::URI::RFC2384 qw /:ALL/; =head1 DESCRIPTION This package exports definitions from RFC2384. It's intended usage is for Regexp::Common::URI submodules only. Its interface might change without notice. =head1 REFERENCES =over 4 =item B<[RFC 2384]> Gellens, R.: I August 1998. =back =head1 AUTHOR Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Bound to be plenty. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/URI/RFC2396.pm000644 000765 000024 00000012075 13114356476 022533 0ustar00abigailstaff000000 000000 package Regexp::Common::URI::RFC2396; use Regexp::Common qw /pattern clean no_defaults/; use strict; use warnings; use vars qw /$VERSION/; $VERSION = '2017060201'; use vars qw /@EXPORT @EXPORT_OK %EXPORT_TAGS @ISA/; use Exporter (); @ISA = qw /Exporter/; my %vars; BEGIN { $vars {low} = [qw /$digit $upalpha $lowalpha $alpha $alphanum $hex $escaped $mark $unreserved $reserved $pchar $uric $urics $userinfo $userinfo_no_colon $uric_no_slash/]; $vars {parts} = [qw /$query $fragment $param $segment $path_segments $ftp_segments $rel_segment $abs_path $rel_path $path/]; $vars {connect} = [qw /$port $IPv4address $toplabel $domainlabel $hostname $host $hostport $server $reg_name $authority/]; $vars {URI} = [qw /$scheme $net_path $opaque_part $hier_part $relativeURI $absoluteURI $URI_reference/]; } use vars map {@$_} values %vars; @EXPORT = (); @EXPORT_OK = map {@$_} values %vars; %EXPORT_TAGS = (%vars, ALL => [@EXPORT_OK]); # RFC 2396, base definitions. $digit = '[0-9]'; $upalpha = '[A-Z]'; $lowalpha = '[a-z]'; $alpha = '[a-zA-Z]'; # lowalpha | upalpha $alphanum = '[a-zA-Z0-9]'; # alpha | digit $hex = '[a-fA-F0-9]'; $escaped = "(?:%$hex$hex)"; $mark = "[\\-_.!~*'()]"; $unreserved = "[a-zA-Z0-9\\-_.!~*'()]"; # alphanum | mark # %61-%7A, %41-%5A, %30-%39 # a - z A - Z 0 - 9 # %21, %27, %28, %29, %2A, %2D, %2E, %5F, %7E # ! ' ( ) * - . _ ~ $reserved = "[;/?:@&=+\$,]"; $pchar = "(?:[a-zA-Z0-9\\-_.!~*'():\@&=+\$,]|$escaped)"; # unreserved | escaped | [:@&=+$,] $uric = "(?:[;/?:\@&=+\$,a-zA-Z0-9\\-_.!~*'()]|$escaped)"; # reserved | unreserved | escaped $urics = "(?:(?:[;/?:\@&=+\$,a-zA-Z0-9\\-_.!~*'()]+|" . "$escaped)*)"; $query = $urics; $fragment = $urics; $param = "(?:(?:[a-zA-Z0-9\\-_.!~*'():\@&=+\$,]+|$escaped)*)"; $segment = "(?:$param(?:;$param)*)"; $path_segments = "(?:$segment(?:/$segment)*)"; $ftp_segments = "(?:$param(?:/$param)*)"; # NOT from RFC 2396. $rel_segment = "(?:(?:[a-zA-Z0-9\\-_.!~*'();\@&=+\$,]*|$escaped)+)"; $abs_path = "(?:/$path_segments)"; $rel_path = "(?:$rel_segment(?:$abs_path)?)"; $path = "(?:(?:$abs_path|$rel_path)?)"; $port = "(?:$digit*)"; $IPv4address = "(?:$digit+[.]$digit+[.]$digit+[.]$digit+)"; $toplabel = "(?:$alpha"."[-a-zA-Z0-9]*$alphanum|$alpha)"; $domainlabel = "(?:(?:$alphanum"."[-a-zA-Z0-9]*)?$alphanum)"; $hostname = "(?:(?:$domainlabel\[.])*$toplabel\[.]?)"; $host = "(?:$hostname|$IPv4address)"; $hostport = "(?:$host(?::$port)?)"; $userinfo = "(?:(?:[a-zA-Z0-9\\-_.!~*'();:&=+\$,]+|$escaped)*)"; $userinfo_no_colon = "(?:(?:[a-zA-Z0-9\\-_.!~*'();&=+\$,]+|$escaped)*)"; $server = "(?:(?:$userinfo\@)?$hostport)"; $reg_name = "(?:(?:[a-zA-Z0-9\\-_.!~*'()\$,;:\@&=+]*|$escaped)+)"; $authority = "(?:$server|$reg_name)"; $scheme = "(?:$alpha"."[a-zA-Z0-9+\\-.]*)"; $net_path = "(?://$authority$abs_path?)"; $uric_no_slash = "(?:[a-zA-Z0-9\\-_.!~*'();?:\@&=+\$,]|$escaped)"; $opaque_part = "(?:$uric_no_slash$urics)"; $hier_part = "(?:(?:$net_path|$abs_path)(?:[?]$query)?)"; $relativeURI = "(?:(?:$net_path|$abs_path|$rel_path)(?:[?]$query)?"; $absoluteURI = "(?:$scheme:(?:$hier_part|$opaque_part))"; $URI_reference = "(?:(?:$absoluteURI|$relativeURI)?(?:#$fragment)?)"; 1; __END__ =pod =head1 NAME Regexp::Common::URI::RFC2396 -- Definitions from RFC2396; =head1 SYNOPSIS use Regexp::Common::URI::RFC2396 qw /:ALL/; =head1 DESCRIPTION This package exports definitions from RFC2396. It's intended usage is for Regexp::Common::URI submodules only. Its interface might change without notice. =head1 REFERENCES =over 4 =item B<[RFC 2396]> Berners-Lee, Tim, Fielding, R., and Masinter, L.: I. August 1998. =back =head1 AUTHOR Damian Conway (damian@conway.org) =head1 MAINTENANCE This package is maintained by Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Bound to be plenty. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/URI/RFC2806.pm000644 000765 000024 00000017621 13114356476 022531 0ustar00abigailstaff000000 000000 package Regexp::Common::URI::RFC2806; use Regexp::Common::URI::RFC1035 qw /$domain/; use Regexp::Common::URI::RFC2396 qw /$unreserved $escaped $hex/; use strict; use warnings; use vars qw /$VERSION/; $VERSION = '2017060201'; use vars qw /@EXPORT @EXPORT_OK %EXPORT_TAGS @ISA/; use Exporter (); @ISA = qw /Exporter/; my %vars; BEGIN { $vars {low} = [qw /$dtmf_digit $wait_for_dial_tone $one_second_pause $pause_character $visual_separator $phonedigit $escaped_no_dquote $quoted_string $token_char $token_chars/]; $vars {parts} = [qw /$future_extension/]; $vars {connect} = [qw /$provider_hostname $provider_tag $service_provider $private_prefix $local_network_prefix $global_network_prefix $network_prefix/]; $vars {phone} = [qw /$phone_context_ident $phone_context_tag $area_specifier $post_dial $isdn_subaddress $t33_subaddress $local_phone_number $local_phone_number_no_future $base_phone_number $global_phone_number $global_phone_number_no_future $telephone_subscriber $telephone_subscriber_no_future/]; $vars {fax} = [qw /$fax_local_phone $fax_local_phone_no_future $fax_global_phone $fax_global_phone_no_future $fax_subscriber $fax_subscriber_no_future/]; $vars {modem} = [qw //]; } use vars map {@$_} values %vars; @EXPORT = (); @EXPORT_OK = map {@$_} values %vars; %EXPORT_TAGS = (%vars, ALL => [@EXPORT_OK]); # RFC 2806, URIs for tel, fax & modem. $dtmf_digit = "(?:[*#ABCD])"; $wait_for_dial_tone= "(?:w)"; $one_second_pause = "(?:p)"; $pause_character = "(?:[wp])"; # wait_for_dial_tone | one_second_pause. $visual_separator = "(?:[\\-.()])"; $phonedigit = "(?:[0-9\\-.()])"; # DIGIT | visual_separator $escaped_no_dquote = "(?:%(?:[01]$hex)|2[013-9A-Fa-f]|[3-9A-Fa-f]$hex)"; $quoted_string = "(?:%22(?:(?:%5C(?:$unreserved|$escaped))|" . "$unreserved+|$escaped_no_dquote)*%22)"; # It is unclear wether we can allow only unreserved # characters to unescaped, or can we also use uric # characters that are unescaped? Or pchars? $token_char = "(?:[!'*\\-.0-9A-Z_a-z~]|" . "%(?:2[13-7ABDEabde]|3[0-9]|4[1-9A-Fa-f]|" . "5[AEFaef]|6[0-9A-Fa-f]|7[0-9ACEace]))"; # Only allowing unreserved chars to be unescaped. $token_chars = "(?:(?:[!'*\\-.0-9A-Z_a-z~]+|" . "%(?:2[13-7ABDEabde]|3[0-9]|4[1-9A-Fa-f]|" . "5[AEFaef]|6[0-9A-Fa-f]|7[0-9ACEace]))*)"; $future_extension = "(?:;$token_chars" . "(?:=(?:(?:$token_chars(?:[?]$token_chars)?)|" . "$quoted_string))?)"; $provider_hostname = $domain; $provider_tag = "(?:tsp)"; $service_provider = "(?:;$provider_tag=$provider_hostname)"; $private_prefix = "(?:(?:[!'E-OQ-VX-Z_e-oq-vx-z~]|" . "(?:%(?:2[124-7CFcf]|3[AC-Fac-f]|4[05-9A-Fa-f]|" . "5[1-689A-Fa-f]|6[05-9A-Fa-f]|" . "7[1-689A-Ea-e])))" . "(?:[!'()*\\-.0-9A-Z_a-z~]+|" . "(?:%(?:2[1-9A-Fa-f]|3[AC-Fac-f]|" . "[4-6][0-9A-Fa-f]|7[0-9A-Ea-e])))*)"; $local_network_prefix = "(?:[0-9\\-.()*#ABCDwp]+)"; $global_network_prefix = "(?:[+][0-9\\-.()]+)"; $network_prefix = "(?:$global_network_prefix|$local_network_prefix)"; $phone_context_ident = "(?:$network_prefix|$private_prefix)"; $phone_context_tag = "(?:phone-context)"; $area_specifier = "(?:;$phone_context_tag=$phone_context_ident)"; $post_dial = "(?:;postd=[0-9\\-.()*#ABCDwp]+)"; $isdn_subaddress = "(?:;isub=[0-9\\-.()]+)"; $t33_subaddress = "(?:;tsub=[0-9\\-.()]+)"; $local_phone_number= "(?:[0-9\\-.()*#ABCDwp]+$isdn_subaddress?" . "$post_dial?$area_specifier" . "(?:$area_specifier|$service_provider|" . "$future_extension)*)"; $local_phone_number_no_future = "(?:[0-9\\-.()*#ABCDwp]+$isdn_subaddress?" . "$post_dial?$area_specifier" . "(?:$area_specifier|$service_provider)*)"; $fax_local_phone = "(?:[0-9\\-.()*#ABCDwp]+$isdn_subaddress?" . "$t33_subaddress?$post_dial?$area_specifier" . "(?:$area_specifier|$service_provider|" . "$future_extension)*)"; $fax_local_phone_no_future = "(?:[0-9\\-.()*#ABCDwp]+$isdn_subaddress?" . "$t33_subaddress?$post_dial?$area_specifier" . "(?:$area_specifier|$service_provider)*)"; $base_phone_number = "(?:[0-9\\-.()]+)"; $global_phone_number = "(?:[+]$base_phone_number$isdn_subaddress?" . "$post_dial?" . "(?:$area_specifier|$service_provider|" . "$future_extension)*)"; $global_phone_number_no_future = "(?:[+]$base_phone_number$isdn_subaddress?" . "$post_dial?" . "(?:$area_specifier|$service_provider)*)"; $fax_global_phone = "(?:[+]$base_phone_number$isdn_subaddress?" . "$t33_subaddress?$post_dial?" . "(?:$area_specifier|$service_provider|" . "$future_extension)*)"; $fax_global_phone_no_future = "(?:[+]$base_phone_number$isdn_subaddress?" . "$t33_subaddress?$post_dial?" . "(?:$area_specifier|$service_provider)*)"; $telephone_subscriber = "(?:$global_phone_number|$local_phone_number)"; $telephone_subscriber_no_future = "(?:$global_phone_number_no_future|" . "$local_phone_number_no_future)"; $fax_subscriber = "(?:$fax_global_phone|$fax_local_phone)"; $fax_subscriber_no_future = "(?:$fax_global_phone_no_future|" . "$fax_local_phone_no_future)"; 1; __END__ =pod =head1 NAME Regexp::Common::URI::RFC2806 -- Definitions from RFC2806; =head1 SYNOPSIS use Regexp::Common::URI::RFC2806 qw /:ALL/; =head1 DESCRIPTION This package exports definitions from RFC2806. It's intended usage is for Regexp::Common::URI submodules only. Its interface might change without notice. =head1 REFERENCES =over 4 =item B<[RFC 2616]> Fielding, R., Gettys, J., Mogul, J., Frystyk, H., Masinter, L., Leach, P. and Berners-Lee, Tim: I. June 1999. =back =head1 AUTHOR Damian Conway (damian@conway.org) =head1 MAINTENANCE This package is maintained by Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Bound to be plenty. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/URI/tel.pm000644 000765 000024 00000005367 13114356476 022367 0ustar00abigailstaff000000 000000 package Regexp::Common::URI::tel; use Regexp::Common qw /pattern clean no_defaults/; use Regexp::Common::URI qw /register_uri/; use Regexp::Common::URI::RFC2806 qw /$telephone_subscriber $telephone_subscriber_no_future/; use strict; use warnings; use vars qw /$VERSION/; $VERSION = '2017060201'; my $tel_scheme = 'tel'; my $tel_uri = "(?k:(?k:$tel_scheme):(?k:$telephone_subscriber))"; my $tel_uri_nf = "(?k:(?k:$tel_scheme):(?k:$telephone_subscriber_no_future))"; register_uri $tel_scheme => $tel_uri; pattern name => [qw (URI tel)], create => $tel_uri ; pattern name => [qw (URI tel nofuture)], create => $tel_uri_nf ; 1; __END__ =pod =head1 NAME Regexp::Common::URI::tel -- Returns a pattern for telephone URIs. =head1 SYNOPSIS use Regexp::Common qw /URI/; while (<>) { /$RE{URI}{tel}/ and print "Contains a telephone URI.\n"; } =head1 DESCRIPTION =head2 $RE{URI}{tel} Returns a pattern that matches I URIs, as defined by RFC 2806. Under C<{-keep}>, the following are returned: =over 4 =item $1 The complete URI. =item $2 The scheme. =item $3 The phone number, including any possible add-ons like ISDN subaddress, a post dial part, area specifier, service provider, etc. =back =head2 C<$RE{URI}{tel}{nofuture}> As above (including what's returned by C<{-keep}>), with the exception that I are not allowed. Without allowing those I, it becomes much easier to check a URI if the correct syntax for post dial, service provider, phone context, etc has been used - otherwise the regex could always classify them as a I. =head1 REFERENCES =over 4 =item B<[RFC 1035]> Mockapetris, P.: I. November 1987. =item B<[RFC 2396]> Berners-Lee, Tim, Fielding, R., and Masinter, L.: I. August 1998. =item B<[RFC 2806]> Vaha-Sipila, A.: I. April 2000. =back =head1 SEE ALSO L for other supported URIs. =head1 AUTHOR Damian Conway (damian@conway.org) =head1 MAINTENANCE This package is maintained by Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Bound to be plenty. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/URI/telnet.pm000644 000765 000024 00000004412 13114356476 023064 0ustar00abigailstaff000000 000000 package Regexp::Common::URI::telnet; use Regexp::Common qw /pattern clean no_defaults/; use Regexp::Common::URI qw /register_uri/; use Regexp::Common::URI::RFC1738 qw /$user $password $host $port/; use strict; use warnings; use vars qw /$VERSION/; $VERSION = '2017060201'; my $telnet_uri = "(?k:(?k:telnet)://(?:(?k:(?k:$user)(?::(?k:$password))?)\@)?" . "(?k:(?k:$host)(?::(?k:$port))?)(?k:/)?)"; register_uri telnet => $telnet_uri; pattern name => [qw (URI telnet)], create => $telnet_uri, ; 1; __END__ =pod =head1 NAME Regexp::Common::URI::telnet -- Returns a pattern for telnet URIs. =head1 SYNOPSIS use Regexp::Common qw /URI/; while (<>) { /$RE{URI}{telnet}/ and print "Contains a telnet URI.\n"; } =head1 DESCRIPTION =head2 $RE{URI}{telnet} Returns a pattern that matches I URIs, as defined by RFC 1738. Telnet URIs have the form: "telnet:" "//" [ user [ ":" password ] "@" ] host [ ":" port ] [ "/" ] Under C<{-keep}>, the following are returned: =over 4 =item $1 The complete URI. =item $2 The scheme. =item $3 The username:password combo, or just the username if there is no password. =item $4 The username, if given. =item $5 The password, if given. =item $6 The host:port combo, or just the host if there's no port. =item $7 The host. =item $8 The port, if given. =item $9 The trailing slash, if any. =back =head1 REFERENCES =over 4 =item B<[RFC 1738]> Berners-Lee, Tim, Masinter, L., McCahill, M.: I. December 1994. =back =head1 SEE ALSO L for other supported URIs. =head1 AUTHOR Damian Conway (damian@conway.org) =head1 MAINTENANCE This package is maintained by Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Bound to be plenty. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/URI/tv.pm000644 000765 000024 00000003750 13114356476 022226 0ustar00abigailstaff000000 000000 # TV URLs. # Internet draft: draft-zigmond-tv-url-03.txt package Regexp::Common::URI::tv; use Regexp::Common qw /pattern clean no_defaults/; use Regexp::Common::URI qw /register_uri/; use Regexp::Common::URI::RFC2396 qw /$hostname/; use strict; use warnings; use vars qw /$VERSION/; $VERSION = '2017060201'; my $tv_scheme = 'tv'; my $tv_url = "(?k:(?k:$tv_scheme):(?k:$hostname)?)"; register_uri $tv_scheme => $tv_url; pattern name => [qw (URI tv)], create => $tv_url, ; 1; __END__ =pod =head1 NAME Regexp::Common::URI::tv -- Returns a pattern for tv URIs. =head1 SYNOPSIS use Regexp::Common qw /URI/; while (<>) { /$RE{URI}{tv}/ and print "Contains a tv URI.\n"; } =head1 DESCRIPTION =head2 C<$RE{URI}{tv}> Returns a pattern that recognizes TV uris as per an Internet draft [DRAFT-URI-TV]. Under C<{-keep}>, the following are returned: =over 4 =item $1 The entire URI. =item $2 The scheme. =item $3 The host. =back =head1 REFERENCES =over 4 =item B<[DRAFT-URI-TV]> Zigmond, D. and Vickers, M: I. December 2000. =item B<[RFC 2396]> Berners-Lee, Tim, Fielding, R., and Masinter, L.: I. August 1998. =back =head1 SEE ALSO L for other supported URIs. =head1 AUTHOR Damian Conway (damian@conway.org) =head1 MAINTENANCE This package is maintained by Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Bound to be plenty. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut Regexp-Common-2017060201/lib/Regexp/Common/URI/wais.pm000644 000765 000024 00000004641 13114356476 022540 0ustar00abigailstaff000000 000000 package Regexp::Common::URI::wais; use Regexp::Common qw /pattern clean no_defaults/; use Regexp::Common::URI qw /register_uri/; use Regexp::Common::URI::RFC1738 qw /$host $port $search $database $wtype $wpath/; use strict; use warnings; use vars qw /$VERSION/; $VERSION = '2017060201'; my $scheme = 'wais'; my $uri = "(?k:(?k:$scheme)://(?k:$host)(?::(?k:$port))?/(?k:(?k:$database)" . "(?k:[?](?k:$search)|/(?k:$wtype)/(?k:$wpath))?))"; register_uri $scheme => $uri; pattern name => [qw (URI WAIS)], create => $uri, ; 1; __END__ =pod =head1 NAME Regexp::Common::URI::wais -- Returns a pattern for WAIS URIs. =head1 SYNOPSIS use Regexp::Common qw /URI/; while (<>) { /$RE{URI}{WAIS}/ and print "Contains a WAIS URI.\n"; } =head1 DESCRIPTION =head2 $RE{URI}{WAIS} Returns a pattern that matches I URIs, as defined by RFC 1738. WAIS URIs have the form: "wais:" "//" host [ ":" port ] "/" database [ ( "?" search ) | ( "/" wtype "/" wpath ) ] Under C<{-keep}>, the following are returned: =over 4 =item $1 The complete URI. =item $2 The I. =item $3 The I. =item $4 The I, if given. =item $5 The I, followed by I or I, if given. =item $6 The I. =item $7 The part following the I if given, including the question mark or slash. =item $8 The I part, if given. =item $9 The I, if given. =item $10 The I, if given. =back =head1 REFERENCES =over 4 =item B<[RFC 1738]> Berners-Lee, Tim, Masinter, L., McCahill, M.: I. December 1994. =back =head1 SEE ALSO L for other supported URIs. =head1 AUTHOR Damian Conway (damian@conway.org) =head1 MAINTENANCE This package is maintained by Abigail S<(I)>. =head1 BUGS AND IRRITATIONS Bound to be plenty. =head1 LICENSE and COPYRIGHT This software is Copyright (c) 2001 - 2017, Damian Conway and Abigail. This module is free software, and maybe used under any of the following licenses: 1) The Perl Artistic License. See the file COPYRIGHT.AL. 2) The Perl Artistic License 2.0. See the file COPYRIGHT.AL2. 3) The BSD License. See the file COPYRIGHT.BSD. 4) The MIT License. See the file COPYRIGHT.MIT. =cut

is C. =head2 C<$RE{net}{IPv4}{hex}{-sep}> Returns a pattern that matches a valid IP address in "dotted hexadecimal", with the letters C to C capitalized. If C<< -sep=I