{"schema":"libjg2-1", "vpath":"/git/", "avatar":"/git/avatar/", "alang":"", "gen_ut":1756236647, "reponame":"openssl", "desc":"OpenSSL", "owner": { "name": "Andy Green", "email": "andy@warmcat.com", "md5": "c50933ca2aa61e0fe2c43d46bb6b59cb" },"url":"https://warmcat.com/repo/openssl", "f":3, "items": [ {"schema":"libjg2-1", "cid":"0fb37e8e22eaa50c2a10907eea4c1d78", "commit": {"type":"commit", "time": 1453500742, "time_ofs": 60, "oid_tree": { "oid": "393ca181167ee0a13e0b2547597fe9ec3ad651d8", "alias": []}, "oid":{ "oid": "8ff2af548303d311ce3591406111f77862875a60", "alias": []}, "msg": "Bundle the non core Perl module Text::Template", "sig_commit": { "git_time": { "time": 1453500742, "offset": 60 }, "name": "Richard Levitte", "email": "richard@levitte.org", "md5": "3b69a4016ef7dab0875855fb8fc3ad98" }, "sig_author": { "git_time": { "time": 1453461914, "offset": 60 }, "name": "Richard Levitte", "email": "richard@levitte.org", "md5": "3b69a4016ef7dab0875855fb8fc3ad98" }}, "body": "Bundle the non core Perl module Text::Template\n\nBecause we're using Text::Template and we know it's a non core Perl\nmodule, we choose to bundle it into our source, for convenience.\n\nexternal/perl/Downloaded.txt document what modules we choose to bundle\nthis way and exactly where we downloaded it from.\n\nWith this changes comes the transfer module for with_fallback.\n\nReviewed-by: Rich Salz \u003crsalz@openssl.org\u003e\n" , "diff": "diff --git a/external/perl/Downloaded.txt b/external/perl/Downloaded.txt\nnew file mode 100644\nindex 0000000..af0c20a\n--- /dev/null\n+++ b/external/perl/Downloaded.txt\n@@ -0,0 +1,13 @@\n+Intro\n+-----\n+\n+If we find a useful Perl module that isn't one of the core Perl\n+modules, we may choose to bundle it with the OpenSSL source.\n+\n+Here, we simply list those modules and where we downloaded them from.\n+\n+Downloaded and bundled Perl modules\n+-----------------------------------\n+\n+Text::Template 1.46 was downloaded from\n+http://search.cpan.org/CPAN/authors/id/M/MJ/MJD/Text-Template-1.46.tar.gz\ndiff --git a/external/perl/Text-Template-1.46/Artistic b/external/perl/Text-Template-1.46/Artistic\nnew file mode 100644\nindex 0000000..5f22124\n--- /dev/null\n+++ b/external/perl/Text-Template-1.46/Artistic\n@@ -0,0 +1,131 @@\n+\n+\n+\n+\n+\t\t\t The \u0022Artistic License\u0022\n+\n+\t\t\t\tPreamble\n+\n+The intent of this document is to state the conditions under which a\n+Package may be copied, such that the Copyright Holder maintains some\n+semblance of artistic control over the development of the package,\n+while giving the users of the package the right to use and distribute\n+the Package in a more-or-less customary fashion, plus the right to make\n+reasonable modifications.\n+\n+Definitions:\n+\n+\t\u0022Package\u0022 refers to the collection of files distributed by the\n+\tCopyright Holder, and derivatives of that collection of files\n+\tcreated through textual modification.\n+\n+\t\u0022Standard Version\u0022 refers to such a Package if it has not been\n+\tmodified, or has been modified in accordance with the wishes\n+\tof the Copyright Holder as specified below.\n+\n+\t\u0022Copyright Holder\u0022 is whoever is named in the copyright or\n+\tcopyrights for the package.\n+\n+\t\u0022You\u0022 is you, if you're thinking about copying or distributing\n+\tthis Package.\n+\n+\t\u0022Reasonable copying fee\u0022 is whatever you can justify on the\n+\tbasis of media cost, duplication charges, time of people involved,\n+\tand so on. (You will not be required to justify it to the\n+\tCopyright Holder, but only to the computing community at large\n+\tas a market that must bear the fee.)\n+\n+\t\u0022Freely Available\u0022 means that no fee is charged for the item\n+\titself, though there may be fees involved in handling the item.\n+\tIt also means that recipients of the item may redistribute it\n+\tunder the same conditions they received it.\n+\n+1. You may make and give away verbatim copies of the source form of the\n+Standard Version of this Package without restriction, provided that you\n+duplicate all of the original copyright notices and associated disclaimers.\n+\n+2. You may apply bug fixes, portability fixes and other modifications\n+derived from the Public Domain or from the Copyright Holder. A Package\n+modified in such a way shall still be considered the Standard Version.\n+\n+3. You may otherwise modify your copy of this Package in any way, provided\n+that you insert a prominent notice in each changed file stating how and\n+when you changed that file, and provided that you do at least ONE of the\n+following:\n+\n+ a) place your modifications in the Public Domain or otherwise make them\n+ Freely Available, such as by posting said modifications to Usenet or\n+ an equivalent medium, or placing the modifications on a major archive\n+ site such as uunet.uu.net, or by allowing the Copyright Holder to include\n+ your modifications in the Standard Version of the Package.\n+\n+ b) use the modified Package only within your corporation or organization.\n+\n+ c) rename any non-standard executables so the names do not conflict\n+ with standard executables, which must also be provided, and provide\n+ a separate manual page for each non-standard executable that clearly\n+ documents how it differs from the Standard Version.\n+\n+ d) make other distribution arrangements with the Copyright Holder.\n+\n+4. You may distribute the programs of this Package in object code or\n+executable form, provided that you do at least ONE of the following:\n+\n+ a) distribute a Standard Version of the executables and library files,\n+ together with instructions (in the manual page or equivalent) on where\n+ to get the Standard Version.\n+\n+ b) accompany the distribution with the machine-readable source of\n+ the Package with your modifications.\n+\n+ c) give non-standard executables non-standard names, and clearly\n+ document the differences in manual pages (or equivalent), together\n+ with instructions on where to get the Standard Version.\n+\n+ d) make other distribution arrangements with the Copyright Holder.\n+\n+5. You may charge a reasonable copying fee for any distribution of this\n+Package. You may charge any fee you choose for support of this\n+Package. You may not charge a fee for this Package itself. However,\n+you may distribute this Package in aggregate with other (possibly\n+commercial) programs as part of a larger (possibly commercial) software\n+distribution provided that you do not advertise this Package as a\n+product of your own. You may embed this Package's interpreter within\n+an executable of yours (by linking); this shall be construed as a mere\n+form of aggregation, provided that the complete Standard Version of the\n+interpreter is so embedded.\n+\n+6. The scripts and library files supplied as input to or produced as\n+output from the programs of this Package do not automatically fall\n+under the copyright of this Package, but belong to whoever generated\n+them, and may be sold commercially, and may be aggregated with this\n+Package. If such scripts or library files are aggregated with this\n+Package via the so-called \u0022undump\u0022 or \u0022unexec\u0022 methods of producing a\n+binary executable image, then distribution of such an image shall\n+neither be construed as a distribution of this Package nor shall it\n+fall under the restrictions of Paragraphs 3 and 4, provided that you do\n+not represent such an executable image as a Standard Version of this\n+Package.\n+\n+7. C subroutines (or comparably compiled subroutines in other\n+languages) supplied by you and linked into this Package in order to\n+emulate subroutines and variables of the language defined by this\n+Package shall not be considered part of this Package, but are the\n+equivalent of input as in Paragraph 6, provided these subroutines do\n+not change the language in any way that would cause it to fail the\n+regression tests for the language.\n+\n+8. Aggregation of this Package with a commercial distribution is always\n+permitted provided that the use of this Package is embedded; that is,\n+when no overt attempt is made to make this Package's interfaces visible\n+to the end user of the commercial distribution. Such use shall not be\n+construed as a distribution of this Package.\n+\n+9. The name of the Copyright Holder may not be used to endorse or promote\n+products derived from this software without specific prior written permission.\n+\n+10. THIS PACKAGE IS PROVIDED \u0022AS IS\u0022 AND WITHOUT ANY EXPRESS OR\n+IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED\n+WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.\n+\n+\t\t\t\tThe End\ndiff --git a/external/perl/Text-Template-1.46/COPYING b/external/perl/Text-Template-1.46/COPYING\nnew file mode 100644\nindex 0000000..a3f6b12\n--- /dev/null\n+++ b/external/perl/Text-Template-1.46/COPYING\n@@ -0,0 +1,340 @@\n+\t\t GNU GENERAL PUBLIC LICENSE\n+\t\t Version 2, June 1991\n+\n+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.\n+ 59 Temple Place - Suite 330, Boston, MA\n+ 02111-1307, USA.\n+ Everyone is permitted to copy and distribute verbatim copies\n+ of this license document, but changing it is not allowed.\n+\n+\t\t\t Preamble\n+\n+ The licenses for most software are designed to take away your\n+freedom to share and change it. By contrast, the GNU General Public\n+License is intended to guarantee your freedom to share and change free\n+software--to make sure the software is free for all its users. This\n+General Public License applies to most of the Free Software\n+Foundation's software and to any other program whose authors commit to\n+using it. (Some other Free Software Foundation software is covered by\n+the GNU Library General Public License instead.) You can apply it to\n+your programs, too.\n+\n+ When we speak of free software, we are referring to freedom, not\n+price. Our General Public Licenses are designed to make sure that you\n+have the freedom to distribute copies of free software (and charge for\n+this service if you wish), that you receive source code or can get it\n+if you want it, that you can change the software or use pieces of it\n+in new free programs; and that you know you can do these things.\n+\n+ To protect your rights, we need to make restrictions that forbid\n+anyone to deny you these rights or to ask you to surrender the rights.\n+These restrictions translate to certain responsibilities for you if you\n+distribute copies of the software, or if you modify it.\n+\n+ For example, if you distribute copies of such a program, whether\n+gratis or for a fee, you must give the recipients all the rights that\n+you have. You must make sure that they, too, receive or can get the\n+source code. And you must show them these terms so they know their\n+rights.\n+\n+ We protect your rights with two steps: (1) copyright the software, and\n+(2) offer you this license which gives you legal permission to copy,\n+distribute and/or modify the software.\n+\n+ Also, for each author's protection and ours, we want to make certain\n+that everyone understands that there is no warranty for this free\n+software. If the software is modified by someone else and passed on, we\n+want its recipients to know that what they have is not the original, so\n+that any problems introduced by others will not reflect on the original\n+authors' reputations.\n+\n+ Finally, any free program is threatened constantly by software\n+patents. We wish to avoid the danger that redistributors of a free\n+program will individually obtain patent licenses, in effect making the\n+program proprietary. To prevent this, we have made it clear that any\n+patent must be licensed for everyone's free use or not licensed at all.\n+\n+ The precise terms and conditions for copying, distribution and\n+modification follow.\n+\u000c\n+\t\t GNU GENERAL PUBLIC LICENSE\n+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\n+\n+ 0. This License applies to any program or other work which contains\n+a notice placed by the copyright holder saying it may be distributed\n+under the terms of this General Public License. The \u0022Program\u0022, below,\n+refers to any such program or work, and a \u0022work based on the Program\u0022\n+means either the Program or any derivative work under copyright law:\n+that is to say, a work containing the Program or a portion of it,\n+either verbatim or with modifications and/or translated into another\n+language. (Hereinafter, translation is included without limitation in\n+the term \u0022modification\u0022.) Each licensee is addressed as \u0022you\u0022.\n+\n+Activities other than copying, distribution and modification are not\n+covered by this License; they are outside its scope. The act of\n+running the Program is not restricted, and the output from the Program\n+is covered only if its contents constitute a work based on the\n+Program (independent of having been made by running the Program).\n+Whether that is true depends on what the Program does.\n+\n+ 1. You may copy and distribute verbatim copies of the Program's\n+source code as you receive it, in any medium, provided that you\n+conspicuously and appropriately publish on each copy an appropriate\n+copyright notice and disclaimer of warranty; keep intact all the\n+notices that refer to this License and to the absence of any warranty;\n+and give any other recipients of the Program a copy of this License\n+along with the Program.\n+\n+You may charge a fee for the physical act of transferring a copy, and\n+you may at your option offer warranty protection in exchange for a fee.\n+\n+ 2. You may modify your copy or copies of the Program or any portion\n+of it, thus forming a work based on the Program, and copy and\n+distribute such modifications or work under the terms of Section 1\n+above, provided that you also meet all of these conditions:\n+\n+ a) You must cause the modified files to carry prominent notices\n+ stating that you changed the files and the date of any change.\n+\n+ b) You must cause any work that you distribute or publish, that in\n+ whole or in part contains or is derived from the Program or any\n+ part thereof, to be licensed as a whole at no charge to all third\n+ parties under the terms of this License.\n+\n+ c) If the modified program normally reads commands interactively\n+ when run, you must cause it, when started running for such\n+ interactive use in the most ordinary way, to print or display an\n+ announcement including an appropriate copyright notice and a\n+ notice that there is no warranty (or else, saying that you provide\n+ a warranty) and that users may redistribute the program under\n+ these conditions, and telling the user how to view a copy of this\n+ License. (Exception: if the Program itself is interactive but\n+ does not normally print such an announcement, your work based on\n+ the Program is not required to print an announcement.)\n+\u000c\n+These requirements apply to the modified work as a whole. If\n+identifiable sections of that work are not derived from the Program,\n+and can be reasonably considered independent and separate works in\n+themselves, then this License, and its terms, do not apply to those\n+sections when you distribute them as separate works. But when you\n+distribute the same sections as part of a whole which is a work based\n+on the Program, the distribution of the whole must be on the terms of\n+this License, whose permissions for other licensees extend to the\n+entire whole, and thus to each and every part regardless of who wrote it.\n+\n+Thus, it is not the intent of this section to claim rights or contest\n+your rights to work written entirely by you; rather, the intent is to\n+exercise the right to control the distribution of derivative or\n+collective works based on the Program.\n+\n+In addition, mere aggregation of another work not based on the Program\n+with the Program (or with a work based on the Program) on a volume of\n+a storage or distribution medium does not bring the other work under\n+the scope of this License.\n+\n+ 3. You may copy and distribute the Program (or a work based on it,\n+under Section 2) in object code or executable form under the terms of\n+Sections 1 and 2 above provided that you also do one of the following:\n+\n+ a) Accompany it with the complete corresponding machine-readable\n+ source code, which must be distributed under the terms of Sections\n+ 1 and 2 above on a medium customarily used for software interchange; or,\n+\n+ b) Accompany it with a written offer, valid for at least three\n+ years, to give any third party, for a charge no more than your\n+ cost of physically performing source distribution, a complete\n+ machine-readable copy of the corresponding source code, to be\n+ distributed under the terms of Sections 1 and 2 above on a medium\n+ customarily used for software interchange; or,\n+\n+ c) Accompany it with the information you received as to the offer\n+ to distribute corresponding source code. (This alternative is\n+ allowed only for noncommercial distribution and only if you\n+ received the program in object code or executable form with such\n+ an offer, in accord with Subsection b above.)\n+\n+The source code for a work means the preferred form of the work for\n+making modifications to it. For an executable work, complete source\n+code means all the source code for all modules it contains, plus any\n+associated interface definition files, plus the scripts used to\n+control compilation and installation of the executable. However, as a\n+special exception, the source code distributed need not include\n+anything that is normally distributed (in either source or binary\n+form) with the major components (compiler, kernel, and so on) of the\n+operating system on which the executable runs, unless that component\n+itself accompanies the executable.\n+\n+If distribution of executable or object code is made by offering\n+access to copy from a designated place, then offering equivalent\n+access to copy the source code from the same place counts as\n+distribution of the source code, even though third parties are not\n+compelled to copy the source along with the object code.\n+\u000c\n+ 4. You may not copy, modify, sublicense, or distribute the Program\n+except as expressly provided under this License. Any attempt\n+otherwise to copy, modify, sublicense or distribute the Program is\n+void, and will automatically terminate your rights under this License.\n+However, parties who have received copies, or rights, from you under\n+this License will not have their licenses terminated so long as such\n+parties remain in full compliance.\n+\n+ 5. You are not required to accept this License, since you have not\n+signed it. However, nothing else grants you permission to modify or\n+distribute the Program or its derivative works. These actions are\n+prohibited by law if you do not accept this License. Therefore, by\n+modifying or distributing the Program (or any work based on the\n+Program), you indicate your acceptance of this License to do so, and\n+all its terms and conditions for copying, distributing or modifying\n+the Program or works based on it.\n+\n+ 6. Each time you redistribute the Program (or any work based on the\n+Program), the recipient automatically receives a license from the\n+original licensor to copy, distribute or modify the Program subject to\n+these terms and conditions. You may not impose any further\n+restrictions on the recipients' exercise of the rights granted herein.\n+You are not responsible for enforcing compliance by third parties to\n+this License.\n+\n+ 7. If, as a consequence of a court judgment or allegation of patent\n+infringement or for any other reason (not limited to patent issues),\n+conditions are imposed on you (whether by court order, agreement or\n+otherwise) that contradict the conditions of this License, they do not\n+excuse you from the conditions of this License. If you cannot\n+distribute so as to satisfy simultaneously your obligations under this\n+License and any other pertinent obligations, then as a consequence you\n+may not distribute the Program at all. For example, if a patent\n+license would not permit royalty-free redistribution of the Program by\n+all those who receive copies directly or indirectly through you, then\n+the only way you could satisfy both it and this License would be to\n+refrain entirely from distribution of the Program.\n+\n+If any portion of this section is held invalid or unenforceable under\n+any particular circumstance, the balance of the section is intended to\n+apply and the section as a whole is intended to apply in other\n+circumstances.\n+\n+It is not the purpose of this section to induce you to infringe any\n+patents or other property right claims or to contest validity of any\n+such claims; this section has the sole purpose of protecting the\n+integrity of the free software distribution system, which is\n+implemented by public license practices. Many people have made\n+generous contributions to the wide range of software distributed\n+through that system in reliance on consistent application of that\n+system; it is up to the author/donor to decide if he or she is willing\n+to distribute software through any other system and a licensee cannot\n+impose that choice.\n+\n+This section is intended to make thoroughly clear what is believed to\n+be a consequence of the rest of this License.\n+\u000c\n+ 8. If the distribution and/or use of the Program is restricted in\n+certain countries either by patents or by copyrighted interfaces, the\n+original copyright holder who places the Program under this License\n+may add an explicit geographical distribution limitation excluding\n+those countries, so that distribution is permitted only in or among\n+countries not thus excluded. In such case, this License incorporates\n+the limitation as if written in the body of this License.\n+\n+ 9. The Free Software Foundation may publish revised and/or new versions\n+of the General Public License from time to time. Such new versions will\n+be similar in spirit to the present version, but may differ in detail to\n+address new problems or concerns.\n+\n+Each version is given a distinguishing version number. If the Program\n+specifies a version number of this License which applies to it and \u0022any\n+later version\u0022, you have the option of following the terms and conditions\n+either of that version or of any later version published by the Free\n+Software Foundation. If the Program does not specify a version number of\n+this License, you may choose any version ever published by the Free Software\n+Foundation.\n+\n+ 10. If you wish to incorporate parts of the Program into other free\n+programs whose distribution conditions are different, write to the author\n+to ask for permission. For software which is copyrighted by the Free\n+Software Foundation, write to the Free Software Foundation; we sometimes\n+make exceptions for this. Our decision will be guided by the two goals\n+of preserving the free status of all derivatives of our free software and\n+of promoting the sharing and reuse of software generally.\n+\n+\t\t\t NO WARRANTY\n+\n+ 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY\n+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN\n+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES\n+PROVIDE THE PROGRAM \u0022AS IS\u0022 WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED\n+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\n+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS\n+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE\n+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,\n+REPAIR OR CORRECTION.\n+\n+ 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING\n+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR\n+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,\n+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING\n+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED\n+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY\n+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER\n+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE\n+POSSIBILITY OF SUCH DAMAGES.\n+\n+\t\t END OF TERMS AND CONDITIONS\n+\u000c\n+\tAppendix: How to Apply These Terms to Your New Programs\n+\n+ If you develop a new program, and you want it to be of the greatest\n+possible use to the public, the best way to achieve this is to make it\n+free software which everyone can redistribute and change under these terms.\n+\n+ To do so, attach the following notices to the program. It is safest\n+to attach them to the start of each source file to most effectively\n+convey the exclusion of warranty; and each file should have at least\n+the \u0022copyright\u0022 line and a pointer to where the full notice is found.\n+\n+ \u003cone line to give the program's name and a brief idea of what it does.\u003e\n+ Copyright (C) 19yy \u003cname of author\u003e\n+\n+ This program is free software; you can redistribute it and/or modify\n+ it under the terms of the GNU General Public License as published by\n+ the Free Software Foundation; either version 2 of the License, or\n+ (at your option) any later version.\n+\n+ This program is distributed in the hope that it will be useful,\n+ but WITHOUT ANY WARRANTY; without even the implied warranty of\n+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n+ GNU General Public License for more details.\n+\n+ You should have received a copy of the GNU General Public License\n+ along with this program; if not, write to the Free Software\n+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n+\n+Also add information on how to contact you by electronic and paper mail.\n+\n+If the program is interactive, make it output a short notice like this\n+when it starts in an interactive mode:\n+\n+ Gnomovision version 69, Copyright (C) 19yy name of author\n+ Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.\n+ This is free software, and you are welcome to redistribute it\n+ under certain conditions; type `show c' for details.\n+\n+The hypothetical commands `show w' and `show c' should show the appropriate\n+parts of the General Public License. Of course, the commands you use may\n+be called something other than `show w' and `show c'; they could even be\n+mouse-clicks or menu items--whatever suits your program.\n+\n+You should also get your employer (if you work as a programmer) or your\n+school, if any, to sign a \u0022copyright disclaimer\u0022 for the program, if\n+necessary. Here is a sample; alter the names:\n+\n+ Yoyodyne, Inc., hereby disclaims all copyright interest in the program\n+ `Gnomovision' (which makes passes at compilers) written by James Hacker.\n+\n+ \u003csignature of Ty Coon\u003e, 1 April 1989\n+ Ty Coon, President of Vice\n+\n+This General Public License does not permit incorporating your program into\n+proprietary programs. If your program is a subroutine library, you may\n+consider it more useful to permit linking proprietary applications with the\n+library. If this is what you want to do, use the GNU Library General\n+Public License instead of this License.\ndiff --git a/external/perl/Text-Template-1.46/INSTALL b/external/perl/Text-Template-1.46/INSTALL\nnew file mode 100644\nindex 0000000..7c5e4c6\n--- /dev/null\n+++ b/external/perl/Text-Template-1.46/INSTALL\n@@ -0,0 +1,31 @@\n+\n+To install:\n+\n+\tperl Makefile.PL\n+\n+to construct the Makefile, then\n+\n+\tmake test\n+\n+to test the package. If it fails any tests, please send me the output\n+of `make test' and `perl -V'. I'll tell you whether it is safe to go\n+ahead, or I'll provide a fix.\n+\n+If it passes the tests, use\n+\n+\tmake install\n+\n+to install it.\n+\n+Detailed documentation is at the bottom of the lib/Text/Template.pm\n+file. You may be able to view it with the following command:\n+\n+ perldoc Text::Template\n+ \n+Or:\n+\n+ perldoc lib/Text/Template.pm\n+\n+If you have problems, send me mail:\n+\n+mjd-perl-template+@plover.com\ndiff --git a/external/perl/Text-Template-1.46/MANIFEST b/external/perl/Text-Template-1.46/MANIFEST\nnew file mode 100644\nindex 0000000..22460fe\n--- /dev/null\n+++ b/external/perl/Text-Template-1.46/MANIFEST\n@@ -0,0 +1,25 @@\n+MANIFEST\n+COPYING\n+Artistic\n+Makefile.PL\n+INSTALL\n+README\n+lib/Text/Template.pm\n+lib/Text/Template/Preprocess.pm\n+t/00-version.t\n+t/01-basic.t\n+t/02-hash.t\n+t/03-out.t\n+t/04-safe.t\n+t/05-safe2.t\n+t/06-ofh.t\n+t/07-safe3.t\n+t/08-exported.t\n+t/09-error.t\n+t/10-delimiters.t\n+t/11-prepend.t\n+t/12-preprocess.t\n+t/13-taint.t\n+t/14-broken.t\n+META.yml Module meta-data (added by MakeMaker)\n+META.json Module JSON meta-data (added by MakeMaker)\ndiff --git a/external/perl/Text-Template-1.46/META.json b/external/perl/Text-Template-1.46/META.json\nnew file mode 100644\nindex 0000000..6b335eb\n--- /dev/null\n+++ b/external/perl/Text-Template-1.46/META.json\n@@ -0,0 +1,39 @@\n+{\n+ \u0022abstract\u0022 : \u0022unknown\u0022,\n+ \u0022author\u0022 : [\n+ \u0022unknown\u0022\n+ ],\n+ \u0022dynamic_config\u0022 : 1,\n+ \u0022generated_by\u0022 : \u0022ExtUtils::MakeMaker version 6.62, CPAN::Meta::Converter version 2.120630\u0022,\n+ \u0022license\u0022 : [\n+ \u0022unknown\u0022\n+ ],\n+ \u0022meta-spec\u0022 : {\n+ \u0022url\u0022 : \u0022http://search.cpan.org/perldoc?CPAN::Meta::Spec\u0022,\n+ \u0022version\u0022 : \u00222\u0022\n+ },\n+ \u0022name\u0022 : \u0022Text-Template\u0022,\n+ \u0022no_index\u0022 : {\n+ \u0022directory\u0022 : [\n+ \u0022t\u0022,\n+ \u0022inc\u0022\n+ ]\n+ },\n+ \u0022prereqs\u0022 : {\n+ \u0022build\u0022 : {\n+ \u0022requires\u0022 : {\n+ \u0022ExtUtils::MakeMaker\u0022 : \u00220\u0022\n+ }\n+ },\n+ \u0022configure\u0022 : {\n+ \u0022requires\u0022 : {\n+ \u0022ExtUtils::MakeMaker\u0022 : \u00220\u0022\n+ }\n+ },\n+ \u0022runtime\u0022 : {\n+ \u0022requires\u0022 : {}\n+ }\n+ },\n+ \u0022release_status\u0022 : \u0022stable\u0022,\n+ \u0022version\u0022 : \u00221.46\u0022\n+}\ndiff --git a/external/perl/Text-Template-1.46/META.yml b/external/perl/Text-Template-1.46/META.yml\nnew file mode 100644\nindex 0000000..a2e2715\n--- /dev/null\n+++ b/external/perl/Text-Template-1.46/META.yml\n@@ -0,0 +1,21 @@\n+---\n+abstract: unknown\n+author:\n+ - unknown\n+build_requires:\n+ ExtUtils::MakeMaker: 0\n+configure_requires:\n+ ExtUtils::MakeMaker: 0\n+dynamic_config: 1\n+generated_by: 'ExtUtils::MakeMaker version 6.62, CPAN::Meta::Converter version 2.120630'\n+license: unknown\n+meta-spec:\n+ url: http://module-build.sourceforge.net/META-spec-v1.4.html\n+ version: 1.4\n+name: Text-Template\n+no_index:\n+ directory:\n+ - t\n+ - inc\n+requires: {}\n+version: 1.46\ndiff --git a/external/perl/Text-Template-1.46/Makefile.PL b/external/perl/Text-Template-1.46/Makefile.PL\nnew file mode 100644\nindex 0000000..491e03c\n--- /dev/null\n+++ b/external/perl/Text-Template-1.46/Makefile.PL\n@@ -0,0 +1,7 @@\n+use ExtUtils::MakeMaker;\n+WriteMakefile(\n+\t NAME \u003d\u003e 'Text::Template',\n+\t VERSION_FROM \u003d\u003e 'lib/Text/Template.pm',\n+#\t 'linkext' \u003d\u003e {LINKTYPE \u003d\u003e ''},\n+\t 'dist' \u003d\u003e {COMPRESS \u003d\u003e 'gzip', SUFFIX \u003d\u003e 'gz'},\n+);\ndiff --git a/external/perl/Text-Template-1.46/README b/external/perl/Text-Template-1.46/README\nnew file mode 100644\nindex 0000000..e184d8c\n--- /dev/null\n+++ b/external/perl/Text-Template-1.46/README\n@@ -0,0 +1,339 @@\n+\n+Text::Template v1.46\n+\n+This is a library for generating form letters, building HTML pages, or\n+filling in templates generally. A `template' is a piece of text that\n+has little Perl programs embedded in it here and there. When you\n+`fill in' a template, you evaluate the little programs and replace\n+them with their values. \n+\n+Here's an example of a template:\n+\n+\tDear {$title} {$lastname},\n+\n+\tIt has come to our attention that you are delinquent in your\n+\t{$monthname[$last_paid_month]} payment. Please remit\n+\t${sprintf(\u0022%.2f\u0022, $amount)} immediately, or your patellae may\n+\tbe needlessly endangered.\n+\n+\t\t\tLove,\n+\n+\t\t\tMark \u0022{nickname(rand 20)}\u0022 Dominus\n+\n+\n+The result of filling in this template is a string, which might look\n+something like this:\n+\n+\tDear Mr. Gates,\n+\n+\tIt has come to our attention that you are delinquent in your\n+\tFebruary payment. Please remit\n+\t$392.12 immediately, or your patellae may\n+\tbe needlessly endangered.\n+\n+\n+\t\t\tLove,\n+\n+\t\t\tMark \u0022Vizopteryx\u0022 Dominus\n+\n+You can store a template in a file outside your program. People can\n+modify the template without modifying the program. You can separate\n+the formatting details from the main code, and put the formatting\n+parts of the program into the template. That prevents code bloat and\n+encourages functional separation.\n+\n+You can fill in the template in a `Safe' compartment. This means that\n+if you don't trust the person who wrote the code in the template, you\n+won't have to worry that they are tampering with your program when you\n+execute it. \n+\n+----------------------------------------------------------------\n+\n+Text::Template was originally released some time in late 1995 or early\n+1996. After three years of study and investigation, I rewrote it from\n+scratch in January 1999. The new version, 1.0, was much faster,\n+delivered better functionality and was almost 100% backward-compatible\n+with the previous beta versions.\n+\n+I have added a number of useful features and conveniences since the\n+1.0 release, while still retaining backward compatibility. With one\n+merely cosmetic change, the current version of Text::Template passes\n+the test suite that the old beta versions passed.\n+\n+Questions or comments should be addressed to\n+mjd-perl-template+@plover.com. This address goes directly to me, and\n+not to anyone else; it is not a mailing list address.\n+\n+To receive occasional announcements of new versions of T::T, send an\n+empty note to mjd-perl-template-request@plover.com. This mailing list\n+is not for discussion; it is for announcements only. Therefore, there\n+is no address for sending messages to the list.\n+\n+You can get the most recent version of Text::Template, news, comments,\n+and other collateral information from\n+\u003cURL:http://www.plover.com/~mjd/perl/Template/\u003e.\n+\n+----------------------------------------------------------------\n+\n+What's new in v1.46 since v1.44:\n+\n+ Thanks to Rik Signes, there is a new\n+ Text::Template-\u003eappend_text_to_output method, which\n+ Text::Template always uses whenever it wants to emit output.\n+ You can subclass this to get control over the output, for\n+ example for postprocessing.\n+\n+ A spurious warning is no longer emitted when the TYPE\n+ parameter to -\u003enew is omitted.\n+\n+----------------------------------------------------------------\n+What's new in v1.44 since v1.43: \n+\n+This is a maintentance release. There are no feature changes.\n+\n+ _scrubpkg, which was responsible for eptying out temporary\n+ packages after the module had done with them, wasn't always\n+ working; the result was memory-leaks in long-running\n+ applications. This should be fixed now, and there is a test\n+ in the test suite for it.\n+\n+ Minor changes to the test suite to prevent spurious errors.\n+\n+ Minor documentation changes.\n+\n+----------------------------------------------------------------\n+What's new in v1.43 since v1.42:\n+\n+ The -\u003enew method now fails immediately and sets\n+ $Text::Template::ERROR if the file that is named by a filename\n+ argument does not exist or cannot be opened for some other\n+ reason. Formerly, the constructor would succeed and the\n+ -\u003efill_in call would fail.\n+\n+----------------------------------------------------------------\n+\n+What's new in v1.42 since v1.41:\n+\n+This is a maintentance release. There are no feature changes.\n+\n+ Fixed a bug relating to use of UNTAINT under perl 5.005_03 and\n+ possibly other versions.\n+\n+ Taint-related tests are now more comprehensive.\n+----------------------------------------------------------------\n+\n+What's new in v1.41 since v1.40:\n+\n+This is a maintentance release. There are no feature changes.\n+\n+ Tests now work correctly on Windows systems and possibly on\n+ other non-unix systems.\n+\n+----------------------------------------------------------------\n+\n+What's new in v1.40 since v1.31:\n+\n+ New UNTAINT option tells the module that it is safe to 'eval'\n+ code even though it has come from a file or filehandle.\n+\n+ Code added to prevent memory leaks when filling many\n+ templates. Thanks to Itamar Almeida de Carvalho.\n+\n+ Bug fix: $OUT was not correctly initialized when used in\n+ conjunction with SAFE.\n+\n+ You may now use a glob ref when passing a filehandle to the\n+ -\u003enew funcion. Formerly, a glob was reuqired.\n+\n+ New subclass: Text::Template::Preprocess. Just like\n+ Text::Template, but you may supply a PREPROCESS option in the\n+ constructor or the fill_in call; this is a function which\n+ receives each code fragment prior to evaluation, and which may\n+ modify and return the fragment; the modified fragment is what\n+ is evaluated.\n+\n+ Error messages passed to BROKEN subroutines will now report\n+ the correct line number of the template at which the error\n+ occurred:\n+\n+ Illegal division by zero at template line 37.\n+\n+ If the template comes from a file, the filename will be\n+ reported as well:\n+\n+ Illegal division by zero at catalog.tmpl line 37.\n+\n+\n+ INCOMPATIBLE CHANGE:\n+\n+ The format of the default error message has changed. It used\n+ to look like:\n+\n+ Program fragment at line 30 delivered error ``Illegal division by zero''\n+\n+ It now looks like:\n+\n+ Program fragment delivered error ``Illegal division by zero at catalog.tmpl line 37''\n+\n+ Note that the default message used to report the line number\n+ at which the program fragment began; it now reports the line\n+ number at which the error actually occurred.\n+\n+----------------------------------------------------------------\n+What's new in v1.31 since v1.23:\n+\n+\tJust bug fixes---fill_in_string was failing. Thanks to \n+ Donald L. Greer Jr. for the test case.\n+\n+----------------------------------------------------------------\n+What's new in v1.23 since v1.22:\n+\n+\tSmall bug fix: DELIMITER and other arguments were being\n+\tignored in calls to fill_in_file and fill_this_in. (Thanks to\n+\tJonathan Roy for reporting this.)\n+\n+----------------------------------------------------------------\n+What's new in v1.22 since v1.20:\n+\n+\tYou can now specify that certain Perl statements be prepended\n+\tto the beginning of every program fragment in a template,\n+\teither per template, or for all templates, or for the duration\n+\tof only one call to fill_in. This is useful, for example, if\n+\tyou want to enable `strict' checks in your templates but you\n+\tdon't want to manually add `use strict' to the front of every\n+\tprogram fragment everywhere.\n+\n+----------------------------------------------------------------\n+What's new in v1.20 since v1.12:\n+\n+\tYou can now specify that the program fragment delimiters are\n+\tstrings other than { and }. This has three interesting\n+\teffects: First, it changes the delimiter strings. Second, it\n+\tdisables the special meaning of \u005c, so you have to be really,\n+\treally sure that the delimiters will not appear in your\n+\ttemplates. And third, because of the simplifications\n+\tintroduced by the elimination of \u005c processing, template\n+\tparsing is 20-25% faster.\n+\n+\tSee the manual section on `Alternative Delimiters'.\n+\n+\tFixed bug having to do with undefined values in HASH options.\n+\tIn particular, Text::Template no longer generates a warning if\n+\tyou try to give a variable an undefined value.\n+\n+----------------------------------------------------------------\n+\n+What's new in v1.12 since v1.11:\n+\n+\tI forgot to say that Text::Template ISA Exporter, so the\n+\texported functions never got exported. Duhhh!\n+\n+\tTemplate TYPEs are now case-insensitive. The `new' method now\n+\tdiagnoses attempts to use an invalid TYPE.\n+\n+\tMore tests for these things.\n+\n+----------------------------------------------------------------\n+\n+What's new in v1.11 since v1.10:\n+\n+\tFixed a bug in the way backslashes were processed. The 1.10\n+\tbehavior was incompatible with the beta versions and was also\n+\tinconvenient. (`\u005cn' in templates was replaced with `n' before\n+\tit was given to Perl for evaluation.) The new behavior is\n+\talso incompatible with the beta versions, but it is only a\n+\tlittle bit incompatible, and it is probbaly better.\n+\n+\tDocumentation for the new behavior, and tests for the bug.\n+\n+----------------------------------------------------------------\n+\n+What's new in v1.10 since v1.03:\n+\n+\tNew OUTPUT option delivers template results directly to a\n+\tfilehandle instead of making them into a string. Saves space\n+\tand time. \n+\n+\tPACKAGE and HASH now work intelligently with SAFE.\n+\n+\tFragments may now output data directly to the template, rather\n+\tthan having to arrange to return it as a return value at the\n+\tend. This means that where you used to have to write this:\n+\n+\t\t\t{ my $blist \u003d '';\n+\t\t foreach $i (@items) {\n+\t\t $blist .\u003d qq{ * $i\u005cn};\n+\t\t } \n+\t\t $blist;\n+\t\t } \n+\n+\tYou can now write this instead, because $OUT is special.\n+\n+\t\t\t{ foreach $i (@items) {\n+\t\t $OUT.\u003d \u0022 * $i\u005cn\u0022;\n+\t\t } \n+\t\t } \n+\n+\t(`A spoonful of sugar makes the medicine go down.')\n+\n+\tFixed some small bugs. Worked around a bug in Perl that does\n+\tthe wrong thing with $x \u003d \u003cY\u003e when $x contains a glob.\n+\n+\tMore documentation. Errors fixed.\n+\n+\tLots more tests. \n+\n+----------------------------------------------------------------\n+\n+What's new in v1.03 since v1.0:\n+\n+\tCode added to support HASH option to fill_in.\n+\t(Incl. `_gensym' function.)\n+\t\n+\tDocumentation for HASH.\n+\t\n+\tNew test file for HASH.\n+\t\n+\tNote about failure of lexical variables to propagate into\n+ \ttemplates. Why does this surprise people?\n+\t\n+\tBug fix: program fragments are evaluated in an environment with\n+ \t`no strict' by default. Otherwise, you get a lot of `Global\n+ \tsymbol \u0022$v\u0022 requires explicit package name' failures. Why didn't\n+ \tthe test program pick this up? Because the only variable the test\n+ \tprogram ever used was `$a', which is exempt. Duhhhhh.\n+\t\n+\tFixed the test program.\n+\t\n+\tVarious minor documentation fixes.\n+\n+\n+\n+----------------------------------------------------------------\n+\n+Improvements of 1.0 over the old 0.1beta:\n+\n+New features:\n+\n+ At least twice as fast \n+\n+ Better support for filling out the same template more than once \n+\n+ Now supports evaluation of program fragments in Safe\n+ compartments. (Thanks, Jonathan!) \n+\n+ Better argument syntax \n+\n+ More convenience functions \n+\n+ The parser is much better and simpler. \n+\n+ Once a template is parsed, the parsed version is stored so that\n+ it needn't be parsed again. \n+\n+ BROKEN function behavior is rationalized. You can now pass an\n+ arbitrary argument to your BROKEN function, or return a value\n+ from it to the main program. \n+\n+ Documentation overhauled. \n+\ndiff --git a/external/perl/Text-Template-1.46/lib/Text/Template.pm b/external/perl/Text-Template-1.46/lib/Text/Template.pm\nnew file mode 100644\nindex 0000000..dc4f3ba\n--- /dev/null\n+++ b/external/perl/Text-Template-1.46/lib/Text/Template.pm\n@@ -0,0 +1,1973 @@\n+# -*- perl -*-\n+# Text::Template.pm\n+#\n+# Fill in `templates'\n+#\n+# Copyright 2013 M. J. Dominus.\n+# You may copy and distribute this program under the\n+# same terms as Perl iteself. \n+# If in doubt, write to mjd-perl-template+@plover.com for a license.\n+#\n+# Version 1.46\n+\n+package Text::Template;\n+require 5.004;\n+use Exporter;\n+@ISA \u003d qw(Exporter);\n+@EXPORT_OK \u003d qw(fill_in_file fill_in_string TTerror);\n+use vars '$ERROR';\n+use strict;\n+\n+$Text::Template::VERSION \u003d '1.46';\n+my %GLOBAL_PREPEND \u003d ('Text::Template' \u003d\u003e '');\n+\n+sub Version {\n+ $Text::Template::VERSION;\n+}\n+\n+sub _param {\n+ my $kk;\n+ my ($k, %h) \u003d @_;\n+ for $kk ($k, \u0022\u005cu$k\u0022, \u0022\u005cU$k\u0022, \u0022-$k\u0022, \u0022-\u005cu$k\u0022, \u0022-\u005cU$k\u0022) {\n+ return $h{$kk} if exists $h{$kk};\n+ }\n+ return;\n+}\n+\n+sub always_prepend\n+{\n+ my $pack \u003d shift;\n+ my $old \u003d $GLOBAL_PREPEND{$pack};\n+ $GLOBAL_PREPEND{$pack} \u003d shift;\n+ $old;\n+}\n+\n+{\n+ my %LEGAL_TYPE;\n+ BEGIN { \n+ %LEGAL_TYPE \u003d map {$_\u003d\u003e1} qw(FILE FILEHANDLE STRING ARRAY);\n+ }\n+ sub new {\n+ my $pack \u003d shift;\n+ my %a \u003d @_;\n+ my $stype \u003d uc(_param('type', %a) || \u0022FILE\u0022);\n+ my $source \u003d _param('source', %a);\n+ my $untaint \u003d _param('untaint', %a);\n+ my $prepend \u003d _param('prepend', %a);\n+ my $alt_delim \u003d _param('delimiters', %a);\n+ my $broken \u003d _param('broken', %a);\n+ unless (defined $source) {\n+ require Carp;\n+ Carp::croak(\u0022Usage: $ {pack}::new(TYPE \u003d\u003e ..., SOURCE \u003d\u003e ...)\u0022);\n+ }\n+ unless ($LEGAL_TYPE{$stype}) {\n+ require Carp;\n+ Carp::croak(\u0022Illegal value `$stype' for TYPE parameter\u0022);\n+ }\n+ my $self \u003d {TYPE \u003d\u003e $stype,\n+\t\tPREPEND \u003d\u003e $prepend,\n+ UNTAINT \u003d\u003e $untaint,\n+ BROKEN \u003d\u003e $broken,\n+\t\t(defined $alt_delim ? (DELIM \u003d\u003e $alt_delim) : ()),\n+\t };\n+ # Under 5.005_03, if any of $stype, $prepend, $untaint, or $broken\n+ # are tainted, all the others become tainted too as a result of\n+ # sharing the expression with them. We install $source separately\n+ # to prevent it from acquiring a spurious taint.\n+ $self-\u003e{SOURCE} \u003d $source;\n+\n+ bless $self \u003d\u003e $pack;\n+ return unless $self-\u003e_acquire_data;\n+ \n+ $self;\n+ }\n+}\n+\n+# Convert template objects of various types to type STRING,\n+# in which the template data is embedded in the object itself.\n+sub _acquire_data {\n+ my ($self) \u003d @_;\n+ my $type \u003d $self-\u003e{TYPE};\n+ if ($type eq 'STRING') {\n+ # nothing necessary \n+ } elsif ($type eq 'FILE') {\n+ my $data \u003d _load_text($self-\u003e{SOURCE});\n+ unless (defined $data) {\n+ # _load_text already set $ERROR\n+ return undef;\n+ }\n+ if ($self-\u003e{UNTAINT} \u0026\u0026 _is_clean($self-\u003e{SOURCE})) {\n+ _unconditionally_untaint($data);\n+ }\n+ $self-\u003e{TYPE} \u003d 'STRING';\n+ $self-\u003e{FILENAME} \u003d $self-\u003e{SOURCE};\n+ $self-\u003e{SOURCE} \u003d $data;\n+ } elsif ($type eq 'ARRAY') {\n+ $self-\u003e{TYPE} \u003d 'STRING';\n+ $self-\u003e{SOURCE} \u003d join '', @{$self-\u003e{SOURCE}};\n+ } elsif ($type eq 'FILEHANDLE') {\n+ $self-\u003e{TYPE} \u003d 'STRING';\n+ local $/;\n+ my $fh \u003d $self-\u003e{SOURCE};\n+ my $data \u003d \u003c$fh\u003e; # Extra assignment avoids bug in Solaris perl5.00[45].\n+ if ($self-\u003e{UNTAINT}) {\n+ _unconditionally_untaint($data);\n+ }\n+ $self-\u003e{SOURCE} \u003d $data;\n+ } else {\n+ # This should have been caught long ago, so it represents a \n+ # drastic `can't-happen' sort of failure\n+ my $pack \u003d ref $self;\n+ die \u0022Can only acquire data for $pack objects of subtype STRING, but this is $type; aborting\u0022;\n+ }\n+ $self-\u003e{DATA_ACQUIRED} \u003d 1;\n+}\n+\n+sub source {\n+ my ($self) \u003d @_;\n+ $self-\u003e_acquire_data unless $self-\u003e{DATA_ACQUIRED};\n+ return $self-\u003e{SOURCE};\n+}\n+\n+sub set_source_data {\n+ my ($self, $newdata) \u003d @_;\n+ $self-\u003e{SOURCE} \u003d $newdata;\n+ $self-\u003e{DATA_ACQUIRED} \u003d 1;\n+ $self-\u003e{TYPE} \u003d 'STRING';\n+ 1;\n+}\n+\n+sub compile {\n+ my $self \u003d shift;\n+\n+ return 1 if $self-\u003e{TYPE} eq 'PREPARSED';\n+\n+ return undef unless $self-\u003e_acquire_data;\n+ unless ($self-\u003e{TYPE} eq 'STRING') {\n+ my $pack \u003d ref $self;\n+ # This should have been caught long ago, so it represents a \n+ # drastic `can't-happen' sort of failure\n+ die \u0022Can only compile $pack objects of subtype STRING, but this is $self-\u003e{TYPE}; aborting\u0022;\n+ }\n+\n+ my @tokens;\n+ my $delim_pats \u003d shift() || $self-\u003e{DELIM};\n+\n+ \n+\n+ my ($t_open, $t_close) \u003d ('{', '}');\n+ my $DELIM;\t\t\t# Regex matches a delimiter if $delim_pats\n+ if (defined $delim_pats) {\n+ ($t_open, $t_close) \u003d @$delim_pats;\n+ $DELIM \u003d \u0022(?:(?:\u005cQ$t_open\u005cE)|(?:\u005cQ$t_close\u005cE))\u0022;\n+ @tokens \u003d split /($DELIM|\u005cn)/, $self-\u003e{SOURCE};\n+ } else {\n+ @tokens \u003d split /(\u005c\u005c\u005c\u005c(?\u003d\u005c\u005c*[{}])|\u005c\u005c[{}]|[{}\u005cn])/, $self-\u003e{SOURCE};\n+ }\n+ my $state \u003d 'TEXT';\n+ my $depth \u003d 0;\n+ my $lineno \u003d 1;\n+ my @content;\n+ my $cur_item \u003d '';\n+ my $prog_start;\n+ while (@tokens) {\n+ my $t \u003d shift @tokens;\n+ next if $t eq '';\n+ if ($t eq $t_open) {\t# Brace or other opening delimiter\n+ if ($depth \u003d\u003d 0) {\n+\tpush @content, [$state, $cur_item, $lineno] if $cur_item ne '';\n+\t$cur_item \u003d '';\n+\t$state \u003d 'PROG';\n+\t$prog_start \u003d $lineno;\n+ } else {\n+\t$cur_item .\u003d $t;\n+ }\n+ $depth++;\n+ } elsif ($t eq $t_close) {\t# Brace or other closing delimiter\n+ $depth--;\n+ if ($depth \u003c 0) {\n+\t$ERROR \u003d \u0022Unmatched close brace at line $lineno\u0022;\n+\treturn undef;\n+ } elsif ($depth \u003d\u003d 0) {\n+\tpush @content, [$state, $cur_item, $prog_start] if $cur_item ne '';\n+\t$state \u003d 'TEXT';\n+\t$cur_item \u003d '';\n+ } else {\n+\t$cur_item .\u003d $t;\n+ }\n+ } elsif (!$delim_pats \u0026\u0026 $t eq '\u005c\u005c\u005c\u005c') { # precedes \u005c\u005c\u005c..\u005c\u005c\u005c{ or \u005c\u005c\u005c..\u005c\u005c\u005c}\n+ $cur_item .\u003d '\u005c\u005c';\n+ } elsif (!$delim_pats \u0026\u0026 $t \u003d~ /^\u005c\u005c([{}])$/) { # Escaped (literal) brace?\n+\t$cur_item .\u003d $1;\n+ } elsif ($t eq \u0022\u005cn\u0022) {\t# Newline\n+ $lineno++;\n+ $cur_item .\u003d $t;\n+ } else {\t\t\t# Anything else\n+ $cur_item .\u003d $t;\n+ }\n+ }\n+\n+ if ($state eq 'PROG') {\n+ $ERROR \u003d \u0022End of data inside program text that began at line $prog_start\u0022;\n+ return undef;\n+ } elsif ($state eq 'TEXT') {\n+ push @content, [$state, $cur_item, $lineno] if $cur_item ne '';\n+ } else {\n+ die \u0022Can't happen error #1\u0022;\n+ }\n+ \n+ $self-\u003e{TYPE} \u003d 'PREPARSED';\n+ $self-\u003e{SOURCE} \u003d \u005c@content;\n+ 1;\n+}\n+\n+sub prepend_text {\n+ my ($self) \u003d @_;\n+ my $t \u003d $self-\u003e{PREPEND};\n+ unless (defined $t) {\n+ $t \u003d $GLOBAL_PREPEND{ref $self};\n+ unless (defined $t) {\n+ $t \u003d $GLOBAL_PREPEND{'Text::Template'};\n+ }\n+ }\n+ $self-\u003e{PREPEND} \u003d $_[1] if $#_ \u003e\u003d 1;\n+ return $t;\n+}\n+\n+sub fill_in {\n+ my $fi_self \u003d shift;\n+ my %fi_a \u003d @_;\n+\n+ unless ($fi_self-\u003e{TYPE} eq 'PREPARSED') {\n+ my $delims \u003d _param('delimiters', %fi_a);\n+ my @delim_arg \u003d (defined $delims ? ($delims) : ());\n+ $fi_self-\u003ecompile(@delim_arg)\n+ or return undef;\n+ }\n+\n+ my $fi_varhash \u003d _param('hash', %fi_a);\n+ my $fi_package \u003d _param('package', %fi_a) ;\n+ my $fi_broken \u003d \n+ _param('broken', %fi_a) || $fi_self-\u003e{BROKEN} || \u005c\u0026_default_broken;\n+ my $fi_broken_arg \u003d _param('broken_arg', %fi_a) || [];\n+ my $fi_safe \u003d _param('safe', %fi_a);\n+ my $fi_ofh \u003d _param('output', %fi_a);\n+ my $fi_eval_package;\n+ my $fi_scrub_package \u003d 0;\n+ my $fi_filename \u003d _param('filename') || $fi_self-\u003e{FILENAME} || 'template';\n+\n+ my $fi_prepend \u003d _param('prepend', %fi_a);\n+ unless (defined $fi_prepend) {\n+ $fi_prepend \u003d $fi_self-\u003eprepend_text;\n+ }\n+\n+ if (defined $fi_safe) {\n+ $fi_eval_package \u003d 'main';\n+ } elsif (defined $fi_package) {\n+ $fi_eval_package \u003d $fi_package;\n+ } elsif (defined $fi_varhash) {\n+ $fi_eval_package \u003d _gensym();\n+ $fi_scrub_package \u003d 1;\n+ } else {\n+ $fi_eval_package \u003d caller;\n+ }\n+\n+ my $fi_install_package;\n+ if (defined $fi_varhash) {\n+ if (defined $fi_package) {\n+ $fi_install_package \u003d $fi_package;\n+ } elsif (defined $fi_safe) {\n+ $fi_install_package \u003d $fi_safe-\u003eroot;\n+ } else {\n+ $fi_install_package \u003d $fi_eval_package; # The gensymmed one\n+ }\n+ _install_hash($fi_varhash \u003d\u003e $fi_install_package);\n+ }\n+\n+ if (defined $fi_package \u0026\u0026 defined $fi_safe) {\n+ no strict 'refs';\n+ # Big fat magic here: Fix it so that the user-specified package\n+ # is the default one available in the safe compartment.\n+ *{$fi_safe-\u003eroot . '::'} \u003d \u005c%{$fi_package . '::'}; # LOD\n+ }\n+\n+ my $fi_r \u003d '';\n+ my $fi_item;\n+ foreach $fi_item (@{$fi_self-\u003e{SOURCE}}) {\n+ my ($fi_type, $fi_text, $fi_lineno) \u003d @$fi_item;\n+ if ($fi_type eq 'TEXT') {\n+ $fi_self-\u003eappend_text_to_output(\n+ text \u003d\u003e $fi_text,\n+ handle \u003d\u003e $fi_ofh,\n+ out \u003d\u003e \u005c$fi_r,\n+ type \u003d\u003e $fi_type,\n+ );\n+ } elsif ($fi_type eq 'PROG') {\n+ no strict;\n+ my $fi_lcomment \u003d \u0022#line $fi_lineno $fi_filename\u0022;\n+ my $fi_progtext \u003d \n+ \u0022package $fi_eval_package; $fi_prepend;\u005cn$fi_lcomment\u005cn$fi_text;\u0022;\n+ my $fi_res;\n+ my $fi_eval_err \u003d '';\n+ if ($fi_safe) {\n+ $fi_safe-\u003ereval(q{undef $OUT});\n+\t$fi_res \u003d $fi_safe-\u003ereval($fi_progtext);\n+\t$fi_eval_err \u003d $@;\n+\tmy $OUT \u003d $fi_safe-\u003ereval('$OUT');\n+\t$fi_res \u003d $OUT if defined $OUT;\n+ } else {\n+\tmy $OUT;\n+\t$fi_res \u003d eval $fi_progtext;\n+\t$fi_eval_err \u003d $@;\n+\t$fi_res \u003d $OUT if defined $OUT;\n+ }\n+\n+ # If the value of the filled-in text really was undef,\n+ # change it to an explicit empty string to avoid undefined\n+ # value warnings later.\n+ $fi_res \u003d '' unless defined $fi_res;\n+\n+ if ($fi_eval_err) {\n+\t$fi_res \u003d $fi_broken-\u003e(text \u003d\u003e $fi_text,\n+\t\t\t error \u003d\u003e $fi_eval_err,\n+\t\t\t lineno \u003d\u003e $fi_lineno,\n+\t\t\t arg \u003d\u003e $fi_broken_arg,\n+\t\t\t );\n+\tif (defined $fi_res) {\n+ $fi_self-\u003eappend_text_to_output(\n+ text \u003d\u003e $fi_res,\n+ handle \u003d\u003e $fi_ofh,\n+ out \u003d\u003e \u005c$fi_r,\n+ type \u003d\u003e $fi_type,\n+ );\n+\t} else {\n+\t return $fi_res;\t\t# Undefined means abort processing\n+\t}\n+ } else {\n+ $fi_self-\u003eappend_text_to_output(\n+ text \u003d\u003e $fi_res,\n+ handle \u003d\u003e $fi_ofh,\n+ out \u003d\u003e \u005c$fi_r,\n+ type \u003d\u003e $fi_type,\n+ );\n+ }\n+ } else {\n+ die \u0022Can't happen error #2\u0022;\n+ }\n+ }\n+\n+ _scrubpkg($fi_eval_package) if $fi_scrub_package;\n+ defined $fi_ofh ? 1 : $fi_r;\n+}\n+\n+sub append_text_to_output {\n+ my ($self, %arg) \u003d @_;\n+\n+ if (defined $arg{handle}) {\n+ print { $arg{handle} } $arg{text};\n+ } else {\n+ ${ $arg{out} } .\u003d $arg{text};\n+ }\n+\n+ return;\n+}\n+\n+sub fill_this_in {\n+ my $pack \u003d shift;\n+ my $text \u003d shift;\n+ my $templ \u003d $pack-\u003enew(TYPE \u003d\u003e 'STRING', SOURCE \u003d\u003e $text, @_)\n+ or return undef;\n+ $templ-\u003ecompile or return undef;\n+ my $result \u003d $templ-\u003efill_in(@_);\n+ $result;\n+}\n+\n+sub fill_in_string {\n+ my $string \u003d shift;\n+ my $package \u003d _param('package', @_);\n+ push @_, 'package' \u003d\u003e scalar(caller) unless defined $package;\n+ Text::Template-\u003efill_this_in($string, @_);\n+}\n+\n+sub fill_in_file {\n+ my $fn \u003d shift;\n+ my $templ \u003d Text::Template-\u003enew(TYPE \u003d\u003e 'FILE', SOURCE \u003d\u003e $fn, @_)\n+ or return undef;\n+ $templ-\u003ecompile or return undef;\n+ my $text \u003d $templ-\u003efill_in(@_);\n+ $text;\n+}\n+\n+sub _default_broken {\n+ my %a \u003d @_;\n+ my $prog_text \u003d $a{text};\n+ my $err \u003d $a{error};\n+ my $lineno \u003d $a{lineno};\n+ chomp $err;\n+# $err \u003d~ s/\u005cs+at .*//s;\n+ \u0022Program fragment delivered error ``$err''\u0022;\n+}\n+\n+sub _load_text {\n+ my $fn \u003d shift;\n+ local *F;\n+ unless (open F, $fn) {\n+ $ERROR \u003d \u0022Couldn't open file $fn: $!\u0022;\n+ return undef;\n+ }\n+ local $/;\n+ \u003cF\u003e;\n+}\n+\n+sub _is_clean {\n+ my $z;\n+ eval { ($z \u003d join('', @_)), eval '#' . substr($z,0,0); 1 } # LOD\n+}\n+\n+sub _unconditionally_untaint {\n+ for (@_) {\n+ ($_) \u003d /(.*)/s;\n+ }\n+}\n+\n+{\n+ my $seqno \u003d 0;\n+ sub _gensym {\n+ __PACKAGE__ . '::GEN' . $seqno++;\n+ }\n+ sub _scrubpkg {\n+ my $s \u003d shift;\n+ $s \u003d~ s/^Text::Template:://;\n+ no strict 'refs';\n+ my $hash \u003d $Text::Template::{$s.\u0022::\u0022};\n+ foreach my $key (keys %$hash) {\n+ undef $hash-\u003e{$key};\n+ }\n+ }\n+}\n+ \n+# Given a hashful of variables (or a list of such hashes)\n+# install the variables into the specified package,\n+# overwriting whatever variables were there before.\n+sub _install_hash {\n+ my $hashlist \u003d shift;\n+ my $dest \u003d shift;\n+ if (UNIVERSAL::isa($hashlist, 'HASH')) {\n+ $hashlist \u003d [$hashlist];\n+ }\n+ my $hash;\n+ foreach $hash (@$hashlist) {\n+ my $name;\n+ foreach $name (keys %$hash) {\n+ my $val \u003d $hash-\u003e{$name};\n+ no strict 'refs';\n+ local *SYM \u003d *{\u0022$ {dest}::$name\u0022};\n+ if (! defined $val) {\n+\tdelete ${\u0022$ {dest}::\u0022}{$name};\n+ } elsif (ref $val) {\n+\t*SYM \u003d $val;\n+ } else {\n+ \t*SYM \u003d \u005c$val;\n+ }\n+ }\n+ }\n+}\n+\n+sub TTerror { $ERROR }\n+\n+1;\n+\n+\n+\u003dhead1 NAME \n+\n+Text::Template - Expand template text with embedded Perl\n+\n+\u003dhead1 VERSION\n+\n+This file documents C\u003cText::Template\u003e version B\u003c1.46\u003e\n+\n+\u003dhead1 SYNOPSIS\n+\n+ use Text::Template;\n+\n+\n+ $template \u003d Text::Template-\u003enew(TYPE \u003d\u003e 'FILE', SOURCE \u003d\u003e 'filename.tmpl');\n+ $template \u003d Text::Template-\u003enew(TYPE \u003d\u003e 'ARRAY', SOURCE \u003d\u003e [ ... ] );\n+ $template \u003d Text::Template-\u003enew(TYPE \u003d\u003e 'FILEHANDLE', SOURCE \u003d\u003e $fh );\n+ $template \u003d Text::Template-\u003enew(TYPE \u003d\u003e 'STRING', SOURCE \u003d\u003e '...' );\n+ $template \u003d Text::Template-\u003enew(PREPEND \u003d\u003e q{use strict;}, ...);\n+\n+ # Use a different template file syntax:\n+ $template \u003d Text::Template-\u003enew(DELIMITERS \u003d\u003e [$open, $close], ...);\n+\n+ $recipient \u003d 'King';\n+ $text \u003d $template-\u003efill_in(); # Replaces `{$recipient}' with `King'\n+ print $text;\n+\n+ $T::recipient \u003d 'Josh';\n+ $text \u003d $template-\u003efill_in(PACKAGE \u003d\u003e T);\n+\n+ # Pass many variables explicitly\n+ $hash \u003d { recipient \u003d\u003e 'Abed-Nego',\n+ friends \u003d\u003e [ 'me', 'you' ],\n+ enemies \u003d\u003e { loathsome \u003d\u003e 'Bill Gates',\n+ fearsome \u003d\u003e 'Larry Ellison' },\n+ };\n+ $text \u003d $template-\u003efill_in(HASH \u003d\u003e $hash, ...);\n+ # $recipient is Abed-Nego,\n+ # @friends is ( 'me', 'you' ),\n+ # %enemies is ( loathsome \u003d\u003e ..., fearsome \u003d\u003e ... )\n+\n+\n+ # Call \u0026callback in case of programming errors in template\n+ $text \u003d $template-\u003efill_in(BROKEN \u003d\u003e \u005c\u0026callback, BROKEN_ARG \u003d\u003e $ref, ...);\n+\n+ # Evaluate program fragments in Safe compartment with restricted permissions\n+ $text \u003d $template-\u003efill_in(SAFE \u003d\u003e $compartment, ...);\n+\n+ # Print result text instead of returning it\n+ $success \u003d $template-\u003efill_in(OUTPUT \u003d\u003e \u005c*FILEHANDLE, ...);\n+\n+ # Parse template with different template file syntax:\n+ $text \u003d $template-\u003efill_in(DELIMITERS \u003d\u003e [$open, $close], ...);\n+ # Note that this is *faster* than using the default delimiters\n+\n+ # Prepend specified perl code to each fragment before evaluating:\n+ $text \u003d $template-\u003efill_in(PREPEND \u003d\u003e q{use strict 'vars';}, ...);\n+\n+ use Text::Template 'fill_in_string';\n+ $text \u003d fill_in_string( \u003c\u003cEOM, PACKAGE \u003d\u003e 'T', ...);\n+ Dear {$recipient},\n+ Pay me at once.\n+ Love, \n+ G.V.\n+ EOM\n+\n+ use Text::Template 'fill_in_file';\n+ $text \u003d fill_in_file($filename, ...);\n+\n+ # All templates will always have `use strict vars' attached to all fragments\n+ Text::Template-\u003ealways_prepend(q{use strict 'vars';});\n+\n+\u003dhead1 DESCRIPTION\n+\n+This is a library for generating form letters, building HTML pages, or\n+filling in templates generally. A `template' is a piece of text that\n+has little Perl programs embedded in it here and there. When you\n+`fill in' a template, you evaluate the little programs and replace\n+them with their values. \n+\n+You can store a template in a file outside your program. People can\n+modify the template without modifying the program. You can separate\n+the formatting details from the main code, and put the formatting\n+parts of the program into the template. That prevents code bloat and\n+encourages functional separation.\n+\n+\u003dhead2 Example\n+\n+Here's an example of a template, which we'll suppose is stored in the\n+file C\u003cformletter.tmpl\u003e:\n+\n+\tDear {$title} {$lastname},\n+\n+\tIt has come to our attention that you are delinquent in your\n+\t{$monthname[$last_paid_month]} payment. Please remit\n+\t${sprintf(\u0022%.2f\u0022, $amount)} immediately, or your patellae may\n+\tbe needlessly endangered.\n+\n+\t\t\tLove,\n+\n+\t\t\tMark \u0022Vizopteryx\u0022 Dominus\n+\n+\n+The result of filling in this template is a string, which might look\n+something like this:\n+\n+\tDear Mr. Gates,\n+\n+\tIt has come to our attention that you are delinquent in your\n+\tFebruary payment. Please remit\n+\t$392.12 immediately, or your patellae may\n+\tbe needlessly endangered.\n+\n+\n+\t\t\tLove,\n+\n+\t\t\tMark \u0022Vizopteryx\u0022 Dominus\n+\n+Here is a complete program that transforms the example\n+template into the example result, and prints it out:\n+\n+\tuse Text::Template;\n+\n+\tmy $template \u003d Text::Template-\u003enew(SOURCE \u003d\u003e 'formletter.tmpl')\n+\t or die \u0022Couldn't construct template: $Text::Template::ERROR\u0022;\n+\n+\tmy @monthname \u003d qw(January February March April May June\n+ July August September October November December);\n+\tmy %vars \u003d (title \u003d\u003e 'Mr.',\n+\t\t firstname \u003d\u003e 'Bill',\n+\t\t lastname \u003d\u003e 'Gates',\n+\t\t last_paid_month \u003d\u003e 1, # February\n+\t\t amount \u003d\u003e 392.12,\n+\t\t monthname \u003d\u003e \u005c@monthname,\n+\t\t );\n+\n+\tmy $result \u003d $template-\u003efill_in(HASH \u003d\u003e \u005c%vars);\n+\n+\tif (defined $result) { print $result }\n+\telse { die \u0022Couldn't fill in template: $Text::Template::ERROR\u0022 }\n+\n+\n+\u003dhead2 Philosophy\n+\n+When people make a template module like this one, they almost always\n+start by inventing a special syntax for substitutions. For example,\n+they build it so that a string like C\u003c%%VAR%%\u003e is replaced with the\n+value of C\u003c$VAR\u003e. Then they realize the need extra formatting, so\n+they put in some special syntax for formatting. Then they need a\n+loop, so they invent a loop syntax. Pretty soon they have a new\n+little template language.\n+\n+This approach has two problems: First, their little language is\n+crippled. If you need to do something the author hasn't thought of,\n+you lose. Second: Who wants to learn another language? You already\n+know Perl, so why not use it?\n+\n+C\u003cText::Template\u003e templates are programmed in I\u003cPerl\u003e. You embed Perl\n+code in your template, with C\u003c{\u003e at the beginning and C\u003c}\u003e at the end.\n+If you want a variable interpolated, you write it the way you would in\n+Perl. If you need to make a loop, you can use any of the Perl loop\n+constructions. All the Perl built-in functions are available.\n+\n+\u003dhead1 Details\n+\n+\u003dhead2 Template Parsing\n+\n+The C\u003cText::Template\u003e module scans the template source. An open brace\n+C\u003c{\u003e begins a program fragment, which continues until the matching\n+close brace C\u003c}\u003e. When the template is filled in, the program\n+fragments are evaluated, and each one is replaced with the resulting\n+value to yield the text that is returned.\n+\n+A backslash C\u003c\u005c\u003e in front of a brace (or another backslash that is in\n+front of a brace) escapes its special meaning. The result of filling\n+out this template:\n+\n+\t\u005c{ The sum of 1 and 2 is {1+2} \u005c}\n+\n+is\n+\n+\t{ The sum of 1 and 2 is 3 }\n+\n+If you have an unmatched brace, C\u003cText::Template\u003e will return a\n+failure code and a warning about where the problem is. Backslashes\n+that do not precede a brace are passed through unchanged. If you have\n+a template like this:\n+\n+\t{ \u0022String that ends in a newline.\u005cn\u0022 }\n+\n+The backslash inside the string is passed through to Perl unchanged,\n+so the C\u003c\u005cn\u003e really does turn into a newline. See the note at the end\n+for details about the way backslashes work. Backslash processing is\n+I\u003cnot\u003e done when you specify alternative delimiters with the\n+C\u003cDELIMITERS\u003e option. (See L\u003c\u0022Alternative Delimiters\u0022\u003e, below.)\n+\n+Each program fragment should be a sequence of Perl statements, which\n+are evaluated the usual way. The result of the last statement\n+executed will be evaluted in scalar context; the result of this\n+statement is a string, which is interpolated into the template in\n+place of the program fragment itself.\n+\n+The fragments are evaluated in order, and side effects from earlier\n+fragments will persist into later fragments:\n+\n+\t{$x \u003d @things; ''}The Lord High Chamberlain has gotten {$x}\n+\tthings for me this year. \n+\t{ $diff \u003d $x - 17; \n+\t $more \u003d 'more'\n+\t if ($diff \u003d\u003d 0) {\n+\t $diff \u003d 'no';\n+\t } elsif ($diff \u003c 0) {\n+\t $more \u003d 'fewer';\n+\t } \n+ '';\n+\t} \n+\tThat is {$diff} {$more} than he gave me last year.\n+\n+The value of C\u003c$x\u003e set in the first line will persist into the next\n+fragment that begins on the third line, and the values of C\u003c$diff\u003e and\n+C\u003c$more\u003e set in the second fragment will persist and be interpolated\n+into the last line. The output will look something like this:\n+\n+\tThe Lord High Chamberlain has gotten 42\n+\tthings for me this year. \n+\n+\tThat is 25 more than he gave me last year.\n+\n+That is all the syntax there is. \n+\n+\u003dhead2 The C\u003c$OUT\u003e variable\n+\n+There is one special trick you can play in a template. Here is the\n+motivation for it: Suppose you are going to pass an array, C\u003c@items\u003e,\n+into the template, and you want the template to generate a bulleted\n+list with a header, like this:\n+\n+\tHere is a list of the things I have got for you since 1907:\n+\t * Ivory\n+\t * Apes\n+\t * Peacocks\n+\t * ...\n+\n+One way to do it is with a template like this:\n+\n+\tHere is a list of the things I have got for you since 1907:\n+\t{ my $blist \u003d '';\n+ foreach $i (@items) {\n+ $blist .\u003d qq{ * $i\u005cn};\n+ } \n+ $blist;\n+ } \n+\n+Here we construct the list in a variable called C\u003c$blist\u003e, which we\n+return at the end. This is a little cumbersome. There is a shortcut.\n+\n+Inside of templates, there is a special variable called C\u003c$OUT\u003e.\n+Anything you append to this variable will appear in the output of the\n+template. Also, if you use C\u003c$OUT\u003e in a program fragment, the normal\n+behavior, of replacing the fragment with its return value, is\n+disabled; instead the fragment is replaced with the value of C\u003c$OUT\u003e.\n+This means that you can write the template above like this:\n+\n+\tHere is a list of the things I have got for you since 1907:\n+\t{ foreach $i (@items) {\n+ $OUT .\u003d \u0022 * $i\u005cn\u0022;\n+ } \n+ } \n+\n+C\u003c$OUT\u003e is reinitialized to the empty string at the start of each\n+program fragment. It is private to C\u003cText::Template\u003e, so \n+you can't use a variable named C\u003c$OUT\u003e in your template without\n+invoking the special behavior.\n+\n+\u003dhead2 General Remarks\n+\n+All C\u003cText::Template\u003e functions return C\u003cundef\u003e on failure, and set the\n+variable C\u003c$Text::Template::ERROR\u003e to contain an explanation of what\n+went wrong. For example, if you try to create a template from a file\n+that does not exist, C\u003c$Text::Template::ERROR\u003e will contain something like:\n+\n+\tCouldn't open file xyz.tmpl: No such file or directory\n+\n+\u003dhead2 C\u003cnew\u003e\n+\n+\t$template \u003d new Text::Template ( TYPE \u003d\u003e ..., SOURCE \u003d\u003e ... );\n+\n+This creates and returns a new template object. C\u003cnew\u003e returns\n+C\u003cundef\u003e and sets C\u003c$Text::Template::ERROR\u003e if it can't create the\n+template object. C\u003cSOURCE\u003e says where the template source code will\n+come from. C\u003cTYPE\u003e says what kind of object the source is.\n+\n+The most common type of source is a file:\n+\n+\tnew Text::Template ( TYPE \u003d\u003e 'FILE', SOURCE \u003d\u003e $filename );\n+\n+This reads the template from the specified file. The filename is\n+opened with the Perl C\u003copen\u003e command, so it can be a pipe or anything\n+else that makes sense with C\u003copen\u003e.\n+\n+The C\u003cTYPE\u003e can also be C\u003cSTRING\u003e, in which case the C\u003cSOURCE\u003e should\n+be a string:\n+\n+\tnew Text::Template ( TYPE \u003d\u003e 'STRING', \n+ SOURCE \u003d\u003e \u0022This is the actual template!\u0022 );\n+\n+The C\u003cTYPE\u003e can be C\u003cARRAY\u003e, in which case the source should be a\n+reference to an array of strings. The concatenation of these strings\n+is the template:\n+\n+\tnew Text::Template ( TYPE \u003d\u003e 'ARRAY', \n+ SOURCE \u003d\u003e [ \u0022This is \u0022, \u0022the actual\u0022, \n+ \u0022 template!\u0022,\n+ ]\n+ );\n+\n+The C\u003cTYPE\u003e can be FILEHANDLE, in which case the source should be an\n+open filehandle (such as you got from the C\u003cFileHandle\u003e or C\u003cIO::*\u003e\n+packages, or a glob, or a reference to a glob). In this case\n+C\u003cText::Template\u003e will read the text from the filehandle up to\n+end-of-file, and that text is the template:\n+\n+\t# Read template source code from STDIN:\n+\tnew Text::Template ( TYPE \u003d\u003e 'FILEHANDLE', \n+ SOURCE \u003d\u003e \u005c*STDIN );\n+\n+\n+If you omit the C\u003cTYPE\u003e attribute, it's taken to be C\u003cFILE\u003e.\n+C\u003cSOURCE\u003e is required. If you omit it, the program will abort.\n+\n+The words C\u003cTYPE\u003e and C\u003cSOURCE\u003e can be spelled any of the following ways:\n+\n+\tTYPE\tSOURCE\n+\tType\tSource\n+\ttype\tsource\n+\t-TYPE\t-SOURCE\n+\t-Type\t-Source\n+\t-type\t-source\n+\n+Pick a style you like and stick with it.\n+\n+\u003dover 4\n+\n+\u003ditem C\u003cDELIMITERS\u003e\n+\n+You may also add a C\u003cDELIMITERS\u003e option. If this option is present,\n+its value should be a reference to an array of two strings. The first\n+string is the string that signals the beginning of each program\n+fragment, and the second string is the string that signals the end of\n+each program fragment. See L\u003c\u0022Alternative Delimiters\u0022\u003e, below.\n+\n+\u003ditem C\u003cUNTAINT\u003e\n+\n+If your program is running in taint mode, you may have problems if\n+your templates are stored in files. Data read from files is\n+considered 'untrustworthy', and taint mode will not allow you to\n+evaluate the Perl code in the file. (It is afraid that a malicious\n+person might have tampered with the file.)\n+\n+In some environments, however, local files are trustworthy. You can\n+tell C\u003cText::Template\u003e that a certain file is trustworthy by supplying\n+C\u003cUNTAINT \u003dE\u003cgt\u003e 1\u003e in the call to C\u003cnew\u003e. This will tell\n+C\u003cText::Template\u003e to disable taint checks on template code that has\n+come from a file, as long as the filename itself is considered\n+trustworthy. It will also disable taint checks on template code that\n+comes from a filehandle. When used with C\u003cTYPE \u003dE\u003cgt\u003e 'string'\u003e or C\u003cTYPE\n+\u003dE\u003cgt\u003e 'array'\u003e, it has no effect.\n+\n+See L\u003cperlsec\u003e for more complete information about tainting.\n+\n+Thanks to Steve Palincsar, Gerard Vreeswijk, and Dr. Christoph Baehr\n+for help with this feature.\n+\n+\u003ditem C\u003cPREPEND\u003e\n+\n+This option is passed along to the C\u003cfill_in\u003e call unless it is\n+overridden in the arguments to C\u003cfill_in\u003e. See L\u003cC\u003cPREPEND\u003e feature\n+and using C\u003cstrict\u003e in templates\u003e below.\n+\n+\u003ditem C\u003cBROKEN\u003e\n+\n+This option is passed along to the C\u003cfill_in\u003e call unless it is\n+overridden in the arguments to C\u003cfill_in\u003e. See L\u003cC\u003cBROKEN\u003e\u003e below.\n+\n+\u003dback\n+\n+\u003dhead2 C\u003ccompile\u003e\n+\n+\t$template-\u003ecompile()\n+\n+Loads all the template text from the template's source, parses and\n+compiles it. If successful, returns true; otherwise returns false and\n+sets C\u003c$Text::Template::ERROR\u003e. If the template is already compiled,\n+it returns true and does nothing. \n+\n+You don't usually need to invoke this function, because C\u003cfill_in\u003e\n+(see below) compiles the template if it isn't compiled already.\n+\n+If there is an argument to this function, it must be a reference to an\n+array containing alternative delimiter strings. See C\u003c\u0022Alternative\n+Delimiters\u0022\u003e, below.\n+\n+\u003dhead2 C\u003cfill_in\u003e\n+\n+\t$template-\u003efill_in(OPTIONS);\n+\n+Fills in a template. Returns the resulting text if successful.\n+Otherwise, returns C\u003cundef\u003e and sets C\u003c$Text::Template::ERROR\u003e.\n+\n+The I\u003cOPTIONS\u003e are a hash, or a list of key-value pairs. You can\n+write the key names in any of the six usual styles as above; this\n+means that where this manual says C\u003cPACKAGE\u003e (for example) you can\n+actually use any of\n+\n+\tPACKAGE Package package -PACKAGE -Package -package\n+\n+Pick a style you like and stick with it. The all-lowercase versions\n+may yield spurious warnings about\n+\n+\tAmbiguous use of package \u003d\u003e resolved to \u0022package\u0022\n+\n+so you might like to avoid them and use the capitalized versions.\n+\n+At present, there are eight legal options: C\u003cPACKAGE\u003e, C\u003cBROKEN\u003e,\n+C\u003cBROKEN_ARG\u003e, C\u003cSAFE\u003e, C\u003cHASH\u003e, C\u003cOUTPUT\u003e, and C\u003cDELIMITERS\u003e.\n+\n+\u003dover 4\n+\n+\u003ditem C\u003cPACKAGE\u003e\n+\n+C\u003cPACKAGE\u003e specifies the name of a package in which the program\n+fragments should be evaluated. The default is to use the package from\n+which C\u003cfill_in\u003e was called. For example, consider this template:\n+\n+\tThe value of the variable x is {$x}.\n+\n+If you use C\u003c$template-E\u003cgt\u003efill_in(PACKAGE \u003dE\u003cgt\u003e 'R')\u003e , then the C\u003c$x\u003e in\n+the template is actually replaced with the value of C\u003c$R::x\u003e. If you\n+omit the C\u003cPACKAGE\u003e option, C\u003c$x\u003e will be replaced with the value of\n+the C\u003c$x\u003e variable in the package that actually called C\u003cfill_in\u003e.\n+\n+You should almost always use C\u003cPACKAGE\u003e. If you don't, and your\n+template makes changes to variables, those changes will be propagated\n+back into the main program. Evaluating the template in a private\n+package helps prevent this. The template can still modify variables\n+in your program if it wants to, but it will have to do so explicitly.\n+See the section at the end on `Security'.\n+\n+Here's an example of using C\u003cPACKAGE\u003e:\n+\n+\tYour Royal Highness,\n+\n+\tEnclosed please find a list of things I have gotten\n+\tfor you since 1907:\n+\n+\t{ foreach $item (@items) {\n+ $item_no++;\n+\t $OUT .\u003d \u0022 $item_no. \u005cu$item\u005cn\u0022;\n+\t }\n+\t}\n+\n+\tSigned,\n+\tLord High Chamberlain\n+\n+We want to pass in an array which will be assigned to the array\n+C\u003c@items\u003e. Here's how to do that:\n+\n+\n+\t@items \u003d ('ivory', 'apes', 'peacocks', );\n+\t$template-\u003efill_in();\n+\n+This is not very safe. The reason this isn't as safe is that if you\n+had a variable named C\u003c$item_no\u003e in scope in your program at the point\n+you called C\u003cfill_in\u003e, its value would be clobbered by the act of\n+filling out the template. The problem is the same as if you had\n+written a subroutine that used those variables in the same way that\n+the template does. (C\u003c$OUT\u003e is special in templates and is always\n+safe.)\n+\n+One solution to this is to make the C\u003c$item_no\u003e variable private to the\n+template by declaring it with C\u003cmy\u003e. If the template does this, you\n+are safe.\n+\n+But if you use the C\u003cPACKAGE\u003e option, you will probably be safe even\n+if the template does I\u003cnot\u003e declare its variables with C\u003cmy\u003e:\n+\n+\t@Q::items \u003d ('ivory', 'apes', 'peacocks', );\n+\t$template-\u003efill_in(PACKAGE \u003d\u003e 'Q');\n+\n+In this case the template will clobber the variable C\u003c$Q::item_no\u003e,\n+which is not related to the one your program was using.\n+\n+Templates cannot affect variables in the main program that are\n+declared with C\u003cmy\u003e, unless you give the template references to those\n+variables.\n+\n+\u003ditem C\u003cHASH\u003e\n+\n+You may not want to put the template variables into a package.\n+Packages can be hard to manage: You can't copy them, for example.\n+C\u003cHASH\u003e provides an alternative. \n+\n+The value for C\u003cHASH\u003e should be a reference to a hash that maps\n+variable names to values. For example, \n+\n+\t$template-\u003efill_in(HASH \u003d\u003e { recipient \u003d\u003e \u0022The King\u0022,\n+\t\t\t\t items \u003d\u003e ['gold', 'frankincense', 'myrrh'],\n+\t object \u003d\u003e \u005c$self,\n+\t\t\t\t });\n+\n+will fill out the template and use C\u003c\u0022The King\u0022\u003e as the value of\n+C\u003c$recipient\u003e and the list of items as the value of C\u003c@items\u003e. Note\n+that we pass an array reference, but inside the template it appears as\n+an array. In general, anything other than a simple string or number\n+should be passed by reference.\n+\n+We also want to pass an object, which is in C\u003c$self\u003e; note that we\n+pass a reference to the object, C\u003c\u005c$self\u003e instead. Since we've passed\n+a reference to a scalar, inside the template the object appears as\n+C\u003c$object\u003e. \n+\n+The full details of how it works are a little involved, so you might\n+want to skip to the next section.\n+\n+Suppose the key in the hash is I\u003ckey\u003e and the value is I\u003cvalue\u003e. \n+\n+\u003dover 4\n+\n+\u003ditem *\n+\n+If the I\u003cvalue\u003e is C\u003cundef\u003e, then any variables named C\u003c$key\u003e,\n+C\u003c@key\u003e, C\u003c%key\u003e, etc., are undefined. \n+\n+\u003ditem *\n+\n+If the I\u003cvalue\u003e is a string or a number, then C\u003c$key\u003e is set to that\n+value in the template.\n+\n+\u003ditem *\n+\n+For anything else, you must pass a reference.\n+\n+If the I\u003cvalue\u003e is a reference to an array, then C\u003c@key\u003e is set to\n+that array. If the I\u003cvalue\u003e is a reference to a hash, then C\u003c%key\u003e is\n+set to that hash. Similarly if I\u003cvalue\u003e is any other kind of\n+reference. This means that\n+\n+\tvar \u003d\u003e \u0022foo\u0022\n+\n+and\n+\n+\tvar \u003d\u003e \u005c\u0022foo\u0022\n+\n+have almost exactly the same effect. (The difference is that in the\n+former case, the value is copied, and in the latter case it is\n+aliased.) \n+\n+\u003ditem *\n+\n+In particular, if you want the template to get an object or any kind,\n+you must pass a reference to it:\n+\n+\t$template-\u003efill_in(HASH \u003d\u003e { database_handle \u003d\u003e \u005c$dbh, ... });\n+\n+If you do this, the template will have a variable C\u003c$database_handle\u003e\n+which is the database handle object. If you leave out the C\u003c\u005c\u003e, the\n+template will have a hash C\u003c%database_handle\u003e, which exposes the\n+internal structure of the database handle object; you don't want that.\n+\n+\u003dback\n+\n+Normally, the way this works is by allocating a private package,\n+loading all the variables into the package, and then filling out the\n+template as if you had specified that package. A new package is\n+allocated each time. However, if you I\u003calso\u003e use the C\u003cPACKAGE\u003e\n+option, C\u003cText::Template\u003e loads the variables into the package you\n+specified, and they stay there after the call returns. Subsequent\n+calls to C\u003cfill_in\u003e that use the same package will pick up the values\n+you loaded in.\n+\n+If the argument of C\u003cHASH\u003e is a reference to an array instead of a\n+reference to a hash, then the array should contain a list of hashes\n+whose contents are loaded into the template package one after the\n+other. You can use this feature if you want to combine several sets\n+of variables. For example, one set of variables might be the defaults\n+for a fill-in form, and the second set might be the user inputs, which\n+override the defaults when they are present:\n+\n+\t$template-\u003efill_in(HASH \u003d\u003e [\u005c%defaults, \u005c%user_input]);\n+\n+You can also use this to set two variables with the same name:\n+\n+\t$template-\u003efill_in(HASH \u003d\u003e [{ v \u003d\u003e \u0022The King\u0022 },\n+ { v \u003d\u003e [1,2,3] },\n+\t ]\n+ );\n+\n+This sets C\u003c$v\u003e to C\u003c\u0022The King\u0022\u003e and C\u003c@v\u003e to C\u003c(1,2,3)\u003e.\t\n+\n+\u003ditem C\u003cBROKEN\u003e\n+\n+If any of the program fragments fails to compile or aborts for any\n+reason, and you have set the C\u003cBROKEN\u003e option to a function reference,\n+C\u003cText::Template\u003e will invoke the function. This function is called\n+the I\u003cC\u003cBROKEN\u003e function\u003e. The C\u003cBROKEN\u003e function will tell\n+C\u003cText::Template\u003e what to do next. \n+\n+If the C\u003cBROKEN\u003e function returns C\u003cundef\u003e, C\u003cText::Template\u003e will\n+immediately abort processing the template and return the text that it\n+has accumulated so far. If your function does this, it should set a\n+flag that you can examine after C\u003cfill_in\u003e returns so that you can\n+tell whether there was a premature return or not. \n+\n+If the C\u003cBROKEN\u003e function returns any other value, that value will be\n+interpolated into the template as if that value had been the return\n+value of the program fragment to begin with. For example, if the\n+C\u003cBROKEN\u003e function returns an error string, the error string will be\n+interpolated into the output of the template in place of the program\n+fragment that cased the error.\n+\n+If you don't specify a C\u003cBROKEN\u003e function, C\u003cText::Template\u003e supplies\n+a default one that returns something like\n+\n+\tProgram fragment delivered error ``Illegal division by 0 at\n+\ttemplate line 37''\n+\n+(Note that the format of this message has changed slightly since\n+version 1.31.) The return value of the C\u003cBROKEN\u003e function is\n+interpolated into the template at the place the error occurred, so\n+that this template:\n+\n+\t(3+4)*5 \u003d { 3+4)*5 }\n+\n+yields this result:\n+\n+\t(3+4)*5 \u003d Program fragment delivered error ``syntax error at template line 1''\n+\n+If you specify a value for the C\u003cBROKEN\u003e attribute, it should be a\n+reference to a function that C\u003cfill_in\u003e can call instead of the\n+default function.\n+\n+C\u003cfill_in\u003e will pass a hash to the C\u003cbroken\u003e function.\n+The hash will have at least these three members:\n+\n+\u003dover 4\n+\n+\u003ditem C\u003ctext\u003e\n+\n+The source code of the program fragment that failed\n+\n+\u003ditem C\u003cerror\u003e\n+\n+The text of the error message (C\u003c$@\u003e) generated by eval.\n+\n+The text has been modified to omit the trailing newline and to include\n+the name of the template file (if there was one). The line number\n+counts from the beginning of the template, not from the beginning of\n+the failed program fragment.\n+\n+\u003ditem C\u003clineno\u003e\n+\n+The line number of the template at which the program fragment began.\n+\n+\u003dback\n+\n+There may also be an C\u003carg\u003e member. See C\u003cBROKEN_ARG\u003e, below\n+\n+\u003ditem C\u003cBROKEN_ARG\u003e\n+\n+If you supply the C\u003cBROKEN_ARG\u003e option to C\u003cfill_in\u003e, the value of the\n+option is passed to the C\u003cBROKEN\u003e function whenever it is called. The\n+default C\u003cBROKEN\u003e function ignores the C\u003cBROKEN_ARG\u003e, but you can\n+write a custom C\u003cBROKEN\u003e function that uses the C\u003cBROKEN_ARG\u003e to get\n+more information about what went wrong. \n+\n+The C\u003cBROKEN\u003e function could also use the C\u003cBROKEN_ARG\u003e as a reference\n+to store an error message or some other information that it wants to\n+communicate back to the caller. For example:\n+\n+\t$error \u003d '';\n+\n+\tsub my_broken {\t\n+\t my %args \u003d @_;\n+\t my $err_ref \u003d $args{arg};\n+\t ...\n+\t $$err_ref \u003d \u0022Some error message\u0022;\n+\t return undef;\n+\t}\n+\n+\t$template-\u003efill_in(BROKEN \u003d\u003e \u005c\u0026my_broken,\n+\t\t\t BROKEN_ARG \u003d\u003e \u005c$error,\n+\t\t\t );\n+\n+\tif ($error) {\n+\t die \u0022It didn't work: $error\u0022;\n+\t}\n+\n+If one of the program fragments in the template fails, it will call\n+the C\u003cBROKEN\u003e function, C\u003cmy_broken\u003e, and pass it the C\u003cBROKEN_ARG\u003e,\n+which is a reference to C\u003c$error\u003e. C\u003cmy_broken\u003e can store an error\n+message into C\u003c$error\u003e this way. Then the function that called\n+C\u003cfill_in\u003e can see if C\u003cmy_broken\u003e has left an error message for it\n+to find, and proceed accordingly.\n+\n+\u003ditem C\u003cSAFE\u003e\n+\n+If you give C\u003cfill_in\u003e a C\u003cSAFE\u003e option, its value should be a safe\n+compartment object from the C\u003cSafe\u003e package. All evaluation of\n+program fragments will be performed in this compartment. See L\u003cSafe\u003e\n+for full details about such compartments and how to restrict the\n+operations that can be performed in them.\n+\n+If you use the C\u003cPACKAGE\u003e option with C\u003cSAFE\u003e, the package you specify\n+will be placed into the safe compartment and evaluation will take\n+place in that package as usual. \n+\n+If not, C\u003cSAFE\u003e operation is a little different from the default.\n+Usually, if you don't specify a package, evaluation of program\n+fragments occurs in the package from which the template was invoked.\n+But in C\u003cSAFE\u003e mode the evaluation occurs inside the safe compartment\n+and cannot affect the calling package. Normally, if you use C\u003cHASH\u003e\n+without C\u003cPACKAGE\u003e, the hash variables are imported into a private,\n+one-use-only package. But if you use C\u003cHASH\u003e and C\u003cSAFE\u003e together\n+without C\u003cPACKAGE\u003e, the hash variables will just be loaded into the\n+root namespace of the C\u003cSafe\u003e compartment.\n+\n+\u003ditem C\u003cOUTPUT\u003e\n+\n+If your template is going to generate a lot of text that you are just\n+going to print out again anyway, you can save memory by having\n+C\u003cText::Template\u003e print out the text as it is generated instead of\n+making it into a big string and returning the string. If you supply\n+the C\u003cOUTPUT\u003e option to C\u003cfill_in\u003e, the value should be a filehandle.\n+The generated text will be printed to this filehandle as it is\n+constructed. For example:\n+\n+\t$template-\u003efill_in(OUTPUT \u003d\u003e \u005c*STDOUT, ...);\n+\n+fills in the C\u003c$template\u003e as usual, but the results are immediately\n+printed to STDOUT. This may result in the output appearing more\n+quickly than it would have otherwise.\n+\n+If you use C\u003cOUTPUT\u003e, the return value from C\u003cfill_in\u003e is still true on\n+success and false on failure, but the complete text is not returned to\n+the caller.\n+\n+\u003ditem C\u003cPREPEND\u003e\n+\n+You can have some Perl code prepended automatically to the beginning\n+of every program fragment. See L\u003cC\u003cPREPEND\u003e feature and using\n+C\u003cstrict\u003e in templates\u003e below.\n+\n+\u003ditem C\u003cDELIMITERS\u003e\n+\n+If this option is present, its value should be a reference to a list\n+of two strings. The first string is the string that signals the\n+beginning of each program fragment, and the second string is the\n+string that signals the end of each program fragment. See\n+L\u003c\u0022Alternative Delimiters\u0022\u003e, below. \n+\n+If you specify C\u003cDELIMITERS\u003e in the call to C\u003cfill_in\u003e, they override\n+any delimiters you set when you created the template object with\n+C\u003cnew\u003e. \n+\n+\u003dback\n+\n+\u003dhead1 Convenience Functions\n+\n+\u003dhead2 C\u003cfill_this_in\u003e\n+\n+The basic way to fill in a template is to create a template object and\n+then call C\u003cfill_in\u003e on it. This is useful if you want to fill in\n+the same template more than once.\n+\n+In some programs, this can be cumbersome. C\u003cfill_this_in\u003e accepts a\n+string, which contains the template, and a list of options, which are\n+passed to C\u003cfill_in\u003e as above. It constructs the template object for\n+you, fills it in as specified, and returns the results. It returns\n+C\u003cundef\u003e and sets C\u003c$Text::Template::ERROR\u003e if it couldn't generate\n+any results.\n+\n+An example:\n+\n+\t$Q::name \u003d 'Donald';\n+\t$Q::amount \u003d 141.61;\n+\t$Q::part \u003d 'hyoid bone';\n+\n+\t$text \u003d Text::Template-\u003efill_this_in( \u003c\u003c'EOM', PACKAGE \u003d\u003e Q);\n+\tDear {$name},\n+\tYou owe me \u005c\u005c${sprintf('%.2f', $amount)}. \n+\tPay or I will break your {$part}.\n+\t\tLove,\n+\t\tGrand Vizopteryx of Irkutsk.\n+\tEOM\n+\n+Notice how we included the template in-line in the program by using a\n+`here document' with the C\u003cE\u003clt\u003eE\u003clt\u003e\u003e notation.\n+\n+C\u003cfill_this_in\u003e is a deprecated feature. It is only here for\n+backwards compatibility, and may be removed in some far-future version\n+in C\u003cText::Template\u003e. You should use C\u003cfill_in_string\u003e instead. It\n+is described in the next section.\n+\n+\u003dhead2 C\u003cfill_in_string\u003e\n+\n+It is stupid that C\u003cfill_this_in\u003e is a class method. It should have\n+been just an imported function, so that you could omit the\n+C\u003cText::Template-E\u003cgt\u003e\u003e in the example above. But I made the mistake\n+four years ago and it is too late to change it.\n+\n+C\u003cfill_in_string\u003e is exactly like C\u003cfill_this_in\u003e except that it is\n+not a method and you can omit the C\u003cText::Template-E\u003cgt\u003e\u003e and just say\n+\n+\tprint fill_in_string(\u003c\u003c'EOM', ...);\n+\tDear {$name},\n+\t ...\n+\tEOM\n+\n+To use C\u003cfill_in_string\u003e, you need to say\n+\n+\tuse Text::Template 'fill_in_string';\n+\n+at the top of your program. You should probably use\n+C\u003cfill_in_string\u003e instead of C\u003cfill_this_in\u003e.\n+\n+\u003dhead2 C\u003cfill_in_file\u003e\n+\n+If you import C\u003cfill_in_file\u003e, you can say\n+\n+\t$text \u003d fill_in_file(filename, ...);\n+\n+The C\u003c...\u003e are passed to C\u003cfill_in\u003e as above. The filename is the\n+name of the file that contains the template you want to fill in. It\n+returns the result text. or C\u003cundef\u003e, as usual.\n+\n+If you are going to fill in the same file more than once in the same\n+program you should use the longer C\u003cnew\u003e / C\u003cfill_in\u003e sequence instead.\n+It will be a lot faster because it only has to read and parse the file\n+once.\n+\n+\u003dhead2 Including files into templates\n+\n+People always ask for this. ``Why don't you have an include\n+function?'' they want to know. The short answer is this is Perl, and\n+Perl already has an include function. If you want it, you can just put\n+\n+\t{qx{cat filename}}\n+\n+into your template. VoilE\u003cagrave\u003e.\n+\n+If you don't want to use C\u003ccat\u003e, you can write a little four-line\n+function that opens a file and dumps out its contents, and call it\n+from the template. I wrote one for you. In the template, you can say\n+\n+\t{Text::Template::_load_text(filename)}\n+\n+If that is too verbose, here is a trick. Suppose the template package\n+that you are going to be mentioning in the C\u003cfill_in\u003e call is package\n+C\u003cQ\u003e. Then in the main program, write\n+\n+\t*Q::include \u003d \u005c\u0026Text::Template::_load_text;\n+\n+This imports the C\u003c_load_text\u003e function into package C\u003cQ\u003e with the\n+name C\u003cinclude\u003e. From then on, any template that you fill in with\n+package C\u003cQ\u003e can say\n+\n+\t{include(filename)}\n+\n+to insert the text from the named file at that point. If you are\n+using the C\u003cHASH\u003e option instead, just put C\u003cinclude \u003dE\u003cgt\u003e\n+\u005c\u0026Text::Template::_load_text\u003e into the hash instead of importing it\n+explicitly.\n+\n+Suppose you don't want to insert a plain text file, but rather you\n+want to include one template within another? Just use C\u003cfill_in_file\u003e\n+in the template itself:\n+\n+\t{Text::Template::fill_in_file(filename)}\n+\n+You can do the same importing trick if this is too much to type.\n+\n+\u003dhead1 Miscellaneous\n+\n+\u003dhead2 C\u003cmy\u003e variables\n+\n+People are frequently surprised when this doesn't work:\n+\n+\tmy $recipient \u003d 'The King';\n+\tmy $text \u003d fill_in_file('formletter.tmpl');\n+\n+The text C\u003cThe King\u003e doesn't get into the form letter. Why not?\n+Because C\u003c$recipient\u003e is a C\u003cmy\u003e variable, and the whole point of\n+C\u003cmy\u003e variables is that they're private and inaccessible except in the\n+scope in which they're declared. The template is not part of that\n+scope, so the template can't see C\u003c$recipient\u003e. \n+\n+If that's not the behavior you want, don't use C\u003cmy\u003e. C\u003cmy\u003e means a\n+private variable, and in this case you don't want the variable to be\n+private. Put the variables into package variables in some other\n+package, and use the C\u003cPACKAGE\u003e option to C\u003cfill_in\u003e:\n+\n+\t$Q::recipient \u003d $recipient;\n+\tmy $text \u003d fill_in_file('formletter.tmpl', PACKAGE \u003d\u003e 'Q');\n+\t\n+\n+or pass the names and values in a hash with the C\u003cHASH\u003e option:\n+\n+\tmy $text \u003d fill_in_file('formletter.tmpl', HASH \u003d\u003e { recipient \u003d\u003e $recipient });\n+\n+\u003dhead2 Security Matters\n+\n+All variables are evaluated in the package you specify with the\n+C\u003cPACKAGE\u003e option of C\u003cfill_in\u003e. if you use this option, and if your\n+templates don't do anything egregiously stupid, you won't have to\n+worry that evaluation of the little programs will creep out into the\n+rest of your program and wreck something.\n+\n+Nevertheless, there's really no way (except with C\u003cSafe\u003e) to protect\n+against a template that says\n+\n+\t{ $Important::Secret::Security::Enable \u003d 0; \n+\t # Disable security checks in this program \n+\t}\n+\n+or\n+\n+\t{ $/ \u003d \u0022ho ho ho\u0022; # Sabotage future uses of \u003cFH\u003e.\n+\t # $/ is always a global variable\n+\t}\n+\n+or even\n+\n+\t{ system(\u0022rm -rf /\u0022) }\n+\n+so B\u003cdon't\u003e go filling in templates unless you're sure you know what's\n+in them. If you're worried, or you can't trust the person who wrote\n+the template, use the C\u003cSAFE\u003e option.\n+\n+A final warning: program fragments run a small risk of accidentally\n+clobbering local variables in the C\u003cfill_in\u003e function itself. These\n+variables all have names that begin with C\u003c$fi_\u003e, so if you stay away\n+from those names you'll be safe. (Of course, if you're a real wizard\n+you can tamper with them deliberately for exciting effects; this is\n+actually how C\u003c$OUT\u003e works.) I can fix this, but it will make the\n+package slower to do it, so I would prefer not to. If you are worried\n+about this, send me mail and I will show you what to do about it.\n+\n+\u003dhead2 Alternative Delimiters\n+\n+Lorenzo Valdettaro pointed out that if you are using C\u003cText::Template\u003e\n+to generate TeX output, the choice of braces as the program fragment\n+delimiters makes you suffer suffer suffer. Starting in version 1.20,\n+you can change the choice of delimiters to something other than curly\n+braces.\n+\n+In either the C\u003cnew()\u003e call or the C\u003cfill_in()\u003e call, you can specify\n+an alternative set of delimiters with the C\u003cDELIMITERS\u003e option. For\n+example, if you would like code fragments to be delimited by C\u003c[@--\u003e\n+and C\u003c--@]\u003e instead of C\u003c{\u003e and C\u003c}\u003e, use\n+\n+\t... DELIMITERS \u003d\u003e [ '[@--', '--@]' ], ...\n+\n+Note that these delimiters are I\u003cliteral strings\u003e, not regexes. (I\n+tried for regexes, but it complicates the lexical analysis too much.)\n+Note also that C\u003cDELIMITERS\u003e disables the special meaning of the\n+backslash, so if you want to include the delimiters in the literal\n+text of your template file, you are out of luck---it is up to you to\n+choose delimiters that do not conflict with what you are doing. The\n+delimiter strings may still appear inside of program fragments as long\n+as they nest properly. This means that if for some reason you\n+absolutely must have a program fragment that mentions one of the\n+delimiters, like this:\n+\n+\t[@--\n+\t\tprint \u0022Oh no, a delimiter: --@]\u005cn\u0022\n+\t--@]\n+\n+you may be able to make it work by doing this instead:\n+\n+\t[@--\n+\t\t# Fake matching delimiter in a comment: [@--\n+\t\tprint \u0022Oh no, a delimiter: --@]\u005cn\u0022\n+\t--@]\n+\n+It may be safer to choose delimiters that begin with a newline\n+character. \n+\n+Because the parsing of templates is simplified by the absence of\n+backslash escapes, using alternative C\u003cDELIMITERS\u003e may speed up the\n+parsing process by 20-25%. This shows that my original choice of C\u003c{\u003e\n+and C\u003c}\u003e was very bad. \n+\n+\u003dhead2 C\u003cPREPEND\u003e feature and using C\u003cstrict\u003e in templates\n+\n+Suppose you would like to use C\u003cstrict\u003e in your templates to detect\n+undeclared variables and the like. But each code fragment is a\n+separate lexical scope, so you have to turn on C\u003cstrict\u003e at the top of\n+each and every code fragment:\n+\n+\t{ use strict;\n+\t use vars '$foo';\n+\t $foo \u003d 14;\n+\t ...\n+\t}\n+\n+\t...\n+\n+\t{ # we forgot to put `use strict' here\n+\t my $result \u003d $boo + 12; # $boo is misspelled and should be $foo\n+\t # No error is raised on `$boo'\n+\t}\n+\n+Because we didn't put C\u003cuse strict\u003e at the top of the second fragment,\n+it was only active in the first fragment, and we didn't get any\n+C\u003cstrict\u003e checking in the second fragment. Then we mispelled C\u003c$foo\u003e\n+and the error wasn't caught. \n+\n+C\u003cText::Template\u003e version 1.22 and higher has a new feature to make\n+this easier. You can specify that any text at all be automatically\n+added to the beginning of each program fragment. \n+\n+When you make a call to C\u003cfill_in\u003e, you can specify a\n+\n+\tPREPEND \u003d\u003e 'some perl statements here'\n+\n+option; the statements will be prepended to each program fragment for\n+that one call only. Suppose that the C\u003cfill_in\u003e call included a\n+\n+\tPREPEND \u003d\u003e 'use strict;'\n+\n+option, and that the template looked like this:\n+\n+\t{ use vars '$foo';\n+\t $foo \u003d 14;\n+\t ...\n+\t}\n+\n+\t...\n+\n+\t{ my $result \u003d $boo + 12; # $boo is misspelled and should be $foo\n+\t ...\n+\t}\n+\n+The code in the second fragment would fail, because C\u003c$boo\u003e has not\n+been declared. C\u003cuse strict\u003e was implied, even though you did not\n+write it explicitly, because the C\u003cPREPEND\u003e option added it for you\n+automatically.\n+\n+There are two other ways to do this. At the time you create the\n+template object with C\u003cnew\u003e, you can also supply a C\u003cPREPEND\u003e option,\n+in which case the statements will be prepended each time you fill in\n+that template. If the C\u003cfill_in\u003e call has its own C\u003cPREPEND\u003e option,\n+this overrides the one specified at the time you created the\n+template. Finally, you can make the class method call\n+\n+\tText::Template-\u003ealways_prepend('perl statements');\n+\n+If you do this, then call calls to C\u003cfill_in\u003e for I\u003cany\u003e template will\n+attach the perl statements to the beginning of each program fragment,\n+except where overridden by C\u003cPREPEND\u003e options to C\u003cnew\u003e or C\u003cfill_in\u003e.\n+\n+\u003dhead2 Prepending in Derived Classes\n+\n+This section is technical, and you should skip it on the first few\n+readings. \n+\n+Normally there are three places that prepended text could come from.\n+It could come from the C\u003cPREPEND\u003e option in the C\u003cfill_in\u003e call, from\n+the C\u003cPREPEND\u003e option in the C\u003cnew\u003e call that created the template\n+object, or from the argument of the C\u003calways_prepend\u003e call.\n+C\u003cText::Template\u003e looks for these three things in order and takes the\n+first one that it finds.\n+\n+In a subclass of C\u003cText::Template\u003e, this last possibility is\n+ambiguous. Suppose C\u003cS\u003e is a subclass of C\u003cText::Template\u003e. Should \n+\n+\tText::Template-\u003ealways_prepend(...);\n+\n+affect objects in class C\u003cDerived\u003e? The answer is that you can have it\n+either way. \n+\n+The C\u003calways_prepend\u003e value for C\u003cText::Template\u003e is normally stored\n+in a hash variable named C\u003c%GLOBAL_PREPEND\u003e under the key\n+C\u003cText::Template\u003e. When C\u003cText::Template\u003e looks to see what text to\n+prepend, it first looks in the template object itself, and if not, it\n+looks in C\u003c$GLOBAL_PREPEND{I\u003cclass\u003e}\u003e where I\u003cclass\u003e is the class to\n+which the template object belongs. If it doesn't find any value, it\n+looks in C\u003c$GLOBAL_PREPEND{'Text::Template'}\u003e. This means that\n+objects in class C\u003cDerived\u003e I\u003cwill\u003e be affected by\n+\n+\tText::Template-\u003ealways_prepend(...);\n+\n+I\u003cunless\u003e there is also a call to\n+\n+\tDerived-\u003ealways_prepend(...);\n+\n+So when you're designing your derived class, you can arrange to have\n+your objects ignore C\u003cText::Template::always_prepend\u003e calls by simply\n+putting C\u003cDerived-E\u003cgt\u003ealways_prepend('')\u003e at the top of your module.\n+\n+Of course, there is also a final escape hatch: Templates support a\n+C\u003cprepend_text\u003e that is used to look up the appropriate text to be\n+prepended at C\u003cfill_in\u003e time. Your derived class can override this\n+method to get an arbitrary effect.\n+\n+\u003dhead2 JavaScript\n+\n+Jennifer D. St Clair asks:\n+\n+\t\u003e Most of my pages contain JavaScript and Stylesheets.\n+ \u003e How do I change the template identifier? \n+\n+Jennifer is worried about the braces in the JavaScript being taken as\n+the delimiters of the Perl program fragments. Of course, disaster\n+will ensue when perl tries to evaluate these as if they were Perl\n+programs. The best choice is to find some unambiguous delimiter\n+strings that you can use in your template instead of curly braces, and\n+then use the C\u003cDELIMITERS\u003e option. However, if you can't do this for\n+some reason, there are two easy workarounds:\n+\n+1. You can put C\u003c\u005c\u003e in front of C\u003c{\u003e, C\u003c}\u003e, or C\u003c\u005c\u003e to remove its\n+special meaning. So, for example, instead of\n+\n+\t if (br\u003d\u003d \u0022n3\u0022) { \n+\t\t// etc.\n+\t }\n+\n+you can put\n+\n+\t if (br\u003d\u003d \u0022n3\u0022) \u005c{ \n+\t\t// etc.\n+\t \u005c}\n+\n+and it'll come out of the template engine the way you want.\n+\n+But here is another method that is probably better. To see how it\n+works, first consider what happens if you put this into a template:\n+\n+\t { 'foo' }\n+\n+Since it's in braces, it gets evaluated, and obviously, this is going\n+to turn into\n+\n+\t foo\n+\n+So now here's the trick: In Perl, C\u003cq{...}\u003e is the same as C\u003c'...'\u003e.\n+So if we wrote\n+\n+\t {q{foo}}\n+\n+it would turn into \n+\n+\t foo\n+\n+So for your JavaScript, just write\n+\n+\t {q{if (br\u003d\u003d \u0022n3\u0022) { \n+\t \t // etc.\n+\t }}\n+\t }\n+\n+and it'll come out as\n+\n+\t if (br\u003d\u003d \u0022n3\u0022) { \n+\t \t // etc.\n+\t }\n+\n+which is what you want.\n+\n+\n+\u003dhead2 Shut Up!\n+\n+People sometimes try to put an initialization section at the top of\n+their templates, like this:\n+\n+\t{ ...\n+\t $var \u003d 17;\n+\t}\n+\n+Then they complain because there is a C\u003c17\u003e at the top of the output\n+that they didn't want to have there. \n+\n+Remember that a program fragment is replaced with its own return\n+value, and that in Perl the return value of a code block is the value\n+of the last expression that was evaluated, which in this case is 17.\n+If it didn't do that, you wouldn't be able to write C\u003c{$recipient}\u003e\n+and have the recipient filled in.\n+\n+To prevent the 17 from appearing in the output is very simple:\n+\n+\t{ ...\n+\t $var \u003d 17;\n+\t '';\n+\t}\n+\n+Now the last expression evaluated yields the empty string, which is\n+invisible. If you don't like the way this looks, use\n+\n+\t{ ...\n+\t $var \u003d 17;\n+\t ($SILENTLY);\n+\t}\n+\n+instead. Presumably, C\u003c$SILENTLY\u003e has no value, so nothing will be\n+interpolated. This is what is known as a `trick'.\n+\n+\u003dhead2 Compatibility\n+\n+Every effort has been made to make this module compatible with older\n+versions. The only known exceptions follow:\n+\n+The output format of the default C\u003cBROKEN\u003e subroutine has changed\n+twice, most recently between versions 1.31 and 1.40.\n+\n+Starting in version 1.10, the C\u003c$OUT\u003e variable is arrogated for a\n+special meaning. If you had templates before version 1.10 that\n+happened to use a variable named C\u003c$OUT\u003e, you will have to change them\n+to use some other variable or all sorts of strangeness will result.\n+\n+Between versions 0.1b and 1.00 the behavior of the \u005c metacharacter\n+changed. In 0.1b, \u005c\u005c was special everywhere, and the template\n+processor always replaced it with a single backslash before passing\n+the code to Perl for evaluation. The rule now is more complicated but\n+probably more convenient. See the section on backslash processing,\n+below, for a full discussion.\n+\n+\u003dhead2 Backslash Processing\n+\n+In C\u003cText::Template\u003e beta versions, the backslash was special whenever\n+it appeared before a brace or another backslash. That meant that\n+while C\u003c{\u0022\u005cn\u0022}\u003e did indeed generate a newline, C\u003c{\u0022\u005c\u005c\u0022}\u003e did not\n+generate a backslash, because the code passed to Perl for evaluation\n+was C\u003c\u0022\u005c\u0022\u003e which is a syntax error. If you wanted a backslash, you\n+would have had to write C\u003c{\u0022\u005c\u005c\u005c\u005c\u0022}\u003e.\n+\n+In C\u003cText::Template\u003e versions 1.00 through 1.10, there was a bug:\n+Backslash was special everywhere. In these versions, C\u003c{\u0022\u005cn\u0022}\u003e\n+generated the letter C\u003cn\u003e.\n+\n+The bug has been corrected in version 1.11, but I did not go back to\n+exactly the old rule, because I did not like the idea of having to\n+write C\u003c{\u0022\u005c\u005c\u005c\u005c\u0022}\u003e to get one backslash. The rule is now more\n+complicated to remember, but probably easier to use. The rule is now:\n+Backslashes are always passed to Perl unchanged I\u003cunless\u003e they occur\n+as part of a sequence like C\u003c\u005c\u005c\u005c\u005c\u005c\u005c{\u003e or C\u003c\u005c\u005c\u005c\u005c\u005c\u005c}\u003e. In these\n+contexts, they are special; C\u003c\u005c\u005c\u003e is replaced with C\u003c\u005c\u003e, and C\u003c\u005c{\u003e and\n+C\u003c\u005c}\u003e signal a literal brace. \n+\n+Examples:\n+\n+\t\u005c{ foo \u005c}\n+\n+is I\u003cnot\u003e evaluated, because the C\u003c\u005c\u003e before the braces signals that\n+they should be taken literally. The result in the output looks like this: \n+\n+\t{ foo }\n+\n+\n+This is a syntax error:\n+\n+\t{ \u0022foo}\u0022 }\n+\n+because C\u003cText::Template\u003e thinks that the code ends at the first C\u003c}\u003e,\n+and then gets upset when it sees the second one. To make this work\n+correctly, use\n+\n+\t{ \u0022foo\u005c}\u0022 }\n+\n+This passes C\u003c\u0022foo}\u0022\u003e to Perl for evaluation. Note there's no C\u003c\u005c\u003e in\n+the evaluated code. If you really want a C\u003c\u005c\u003e in the evaluated code,\n+use\n+\n+\t{ \u0022foo\u005c\u005c\u005c}\u0022 }\n+\n+This passes C\u003c\u0022foo\u005c}\u0022\u003e to Perl for evaluation.\n+\n+Starting with C\u003cText::Template\u003e version 1.20, backslash processing is\n+disabled if you use the C\u003cDELIMITERS\u003e option to specify alternative\n+delimiter strings.\n+\n+\u003dhead2 A short note about C\u003c$Text::Template::ERROR\u003e\n+\n+In the past some people have fretted about `violating the package\n+boundary' by examining a variable inside the C\u003cText::Template\u003e\n+package. Don't feel this way. C\u003c$Text::Template::ERROR\u003e is part of\n+the published, official interface to this package. It is perfectly OK\n+to inspect this variable. The interface is not going to change.\n+\n+If it really, really bothers you, you can import a function called\n+C\u003cTTerror\u003e that returns the current value of the C\u003c$ERROR\u003e variable.\n+So you can say:\n+\n+\tuse Text::Template 'TTerror';\n+\n+\tmy $template \u003d new Text::Template (SOURCE \u003d\u003e $filename);\n+\tunless ($template) {\n+\t my $err \u003d TTerror;\n+\t die \u0022Couldn't make template: $err; aborting\u0022;\n+\t}\n+\n+I don't see what benefit this has over just doing this:\n+\n+\tuse Text::Template;\n+\n+\tmy $template \u003d new Text::Template (SOURCE \u003d\u003e $filename)\n+\t or die \u0022Couldn't make template: $Text::Template::ERROR; aborting\u0022;\n+\n+But if it makes you happy to do it that way, go ahead.\n+\n+\u003dhead2 Sticky Widgets in Template Files\n+\n+The C\u003cCGI\u003e module provides functions for `sticky widgets', which are\n+form input controls that retain their values from one page to the\n+next. Sometimes people want to know how to include these widgets\n+into their template output.\n+\n+It's totally straightforward. Just call the C\u003cCGI\u003e functions from\n+inside the template:\n+\n+\t{ $q-\u003echeckbox_group(NAME \u003d\u003e 'toppings',\n+\t\t \t LINEBREAK \u003d\u003e true,\n+\t\t\t COLUMNS \u003d\u003e 3,\n+\t\t\t VALUES \u003d\u003e \u005c@toppings,\n+\t\t\t );\n+\t}\n+\n+\u003dhead2 Automatic preprocessing of program fragments\n+\n+It may be useful to preprocess the program fragments before they are\n+evaluated. See C\u003cText::Template::Preprocess\u003e for more details.\n+\n+\u003dhead2 Automatic postprocessing of template hunks\n+\n+It may be useful to process hunks of output before they are appended to\n+the result text. For this, subclass and replace the C\u003cappend_text_to_result\u003e\n+method. It is passed a list of pairs with these entries:\n+\n+ handle - a filehandle to which to print the desired output\n+ out - a ref to a string to which to append, to use if handle is not given\n+ text - the text that will be appended\n+ type - where the text came from: TEXT for literal text, PROG for code\n+\n+\u003dhead2 Author\n+\n+Mark Jason Dominus, Plover Systems\n+\n+Please send questions and other remarks about this software to\n+C\u003cmjd-perl-template+@plover.com\u003e\n+\n+You can join a very low-volume (E\u003clt\u003e10 messages per year) mailing\n+list for announcements about this package. Send an empty note to\n+C\u003cmjd-perl-template-request@plover.com\u003e to join.\n+\n+For updates, visit C\u003chttp://www.plover.com/~mjd/perl/Template/\u003e.\n+\n+\u003dhead2 Support?\n+\n+This software is version 1.46. It may have bugs. Suggestions and bug\n+reports are always welcome. Send them to\n+C\u003cmjd-perl-template+@plover.com\u003e. (That is my address, not the address\n+of the mailing list. The mailing list address is a secret.)\n+\n+\u003dhead1 LICENSE\n+\n+ Text::Template version 1.46\n+ Copyright 2013 Mark Jason Dominus\n+\n+ This program is free software; you can redistribute it and/or\n+ modify it under the terms of the GNU General Public License as\n+ published by the Free Software Foundation; either version 2 of the\n+ License, or (at your option) any later version. You may also can\n+ redistribute it and/or modify it under the terms of the Perl\n+ Artistic License.\n+\n+ This program is distributed in the hope that it will be useful,\n+ but WITHOUT ANY WARRANTY; without even the implied warranty of\n+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n+ GNU General Public License for more details.\n+\n+ You should have received copies of the GNU General Public License\n+ along with this program; if not, write to the Free Software\n+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n+\n+\n+\u003dhead1 THANKS\n+\n+Many thanks to the following people for offering support,\n+encouragement, advice, bug reports, and all the other good stuff. \n+\n+David H. Adler /\n+Joel Appelbaum /\n+Klaus Arnhold /\n+AntE\u003coacute\u003enio AragE\u003catilde\u003eo /\n+Kevin Atteson /\n+Chris.Brezil /\n+Mike Brodhead /\n+Tom Brown /\n+Dr. Frank Bucolo /\n+Tim Bunce /\n+Juan E. Camacho /\n+Itamar Almeida de Carvalho /\n+Joseph Cheek /\n+Gene Damon /\n+San Deng /\n+Bob Dougherty /\n+Marek Grac /\n+Dan Franklin /\n+gary at dls.net /\n+Todd A. Green /\n+Donald L. Greer Jr. /\n+Michelangelo Grigni /\n+Zac Hansen /\n+Tom Henry /\n+Jarko Hietaniemi /\n+Matt X. Hunter /\n+Robert M. Ioffe /\n+Daniel LaLiberte /\n+Reuven M. Lerner /\n+Trip Lilley / \n+Yannis Livassof /\n+Val Luck /\n+Kevin Madsen /\n+David Marshall /\n+James Mastros /\n+Joel Meulenberg /\n+Jason Moore /\n+Sergey Myasnikov /\n+Chris Nandor /\n+Bek Oberin /\n+Steve Palincsar /\n+Ron Pero /\n+Hans Persson /\n+Sean Roehnelt /\n+Jonathan Roy /\n+Shabbir J. Safdar /\n+Jennifer D. St Clair /\n+Uwe Schneider /\n+Randal L. Schwartz /\n+Michael G Schwern /\n+Yonat Sharon /\n+Brian C. Shensky /\n+Niklas Skoglund /\n+Tom Snee /\n+Fred Steinberg /\n+Hans Stoop /\n+Michael J. Suzio /\n+Dennis Taylor /\n+James H. Thompson /\n+Shad Todd /\n+Lieven Tomme /\n+Lorenzo Valdettaro /\n+Larry Virden /\n+Andy Wardley /\n+Archie Warnock /\n+Chris Wesley /\n+Matt Womer /\n+Andrew G Wood /\n+Daini Xie /\n+Michaely Yeung\n+\n+Special thanks to:\n+\n+\u003dover 2\n+\n+\u003ditem Jonathan Roy \n+\n+for telling me how to do the C\u003cSafe\u003e support (I spent two years\n+worrying about it, and then Jonathan pointed out that it was trivial.)\n+\n+\u003ditem Ranjit Bhatnagar \n+\n+for demanding less verbose fragments like they have in ASP, for\n+helping me figure out the Right Thing, and, especially, for talking me\n+out of adding any new syntax. These discussions resulted in the\n+C\u003c$OUT\u003e feature.\n+\n+\u003dback\n+\n+\u003dhead2 Bugs and Caveats\n+\n+C\u003cmy\u003e variables in C\u003cfill_in\u003e are still susceptible to being clobbered\n+by template evaluation. They all begin with C\u003cfi_\u003e, so avoid those\n+names in your templates.\n+\n+The line number information will be wrong if the template's lines are\n+not terminated by C\u003c\u0022\u005cn\u0022\u003e. You should let me know if this is a\n+problem. If you do, I will fix it.\n+\n+The C\u003c$OUT\u003e variable has a special meaning in templates, so you cannot\n+use it as if it were a regular variable.\n+\n+There are not quite enough tests in the test suite.\n+\n+\u003dcut\ndiff --git a/external/perl/Text-Template-1.46/lib/Text/Template/Preprocess.pm b/external/perl/Text-Template-1.46/lib/Text/Template/Preprocess.pm\nnew file mode 100644\nindex 0000000..1e41037\n--- /dev/null\n+++ b/external/perl/Text-Template-1.46/lib/Text/Template/Preprocess.pm\n@@ -0,0 +1,144 @@\n+\n+package Text::Template::Preprocess;\n+use Text::Template;\n+@ISA \u003d qw(Text::Template);\n+$Text::Template::Preprocess::VERSION \u003d 1.46;\n+\n+sub fill_in {\n+ my $self \u003d shift;\n+ my (%args) \u003d @_;\n+ my $pp \u003d $args{PREPROCESSOR} || $self-\u003e{PREPROCESSOR} ;\n+ if ($pp) {\n+ local $_ \u003d $self-\u003esource();\n+# print \u0022# fill_in: before \u003c$_\u003e\u005cn\u0022;\n+ \u0026$pp;\n+# print \u0022# fill_in: after \u003c$_\u003e\u005cn\u0022;\n+ $self-\u003eset_source_data($_);\n+ }\n+ $self-\u003eSUPER::fill_in(@_);\n+}\n+\n+sub preprocessor {\n+ my ($self, $pp) \u003d @_;\n+ my $old_pp \u003d $self-\u003e{PREPROCESSOR};\n+ $self-\u003e{PREPROCESSOR} \u003d $pp if @_ \u003e 1; # OK to pass $pp\u003dundef\n+ $old_pp;\n+}\n+\n+1;\n+\n+\n+\u003dhead1 NAME \n+\n+Text::Template::Preprocess - Expand template text with embedded Perl\n+\n+\u003dhead1 VERSION\n+\n+This file documents C\u003cText::Template::Preprocess\u003e version B\u003c1.46\u003e\n+\n+\u003dhead1 SYNOPSIS\n+\n+ use Text::Template::Preprocess;\n+\n+ my $t \u003d Text::Template::Preprocess-\u003enew(...); # identical to Text::Template\n+\n+ # Fill in template, but preprocess each code fragment with pp().\n+ my $result \u003d $t-\u003efill_in(..., PREPROCESSOR \u003d\u003e \u005c\u0026pp);\n+\n+ my $old_pp \u003d $t-\u003epreprocessor(\u005c\u0026new_pp);\n+\n+\u003dhead1 DESCRIPTION\n+\n+C\u003cText::Template::Preprocess\u003e provides a new C\u003cPREPROCESSOR\u003e option to\n+C\u003cfill_in\u003e. If the C\u003cPREPROCESSOR\u003e option is supplied, it must be a\n+reference to a preprocessor subroutine. When filling out a template,\n+C\u003cText::Template::Preprocessor\u003e will use this subroutine to preprocess\n+the program fragment prior to evaluating the code.\n+\n+The preprocessor subroutine will be called repeatedly, once for each\n+program fragment. The program fragment will be in C\u003c$_\u003e. The\n+subroutine should modify the contents of C\u003c$_\u003e and return.\n+C\u003cText::Template::Preprocess\u003e will then execute contents of C\u003c$_\u003e and\n+insert the result into the appropriate part of the template.\n+\n+C\u003cText::Template::Preprocess\u003e objects also support a utility method,\n+C\u003cpreprocessor()\u003e, which sets a new preprocessor for the object. This\n+preprocessor is used for all subsequent calls to C\u003cfill_in\u003e except\n+where overridden by an explicit C\u003cPREPROCESSOR\u003e option.\n+C\u003cpreprocessor()\u003e returns the previous default preprocessor function,\n+or undefined if there wasn't one. When invoked with no arguments,\n+C\u003cpreprocessor()\u003e returns the object's current default preprocessor\n+function without changing it.\n+\n+In all other respects, C\u003cText::Template::Preprocess\u003e is identical to\n+C\u003cText::Template\u003e.\n+\n+\u003dhead1 WHY?\n+\n+One possible purpose: If your files contain a lot of JavaScript, like\n+this:\n+\n+\n+ Plain text here...\n+ { perl code }\n+ \u003cscript language\u003dJavaScript\u003e\n+ \t if (br\u003d\u003d \u0022n3\u0022) { \n+\t \t // etc.\n+\t }\n+ \u003c/script\u003e\n+ { more perl code }\n+ More plain text...\n+\n+You don't want C\u003cText::Template\u003e to confuse the curly braces in the\n+JavaScript program with executable Perl code. One strategy:\n+\n+ sub quote_scripts {\n+ s(\u003cscript(.*?)\u003c/script\u003e)(q{$1})gsi;\n+ }\n+\n+Then use C\u003cPREPROCESSOR \u003dE\u003cgt\u003e \u005c\u0026quote_scripts\u003e. This will transform \n+\n+\n+\n+\u003dhead1 SEE ALSO\n+\n+L\u003cText::Template\u003e\n+\n+\u003dhead1 AUTHOR\n+\n+\n+Mark Jason Dominus, Plover Systems\n+\n+Please send questions and other remarks about this software to\n+C\u003cmjd-perl-template+@plover.com\u003e\n+\n+You can join a very low-volume (E\u003clt\u003e10 messages per year) mailing\n+list for announcements about this package. Send an empty note to\n+C\u003cmjd-perl-template-request@plover.com\u003e to join.\n+\n+For updates, visit C\u003chttp://www.plover.com/~mjd/perl/Template/\u003e.\n+\n+\u003dhead1 LICENSE\n+\n+ Text::Template::Preprocess version 1.46\n+ Copyright 2013 Mark Jason Dominus\n+\n+ This program is free software; you can redistribute it and/or\n+ modify it under the terms of the GNU General Public License as\n+ published by the Free Software Foundation; either version 2 of the\n+ License, or (at your option) any later version. You may also can\n+ redistribute it and/or modify it under the terms of the Perl\n+ Artistic License.\n+\n+ This program is distributed in the hope that it will be useful,\n+ but WITHOUT ANY WARRANTY; without even the implied warranty of\n+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n+ GNU General Public License for more details.\n+\n+ You should have received copies of the GNU General Public License\n+ along with this program; if not, write to the Free Software\n+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n+\n+\n+\u003dcut\n+\ndiff --git a/external/perl/Text-Template-1.46/t/00-version.t b/external/perl/Text-Template-1.46/t/00-version.t\nnew file mode 100644\nindex 0000000..5f9560f\n--- /dev/null\n+++ b/external/perl/Text-Template-1.46/t/00-version.t\n@@ -0,0 +1,11 @@\n+#!perl\n+\n+use Text::Template;\n+print \u00221..1\u005cn\u0022;\n+\n+if ($Text::Template::VERSION \u003d\u003d 1.46) {\n+ print \u0022ok 1\u005cn\u0022;\n+} else {\n+ print \u0022not ok 1\u005cn\u0022;\n+}\n+\ndiff --git a/external/perl/Text-Template-1.46/t/01-basic.t b/external/perl/Text-Template-1.46/t/01-basic.t\nnew file mode 100644\nindex 0000000..be43390\n--- /dev/null\n+++ b/external/perl/Text-Template-1.46/t/01-basic.t\n@@ -0,0 +1,266 @@\n+#!perl\n+#\n+# Tests of basic, essential functionality\n+#\n+\n+use Text::Template;\n+$X::v \u003d $Y::v \u003d 0;\t\t# Suppress `var used only once'\n+\n+print \u00221..31\u005cn\u0022;\n+\n+$n\u003d1;\n+\n+$template_1 \u003d \u003c\u003cEOM;\n+We will put value of \u005c$v (which is \u0022abc\u0022) here -\u003e {\u005c$v}\n+We will evaluate 1+1 here -\u003e {1 + 1}\n+EOM\n+\n+# (1) Construct temporary template file for testing\n+# file operations\n+$TEMPFILE \u003d \u0022tt$$\u0022;\n+open(TMP, \u0022\u003e $TEMPFILE\u0022) or print \u0022not ok $n\u005cn\u0022 \u0026\u0026 \u0026abort(\u0022Couldn\u005c't write tempfile $TEMPFILE: $!\u0022);\n+print TMP $template_1;\n+close TMP;\n+print \u0022ok $n\u005cn\u0022; $n++;\n+\n+# (2) Build template from file\n+$template \u003d new Text::Template ('type' \u003d\u003e 'FILE', 'source' \u003d\u003e $TEMPFILE);\n+if (defined($template)) {\n+ print \u0022ok $n\u005cn\u0022;\n+} else {\n+ print \u0022not ok $n $Text::Template::ERROR\u005cn\u0022;\n+}\n+$n++;\n+\n+# (3) Fill in template from file\n+$X::v \u003d \u0022abc\u0022;\t\n+$resultX \u003d \u003c\u003cEOM;\n+We will put value of \u005c$v (which is \u0022abc\u0022) here -\u003e abc\n+We will evaluate 1+1 here -\u003e 2\n+EOM\n+$Y::v \u003d \u0022ABC\u0022;\t\n+$resultY \u003d \u003c\u003cEOM;\n+We will put value of \u005c$v (which is \u0022abc\u0022) here -\u003e ABC\n+We will evaluate 1+1 here -\u003e 2\n+EOM\n+\n+$text \u003d $template-\u003efill_in('package' \u003d\u003e X);\n+if ($text eq $resultX) {\n+ print \u0022ok $n\u005cn\u0022;\n+} else {\n+ print \u0022not ok $n\u005cn\u0022;\n+}\n+$n++;\n+\n+# (4) Fill in same template again\n+$text \u003d $template-\u003efill_in('package' \u003d\u003e Y);\n+if ($text eq $resultY) {\n+ print \u0022ok $n\u005cn\u0022;\n+} else {\n+ print \u0022not ok $n\u005cn\u0022;\n+}\n+$n++;\n+\n+\n+\n+# (5) Simple test of `fill_this_in'\n+$text \u003d Text::Template-\u003efill_this_in( $template_1, 'package' \u003d\u003e X);\n+if ($text eq $resultX) {\n+ print \u0022ok $n\u005cn\u0022;\n+} else {\n+ print \u0022not ok $n\u005cn\u0022;\n+}\n+$n++;\n+\n+# (6) test creation of template from filehandle\n+if (open (TMPL, \u0022\u003c $TEMPFILE\u0022)) {\n+ $template \u003d new Text::Template ('type' \u003d\u003e 'FILEHANDLE', \n+\t\t\t\t 'source' \u003d\u003e *TMPL);\n+ if (defined($template)) {\n+ print \u0022ok $n\u005cn\u0022;\n+ } else {\n+ print \u0022not ok $n $Text::Template::ERROR\u005cn\u0022;\n+ }\n+ $n++;\n+\n+# (7) test filling in of template from filehandle\n+ $text \u003d $template-\u003efill_in('package' \u003d\u003e X);\n+ if ($text eq $resultX) {\n+ print \u0022ok $n\u005cn\u0022;\n+ } else {\n+ print \u0022not ok $n\u005cn\u0022;\n+ }\n+ $n++;\n+\n+# (8) test second fill_in on same template object\n+ $text \u003d $template-\u003efill_in('package' \u003d\u003e Y);\n+ if ($text eq $resultY) {\n+ print \u0022ok $n\u005cn\u0022;\n+ } else {\n+ print \u0022not ok $n\u005cn\u0022;\n+ }\n+ $n++;\n+ close TMPL;\n+} else {\n+ print \u0022not ok $n\u005cn\u0022; $n++;\n+ print \u0022not ok $n\u005cn\u0022; $n++;\n+ print \u0022not ok $n\u005cn\u0022; $n++;\n+}\n+\n+\n+# (9) test creation of template from array\n+$template \u003d new Text::Template \n+ ('type' \u003d\u003e 'ARRAY', \n+ 'source' \u003d\u003e [ \n+\t\t 'We will put value of $v (which is \u0022abc\u0022) here -\u003e {$v}',\n+\t\t \u0022\u005cn\u0022,\n+\t\t 'We will evaluate 1+1 here -\u003e {1+1}',\n+\t\t \u0022\u005cn\u0022,\n+\t\t ]);\n+if (defined($template)) {\n+ print \u0022ok $n\u005cn\u0022;\n+} else {\n+ print \u0022not ok $n $Text::Template::ERROR\u005cn\u0022;\n+}\n+$n++;\n+\n+# (10) test filling in of template from array\n+$text \u003d $template-\u003efill_in('package' \u003d\u003e X);\n+if ($text eq $resultX) {\n+ print \u0022ok $n\u005cn\u0022;\n+} else {\n+ print \u0022not ok $n\u005cn\u0022;\n+}\n+$n++;\n+\n+# (11) test second fill_in on same array template object\n+$text \u003d $template-\u003efill_in('package' \u003d\u003e Y);\n+if ($text eq $resultY) {\n+ print \u0022ok $n\u005cn\u0022;\n+} else {\n+ print \u0022not ok $n\u005cn\u0022;\n+ print STDERR \u0022$resultX\u005cn---\u005cn$text\u0022;\n+ unless (!defined($text)) { print STDERR \u0022ERROR: $Text::Template::ERROR\u005cn\u0022};\n+}\n+$n++;\n+\n+\n+\n+# (12) Make sure \u005c is working properly\n+# Test added for version 1.11\n+my $tmpl \u003d Text::Template-\u003enew(TYPE \u003d\u003e 'STRING',\n+\t\t\t SOURCE \u003d\u003e 'B{\u0022\u005c\u005c}\u0022}C{\u0022\u005c\u005c{\u0022}D',\n+\t\t\t );\n+# This should fail if the \u005c are not interpreted properly.\n+my $text \u003d $tmpl-\u003efill_in();\n+print +($text eq \u0022B}C{D\u0022 ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (13) Make sure \u005c is working properly\n+# Test added for version 1.11\n+$tmpl \u003d Text::Template-\u003enew(TYPE \u003d\u003e 'STRING',\n+\t\t\t SOURCE \u003d\u003e qq{A{\u0022\u005ct\u0022}B},\n+\t\t\t );\n+# Symptom of old problem: ALL \u005c were special in templates, so\n+# The lexer would return (A, PROGTEXT(\u0022t\u0022), B), and the\n+# result text would be AtB instead of A(tab)B.\n+$text \u003d $tmpl-\u003efill_in();\n+\n+print +($text eq \u0022A\u005ctB\u0022 ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (14-27) Make sure \u005c is working properly\n+# Test added for version 1.11\n+# This is a sort of general test.\n+my @tests \u003d ('{\u0022\u0022}' \u003d\u003e '',\t# (14)\n+\t '{\u0022}\u0022}' \u003d\u003e undef, # (15)\n+\t '{\u0022\u005c\u005c}\u0022}' \u003d\u003e '}',\t# One backslash\n+\t '{\u0022\u005c\u005c\u005c\u005c}\u0022}' \u003d\u003e undef, # Two backslashes\n+\t '{\u0022\u005c\u005c\u005c\u005c\u005c\u005c}\u0022}' \u003d\u003e '}', # Three backslashes\n+\t '{\u0022\u005c\u005c\u005c\u005c\u005c\u005c\u005c\u005c}\u0022}' \u003d\u003e undef, # Four backslashes\n+\t '{\u0022\u005c\u005c\u005c\u005c\u005c\u005c\u005c\u005c\u005c\u005c}\u0022}' \u003d\u003e '\u005c}', # Five backslashes (20)\n+\t '{\u0022x20\u0022}' \u003d\u003e 'x20',\n+\t '{\u0022\u005c\u005cx20\u0022}' \u003d\u003e ' ',\t# One backslash\n+\t '{\u0022\u005c\u005c\u005c\u005cx20\u0022}' \u003d\u003e '\u005c\u005cx20', # Two backslashes\n+\t '{\u0022\u005c\u005c\u005c\u005c\u005c\u005cx20\u0022}' \u003d\u003e '\u005c\u005c ', # Three backslashes\n+\t '{\u0022\u005c\u005c\u005c\u005c\u005c\u005c\u005c\u005cx20\u0022}' \u003d\u003e '\u005c\u005c\u005c\u005cx20', # Four backslashes (25)\n+\t '{\u0022\u005c\u005c\u005c\u005c\u005c\u005c\u005c\u005c\u005c\u005cx20\u0022}' \u003d\u003e '\u005c\u005c\u005c\u005c ', # Five backslashes\n+\t '{\u0022\u005c\u005cx20\u005c\u005c}\u0022}' \u003d\u003e ' }', # (27)\n+\t );\n+\n+my $i;\n+for ($i\u003d0; $i\u003c@tests; $i+\u003d2) {\n+ my $tmpl \u003d Text::Template-\u003enew(TYPE \u003d\u003e 'STRING',\n+\t\t\t\t SOURCE \u003d\u003e $tests[$i],\n+\t\t\t\t);\n+ my $text \u003d $tmpl-\u003efill_in;\n+ my $result \u003d $tests[$i+1];\n+ my $ok \u003d (! defined $text \u0026\u0026 ! defined $result\n+\t || $text eq $result);\n+ unless ($ok) {\n+ print STDERR \u0022($n) expected .$result., got .$text.\u005cn\u0022;\n+ }\n+ print +($ok ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+ $n++;\n+}\n+\n+\n+# (28-30) I discovered that you can't pass a glob ref as your filehandle.\n+# MJD 20010827\n+# (28) test creation of template from filehandle\n+if (open (TMPL, \u0022\u003c $TEMPFILE\u0022)) {\n+ $template \u003d new Text::Template ('type' \u003d\u003e 'FILEHANDLE', \n+\t\t\t\t 'source' \u003d\u003e \u005c*TMPL);\n+ if (defined($template)) {\n+ print \u0022ok $n\u005cn\u0022;\n+ } else {\n+ print \u0022not ok $n $Text::Template::ERROR\u005cn\u0022;\n+ }\n+ $n++;\n+\n+# (29) test filling in of template from filehandle\n+ $text \u003d $template-\u003efill_in('package' \u003d\u003e X);\n+ if ($text eq $resultX) {\n+ print \u0022ok $n\u005cn\u0022;\n+ } else {\n+ print \u0022not ok $n\u005cn\u0022;\n+ }\n+ $n++;\n+\n+# (30) test second fill_in on same template object\n+ $text \u003d $template-\u003efill_in('package' \u003d\u003e Y);\n+ if ($text eq $resultY) {\n+ print \u0022ok $n\u005cn\u0022;\n+ } else {\n+ print \u0022not ok $n\u005cn\u0022;\n+ }\n+ $n++;\n+ close TMPL;\n+} else {\n+ print \u0022not ok $n\u005cn\u0022; $n++;\n+ print \u0022not ok $n\u005cn\u0022; $n++;\n+ print \u0022not ok $n\u005cn\u0022; $n++;\n+}\n+\n+# (31) Test _scrubpkg for leakiness\n+$Text::Template::GEN0::test \u003d 1;\n+Text::Template::_scrubpkg('Text::Template::GEN0');\n+if ($Text::Template::GEN0::test) {\n+ print \u0022not ok $n\u005cn\u0022;\n+} else {\n+ print \u0022ok $n\u005cn\u0022;\n+}\n+$n++;\n+\n+\n+END {unlink $TEMPFILE;}\n+\n+exit;\n+\n+\n+\n+\n+sub abort {\n+ unlink $TEMPFILE;\n+ die $_[0];\n+}\ndiff --git a/external/perl/Text-Template-1.46/t/02-hash.t b/external/perl/Text-Template-1.46/t/02-hash.t\nnew file mode 100644\nindex 0000000..29ba51a\n--- /dev/null\n+++ b/external/perl/Text-Template-1.46/t/02-hash.t\n@@ -0,0 +1,111 @@\n+#!perl\n+#\n+# test apparatus for Text::Template module\n+# still incomplete.\n+\n+use Text::Template;\n+\n+die \u0022This is the test program for Text::Template version 1.46.\n+You are using version $Text::Template::VERSION instead.\n+That does not make sense.\u005cn\n+Aborting\u0022\n+ unless $Text::Template::VERSION \u003d\u003d 1.46;\n+\n+\n+print \u00221..12\u005cn\u0022;\n+\n+$n\u003d1;\n+\n+$template \u003d 'We will put value of $v (which is \u0022good\u0022) here -\u003e {$v}';\n+\n+$v \u003d 'oops (main)';\n+$Q::v \u003d 'oops (Q)';\n+\n+$vars \u003d { 'v' \u003d\u003e \u005c'good' };\n+\n+# (1) Build template from string\n+$template \u003d new Text::Template ('type' \u003d\u003e 'STRING', 'source' \u003d\u003e $template);\n+print +($template ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (2) Fill in template in anonymous package\n+$result2 \u003d 'We will put value of $v (which is \u0022good\u0022) here -\u003e good';\n+$text \u003d $template-\u003efill_in(HASH \u003d\u003e $vars);\n+print +($text eq $result2 ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (3) Did we clobber the main variable?\n+print +($v eq 'oops (main)' ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (4) Fill in same template again\n+$result4 \u003d 'We will put value of $v (which is \u0022good\u0022) here -\u003e good';\n+$text \u003d $template-\u003efill_in(HASH \u003d\u003e $vars);\n+print +($text eq $result4 ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (5) Now with a package\n+$result5 \u003d 'We will put value of $v (which is \u0022good\u0022) here -\u003e good';\n+$text \u003d $template-\u003efill_in(HASH \u003d\u003e $vars, PACKAGE \u003d\u003e 'Q');\n+print +($text eq $result5 ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (6) We expect to have clobbered the Q variable.\n+print +($Q::v eq 'good' ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (7) Now let's try it without a package\n+$result7 \u003d 'We will put value of $v (which is \u0022good\u0022) here -\u003e good';\n+$text \u003d $template-\u003efill_in(HASH \u003d\u003e $vars);\n+print +($text eq $result7 ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (8-11) Now what does it do when we pass a hash with undefined values?\n+# Roy says it does something bad. (Added for 1.20.)\n+my $WARNINGS \u003d 0;\n+{\n+ local $SIG{__WARN__} \u003d sub {$WARNINGS++};\n+ local $^W \u003d 1; # Make sure this is on for this test\n+ $template8 \u003d 'We will put value of $v (which is \u0022good\u0022) here -\u003e {defined $v ? \u0022bad\u0022 : \u0022good\u0022}';\n+ $result8 \u003d 'We will put value of $v (which is \u0022good\u0022) here -\u003e good';\n+ my $template \u003d \n+ new Text::Template ('type' \u003d\u003e 'STRING', 'source' \u003d\u003e $template8);\n+ my $text \u003d $template-\u003efill_in(HASH \u003d\u003e {'v' \u003d\u003e undef});\n+ # (8) Did we generate a warning?\n+ print +($WARNINGS \u003d\u003d 0 ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+ $n++;\n+ \n+ # (9) Was the output correct?\n+ print +($text eq $result8 ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+ $n++;\n+\n+ # (10-11) Let's try that again, with a twist this time\n+ $WARNINGS \u003d 0;\n+ $text \u003d $template-\u003efill_in(HASH \u003d\u003e [{'v' \u003d\u003e 17}, {'v' \u003d\u003e undef}]);\n+ # (10) Did we generate a warning?\n+ print +($WARNINGS \u003d\u003d 0 ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+ $n++;\n+ \n+ # (11) Was the output correct?\n+ if ($] \u003c 5.005) {\n+ print \u0022ok $n # skipped -- not supported before 5.005\u005cn\u0022;\n+ } else {\n+ print +($text eq $result8 ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+ }\n+ $n++;\n+}\n+\n+\n+# (12) Now we'll test the multiple-hash option (Added for 1.20.)\n+$text \u003d Text::Template::fill_in_string(q{$v: {$v}. @v: [{\u0022@v\u0022}].},\n+\t\t\t\t HASH \u003d\u003e [{'v' \u003d\u003e 17}, \n+\t\t\t\t\t\t{'v' \u003d\u003e ['a', 'b', 'c']},\n+\t\t\t\t\t\t{'v' \u003d\u003e \u005c23},\n+\t\t\t\t\t ]);\n+$result \u003d q{$v: 23. @v: [a b c].};\n+print +($text eq $result ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+\n+exit;\n+\ndiff --git a/external/perl/Text-Template-1.46/t/03-out.t b/external/perl/Text-Template-1.46/t/03-out.t\nnew file mode 100644\nindex 0000000..0ba65a5\n--- /dev/null\n+++ b/external/perl/Text-Template-1.46/t/03-out.t\n@@ -0,0 +1,56 @@\n+#!perl\n+#\n+# test apparatus for Text::Template module\n+# still incomplete.\n+#\n+\n+use Text::Template;\n+\n+die \u0022This is the test program for Text::Template version 1.46\n+You are using version $Text::Template::VERSION instead.\n+That does not make sense.\u005cn\n+Aborting\u0022\n+ unless $Text::Template::VERSION \u003d\u003d 1.46;\n+\n+print \u00221..1\u005cn\u0022;\n+\n+$n\u003d1;\n+\n+$template \u003d q{\n+This line should have a 3: {1+2}\n+\n+This line should have several numbers:\n+{ $t \u003d ''; foreach $n (1 .. 20) { $t .\u003d $n . ' ' } $t }\n+};\n+\n+$templateOUT \u003d q{\n+This line should have a 3: { $OUT \u003d 1+2 }\n+\n+This line should have several numbers:\n+{ foreach $n (1 .. 20) { $OUT .\u003d $n . ' ' } }\n+};\n+\n+# Build templates from string\n+$template \u003d new Text::Template ('type' \u003d\u003e 'STRING', 'source' \u003d\u003e $template)\n+ or die;\n+$templateOUT \u003d new Text::Template ('type' \u003d\u003e 'STRING', 'source' \u003d\u003e $templateOUT)\n+ or die;\n+\n+# Fill in templates\n+$text \u003d $template-\u003efill_in()\n+ or die;\n+$textOUT \u003d $templateOUT-\u003efill_in()\n+ or die;\n+\n+# (1) They should be the same\n+print +($text eq $textOUT ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# Missing: Test this feature in Safe compartments; \n+# it's a totally different code path.\n+# Decision: Put that into safe.t, because that file should\n+# be skipped when Safe.pm is unavailable.\n+\n+\n+exit;\n+\ndiff --git a/external/perl/Text-Template-1.46/t/04-safe.t b/external/perl/Text-Template-1.46/t/04-safe.t\nnew file mode 100644\nindex 0000000..4c07121\n--- /dev/null\n+++ b/external/perl/Text-Template-1.46/t/04-safe.t\n@@ -0,0 +1,161 @@\n+#!perl\n+#\n+# test apparatus for Text::Template module\n+# still incomplete.\n+\n+use Text::Template;\n+\n+BEGIN {\n+ eval \u0022use Safe\u0022;\n+ if ($@) {\n+ print \u00221..0\u005cn\u0022;\n+ exit 0;\n+ }\n+}\n+\n+die \u0022This is the test program for Text::Template version 1.46.\n+You are using version $Text::Template::VERSION instead.\n+That does not make sense.\u005cn\n+Aborting\u0022\n+ unless $Text::Template::VERSION \u003d\u003d 1.46;\n+\n+print \u00221..16\u005cn\u0022;\n+\n+if ($^O eq 'MacOS') {\n+ $BADOP \u003d qq{};\n+ $FAILURE \u003d q{};\n+} else {\n+ $BADOP \u003d qq{kill 0};\n+ $FAILURE \u003d q{Program fragment at line 1 delivered error ``kill trapped by operation mask''};\n+}\n+\n+$n\u003d1;\n+$v \u003d $v \u003d 119;\n+\n+$c \u003d new Safe or die;\n+\n+$goodtemplate \u003d q{This should succeed: { $v }};\n+$goodoutput \u003d q{This should succeed: 119};\n+\n+$template1 \u003d new Text::Template ('type' \u003d\u003e 'STRING', 'source' \u003d\u003e $goodtemplate)\n+ or die;\n+$template2 \u003d new Text::Template ('type' \u003d\u003e 'STRING', 'source' \u003d\u003e $goodtemplate)\n+ or die;\n+\n+$text1 \u003d $template1-\u003efill_in();\n+$text2 \u003d $template1-\u003efill_in(SAFE \u003d\u003e $c);\n+$ERR2 \u003d $@;\n+$text3 \u003d $template2-\u003efill_in(SAFE \u003d\u003e $c);\n+$ERR3 \u003d $@;\n+\n+# (1)(2)(3) None of these should have failed.\n+print +(defined $text1 ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+print +(defined $text2 ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+print +(defined $text3 ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (4) Safe and non-safe fills of different template objects with the\n+# same template text should yield the same result.\n+# print +($text1 eq $text3 ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+# (4) voided this test: it's not true, because the unsafe fill\n+# uses package main, while the safe fill uses the secret safe package.\n+# We could alias the secret safe package to be identical to main,\n+# but that wouldn't be safe. If you want the aliasing, you have to\n+# request it explicitly with `PACKAGE'.\n+print \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (5) Safe and non-safe fills of the same template object\n+# should yield the same result.\n+# (5) voided this test for the same reason as #4.\n+# print +($text1 eq $text2 ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+print \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (6) Make sure the output was actually correct\n+print +($text1 eq $goodoutput ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+\n+$badtemplate \u003d qq{This should fail: { $BADOP; 'NOFAIL' }};\n+$badnosafeoutput \u003d q{This should fail: NOFAIL};\n+$badsafeoutput \u003d q{This should fail: Program fragment delivered error ``kill trapped by operation mask at template line 1.''};\n+\n+$template1 \u003d new Text::Template ('type' \u003d\u003e 'STRING', 'source' \u003d\u003e $badtemplate)\n+ or die;\n+$template2 \u003d new Text::Template ('type' \u003d\u003e 'STRING', 'source' \u003d\u003e $badtemplate)\n+ or die;\n+\n+$text1 \u003d $template1-\u003efill_in();\n+$text2 \u003d $template1-\u003efill_in(SAFE \u003d\u003e $c);\n+$ERR2 \u003d $@;\n+$text3 \u003d $template2-\u003efill_in(SAFE \u003d\u003e $c);\n+$ERR3 \u003d $@;\n+$text4 \u003d $template1-\u003efill_in();\n+\n+# (7)(8)(9)(10) None of these should have failed.\n+print +(defined $text1 ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+print +(defined $text2 ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+print +(defined $text3 ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+print +(defined $text4 ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (11) text1 and text4 should be the same (using safe in between\n+# didn't change anything.)\n+print +($text1 eq $text4 ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (12) text2 and text3 should be the same (same template text in different\n+# objects\n+print +($text2 eq $text3 ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (13) text1 should yield badnosafeoutput\n+print +($text1 eq $badnosafeoutput ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (14) text2 should yield badsafeoutput\n+$text2 \u003d~ s/'kill'/kill/; # 5.8.1 added quote marks around the op name\n+print \u0022# expected: \u003c$badsafeoutput\u003e\u005cn# got : \u003c$text2\u003e\u005cn\u0022;\n+print +($text2 eq $badsafeoutput ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+\n+$template \u003d q{{$x\u003d1}{$x+1}};\n+\n+$template1 \u003d new Text::Template ('type' \u003d\u003e 'STRING', 'source' \u003d\u003e $template)\n+ or die;\n+$template2 \u003d new Text::Template ('type' \u003d\u003e 'STRING', 'source' \u003d\u003e $template)\n+ or die;\n+\n+$text1 \u003d $template1-\u003efill_in();\n+$text2 \u003d $template1-\u003efill_in(SAFE \u003d\u003e new Safe);\n+\n+# (15) Do effects persist in safe compartments?\n+print +($text1 eq $text2 ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (16) Try the BROKEN routine in safe compartments\n+sub my_broken { \n+ my %a \u003d @_; $a{error} \u003d~ s/ at.*//s;\n+ \u0022OK! text:$a{text} error:$a{error} lineno:$a{lineno} arg:$a{arg}\u0022 ;\n+}\n+$templateB \u003d new Text::Template (TYPE \u003d\u003e 'STRING', SOURCE \u003d\u003e '{die}')\n+ or die;\n+$text1 \u003d $templateB-\u003efill_in(BROKEN \u003d\u003e \u005c\u0026my_broken, \n+\t\t\t BROKEN_ARG \u003d\u003e 'barg',\n+\t\t\t SAFE \u003d\u003e new Safe,\n+\t\t\t );\n+$result1 \u003d qq{OK! text:die error:Died lineno:1 arg:barg};\n+print +($text1 eq $result1 ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+\n+\n+exit;\n+\ndiff --git a/external/perl/Text-Template-1.46/t/05-safe2.t b/external/perl/Text-Template-1.46/t/05-safe2.t\nnew file mode 100644\nindex 0000000..0353477\n--- /dev/null\n+++ b/external/perl/Text-Template-1.46/t/05-safe2.t\n@@ -0,0 +1,105 @@\n+#!perl\n+#\n+# test apparatus for Text::Template module\n+# still incomplete.\n+\n+use Text::Template;\n+\n+BEGIN {\n+ eval \u0022use Safe\u0022;\n+ if ($@) {\n+ print \u00221..0\u005cn\u0022;\n+ exit 0;\n+ }\n+}\n+\n+die \u0022This is the test program for Text::Template version 1.46.\n+You are using version $Text::Template::VERSION instead.\n+That does not make sense.\u005cn\n+Aborting\u0022\n+ unless $Text::Template::VERSION \u003d\u003d 1.46;\n+\n+print \u00221..12\u005cn\u0022;\n+$n \u003d 1;\n+\n+$c \u003d new Safe or die;\n+\n+# Test handling of packages and importing.\n+$c-\u003ereval('$P \u003d \u0022safe root\u0022');\n+$P \u003d $P \u003d 'main';\n+$Q::P \u003d $Q::P \u003d 'Q';\n+\n+# How to effectively test the gensymming?\n+\n+$t \u003d new Text::Template TYPE \u003d\u003e 'STRING', SOURCE \u003d\u003e 'package is {$P}'\n+ or die;\n+\n+# (1) Default behavior: Inherit from calling package, `main' in this case.\n+$text \u003d $t-\u003efill_in();\n+print +($text eq 'package is main' ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (2) When a package is specified, we should use that package instead.\n+$text \u003d $t-\u003efill_in(PACKAGE \u003d\u003e 'Q');\n+print +($text eq 'package is Q' ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (3) When no package is specified in safe mode, we should use the\n+# default safe root.\n+$text \u003d $t-\u003efill_in(SAFE \u003d\u003e $c);\n+print +($text eq 'package is safe root' ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (4) When a package is specified in safe mode, we should use the\n+# default safe root, after aliasing to the specified package\n+$text \u003d $t-\u003efill_in(SAFE \u003d\u003e $c, PACKAGE \u003d\u003e Q);\n+print +($text eq 'package is Q' ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# Now let's see if hash vars are installed properly into safe templates\n+$t \u003d new Text::Template TYPE \u003d\u003e 'STRING', SOURCE \u003d\u003e 'hash is {$H}'\n+ or die;\n+\n+# (5) First in default mode\n+$text \u003d $t-\u003efill_in(HASH \u003d\u003e {H \u003d\u003e 'good5'} );\n+print +($text eq 'hash is good5' ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (6) Now in packages\n+$text \u003d $t-\u003efill_in(HASH \u003d\u003e {H \u003d\u003e 'good6'}, PACKAGE \u003d\u003e 'Q' );\n+print +($text eq 'hash is good6' ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (7) Now in the default root of the safe compartment\n+$text \u003d $t-\u003efill_in(HASH \u003d\u003e {H \u003d\u003e 'good7'}, SAFE \u003d\u003e $c );\n+print +($text eq 'hash is good7' ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (8) Now in the default root after aliasing to a package that\n+# got the hash stuffed in\n+$text \u003d $t-\u003efill_in(HASH \u003d\u003e {H \u003d\u003e 'good8'}, SAFE \u003d\u003e $c, PACKAGE \u003d\u003e 'Q2' );\n+print +($text eq 'hash is good8' ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# Now let's make sure that none of the packages leaked on each other.\n+# (9) This var should NOT have been installed into the main package\n+print +(defined $H ? 'not ' : ''), \u0022ok $n\u005cn\u0022;\n+$H\u003d$H;\n+$n++;\n+\n+# (10) good6 was overwritten in test 7, so there's nothing to test for here.\n+print \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (11) this value overwrote the one from test 6.\n+print +($Q::H eq 'good7' ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$Q::H \u003d $Q::H;\n+$n++;\n+\n+# (12) \n+print +($Q2::H eq 'good8' ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$Q2::H \u003d $Q2::H;\n+$n++;\n+\n+\n+\ndiff --git a/external/perl/Text-Template-1.46/t/06-ofh.t b/external/perl/Text-Template-1.46/t/06-ofh.t\nnew file mode 100644\nindex 0000000..6865ad1\n--- /dev/null\n+++ b/external/perl/Text-Template-1.46/t/06-ofh.t\n@@ -0,0 +1,39 @@\n+#!perl\n+#\n+# test apparatus for Text::Template module\n+# still incomplete.\n+\n+use Text::Template;\n+\n+die \u0022This is the test program for Text::Template version 1.46.\n+You are using version $Text::Template::VERSION instead.\n+That does not make sense.\u005cn\n+Aborting\u0022\n+ unless $Text::Template::VERSION \u003d\u003d 1.46;\n+\n+print \u00221..2\u005cn\u0022;\n+\n+$n\u003d1;\n+\n+$template \u003d new Text::Template TYPE \u003d\u003e STRING, SOURCE \u003d\u003e q{My process ID is {$$}};\n+$of \u003d \u0022t$$\u0022;\n+END { unlink $of }\n+open O, \u0022\u003e $of\u0022 or die;\n+\n+$text \u003d $template-\u003efill_in(OUTPUT \u003d\u003e \u005c*O);\n+\n+# (1) No $text should have been constructed. Return value should be true.\n+print +($text eq '1' ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+close O or die;\n+open I, \u0022\u003c $of\u0022 or die;\n+{ local $/; $t \u003d \u003cI\u003e }\n+close I;\n+\n+# (2) The text should have been printed to the file\n+print +($t eq \u0022My process ID is $$\u0022 ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+exit;\n+\ndiff --git a/external/perl/Text-Template-1.46/t/07-safe3.t b/external/perl/Text-Template-1.46/t/07-safe3.t\nnew file mode 100644\nindex 0000000..5f438f6\n--- /dev/null\n+++ b/external/perl/Text-Template-1.46/t/07-safe3.t\n@@ -0,0 +1,91 @@\n+#!perl\n+#\n+# test apparatus for Text::Template module\n+\n+use Text::Template;\n+\n+BEGIN {\n+ eval \u0022use Safe\u0022;\n+ if ($@) {\n+ print \u00221..0\u005cn\u0022;\n+ exit 0;\n+ }\n+}\n+\n+die \u0022This is the test program for Text::Template version 1.46.\n+You are using version $Text::Template::VERSION instead.\n+That does not make sense.\u005cn\n+Aborting\u0022\n+ unless $Text::Template::VERSION \u003d\u003d 1.46;\n+\n+print \u00221..3\u005cn\u0022;\n+\n+$n\u003d1;\n+\n+# Test the OUT feature with safe compartments\n+\n+$template \u003d q{\n+This line should have a 3: {1+2}\n+\n+This line should have several numbers:\n+{ $t \u003d ''; foreach $n (1 .. 20) { $t .\u003d $n . ' ' } $t }\n+};\n+\n+$templateOUT \u003d q{\n+This line should have a 3: { $OUT \u003d 1+2 }\n+\n+This line should have several numbers:\n+{ foreach $n (1 .. 20) { $OUT .\u003d $n . ' ' } }\n+};\n+\n+$c \u003d new Safe;\n+\n+# Build templates from string\n+$template \u003d new Text::Template ('type' \u003d\u003e 'STRING', 'source' \u003d\u003e $template,\n+\t\t\t SAFE \u003d\u003e $c)\n+ or die;\n+$templateOUT \u003d new Text::Template ('type' \u003d\u003e 'STRING', 'source' \u003d\u003e $templateOUT,\n+\t\t\t\t SAFE \u003d\u003e $c)\n+ or die;\n+\n+# Fill in templates\n+$text \u003d $template-\u003efill_in()\n+ or die;\n+$textOUT \u003d $templateOUT-\u003efill_in()\n+ or die;\n+\n+# (1) They should be the same\n+print +($text eq $textOUT ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (2-3) \u0022Joel Appelbaum\u0022 \u003cjoel@orbz.com\u003e \u003c000701c0ac2c$aed1d6e0$0201a8c0@prime\u003e\n+# \u0022Contrary to the documentation the $OUT variable is not always\n+# undefined at the start of each program fragment. The $OUT variable\n+# is never undefined after it is used once if you are using the SAFE\n+# option. The result is that every fragment after the fragment that\n+# $OUT was used in is replaced by the old $OUT value instead of the\n+# result of the fragment. This holds true even after the\n+# Text::Template object goes out of scope and a new one is created!\u0022\n+#\n+# Also reported by Daini Xie.\n+\n+{\n+ my $template \u003d q{{$OUT \u003d 'x'}y{$OUT .\u003d 'z'}};\n+ my $expected \u003d \u0022xyz\u0022;\n+ my $s \u003d Safe-\u003enew;\n+ my $o \u003d Text::Template-\u003enew(type \u003d\u003e 'string',\n+ source \u003d\u003e $template,\n+ );\n+ for (1..2) {\n+ my $r \u003d $o-\u003efill_in(SAFE \u003d\u003e $s);\n+ if ($r ne $expected) {\n+ print \u0022not ok $n # \u003c$r\u003e\u005cn\u0022;\n+ } else {\n+ print \u0022ok $n\u005cn\u0022;\n+ }\n+ $n++;\n+ }\n+}\n+\n+exit;\n+\ndiff --git a/external/perl/Text-Template-1.46/t/08-exported.t b/external/perl/Text-Template-1.46/t/08-exported.t\nnew file mode 100644\nindex 0000000..ef9cfaf\n--- /dev/null\n+++ b/external/perl/Text-Template-1.46/t/08-exported.t\n@@ -0,0 +1,75 @@\n+#!perl\n+#\n+# test apparatus for Text::Template module\n+# still incomplete.\n+\n+use Text::Template 'fill_in_file', 'fill_in_string';\n+\n+die \u0022This is the test program for Text::Template version 1.46.\n+You are using version $Text::Template::VERSION instead.\n+That does not make sense.\u005cn\n+Aborting\u0022\n+ unless $Text::Template::VERSION \u003d\u003d 1.46;\n+\n+print \u00221..6\u005cn\u0022;\n+\n+$n\u003d1;\n+$Q::n \u003d $Q::n \u003d 119; \n+\n+# (1) Test fill_in_string\n+$out \u003d fill_in_string('The value of $n is {$n}.', PACKAGE \u003d\u003e 'Q' );\n+print +($out eq 'The value of $n is 119.' ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (2) Test fill_in_file\n+$TEMPFILE \u003d \u0022tt$$\u0022;\n+open F, \u0022\u003e $TEMPFILE\u0022 or die \u0022Couldn't open test file: $!; aborting\u0022;\n+print F 'The value of $n is {$n}.', \u0022\u005cn\u0022;\n+close F or die \u0022Couldn't write test file: $!; aborting\u0022;\n+$R::n \u003d $R::n \u003d 8128; \n+\n+$out \u003d fill_in_file($TEMPFILE, PACKAGE \u003d\u003e 'R');\n+print +($out eq \u0022The value of \u005c$n is 8128.\u005cn\u0022 ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (3) Jonathan Roy reported this bug:\n+open F, \u0022\u003e $TEMPFILE\u0022 or die \u0022Couldn't open test file: $!; aborting\u0022;\n+print F \u0022With a message here? [% \u005c$var %]\u005cn\u0022;\n+close F or die \u0022Couldn't close test file: $!; aborting\u0022;\n+$out \u003d fill_in_file($TEMPFILE, DELIMITERS \u003d\u003e ['[%', '%]'],\n+\t\t HASH \u003d\u003e { \u0022var\u0022 \u003d\u003e \u005c\u0022It is good!\u0022 });\n+print +($out eq \u0022With a message here? It is good!\u005cn\u0022 ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (4) It probably occurs in fill_this_in also:\n+$out \u003d \n+ Text::Template-\u003efill_this_in(\u0022With a message here? [% \u005c$var %]\u005cn\u0022,\n+ DELIMITERS \u003d\u003e ['[%', '%]'],\n+ HASH \u003d\u003e { \u0022var\u0022 \u003d\u003e \u005c\u0022It is good!\u0022 });\n+print +($out eq \u0022With a message here? It is good!\u005cn\u0022 ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (5) This test failed in 1.25. It was supplied by Donald L. Greer Jr.\n+# Note that it's different from (1) in that there's no explicit \n+# package\u003d\u003e argument.\n+use vars qw($string $foo $r);\n+$string\u003d'Hello {$foo}';\n+$foo\u003d\u0022Don\u0022;\n+$r \u003d fill_in_string($string);\n+print (($r eq 'Hello Don' ? '' : 'not '), 'ok ', $n++, \u0022\u005cn\u0022);\n+\n+# (6) This test failed in 1.25. It's a variation on (5)\n+package Q2;\n+use Text::Template 'fill_in_string';\n+use vars qw($string $foo $r);\n+$string\u003d'Hello {$foo}';\n+$foo\u003d\u0022Don\u0022;\n+$r \u003d fill_in_string($string);\n+print (($r eq 'Hello Don' ? '' : 'not '), 'ok ', $main::n++, \u0022\u005cn\u0022);\n+\n+package main;\n+\n+END { $TEMPFILE \u0026\u0026 unlink $TEMPFILE }\n+\n+exit;\n+\ndiff --git a/external/perl/Text-Template-1.46/t/09-error.t b/external/perl/Text-Template-1.46/t/09-error.t\nnew file mode 100644\nindex 0000000..40f9fac\n--- /dev/null\n+++ b/external/perl/Text-Template-1.46/t/09-error.t\n@@ -0,0 +1,63 @@\n+#!perl\n+#\n+# test apparatus for Text::Template module\n+# still incomplete.\n+\n+use Text::Template;\n+\n+die \u0022This is the test program for Text::Template version 1.46.\n+You are using version $Text::Template::VERSION instead.\n+That does not make sense.\u005cn\n+Aborting\u0022\n+ unless $Text::Template::VERSION \u003d\u003d 1.46;\n+\n+print \u00221..5\u005cn\u0022;\n+$n \u003d 1;\n+\n+# (1-2) Missing source\n+eval {\n+ Text::Template-\u003enew();\n+};\n+unless ($@ \u003d~ /^\u005cQUsage: Text::Template::new(TYPE \u003d\u003e ..., SOURCE \u003d\u003e ...)/) {\n+ print STDERR $@;\n+ print \u0022not \u0022;\n+}\n+print \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+eval {\n+ Text::Template-\u003enew(TYPE \u003d\u003e 'FILE');\n+};\n+if ($@ \u003d~ /^\u005cQUsage: Text::Template::new(TYPE \u003d\u003e ..., SOURCE \u003d\u003e ...)/) {\n+ print \u0022ok $n\u005cn\u0022;\n+} else {\n+ print STDERR $@;\n+ print \u0022not ok $n\u005cn\u0022;\n+}\n+$n++;\n+\n+# (3) Invalid type\n+eval {\n+ Text::Template-\u003enew(TYPE \u003d\u003e 'wlunch', SOURCE \u003d\u003e 'fish food');\n+};\n+if ($@ \u003d~ /^\u005cQIllegal value `WLUNCH' for TYPE parameter/) {\n+ print \u0022ok $n\u005cn\u0022;\n+} else {\n+ print STDERR $@;\n+ print \u0022not ok $n\u005cn\u0022;\n+}\n+$n++;\n+\n+# (4-5) File does not exist\n+my $o \u003d Text::Template-\u003enew(TYPE \u003d\u003e 'file', \n+ SOURCE \u003d\u003e 'this file does not exist');\n+print $o ? \u0022not ok $n\u005cn\u0022 : \u0022ok $n\u005cn\u0022;\n+$n++;\n+print defined($Text::Template::ERROR) \n+ \u0026\u0026 $Text::Template::ERROR \u003d~ /^Couldn't open file/\n+ ? \u0022ok $n\u005cn\u0022 : \u0022not ok $n\u005cn\u0022;\n+$n++;\n+\n+\n+exit;\n+\ndiff --git a/external/perl/Text-Template-1.46/t/10-delimiters.t b/external/perl/Text-Template-1.46/t/10-delimiters.t\nnew file mode 100644\nindex 0000000..f74d591\n--- /dev/null\n+++ b/external/perl/Text-Template-1.46/t/10-delimiters.t\n@@ -0,0 +1,99 @@\n+#!perl\n+#\n+# Tests for user-specified delimiter functions\n+# These tests first appeared in version 1.20.\n+\n+use Text::Template;\n+\n+die \u0022This is the test program for Text::Template version 1.46.\n+You are using version $Text::Template::VERSION instead.\n+That does not make sense.\u005cn\n+Aborting\u0022\n+ unless $Text::Template::VERSION \u003d\u003d 1.46;\n+\n+print \u00221..18\u005cn\u0022;\n+$n \u003d 1;\n+\n+# (1) Try a simple delimiter: \u003c\u003c..\u003e\u003e\n+# First with the delimiters specified at object creation time\n+$V \u003d $V \u003d 119;\n+$template \u003d q{The value of $V is \u003c\u003c$V\u003e\u003e.};\n+$result \u003d q{The value of $V is 119.};\n+$template1 \u003d Text::Template-\u003enew(TYPE \u003d\u003e STRING, \n+\t\t\t\t SOURCE \u003d\u003e $template,\n+\t\t\t\t DELIMITERS \u003d\u003e ['\u003c\u003c', '\u003e\u003e']\n+\t\t\t\t)\n+ or die \u0022Couldn't construct template object: $Text::Template::ERROR; aborting\u0022;\n+$text \u003d $template1-\u003efill_in();\n+print +($text eq $result ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (2) Now with delimiter choice deferred until fill-in time.\n+$template1 \u003d Text::Template-\u003enew(TYPE \u003d\u003e STRING, SOURCE \u003d\u003e $template);\n+$text \u003d $template1-\u003efill_in(DELIMITERS \u003d\u003e ['\u003c\u003c', '\u003e\u003e']);\n+print +($text eq $result ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (3) Now we'll try using regex metacharacters\n+# First with the delimiters specified at object creation time\n+$template \u003d q{The value of $V is [$V].};\n+$template1 \u003d Text::Template-\u003enew(TYPE \u003d\u003e STRING, \n+\t\t\t\t SOURCE \u003d\u003e $template,\n+\t\t\t\t DELIMITERS \u003d\u003e ['[', ']']\n+\t\t\t\t)\n+ or die \u0022Couldn't construct template object: $Text::Template::ERROR; aborting\u0022;\n+$text \u003d $template1-\u003efill_in();\n+print +($text eq $result ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+# (4) Now with delimiter choice deferred until fill-in time.\n+$template1 \u003d Text::Template-\u003enew(TYPE \u003d\u003e STRING, SOURCE \u003d\u003e $template);\n+$text \u003d $template1-\u003efill_in(DELIMITERS \u003d\u003e ['[', ']']);\n+print +($text eq $result ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+$n++;\n+\n+\n+\n+# (5-18) Make sure \u005c is working properly\n+# (That is to say, it is ignored.)\n+# These tests are similar to those in 01-basic.t.\n+my @tests \u003d ('{\u0022\u0022}' \u003d\u003e '',\t# (5)\n+\n+\t # Backslashes don't matter\n+\t '{\u0022}\u0022}' \u003d\u003e undef,\n+\t '{\u0022\u005c\u005c}\u0022}' \u003d\u003e undef,\t# One backslash\n+\t '{\u0022\u005c\u005c\u005c\u005c}\u0022}' \u003d\u003e undef, # Two backslashes\n+\t '{\u0022\u005c\u005c\u005c\u005c\u005c\u005c}\u0022}' \u003d\u003e undef, # Three backslashes \n+\t '{\u0022\u005c\u005c\u005c\u005c\u005c\u005c\u005c\u005c}\u0022}' \u003d\u003e undef, # Four backslashes (10)\n+\t '{\u0022\u005c\u005c\u005c\u005c\u005c\u005c\u005c\u005c\u005c\u005c}\u0022}' \u003d\u003e undef, # Five backslashes\n+\t \n+\t # Backslashes are always passed directly to Perl\n+\t '{\u0022x20\u0022}' \u003d\u003e 'x20',\n+\t '{\u0022\u005c\u005cx20\u0022}' \u003d\u003e ' ',\t# One backslash\n+\t '{\u0022\u005c\u005c\u005c\u005cx20\u0022}' \u003d\u003e '\u005c\u005cx20', # Two backslashes\n+\t '{\u0022\u005c\u005c\u005c\u005c\u005c\u005cx20\u0022}' \u003d\u003e '\u005c\u005c ', # Three backslashes (15)\n+\t '{\u0022\u005c\u005c\u005c\u005c\u005c\u005c\u005c\u005cx20\u0022}' \u003d\u003e '\u005c\u005c\u005c\u005cx20', # Four backslashes\n+\t '{\u0022\u005c\u005c\u005c\u005c\u005c\u005c\u005c\u005c\u005c\u005cx20\u0022}' \u003d\u003e '\u005c\u005c\u005c\u005c ', # Five backslashes\n+\t '{\u0022\u005c\u005cx20\u005c\u005c}\u0022}' \u003d\u003e undef, # (18)\n+\t );\n+\n+my $i;\n+for ($i\u003d0; $i\u003c@tests; $i+\u003d2) {\n+ my $tmpl \u003d Text::Template-\u003enew(TYPE \u003d\u003e 'STRING',\n+\t\t\t\t SOURCE \u003d\u003e $tests[$i],\n+\t\t\t\t DELIMITERS \u003d\u003e ['{', '}'],\n+\t\t\t\t);\n+ my $text \u003d $tmpl-\u003efill_in;\n+ my $result \u003d $tests[$i+1];\n+ my $ok \u003d (! defined $text \u0026\u0026 ! defined $result\n+\t || $text eq $result);\n+ unless ($ok) {\n+ print STDERR \u0022($n) expected .$result., got .$text.\u005cn\u0022;\n+ }\n+ print +($ok ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+ $n++;\n+}\n+\n+\n+exit;\n+\ndiff --git a/external/perl/Text-Template-1.46/t/11-prepend.t b/external/perl/Text-Template-1.46/t/11-prepend.t\nnew file mode 100644\nindex 0000000..fe242e5\n--- /dev/null\n+++ b/external/perl/Text-Template-1.46/t/11-prepend.t\n@@ -0,0 +1,94 @@\n+#!perl\n+#\n+# Tests for PREPEND features\n+# These tests first appeared in version 1.22.\n+\n+use Text::Template;\n+\n+die \u0022This is the test program for Text::Template version 1.46\n+You are using version $Text::Template::VERSION instead.\n+That does not make sense.\u005cn\n+Aborting\u0022\n+ unless $Text::Template::VERSION \u003d\u003d 1.46;\n+\n+print \u00221..9\u005cn\u0022;\n+my $n \u003d 1;\n+\n+@Emptyclass1::ISA \u003d 'Text::Template';\n+@Emptyclass2::ISA \u003d 'Text::Template';\n+\n+my $tin \u003d q{The value of $foo is: {$foo}};\n+\n+Text::Template-\u003ealways_prepend(q{$foo \u003d \u0022global\u0022});\n+\n+$tmpl1 \u003d Text::Template-\u003enew(TYPE \u003d\u003e 'STRING',\n+\t\t\t\tSOURCE \u003d\u003e $tin,\t\t\n+\t\t\t );\n+\n+$tmpl2 \u003d Text::Template-\u003enew(TYPE \u003d\u003e 'STRING',\n+\t\t\t SOURCE \u003d\u003e $tin,\t\t\n+\t\t\t PREPEND \u003d\u003e q{$foo \u003d \u0022template\u0022},\n+\t\t\t );\n+\n+$tmpl1-\u003ecompile;\n+$tmpl2-\u003ecompile;\n+\n+$t1 \u003d $tmpl1-\u003efill_in(PACKAGE \u003d\u003e 'T1');\n+$t2 \u003d $tmpl2-\u003efill_in(PACKAGE \u003d\u003e 'T2');\n+$t3 \u003d $tmpl2-\u003efill_in(PREPEND \u003d\u003e q{$foo \u003d \u0022fillin\u0022}, PACKAGE \u003d\u003e 'T3');\n+\n+($t1 eq 'The value of $foo is: global') or print \u0022not \u0022;\n+print \u0022ok $n\u005cn\u0022; $n++;\n+($t2 eq 'The value of $foo is: template') or print \u0022not \u0022;\n+print \u0022ok $n\u005cn\u0022; $n++;\n+($t3 eq 'The value of $foo is: fillin') or print \u0022not \u0022;\n+print \u0022ok $n\u005cn\u0022; $n++;\n+\n+Emptyclass1-\u003ealways_prepend(q{$foo \u003d 'Emptyclass global';});\n+$tmpl1 \u003d Emptyclass1-\u003enew(TYPE \u003d\u003e 'STRING',\n+\t\t\t\tSOURCE \u003d\u003e $tin,\t\t\n+\t\t\t );\n+\n+$tmpl2 \u003d Emptyclass1-\u003enew(TYPE \u003d\u003e 'STRING',\n+\t\t\t SOURCE \u003d\u003e $tin,\t\t\n+\t\t\t PREPEND \u003d\u003e q{$foo \u003d \u0022template\u0022},\n+\t\t\t );\n+\n+$tmpl1-\u003ecompile;\n+$tmpl2-\u003ecompile;\n+\n+$t1 \u003d $tmpl1-\u003efill_in(PACKAGE \u003d\u003e 'T4');\n+$t2 \u003d $tmpl2-\u003efill_in(PACKAGE \u003d\u003e 'T5');\n+$t3 \u003d $tmpl2-\u003efill_in(PREPEND \u003d\u003e q{$foo \u003d \u0022fillin\u0022}, PACKAGE \u003d\u003e 'T6');\n+\n+($t1 eq 'The value of $foo is: Emptyclass global') or print \u0022not \u0022;\n+print \u0022ok $n\u005cn\u0022; $n++;\n+($t2 eq 'The value of $foo is: template') or print \u0022not \u0022;\n+print \u0022ok $n\u005cn\u0022; $n++;\n+($t3 eq 'The value of $foo is: fillin') or print \u0022not \u0022;\n+print \u0022ok $n\u005cn\u0022; $n++;\n+\n+$tmpl1 \u003d Emptyclass2-\u003enew(TYPE \u003d\u003e 'STRING',\n+\t\t\t\tSOURCE \u003d\u003e $tin,\t\t\n+\t\t\t );\n+\n+$tmpl2 \u003d Emptyclass2-\u003enew(TYPE \u003d\u003e 'STRING',\n+\t\t\t SOURCE \u003d\u003e $tin,\t\t\n+\t\t\t PREPEND \u003d\u003e q{$foo \u003d \u0022template\u0022},\n+\t\t\t );\n+\n+$tmpl1-\u003ecompile;\n+$tmpl2-\u003ecompile;\n+\n+$t1 \u003d $tmpl1-\u003efill_in(PACKAGE \u003d\u003e 'T4');\n+$t2 \u003d $tmpl2-\u003efill_in(PACKAGE \u003d\u003e 'T5');\n+$t3 \u003d $tmpl2-\u003efill_in(PREPEND \u003d\u003e q{$foo \u003d \u0022fillin\u0022}, PACKAGE \u003d\u003e 'T6');\n+\n+($t1 eq 'The value of $foo is: global') or print \u0022not \u0022;\n+print \u0022ok $n\u005cn\u0022; $n++;\n+($t2 eq 'The value of $foo is: template') or print \u0022not \u0022;\n+print \u0022ok $n\u005cn\u0022; $n++;\n+($t3 eq 'The value of $foo is: fillin') or print \u0022not \u0022;\n+print \u0022ok $n\u005cn\u0022; $n++;\n+\n+\ndiff --git a/external/perl/Text-Template-1.46/t/12-preprocess.t b/external/perl/Text-Template-1.46/t/12-preprocess.t\nnew file mode 100644\nindex 0000000..60b6b0c\n--- /dev/null\n+++ b/external/perl/Text-Template-1.46/t/12-preprocess.t\n@@ -0,0 +1,52 @@\n+#!perl\n+#\n+# Tests for PREPROCESSOR features\n+# These tests first appeared in version 1.25.\n+\n+use Text::Template::Preprocess;\n+\n+die \u0022This is the test program for Text::Template::Preprocess version 1.46.\n+You are using version $Text::Template::Preprocess::VERSION instead.\n+That does not make sense.\u005cn\n+Aborting\u0022\n+ unless $Text::Template::Preprocess::VERSION \u003d\u003d 1.46;\n+\n+$TMPFILE \u003d \u0022tt$$\u0022;\n+\n+print \u00221..8\u005cn\u0022;\n+my $n \u003d 1;\n+\n+my $py \u003d sub { tr/x/y/ };\n+my $pz \u003d sub { tr/x/z/ };\n+\n+my $t \u003d 'xxx The value of $x is {$x}';\n+my $outx \u003d 'xxx The value of $x is 119';\n+my $outy \u003d 'yyy The value of $y is 23';\n+my $outz \u003d 'zzz The value of $z is 5';\n+open TF, \u0022\u003e $TMPFILE\u0022 or die \u0022Couldn't open test file: $!; aborting\u0022;\n+print TF $t;\n+close TF;\n+\n+@result \u003d ($outx, $outy, $outz, $outz);\n+for my $trial (1, 0) {\n+ for my $test (0 .. 3) {\n+ my $tmpl;\n+ if ($trial \u003d\u003d 0) {\n+ $tmpl \u003d new Text::Template::Preprocess \n+\t(TYPE \u003d\u003e 'STRING', SOURCE \u003d\u003e $t) or die;\n+ } else {\n+ open TF, \u0022\u003c $TMPFILE\u0022 or die \u0022Couldn't open test file: $!; aborting\u0022;\n+ $tmpl \u003d new Text::Template::Preprocess \n+\t(TYPE \u003d\u003e 'FILEHANDLE', SOURCE \u003d\u003e \u005c*TF) or die;\n+ }\n+ $tmpl-\u003epreprocessor($py) if ($test \u0026 1) \u003d\u003d 1;\n+ my @args \u003d ((($test \u0026 2) \u003d\u003d 2) ? (PREPROCESSOR \u003d\u003e $pz) : ());\n+ my $o \u003d $tmpl-\u003efill_in(@args, \n+\t\t\t HASH \u003d\u003e {x \u003d\u003e 119, 'y' \u003d\u003e 23, z \u003d\u003e 5});\n+# print STDERR \u0022$o/$result[$test]\u005cn\u0022;\n+ print +(($o eq $result[$test]) ? '' : 'not '), \u0022ok $n\u005cn\u0022;\n+ $n++;\n+ }\n+}\n+\n+unlink $TMPFILE;\ndiff --git a/external/perl/Text-Template-1.46/t/13-taint.t b/external/perl/Text-Template-1.46/t/13-taint.t\nnew file mode 100644\nindex 0000000..d92a374\n--- /dev/null\n+++ b/external/perl/Text-Template-1.46/t/13-taint.t\n@@ -0,0 +1,119 @@\n+#!perl -T\n+# Tests for taint-mode features\n+\n+use lib 'blib/lib';\n+use Text::Template;\n+\n+die \u0022This is the test program for Text::Template version 1.46.\n+You are using version $Text::Template::VERSION instead.\n+That does not make sense.\u005cn\n+Aborting\u0022\n+ unless $Text::Template::VERSION \u003d\u003d 1.46;\n+\n+my $r \u003d int(rand(10000));\n+my $file \u003d \u0022tt$r\u0022;\n+\n+# makes its arguments tainted\n+sub taint {\n+ for (@_) {\n+ $_ .\u003d substr($0,0,0); # LOD\n+ }\n+}\n+\n+\n+print \u00221..21\u005cn\u0022;\n+\n+my $n \u003d1;\n+print \u0022ok \u0022, $n++, \u0022\u005cn\u0022;\n+\n+my $template \u003d 'The value of $n is {$n}.';\n+\n+open T, \u0022\u003e $file\u0022 or die \u0022Couldn't write temporary file $file: $!\u0022;\n+print T $template, \u0022\u005cn\u0022;\n+close T or die \u0022Couldn't finish temporary file $file: $!\u0022;\n+\n+sub should_fail {\n+ my $obj \u003d Text::Template-\u003enew(@_);\n+ eval {$obj-\u003efill_in()};\n+ if ($@) {\n+ print \u0022ok $n # $@\u005cn\u0022;\n+ } else {\n+ print \u0022not ok $n # (didn't fail)\u005cn\u0022;\n+ }\n+ $n++;\n+}\n+\n+sub should_work {\n+ my $obj \u003d Text::Template-\u003enew(@_);\n+ eval {$obj-\u003efill_in()};\n+ if ($@) {\n+ print \u0022not ok $n # $@\u005cn\u0022;\n+ } else {\n+ print \u0022ok $n\u005cn\u0022;\n+ }\n+ $n++;\n+}\n+\n+sub should_be_tainted {\n+ if (Text::Template::_is_clean($_[0])) {\n+ print \u0022not ok $n\u005cn\u0022; $n++; return;\n+ }\n+ print \u0022ok $n\u005cn\u0022; $n++; return; \n+}\n+\n+sub should_be_clean {\n+ unless (Text::Template::_is_clean($_[0])) {\n+ print \u0022not ok $n\u005cn\u0022; $n++; return;\n+ }\n+ print \u0022ok $n\u005cn\u0022; $n++; return; \n+}\n+\n+# Tainted filename should die with and without UNTAINT option\n+# untainted filename should die without UNTAINT option\n+# filehandle should die without UNTAINT option\n+# string and array with tainted data should die either way\n+\n+# (2)-(7)\n+my $tfile \u003d $file;\n+taint($tfile);\n+should_be_tainted($tfile);\n+should_be_clean($file);\n+should_fail TYPE \u003d\u003e 'file', SOURCE \u003d\u003e $tfile;\n+should_fail TYPE \u003d\u003e 'file', SOURCE \u003d\u003e $tfile, UNTAINT \u003d\u003e 1;\n+should_fail TYPE \u003d\u003e 'file', SOURCE \u003d\u003e $file;\n+should_work TYPE \u003d\u003e 'file', SOURCE \u003d\u003e $file, UNTAINT \u003d\u003e 1;\n+\n+# (8-9)\n+open H, \u0022\u003c $file\u0022 or die \u0022Couldn't open $file for reading: $!; aborting\u0022;\n+should_fail TYPE \u003d\u003e 'filehandle', SOURCE \u003d\u003e \u005c*H;\n+close H;\n+open H, \u0022\u003c $file\u0022 or die \u0022Couldn't open $file for reading: $!; aborting\u0022;\n+should_work TYPE \u003d\u003e 'filehandle', SOURCE \u003d\u003e \u005c*H, UNTAINT \u003d\u003e 1;\n+close H;\n+\n+# (10-15)\n+my $ttemplate \u003d $template;\n+taint($ttemplate);\n+should_be_tainted($ttemplate);\n+should_be_clean($template);\n+should_fail TYPE \u003d\u003e 'string', SOURCE \u003d\u003e $ttemplate;\n+should_fail TYPE \u003d\u003e 'string', SOURCE \u003d\u003e $ttemplate, UNTAINT \u003d\u003e 1;\n+should_work TYPE \u003d\u003e 'string', SOURCE \u003d\u003e $template;\n+should_work TYPE \u003d\u003e 'string', SOURCE \u003d\u003e $template, UNTAINT \u003d\u003e 1;\n+\n+# (16-19)\n+my $array \u003d [ $template ];\n+my $tarray \u003d [ $ttemplate ];\n+should_fail TYPE \u003d\u003e 'array', SOURCE \u003d\u003e $tarray;\n+should_fail TYPE \u003d\u003e 'array', SOURCE \u003d\u003e $tarray, UNTAINT \u003d\u003e 1;\n+should_work TYPE \u003d\u003e 'array', SOURCE \u003d\u003e $array;\n+should_work TYPE \u003d\u003e 'array', SOURCE \u003d\u003e $array, UNTAINT \u003d\u003e 1;\n+\n+# (20-21) Test _unconditionally_untaint utility function\n+Text::Template::_unconditionally_untaint($ttemplate);\n+should_be_clean($ttemplate);\n+Text::Template::_unconditionally_untaint($tfile);\n+should_be_clean($tfile);\n+\n+END { unlink $file }\n+\ndiff --git a/external/perl/Text-Template-1.46/t/14-broken.t b/external/perl/Text-Template-1.46/t/14-broken.t\nnew file mode 100644\nindex 0000000..d362395\n--- /dev/null\n+++ b/external/perl/Text-Template-1.46/t/14-broken.t\n@@ -0,0 +1,82 @@\n+#!perl\n+# test apparatus for Text::Template module\n+\n+use Text::Template;\n+\n+print \u00221..5\u005cn\u0022;\n+\n+$n\u003d1;\n+\n+die \u0022This is the test program for Text::Template version 1.46.\n+You are using version $Text::Template::VERSION instead.\n+That does not make sense.\u005cn\n+Aborting\u0022\n+ unless $Text::Template::VERSION \u003d\u003d 1.46;\n+\n+# (1) basic error delivery\n+{ my $r \u003d Text::Template-\u003enew(TYPE \u003d\u003e 'string',\n+ SOURCE \u003d\u003e '{1/0}',\n+ )-\u003efill_in();\n+ if ($r eq q{Program fragment delivered error ``Illegal division by zero at template line 1.''}) {\n+ print \u0022ok $n\u005cn\u0022;\n+ } else {\n+ print \u0022not ok $n\u005cn# $r\u005cn\u0022;\n+ }\n+ $n++;\n+}\n+\n+# (2) BROKEN sub called in -\u003enew?\n+{ my $r \u003d Text::Template-\u003enew(TYPE \u003d\u003e 'string',\n+ SOURCE \u003d\u003e '{1/0}',\n+ BROKEN \u003d\u003e sub {'---'},\n+ )-\u003efill_in();\n+ if ($r eq q{---}) {\n+ print \u0022ok $n\u005cn\u0022;\n+ } else {\n+ print \u0022not ok $n\u005cn# $r\u005cn\u0022;\n+ }\n+ $n++;\n+}\n+\n+# (3) BROKEN sub called in -\u003efill_in?\n+{ my $r \u003d Text::Template-\u003enew(TYPE \u003d\u003e 'string',\n+ SOURCE \u003d\u003e '{1/0}',\n+ )-\u003efill_in(BROKEN \u003d\u003e sub {'---'});\n+ if ($r eq q{---}) {\n+ print \u0022ok $n\u005cn\u0022;\n+ } else {\n+ print \u0022not ok $n\u005cn# $r\u005cn\u0022;\n+ }\n+ $n++;\n+}\n+\n+# (4) BROKEN sub passed correct args when called in -\u003enew?\n+{ my $r \u003d Text::Template-\u003enew(TYPE \u003d\u003e 'string',\n+ SOURCE \u003d\u003e '{1/0}',\n+ BROKEN \u003d\u003e sub { my %a \u003d @_;\n+ qq{$a{lineno},$a{error},$a{text}}\n+ },\n+ )-\u003efill_in();\n+ if ($r eq qq{1,Illegal division by zero at template line 1.\u005cn,1/0}) {\n+ print \u0022ok $n\u005cn\u0022;\n+ } else {\n+ print \u0022not ok $n\u005cn# $r\u005cn\u0022;\n+ }\n+ $n++;\n+}\n+\n+# (5) BROKEN sub passed correct args when called in -\u003efill_in?\n+{ my $r \u003d Text::Template-\u003enew(TYPE \u003d\u003e 'string',\n+ SOURCE \u003d\u003e '{1/0}',\n+ )-\u003efill_in(BROKEN \u003d\u003e \n+ sub { my %a \u003d @_;\n+ qq{$a{lineno},$a{error},$a{text}}\n+ });\n+ if ($r eq qq{1,Illegal division by zero at template line 1.\u005cn,1/0}) {\n+ print \u0022ok $n\u005cn\u0022;\n+ } else {\n+ print \u0022not ok $n\u005cn# $r\u005cn\u0022;\n+ }\n+ $n++;\n+}\n+\ndiff --git a/external/perl/transfer/Text/Template.pm b/external/perl/transfer/Text/Template.pm\nnew file mode 100644\nindex 0000000..13ed1eb\n--- /dev/null\n+++ b/external/perl/transfer/Text/Template.pm\n@@ -0,0 +1,12 @@\n+#! /usr/bin/perl\n+\n+# Quick transfer to the downloaded Text::Template\n+\n+BEGIN {\n+ use File::Spec::Functions;\n+ use File::Basename;\n+ use lib catdir(dirname(__FILE__), \u0022..\u0022, \u0022..\u0022);\n+ my $texttemplate \u003d catfile(\u0022Text-Template-1.46\u0022, \u0022lib\u0022, \u0022Text\u0022, \u0022Template.pm\u0022);\n+ require $texttemplate;\n+}\n+1;\n","s":{"c":1756122855,"u": 22614}} ],"g": 101904,"chitpc": 0,"ehitpc": 0,"indexed":0 , "ab": 0, "si": 0, "db":0, "di":0, "sat":0, "lfc": "7d0a"}